Merge branch 'master' into conditionals-bug-fixes

* Adds a simple indicator to display FPS

* ratchet up test coverage threshold

CONTRIBUTING.md

@@ -182,7 +182,7 @@ The following guidelines are provided for anyone contributing source code to the
 1. Avoid the use of "magic" values.
    eg.
    ```JavaScript
-   Const UNAUTHORIZED = 401
+   const UNAUTHORIZED = 401;
    if (responseCode === UNAUTHORIZED)
    ```
    is preferable to

index.html

@@ -131,10 +131,10 @@
                         }
                     ],
                     // maximum recent bounds to retain in conductor history
-                    records: 10,
+                    records: 10
                     // maximum duration between start and end bounds
                     // for utc-based time systems this is in milliseconds
-                    limit: ONE_DAY
+                    // limit: ONE_DAY
                 },
                 {
                     name: "Realtime",

karma.conf.js

@@ -86,7 +86,7 @@ module.exports = (config) => {
             reports: ['html', 'lcovonly', 'text-summary'],
             thresholds: {
                 global: {
-                    lines: 65
+                    lines: 66
                 }
             }
         },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmct",
-  "version": "1.4.1-SNAPSHOT",
+  "version": "1.5.0-SNAPSHOT",
   "description": "The Open MCT core platform",
   "dependencies": {},
   "devDependencies": {

platform/entanglement/bundle.js

@@ -21,32 +21,24 @@
  *****************************************************************************/
 
 define([
-    "./src/actions/MoveAction",
-    "./src/actions/CopyAction",
     "./src/actions/LinkAction",
     "./src/actions/SetPrimaryLocationAction",
     "./src/services/LocatingCreationDecorator",
     "./src/services/LocatingObjectDecorator",
     "./src/policies/CopyPolicy",
     "./src/policies/CrossSpacePolicy",
-    "./src/policies/MovePolicy",
     "./src/capabilities/LocationCapability",
-    "./src/services/MoveService",
     "./src/services/LinkService",
     "./src/services/CopyService",
     "./src/services/LocationService"
 ], function (
-    MoveAction,
-    CopyAction,
     LinkAction,
     SetPrimaryLocationAction,
     LocatingCreationDecorator,
     LocatingObjectDecorator,
     CopyPolicy,
     CrossSpacePolicy,
-    MovePolicy,
     LocationCapability,
-    MoveService,
     LinkService,
     CopyService,
     LocationService
@@ -60,39 +52,6 @@ define([
             "configuration": {},
             "extensions": {
                 "actions": [
-                    {
-                        "key": "move",
-                        "name": "Move",
-                        "description": "Move object to another location.",
-                        "cssClass": "icon-move",
-                        "category": "contextual",
-                        "group": "action",
-                        "priority": 9,
-                        "implementation": MoveAction,
-                        "depends": [
-                            "policyService",
-                            "locationService",
-                            "moveService"
-                        ]
-                    },
-                    {
-                        "key": "copy",
-                        "name": "Duplicate",
-                        "description": "Duplicate object to another location.",
-                        "cssClass": "icon-duplicate",
-                        "category": "contextual",
-                        "group": "action",
-                        "priority": 8,
-                        "implementation": CopyAction,
-                        "depends": [
-                            "$log",
-                            "policyService",
-                            "locationService",
-                            "copyService",
-                            "dialogService",
-                            "notificationService"
-                        ]
-                    },
                     {
                         "key": "link",
                         "name": "Create Link",
@@ -141,10 +100,6 @@ define([
                     {
                         "category": "action",
                         "implementation": CopyPolicy
-                    },
-                    {
-                        "category": "action",
-                        "implementation": MovePolicy
                     }
                 ],
                 "capabilities": [
@@ -160,17 +115,6 @@ define([
                     }
                 ],
                 "services": [
-                    {
-                        "key": "moveService",
-                        "name": "Move Service",
-                        "description": "Provides a service for moving objects",
-                        "implementation": MoveService,
-                        "depends": [
-                            "openmct",
-                            "linkService",
-                            "$q"
-                        ]
-                    },
                     {
                         "key": "linkService",
                         "name": "Link Service",

platform/entanglement/src/actions/CopyAction.js

@@ -1,168 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    ['./AbstractComposeAction', './CancelError'],
-    function (AbstractComposeAction, CancelError) {
-
-        /**
-         * The CopyAction is available from context menus and allows a user to
-         * deep copy an object to another location of their choosing.
-         *
-         * @implements {Action}
-         * @constructor
-         * @memberof platform/entanglement
-         */
-        function CopyAction(
-            $log,
-            policyService,
-            locationService,
-            copyService,
-            dialogService,
-            notificationService,
-            context
-        ) {
-            this.dialog = undefined;
-            this.notification = undefined;
-            this.dialogService = dialogService;
-            this.notificationService = notificationService;
-            this.$log = $log;
-            //Extend the behaviour of the Abstract Compose Action
-            AbstractComposeAction.call(
-                this,
-                policyService,
-                locationService,
-                copyService,
-                context,
-                "Duplicate",
-                "To a Location"
-            );
-        }
-
-        CopyAction.prototype = Object.create(AbstractComposeAction.prototype);
-
-        /**
-         * Updates user about progress of copy. Should not be invoked by
-         * client code under any circumstances.
-         *
-         * @private
-         * @param phase
-         * @param totalObjects
-         * @param processed
-         */
-        CopyAction.prototype.progress = function (phase, totalObjects, processed) {
-            /*
-             Copy has two distinct phases. In the first phase a copy plan is
-             made in memory. During this phase of execution, the user is
-             shown a blocking 'modal' dialog.
-
-             In the second phase, the copying is taking place, and the user
-             is shown non-invasive banner notifications at the bottom of the screen.
-             */
-            if (phase.toLowerCase() === 'preparing' && !this.dialog) {
-                this.dialog = this.dialogService.showBlockingMessage({
-                    title: "Preparing to copy objects",
-                    hint: "Do not navigate away from this page or close this browser tab while this message is displayed.",
-                    unknownProgress: true,
-                    severity: "info"
-                });
-            } else if (phase.toLowerCase() === "copying") {
-                if (this.dialog) {
-                    this.dialog.dismiss();
-                }
-
-                if (!this.notification) {
-                    this.notification = this.notificationService
-                        .notify({
-                            title: "Copying objects",
-                            unknownProgress: false,
-                            severity: "info"
-                        });
-                }
-
-                this.notification.model.progress = (processed / totalObjects) * 100;
-                this.notification.model.title = ["Copied ", processed, "of ",
-                    totalObjects, "objects"].join(" ");
-            }
-        };
-
-        /**
-         * Executes the CopyAction. The CopyAction uses the default behaviour of
-         * the AbstractComposeAction, but extends it to support notification
-         * updates of progress on copy.
-         */
-        CopyAction.prototype.perform = function () {
-            var self = this;
-
-            function success(domainObject) {
-                var domainObjectName = domainObject.model.name;
-
-                self.notification.dismiss();
-                self.notificationService.info(domainObjectName + " copied successfully.");
-            }
-
-            function error(errorDetails) {
-                // No need to notify user of their own cancellation
-                if (errorDetails instanceof CancelError) {
-                    return;
-                }
-
-                var errorDialog,
-                    errorMessage = {
-                        title: "Error copying objects.",
-                        severity: "error",
-                        hint: errorDetails.message,
-                        minimized: true, // want the notification to be minimized initially (don't show banner)
-                        options: [{
-                            label: "OK",
-                            callback: function () {
-                                errorDialog.dismiss();
-                            }
-                        }]
-                    };
-
-                self.dialog.dismiss();
-                if (self.notification) {
-                    self.notification.dismiss(); // Clear the progress notification
-                }
-
-                self.$log.error("Error copying objects. ", errorDetails);
-                //Show a minimized notification of error for posterity
-                self.notificationService.notify(errorMessage);
-                //Display a blocking message
-                errorDialog = self.dialogService.showBlockingMessage(errorMessage);
-
-            }
-
-            function notification(details) {
-                self.progress(details.phase, details.totalObjects, details.processed);
-            }
-
-            return AbstractComposeAction.prototype.perform.call(this)
-                .then(success, error, notification);
-        };
-
-        CopyAction.appliesTo = AbstractComposeAction.appliesTo;
-
-        return CopyAction;
-    }
-);

platform/entanglement/src/services/MoveService.js

@@ -1,104 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    function () {
-        /**
-         * MoveService provides an interface for moving objects from one
-         * location to another.  It also provides a method for determining if
-         * an object can be copied to a specific location.
-         * @constructor
-         * @memberof platform/entanglement
-         * @implements {platform/entanglement.AbstractComposeService}
-         */
-        function MoveService(openmct, linkService) {
-            this.openmct = openmct;
-            this.linkService = linkService;
-        }
-
-        MoveService.prototype.validate = function (object, parentCandidate) {
-            var currentParent = object
-                .getCapability('context')
-                .getParent();
-
-            if (!parentCandidate || !parentCandidate.getId) {
-                return false;
-            }
-
-            if (parentCandidate.getId() === currentParent.getId()) {
-                return false;
-            }
-
-            if (parentCandidate.getId() === object.getId()) {
-                return false;
-            }
-
-            if (parentCandidate.getModel().composition.indexOf(object.getId()) !== -1) {
-                return false;
-            }
-
-            return this.openmct.composition.checkPolicy(
-                parentCandidate.useCapability('adapter'),
-                object.useCapability('adapter')
-            );
-        };
-
-        MoveService.prototype.perform = function (object, parentObject) {
-            function relocate(objectInNewContext) {
-                var newLocationCapability = objectInNewContext
-                        .getCapability('location'),
-                    oldLocationCapability = object
-                        .getCapability('location');
-
-                if (!newLocationCapability
-                        || !oldLocationCapability) {
-                    return;
-                }
-
-                if (oldLocationCapability.isOriginal()) {
-                    return newLocationCapability.setPrimaryLocation(
-                        newLocationCapability
-                            .getContextualLocation()
-                    );
-                }
-            }
-
-            if (!this.validate(object, parentObject)) {
-                throw new Error(
-                    "Tried to move objects without validating first."
-                );
-            }
-
-            return this.linkService
-                .perform(object, parentObject)
-                .then(relocate)
-                .then(function () {
-                    return object
-                        .getCapability('action')
-                        .perform('remove', true);
-                });
-        };
-
-        return MoveService;
-    }
-);
-

platform/entanglement/test/actions/CopyActionSpec.js

@@ -1,243 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    [
-        '../../src/actions/CopyAction',
-        '../services/MockCopyService',
-        '../DomainObjectFactory'
-    ],
-    function (CopyAction, MockCopyService, domainObjectFactory) {
-
-        describe("Copy Action", function () {
-
-            var copyAction,
-                policyService,
-                locationService,
-                locationServicePromise,
-                copyService,
-                context,
-                selectedObject,
-                selectedObjectContextCapability,
-                currentParent,
-                newParent,
-                notificationService,
-                notification,
-                dialogService,
-                mockDialog,
-                mockLog,
-                abstractComposePromise,
-                domainObject = {model: {name: "mockObject"}},
-                progress = {
-                    phase: "copying",
-                    totalObjects: 10,
-                    processed: 1
-                };
-
-            beforeEach(function () {
-                policyService = jasmine.createSpyObj(
-                    'policyService',
-                    ['allow']
-                );
-                policyService.allow.and.returnValue(true);
-
-                selectedObjectContextCapability = jasmine.createSpyObj(
-                    'selectedObjectContextCapability',
-                    [
-                        'getParent'
-                    ]
-                );
-
-                selectedObject = domainObjectFactory({
-                    name: 'selectedObject',
-                    model: {
-                        name: 'selectedObject'
-                    },
-                    capabilities: {
-                        context: selectedObjectContextCapability
-                    }
-                });
-
-                currentParent = domainObjectFactory({
-                    name: 'currentParent'
-                });
-
-                selectedObjectContextCapability
-                    .getParent
-                    .and.returnValue(currentParent);
-
-                newParent = domainObjectFactory({
-                    name: 'newParent'
-                });
-
-                locationService = jasmine.createSpyObj(
-                    'locationService',
-                    [
-                        'getLocationFromUser'
-                    ]
-                );
-
-                locationServicePromise = jasmine.createSpyObj(
-                    'locationServicePromise',
-                    [
-                        'then'
-                    ]
-                );
-
-                abstractComposePromise = jasmine.createSpyObj(
-                    'abstractComposePromise',
-                    [
-                        'then'
-                    ]
-                );
-
-                abstractComposePromise.then.and.callFake(function (success, error, notify) {
-                    notify(progress);
-                    success(domainObject);
-                });
-
-                locationServicePromise.then.and.callFake(function (callback) {
-                    callback(newParent);
-
-                    return abstractComposePromise;
-                });
-
-                locationService
-                    .getLocationFromUser
-                    .and.returnValue(locationServicePromise);
-
-                dialogService = jasmine.createSpyObj('dialogService',
-                    ['showBlockingMessage']
-                );
-
-                mockDialog = jasmine.createSpyObj("dialog", ["dismiss"]);
-                dialogService.showBlockingMessage.and.returnValue(mockDialog);
-
-                notification = jasmine.createSpyObj('notification',
-                    ['dismiss', 'model']
-                );
-
-                notificationService = jasmine.createSpyObj('notificationService',
-                    ['notify', 'info']
-                );
-
-                notificationService.notify.and.returnValue(notification);
-
-                mockLog = jasmine.createSpyObj('log', ['error']);
-
-                copyService = new MockCopyService();
-            });
-
-            describe("with context from context-action", function () {
-                beforeEach(function () {
-                    context = {
-                        domainObject: selectedObject
-                    };
-
-                    copyAction = new CopyAction(
-                        mockLog,
-                        policyService,
-                        locationService,
-                        copyService,
-                        dialogService,
-                        notificationService,
-                        context
-                    );
-                });
-
-                it("initializes happily", function () {
-                    expect(copyAction).toBeDefined();
-                });
-
-                describe("when performed it", function () {
-                    beforeEach(function () {
-                        spyOn(copyAction, 'progress').and.callThrough();
-                        copyAction.perform();
-                    });
-
-                    it("prompts for location", function () {
-                        expect(locationService.getLocationFromUser)
-                            .toHaveBeenCalledWith(
-                                "Duplicate selectedObject To a Location",
-                                "Duplicate To",
-                                jasmine.any(Function),
-                                currentParent
-                            );
-                    });
-
-                    it("waits for location and handles cancellation by user", function () {
-                        expect(locationServicePromise.then)
-                            .toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
-                    });
-
-                    it("copies object to selected location", function () {
-                        locationServicePromise
-                            .then
-                            .calls.mostRecent()
-                            .args[0](newParent);
-
-                        expect(copyService.perform)
-                            .toHaveBeenCalledWith(selectedObject, newParent);
-                    });
-
-                    it("notifies the user of progress", function () {
-                        expect(notificationService.info).toHaveBeenCalled();
-                    });
-
-                    it("notifies the user with name of object copied", function () {
-                        expect(notificationService.info)
-                            .toHaveBeenCalledWith("mockObject copied successfully.");
-                    });
-                });
-            });
-
-            describe("with context from drag-drop", function () {
-                beforeEach(function () {
-                    context = {
-                        selectedObject: selectedObject,
-                        domainObject: newParent
-                    };
-
-                    copyAction = new CopyAction(
-                        mockLog,
-                        policyService,
-                        locationService,
-                        copyService,
-                        dialogService,
-                        notificationService,
-                        context
-                    );
-                });
-
-                it("initializes happily", function () {
-                    expect(copyAction).toBeDefined();
-                });
-
-                it("performs copy immediately", function () {
-                    copyAction.perform();
-                    expect(copyService.perform)
-                        .toHaveBeenCalledWith(selectedObject, newParent);
-                });
-            });
-        });
-    }
-);

platform/entanglement/test/actions/MoveActionSpec.js

@@ -1,178 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    [
-        '../../src/actions/MoveAction',
-        '../services/MockMoveService',
-        '../DomainObjectFactory'
-    ],
-    function (MoveAction, MockMoveService, domainObjectFactory) {
-
-        describe("Move Action", function () {
-
-            var moveAction,
-                policyService,
-                locationService,
-                locationServicePromise,
-                moveService,
-                context,
-                selectedObject,
-                selectedObjectContextCapability,
-                currentParent,
-                newParent;
-
-            beforeEach(function () {
-                policyService = jasmine.createSpyObj(
-                    'policyService',
-                    ['allow']
-                );
-                policyService.allow.and.returnValue(true);
-
-                selectedObjectContextCapability = jasmine.createSpyObj(
-                    'selectedObjectContextCapability',
-                    [
-                        'getParent'
-                    ]
-                );
-
-                selectedObject = domainObjectFactory({
-                    name: 'selectedObject',
-                    model: {
-                        name: 'selectedObject'
-                    },
-                    capabilities: {
-                        context: selectedObjectContextCapability
-                    }
-                });
-
-                currentParent = domainObjectFactory({
-                    name: 'currentParent'
-                });
-
-                selectedObjectContextCapability
-                    .getParent
-                    .and.returnValue(currentParent);
-
-                newParent = domainObjectFactory({
-                    name: 'newParent'
-                });
-
-                locationService = jasmine.createSpyObj(
-                    'locationService',
-                    [
-                        'getLocationFromUser'
-                    ]
-                );
-
-                locationServicePromise = jasmine.createSpyObj(
-                    'locationServicePromise',
-                    [
-                        'then'
-                    ]
-                );
-
-                locationService
-                    .getLocationFromUser
-                    .and.returnValue(locationServicePromise);
-
-                moveService = new MockMoveService();
-            });
-
-            describe("with context from context-action", function () {
-                beforeEach(function () {
-                    context = {
-                        domainObject: selectedObject
-                    };
-
-                    moveAction = new MoveAction(
-                        policyService,
-                        locationService,
-                        moveService,
-                        context
-                    );
-                });
-
-                it("initializes happily", function () {
-                    expect(moveAction).toBeDefined();
-                });
-
-                describe("when performed it", function () {
-                    beforeEach(function () {
-                        moveAction.perform();
-                    });
-
-                    it("prompts for location", function () {
-                        expect(locationService.getLocationFromUser)
-                            .toHaveBeenCalledWith(
-                                "Move selectedObject To a New Location",
-                                "Move To",
-                                jasmine.any(Function),
-                                currentParent
-                            );
-                    });
-
-                    it("waits for location and handles cancellation by user", function () {
-                        expect(locationServicePromise.then)
-                            .toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
-                    });
-
-                    it("moves object to selected location", function () {
-                        locationServicePromise
-                            .then
-                            .calls.mostRecent()
-                            .args[0](newParent);
-
-                        expect(moveService.perform)
-                            .toHaveBeenCalledWith(selectedObject, newParent);
-                    });
-                });
-            });
-
-            describe("with context from drag-drop", function () {
-                beforeEach(function () {
-                    context = {
-                        selectedObject: selectedObject,
-                        domainObject: newParent
-                    };
-
-                    moveAction = new MoveAction(
-                        policyService,
-                        locationService,
-                        moveService,
-                        context
-                    );
-                });
-
-                it("initializes happily", function () {
-                    expect(moveAction).toBeDefined();
-                });
-
-                it("performs move immediately", function () {
-                    moveAction.perform();
-                    expect(moveService.perform)
-                        .toHaveBeenCalledWith(selectedObject, newParent);
-                });
-            });
-        });
-    }
-);

platform/entanglement/test/policies/MovePolicySpec.js

@@ -1,124 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define([
-    '../../src/policies/MovePolicy',
-    '../DomainObjectFactory'
-], function (MovePolicy, domainObjectFactory) {
-
-    describe("MovePolicy", function () {
-        var testMetadata,
-            testContext,
-            mockDomainObject,
-            mockParent,
-            mockParentType,
-            mockType,
-            mockAction,
-            policy;
-
-        beforeEach(function () {
-            var mockContextCapability =
-                    jasmine.createSpyObj('context', ['getParent']);
-
-            mockType =
-                jasmine.createSpyObj('type', ['hasFeature']);
-            mockParentType =
-                jasmine.createSpyObj('parent-type', ['hasFeature']);
-
-            testMetadata = {};
-
-            mockDomainObject = domainObjectFactory({
-                capabilities: {
-                    context: mockContextCapability,
-                    type: mockType
-                }
-            });
-            mockParent = domainObjectFactory({
-                capabilities: {
-                    type: mockParentType
-                }
-            });
-
-            mockContextCapability.getParent.and.returnValue(mockParent);
-
-            mockType.hasFeature.and.callFake(function (feature) {
-                return feature === 'creation';
-            });
-            mockParentType.hasFeature.and.callFake(function (feature) {
-                return feature === 'creation';
-            });
-
-            mockAction = jasmine.createSpyObj('action', ['getMetadata']);
-            mockAction.getMetadata.and.returnValue(testMetadata);
-
-            testContext = { domainObject: mockDomainObject };
-
-            policy = new MovePolicy();
-        });
-
-        describe("for move actions", function () {
-            beforeEach(function () {
-                testMetadata.key = 'move';
-            });
-
-            describe("when an object is non-modifiable", function () {
-                beforeEach(function () {
-                    mockType.hasFeature.and.returnValue(false);
-                });
-
-                it("disallows the action", function () {
-                    expect(policy.allow(mockAction, testContext)).toBe(false);
-                });
-            });
-
-            describe("when a parent is non-modifiable", function () {
-                beforeEach(function () {
-                    mockParentType.hasFeature.and.returnValue(false);
-                });
-
-                it("disallows the action", function () {
-                    expect(policy.allow(mockAction, testContext)).toBe(false);
-                });
-            });
-
-            describe("when an object and its parent are modifiable", function () {
-                it("allows the action", function () {
-                    expect(policy.allow(mockAction, testContext)).toBe(true);
-                });
-            });
-        });
-
-        describe("for other actions", function () {
-            beforeEach(function () {
-                testMetadata.key = 'foo';
-            });
-
-            it("simply allows the action", function () {
-                expect(policy.allow(mockAction, testContext)).toBe(true);
-                mockType.hasFeature.and.returnValue(false);
-                expect(policy.allow(mockAction, testContext)).toBe(true);
-                mockParentType.hasFeature.and.returnValue(false);
-                expect(policy.allow(mockAction, testContext)).toBe(true);
-            });
-        });
-    });
-});

platform/entanglement/test/services/MockMoveService.js

@@ -1,96 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    function () {
-
-        /**
-         * MockMoveService provides the same interface as the moveService,
-         * returning promises where it would normally do so.  At it's core,
-         * it is a jasmine spy object, but it also tracks the promises it
-         * returns and provides shortcut methods for resolving those promises
-         * synchronously.
-         *
-         * Usage:
-         *
-         * ```javascript
-         * var moveService = new MockMoveService();
-         *
-         * // validate is a standard jasmine spy.
-         * moveService.validate.and.returnValue(true);
-         * var isValid = moveService.validate(object, parentCandidate);
-         * expect(isValid).toBe(true);
-         *
-         * // perform returns promises and tracks them.
-         * var whenCopied = jasmine.createSpy('whenCopied');
-         * moveService.perform(object, parentObject).then(whenCopied);
-         * expect(whenCopied).not.toHaveBeenCalled();
-         * moveService.perform.calls.mostRecent().resolve('someArg');
-         * expect(whenCopied).toHaveBeenCalledWith('someArg');
-         * ```
-         */
-        function MockMoveService() {
-            // track most recent call of a function,
-            // perform automatically returns
-            var mockMoveService = jasmine.createSpyObj(
-                'MockMoveService',
-                [
-                    'validate',
-                    'perform'
-                ]
-            );
-
-            mockMoveService.perform.and.callFake(() => {
-                var performPromise,
-                    callExtensions,
-                    spy;
-
-                performPromise = jasmine.createSpyObj(
-                    'performPromise',
-                    ['then']
-                );
-
-                callExtensions = {
-                    promise: performPromise,
-                    resolve: function (resolveWith) {
-                        performPromise.then.calls.all().forEach(function (call) {
-                            call.args[0](resolveWith);
-                        });
-                    }
-                };
-
-                spy = mockMoveService.perform;
-
-                Object.keys(callExtensions).forEach(function (key) {
-                    spy.calls.mostRecent()[key] = callExtensions[key];
-                    spy.calls.all()[spy.calls.count() - 1][key] = callExtensions[key];
-                });
-
-                return performPromise;
-            });
-
-            return mockMoveService;
-        }
-
-        return MockMoveService;
-    }
-);

platform/entanglement/test/services/MoveServiceSpec.js

@@ -1,260 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2020, United States Government
- * as represented by the Administrator of the National Aeronautics and Space
- * Administration. All rights reserved.
- *
- * Open MCT is licensed under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * http://www.apache.org/licenses/LICENSE-2.0.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- * Open MCT includes source code licensed under additional open source
- * licenses. See the Open Source Licenses file (LICENSES.md) included with
- * this source code distribution or the Licensing information page available
- * at runtime from the About dialog for additional information.
- *****************************************************************************/
-
-define(
-    [
-        '../../src/services/MoveService',
-        '../services/MockLinkService',
-        '../DomainObjectFactory',
-        '../ControlledPromise'
-    ],
-    function (
-        MoveService,
-        MockLinkService,
-        domainObjectFactory,
-        ControlledPromise
-    ) {
-
-        xdescribe("MoveService", function () {
-
-            var moveService,
-                policyService,
-                object,
-                objectContextCapability,
-                currentParent,
-                parentCandidate,
-                linkService;
-
-            beforeEach(function () {
-                objectContextCapability = jasmine.createSpyObj(
-                    'objectContextCapability',
-                    [
-                        'getParent'
-                    ]
-                );
-
-                object = domainObjectFactory({
-                    name: 'object',
-                    id: 'a',
-                    capabilities: {
-                        context: objectContextCapability,
-                        type: { type: 'object' }
-                    }
-                });
-
-                currentParent = domainObjectFactory({
-                    name: 'currentParent',
-                    id: 'b'
-                });
-
-                objectContextCapability.getParent.and.returnValue(currentParent);
-
-                parentCandidate = domainObjectFactory({
-                    name: 'parentCandidate',
-                    model: { composition: [] },
-                    id: 'c',
-                    capabilities: {
-                        type: { type: 'parentCandidate' }
-                    }
-                });
-                policyService = jasmine.createSpyObj(
-                    'policyService',
-                    ['allow']
-                );
-                linkService = new MockLinkService();
-                policyService.allow.and.returnValue(true);
-                moveService = new MoveService(policyService, linkService);
-            });
-
-            describe("validate", function () {
-                var validate;
-
-                beforeEach(function () {
-                    validate = function () {
-                        return moveService.validate(object, parentCandidate);
-                    };
-                });
-
-                it("does not allow an invalid parent", function () {
-                    parentCandidate = undefined;
-                    expect(validate()).toBe(false);
-                    parentCandidate = {};
-                    expect(validate()).toBe(false);
-                });
-
-                it("does not allow moving to current parent", function () {
-                    parentCandidate.id = currentParent.id = 'xyz';
-                    expect(validate()).toBe(false);
-                });
-
-                it("does not allow moving to self", function () {
-                    object.id = parentCandidate.id = 'xyz';
-                    expect(validate()).toBe(false);
-                });
-
-                it("does not allow moving to the same location", function () {
-                    object.id = 'abc';
-                    parentCandidate.model.composition = ['abc'];
-                    expect(validate()).toBe(false);
-                });
-
-                describe("defers to policyService", function () {
-
-                    it("calls policy service with correct args", function () {
-                        validate();
-                        expect(policyService.allow).toHaveBeenCalledWith(
-                            "composition",
-                            parentCandidate,
-                            object
-                        );
-                    });
-
-                    it("and returns false", function () {
-                        policyService.allow.and.returnValue(false);
-                        expect(validate()).toBe(false);
-                    });
-
-                    it("and returns true", function () {
-                        policyService.allow.and.returnValue(true);
-                        expect(validate()).toBe(true);
-                    });
-                });
-            });
-
-            describe("perform", function () {
-
-                var actionCapability,
-                    locationCapability,
-                    locationPromise,
-                    newParent,
-                    moveResult;
-
-                beforeEach(function () {
-                    newParent = parentCandidate;
-
-                    actionCapability = jasmine.createSpyObj(
-                        'actionCapability',
-                        ['perform']
-                    );
-
-                    locationCapability = jasmine.createSpyObj(
-                        'locationCapability',
-                        [
-                            'isOriginal',
-                            'setPrimaryLocation',
-                            'getContextualLocation'
-                        ]
-                    );
-
-                    locationPromise = new ControlledPromise();
-                    locationCapability.setPrimaryLocation
-                        .and.returnValue(locationPromise);
-
-                    object = domainObjectFactory({
-                        name: 'object',
-                        capabilities: {
-                            action: actionCapability,
-                            location: locationCapability,
-                            context: objectContextCapability,
-                            type: { type: 'object' }
-                        }
-                    });
-                    moveResult = moveService.perform(object, newParent);
-                });
-
-                it("links object to newParent", function () {
-                    expect(linkService.perform).toHaveBeenCalledWith(
-                        object,
-                        newParent
-                    );
-                });
-
-                it("returns a promise", function () {
-                    expect(moveResult.then).toEqual(jasmine.any(Function));
-                });
-
-                it("waits for result of link", function () {
-                    expect(linkService.perform.calls.mostRecent().promise.then)
-                        .toHaveBeenCalledWith(jasmine.any(Function));
-                });
-
-                it("throws an error when performed on invalid inputs", function () {
-                    function perform() {
-                        moveService.perform(object, newParent);
-                    }
-
-                    spyOn(moveService, "validate");
-                    moveService.validate.and.returnValue(true);
-                    expect(perform).not.toThrow();
-                    moveService.validate.and.returnValue(false);
-                    expect(perform).toThrow();
-                });
-
-                describe("when moving an original", function () {
-                    beforeEach(function () {
-                        locationCapability.getContextualLocation
-                            .and.returnValue('new-location');
-                        locationCapability.isOriginal.and.returnValue(true);
-                        linkService.perform.calls.mostRecent().promise.resolve();
-                    });
-
-                    it("updates location", function () {
-                        expect(locationCapability.setPrimaryLocation)
-                            .toHaveBeenCalledWith('new-location');
-                    });
-
-                    describe("after location update", function () {
-                        beforeEach(function () {
-                            locationPromise.resolve();
-                        });
-
-                        it("removes object from parent without user warning dialog", function () {
-                            expect(actionCapability.perform)
-                                .toHaveBeenCalledWith('remove', true);
-                        });
-
-                    });
-
-                });
-
-                describe("when moving a link", function () {
-                    beforeEach(function () {
-                        locationCapability.isOriginal.and.returnValue(false);
-                        linkService.perform.calls.mostRecent().promise.resolve();
-                    });
-
-                    it("does not update location", function () {
-                        expect(locationCapability.setPrimaryLocation)
-                            .not
-                            .toHaveBeenCalled();
-                    });
-
-                    it("removes object from parent without user warning dialog", function () {
-                        expect(actionCapability.perform)
-                            .toHaveBeenCalledWith('remove', true);
-                    });
-                });
-
-            });
-        });
-    }
-);

src/MCT.js

@@ -46,6 +46,8 @@ define([
     './api/Branding',
     './plugins/licenses/plugin',
     './plugins/remove/plugin',
+    './plugins/move/plugin',
+    './plugins/duplicate/plugin',
     'vue'
 ], function (
     EventEmitter,
@@ -73,6 +75,8 @@ define([
     BrandingAPI,
     LicensesPlugin,
     RemoveActionPlugin,
+    MoveActionPlugin,
+    DuplicateActionPlugin,
     Vue
 ) {
     /**
@@ -263,6 +267,8 @@ define([
         this.install(LegacyIndicatorsPlugin());
         this.install(LicensesPlugin.default());
         this.install(RemoveActionPlugin.default());
+        this.install(MoveActionPlugin.default());
+        this.install(DuplicateActionPlugin.default());
         this.install(this.plugins.FolderView());
         this.install(this.plugins.Tabs());
         this.install(ImageryPlugin.default());
@@ -276,6 +282,7 @@ define([
         this.install(this.plugins.NotificationIndicator());
         this.install(this.plugins.NewFolderAction());
         this.install(this.plugins.ViewDatumAction());
+        this.install(this.plugins.ObjectInterceptors());
     }
 
     MCT.prototype = Object.create(EventEmitter.prototype);

src/api/actions/ActionCollectionSpec.js

@@ -0,0 +1,225 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+import ActionCollection from './ActionCollection';
+import { createOpenMct, resetApplicationState } from '../../utils/testing';
+
+describe('The ActionCollection', () => {
+    let openmct;
+    let actionCollection;
+    let mockApplicableActions;
+    let mockObjectPath;
+    let mockView;
+
+    beforeEach(() => {
+        openmct = createOpenMct();
+        mockObjectPath = [
+            {
+                name: 'mock folder',
+                type: 'fake-folder',
+                identifier: {
+                    key: 'mock-folder',
+                    namespace: ''
+                }
+            },
+            {
+                name: 'mock parent folder',
+                type: 'fake-folder',
+                identifier: {
+                    key: 'mock-parent-folder',
+                    namespace: ''
+                }
+            }
+        ];
+        mockView = {
+            getViewContext: () => {
+                return {
+                    onlyAppliesToTestCase: true
+                };
+            }
+        };
+        mockApplicableActions = {
+            'test-action-object-path': {
+                name: 'Test Action Object Path',
+                key: 'test-action-object-path',
+                cssClass: 'test-action-object-path',
+                description: 'This is a test action for object path',
+                group: 'action',
+                priority: 9,
+                appliesTo: (objectPath) => {
+                    if (objectPath.length) {
+                        return objectPath[0].type === 'fake-folder';
+                    }
+
+                    return false;
+                },
+                invoke: () => {
+                }
+            },
+            'test-action-view': {
+                name: 'Test Action View',
+                key: 'test-action-view',
+                cssClass: 'test-action-view',
+                description: 'This is a test action for view',
+                group: 'action',
+                priority: 9,
+                showInStatusBar: true,
+                appliesTo: (objectPath, view = {}) => {
+                    if (view.getViewContext) {
+                        let viewContext = view.getViewContext();
+
+                        return viewContext.onlyAppliesToTestCase;
+                    }
+
+                    return false;
+                },
+                invoke: () => {
+                }
+            }
+        };
+
+        actionCollection = new ActionCollection(mockApplicableActions, mockObjectPath, mockView, openmct);
+    });
+
+    afterEach(() => {
+        actionCollection.destroy();
+        resetApplicationState(openmct);
+    });
+
+    describe("disable method invoked with action keys", () => {
+        it("marks those actions as isDisabled", () => {
+            let actionKey = 'test-action-object-path';
+            let actionsObject = actionCollection.getActionsObject();
+            let action = actionsObject[actionKey];
+
+            expect(action.isDisabled).toBeFalsy();
+
+            actionCollection.disable([actionKey]);
+            actionsObject = actionCollection.getActionsObject();
+            action = actionsObject[actionKey];
+
+            expect(action.isDisabled).toBeTrue();
+        });
+    });
+
+    describe("enable method invoked with action keys", () => {
+        it("marks the isDisabled property as false", () => {
+            let actionKey = 'test-action-object-path';
+
+            actionCollection.disable([actionKey]);
+
+            let actionsObject = actionCollection.getActionsObject();
+            let action = actionsObject[actionKey];
+
+            expect(action.isDisabled).toBeTrue();
+
+            actionCollection.enable([actionKey]);
+            actionsObject = actionCollection.getActionsObject();
+            action = actionsObject[actionKey];
+
+            expect(action.isDisabled).toBeFalse();
+        });
+    });
+
+    describe("hide method invoked with action keys", () => {
+        it("marks those actions as isHidden", () => {
+            let actionKey = 'test-action-object-path';
+            let actionsObject = actionCollection.getActionsObject();
+            let action = actionsObject[actionKey];
+
+            expect(action.isHidden).toBeFalsy();
+
+            actionCollection.hide([actionKey]);
+            actionsObject = actionCollection.getActionsObject();
+            action = actionsObject[actionKey];
+
+            expect(action.isHidden).toBeTrue();
+        });
+    });
+
+    describe("show method invoked with action keys", () => {
+        it("marks the isHidden property as false", () => {
+            let actionKey = 'test-action-object-path';
+
+            actionCollection.hide([actionKey]);
+
+            let actionsObject = actionCollection.getActionsObject();
+            let action = actionsObject[actionKey];
+
+            expect(action.isHidden).toBeTrue();
+
+            actionCollection.show([actionKey]);
+            actionsObject = actionCollection.getActionsObject();
+            action = actionsObject[actionKey];
+
+            expect(action.isHidden).toBeFalse();
+        });
+    });
+
+    describe("getVisibleActions method", () => {
+        it("returns an array of non hidden actions", () => {
+            let action1Key = 'test-action-object-path';
+            let action2Key = 'test-action-view';
+
+            actionCollection.hide([action1Key]);
+
+            let visibleActions = actionCollection.getVisibleActions();
+
+            expect(Array.isArray(visibleActions)).toBeTrue();
+            expect(visibleActions.length).toEqual(1);
+            expect(visibleActions[0].key).toEqual(action2Key);
+
+            actionCollection.show([action1Key]);
+            visibleActions = actionCollection.getVisibleActions();
+
+            expect(visibleActions.length).toEqual(2);
+        });
+    });
+
+    describe("getStatusBarActions method", () => {
+        it("returns an array of non disabled, non hidden statusBar actions", () => {
+            let action2Key = 'test-action-view';
+
+            let statusBarActions = actionCollection.getStatusBarActions();
+
+            expect(Array.isArray(statusBarActions)).toBeTrue();
+            expect(statusBarActions.length).toEqual(1);
+            expect(statusBarActions[0].key).toEqual(action2Key);
+
+            actionCollection.disable([action2Key]);
+            statusBarActions = actionCollection.getStatusBarActions();
+
+            expect(statusBarActions.length).toEqual(0);
+
+            actionCollection.enable([action2Key]);
+            statusBarActions = actionCollection.getStatusBarActions();
+
+            expect(statusBarActions.length).toEqual(1);
+            expect(statusBarActions[0].key).toEqual(action2Key);
+
+            actionCollection.hide([action2Key]);
+            statusBarActions = actionCollection.getStatusBarActions();
+
+            expect(statusBarActions.length).toEqual(0);
+        });
+    });
+});

src/api/actions/ActionsAPISpec.js

@@ -22,22 +22,41 @@
 
 import ActionsAPI from './ActionsAPI';
 import { createOpenMct, resetApplicationState } from '../../utils/testing';
+import ActionCollection from './ActionCollection';
 
 describe('The Actions API', () => {
     let openmct;
     let actionsAPI;
     let mockAction;
     let mockObjectPath;
+    let mockObjectPathAction;
     let mockViewContext1;
 
     beforeEach(() => {
         openmct = createOpenMct();
         actionsAPI = new ActionsAPI(openmct);
+        mockObjectPathAction = {
+            name: 'Test Action Object Path',
+            key: 'test-action-object-path',
+            cssClass: 'test-action-object-path',
+            description: 'This is a test action for object path',
+            group: 'action',
+            priority: 9,
+            appliesTo: (objectPath) => {
+                if (objectPath.length) {
+                    return objectPath[0].type === 'fake-folder';
+                }
+
+                return false;
+            },
+            invoke: () => {
+            }
+        };
         mockAction = {
-            name: 'Test Action',
-            key: 'test-action',
-            cssClass: 'test-action',
-            description: 'This is a test action',
+            name: 'Test Action View',
+            key: 'test-action-view',
+            cssClass: 'test-action-view',
+            description: 'This is a test action for view',
             group: 'action',
             priority: 9,
             appliesTo: (objectPath, view = {}) => {
@@ -45,8 +64,6 @@ describe('The Actions API', () => {
                     let viewContext = view.getViewContext();
 
                     return viewContext.onlyAppliesToTestCase;
-                } else if (objectPath.length) {
-                    return objectPath[0].type === 'fake-folder';
                 }
 
                 return false;
@@ -100,9 +117,32 @@ describe('The Actions API', () => {
     describe("get method", () => {
         beforeEach(() => {
             actionsAPI.register(mockAction);
+            actionsAPI.register(mockObjectPathAction);
         });
 
-        it("returns an object with relevant actions when invoked with objectPath only", () => {
+        it("returns an ActionCollection when invoked with an objectPath only", () => {
+            let actionCollection = actionsAPI.get(mockObjectPath);
+            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
+
+            expect(instanceOfActionCollection).toBeTrue();
+        });
+
+        it("returns an ActionCollection when invoked with an objectPath and view", () => {
+            let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
+            let instanceOfActionCollection = actionCollection instanceof ActionCollection;
+
+            expect(instanceOfActionCollection).toBeTrue();
+        });
+
+        it("returns relevant actions when invoked with objectPath only", () => {
+            let actionCollection = actionsAPI.get(mockObjectPath);
+            let action = actionCollection.getActionsObject()[mockObjectPathAction.key];
+
+            expect(action.key).toEqual(mockObjectPathAction.key);
+            expect(action.name).toEqual(mockObjectPathAction.name);
+        });
+
+        it("returns relevant actions when invoked with objectPath and view", () => {
             let actionCollection = actionsAPI.get(mockObjectPath, mockViewContext1);
             let action = actionCollection.getActionsObject()[mockAction.key];
 

src/api/objects/InterceptorRegistry.js

@@ -0,0 +1,66 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+export default class InterceptorRegistry {
+    /**
+     * A InterceptorRegistry maintains the definitions for different interceptors that may be invoked on domain objects.
+     * @interface InterceptorRegistry
+     * @memberof module:openmct
+     */
+    constructor() {
+        this.interceptors = [];
+    }
+
+    /**
+     * @interface InterceptorDef
+     * @property {function} appliesTo function that determines if this interceptor should be called for the given identifier/object
+     * @property {function} invoke function that transforms the provided domain object and returns the transformed domain object
+     * @property {function} priority the priority for this interceptor. A higher number returned has more weight than a lower number
+     * @memberof module:openmct InterceptorRegistry#
+     */
+
+    /**
+     * Register a new object interceptor.
+     *
+     * @param {module:openmct.InterceptorDef} interceptorDef the interceptor to add
+     * @method addInterceptor
+     * @memberof module:openmct.InterceptorRegistry#
+     */
+    addInterceptor(interceptorDef) {
+        //TODO: sort by priority
+        this.interceptors.push(interceptorDef);
+    }
+
+    /**
+     * Retrieve all interceptors applicable to a domain object.
+     * @method getInterceptors
+     * @returns [module:openmct.InterceptorDef] the registered interceptors for this identifier/object
+     * @memberof module:openmct.InterceptorRegistry#
+     */
+    getInterceptors(identifier, object) {
+        return this.interceptors.filter(interceptor => {
+            return typeof interceptor.appliesTo === 'function'
+                && interceptor.appliesTo(identifier, object);
+        });
+    }
+
+}
+

src/api/objects/ObjectAPI.js

@@ -26,6 +26,7 @@ define([
     './MutableObject',
     './RootRegistry',
     './RootObjectProvider',
+    './InterceptorRegistry',
     'EventEmitter'
 ], function (
     _,
@@ -33,6 +34,7 @@ define([
     MutableObject,
     RootRegistry,
     RootObjectProvider,
+    InterceptorRegistry,
     EventEmitter
 ) {
 
@@ -48,6 +50,7 @@ define([
         this.rootRegistry = new RootRegistry();
         this.rootProvider = new RootObjectProvider.default(this.rootRegistry);
         this.cache = {};
+        this.interceptorRegistry = new InterceptorRegistry.default();
     }
 
     /**
@@ -177,6 +180,10 @@ define([
 
         return objectPromise.then(result => {
             delete this.cache[keystring];
+            const interceptors = this.listGetInterceptors(identifier, result);
+            interceptors.forEach(interceptor => {
+                result = interceptor.invoke(identifier, result);
+            });
 
             return result;
         });
@@ -312,6 +319,27 @@ define([
         });
     };
 
+    /**
+     * Register an object interceptor that transforms a domain object requested via module:openmct.ObjectAPI.get
+     * The domain object will be transformed after it is retrieved from the persistence store
+     * The domain object will be transformed only if the interceptor is applicable to that domain object as defined by the InterceptorDef
+     *
+     * @param {module:openmct.InterceptorDef} interceptorDef the interceptor definition to add
+     * @method addGetInterceptor
+     * @memberof module:openmct.InterceptorRegistry#
+     */
+    ObjectAPI.prototype.addGetInterceptor = function (interceptorDef) {
+        this.interceptorRegistry.addInterceptor(interceptorDef);
+    };
+
+    /**
+     * Retrieve the interceptors for a given domain object.
+     * @private
+     */
+    ObjectAPI.prototype.listGetInterceptors = function (identifier, object) {
+        return this.interceptorRegistry.getInterceptors(identifier, object);
+    };
+
     /**
      * Uniquely identifies a domain object.
      *

src/api/objects/ObjectAPISpec.js

@@ -63,12 +63,51 @@ describe("The Object API", () => {
     describe("The get function", () => {
         describe("when a provider is available", () => {
             let mockProvider;
+            let mockInterceptor;
+            let anotherMockInterceptor;
+            let notApplicableMockInterceptor;
             beforeEach(() => {
                 mockProvider = jasmine.createSpyObj("mock provider", [
                     "get"
                 ]);
                 mockProvider.get.and.returnValue(Promise.resolve(mockDomainObject));
+
+                mockInterceptor = jasmine.createSpyObj("mock interceptor", [
+                    "appliesTo",
+                    "invoke"
+                ]);
+                mockInterceptor.appliesTo.and.returnValue(true);
+                mockInterceptor.invoke.and.callFake((identifier, object) => {
+                    return Object.assign({
+                        changed: true
+                    }, object);
+                });
+
+                anotherMockInterceptor = jasmine.createSpyObj("another mock interceptor", [
+                    "appliesTo",
+                    "invoke"
+                ]);
+                anotherMockInterceptor.appliesTo.and.returnValue(true);
+                anotherMockInterceptor.invoke.and.callFake((identifier, object) => {
+                    return Object.assign({
+                        alsoChanged: true
+                    }, object);
+                });
+
+                notApplicableMockInterceptor = jasmine.createSpyObj("not applicable mock interceptor", [
+                    "appliesTo",
+                    "invoke"
+                ]);
+                notApplicableMockInterceptor.appliesTo.and.returnValue(false);
+                notApplicableMockInterceptor.invoke.and.callFake((identifier, object) => {
+                    return Object.assign({
+                        shouldNotBeChanged: true
+                    }, object);
+                });
                 objectAPI.addProvider(TEST_NAMESPACE, mockProvider);
+                objectAPI.addGetInterceptor(mockInterceptor);
+                objectAPI.addGetInterceptor(anotherMockInterceptor);
+                objectAPI.addGetInterceptor(notApplicableMockInterceptor);
             });
 
             it("Caches multiple requests for the same object", () => {
@@ -78,6 +117,15 @@ describe("The Object API", () => {
                 objectAPI.get(mockDomainObject.identifier);
                 expect(mockProvider.get.calls.count()).toBe(1);
             });
+
+            it("applies any applicable interceptors", () => {
+                expect(mockDomainObject.changed).toBeUndefined();
+                objectAPI.get(mockDomainObject.identifier).then((object) => {
+                    expect(object.changed).toBeTrue();
+                    expect(object.alsoChanged).toBeTrue();
+                    expect(object.shouldNotBeChanged).toBeUndefined();
+                });
+            });
         });
     });
 });

src/plugins/autoflow/AutoflowTabularPluginSpec.js

@@ -19,342 +19,352 @@
  * this source code distribution or the Licensing information page available
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
+import AutoflowTabularPlugin from './AutoflowTabularPlugin';
+import AutoflowTabularConstants from './AutoflowTabularConstants';
+import $ from 'zepto';
+import DOMObserver from './dom-observer';
+import {
+    createOpenMct,
+    resetApplicationState,
+    spyOnBuiltins
+} from 'utils/testing';
 
-define([
-    './AutoflowTabularPlugin',
-    './AutoflowTabularConstants',
-    '../../MCT',
-    'zepto',
-    './dom-observer'
-], function (AutoflowTabularPlugin, AutoflowTabularConstants, MCT, $, DOMObserver) {
-    describe("AutoflowTabularPlugin", function () {
-        let testType;
-        let testObject;
-        let mockmct;
+describe("AutoflowTabularPlugin", () => {
+    let testType;
+    let testObject;
+    let mockmct;
 
-        beforeEach(function () {
-            testType = "some-type";
-            testObject = { type: testType };
-            mockmct = new MCT();
-            spyOn(mockmct.composition, 'get');
-            spyOn(mockmct.objectViews, 'addProvider');
-            spyOn(mockmct.telemetry, 'getMetadata');
-            spyOn(mockmct.telemetry, 'getValueFormatter');
-            spyOn(mockmct.telemetry, 'limitEvaluator');
-            spyOn(mockmct.telemetry, 'request');
-            spyOn(mockmct.telemetry, 'subscribe');
+    beforeEach(() => {
+        testType = "some-type";
+        testObject = { type: testType };
+        mockmct = createOpenMct();
+        spyOn(mockmct.composition, 'get');
+        spyOn(mockmct.objectViews, 'addProvider');
+        spyOn(mockmct.telemetry, 'getMetadata');
+        spyOn(mockmct.telemetry, 'getValueFormatter');
+        spyOn(mockmct.telemetry, 'limitEvaluator');
+        spyOn(mockmct.telemetry, 'request');
+        spyOn(mockmct.telemetry, 'subscribe');
 
-            const plugin = new AutoflowTabularPlugin({ type: testType });
-            plugin(mockmct);
+        const plugin = new AutoflowTabularPlugin({ type: testType });
+        plugin(mockmct);
+    });
+
+    afterEach(() => {
+        resetApplicationState(mockmct);
+    });
+
+    it("installs a view provider", () => {
+        expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
+    });
+
+    describe("installs a view provider which", () => {
+        let provider;
+
+        beforeEach(() => {
+            provider =
+                mockmct.objectViews.addProvider.calls.mostRecent().args[0];
         });
 
-        it("installs a view provider", function () {
-            expect(mockmct.objectViews.addProvider).toHaveBeenCalled();
+        it("applies its view to the type from options", () => {
+            expect(provider.canView(testObject)).toBe(true);
         });
 
-        describe("installs a view provider which", function () {
-            let provider;
+        it("does not apply to other types", () => {
+            expect(provider.canView({ type: 'foo' })).toBe(false);
+        });
 
-            beforeEach(function () {
-                provider =
-                    mockmct.objectViews.addProvider.calls.mostRecent().args[0];
-            });
+        describe("provides a view which", () => {
+            let testKeys;
+            let testChildren;
+            let testContainer;
+            let testHistories;
+            let mockComposition;
+            let mockMetadata;
+            let mockEvaluator;
+            let mockUnsubscribes;
+            let callbacks;
+            let view;
+            let domObserver;
 
-            it("applies its view to the type from options", function () {
-                expect(provider.canView(testObject)).toBe(true);
-            });
+            function waitsForChange() {
+                return new Promise(function (resolve) {
+                    window.requestAnimationFrame(resolve);
+                });
+            }
 
-            it("does not apply to other types", function () {
-                expect(provider.canView({ type: 'foo' })).toBe(false);
-            });
+            function emitEvent(mockEmitter, type, event) {
+                mockEmitter.on.calls.all().forEach((call) => {
+                    if (call.args[0] === type) {
+                        call.args[1](event);
+                    }
+                });
+            }
 
-            describe("provides a view which", function () {
-                let testKeys;
-                let testChildren;
-                let testContainer;
-                let testHistories;
-                let mockComposition;
-                let mockMetadata;
-                let mockEvaluator;
-                let mockUnsubscribes;
-                let callbacks;
-                let view;
-                let domObserver;
+            beforeEach((done) => {
+                callbacks = {};
 
-                function waitsForChange() {
-                    return new Promise(function (resolve) {
-                        window.requestAnimationFrame(resolve);
+                spyOnBuiltins(['requestAnimationFrame']);
+                window.requestAnimationFrame.and.callFake((callBack) => {
+                    callBack();
+                });
+
+                testObject = { type: 'some-type' };
+                testKeys = ['abc', 'def', 'xyz'];
+                testChildren = testKeys.map((key) => {
+                    return {
+                        identifier: {
+                            namespace: "test",
+                            key: key
+                        },
+                        name: "Object " + key
+                    };
+                });
+                testContainer = $('<div>')[0];
+                domObserver = new DOMObserver(testContainer);
+
+                testHistories = testKeys.reduce((histories, key, index) => {
+                    histories[key] = {
+                        key: key,
+                        range: index + 10,
+                        domain: key + index
+                    };
+
+                    return histories;
+                }, {});
+
+                mockComposition =
+                    jasmine.createSpyObj('composition', ['load', 'on', 'off']);
+                mockMetadata =
+                    jasmine.createSpyObj('metadata', ['valuesForHints']);
+
+                mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
+                mockUnsubscribes = testKeys.reduce((map, key) => {
+                    map[key] = jasmine.createSpy('unsubscribe-' + key);
+
+                    return map;
+                }, {});
+
+                mockmct.composition.get.and.returnValue(mockComposition);
+                mockComposition.load.and.callFake(() => {
+                    testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
+
+                    return Promise.resolve(testChildren);
+                });
+
+                mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
+                mockmct.telemetry.getValueFormatter.and.callFake((metadatum) => {
+                    const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
+                    mockFormatter.format.and.callFake((datum) => {
+                        return datum[metadatum.hint];
                     });
+
+                    return mockFormatter;
+                });
+                mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
+                mockmct.telemetry.subscribe.and.callFake((obj, callback) => {
+                    const key = obj.identifier.key;
+                    callbacks[key] = callback;
+
+                    return mockUnsubscribes[key];
+                });
+                mockmct.telemetry.request.and.callFake((obj, request) => {
+                    const key = obj.identifier.key;
+
+                    return Promise.resolve([testHistories[key]]);
+                });
+                mockMetadata.valuesForHints.and.callFake((hints) => {
+                    return [{ hint: hints[0] }];
+                });
+
+                view = provider.view(testObject);
+                view.show(testContainer);
+
+                return done();
+            });
+
+            afterEach(() => {
+                domObserver.destroy();
+            });
+
+            it("populates its container", () => {
+                expect(testContainer.children.length > 0).toBe(true);
+            });
+
+            describe("when rows have been populated", () => {
+                function rowsMatch() {
+                    const rows = $(testContainer).find(".l-autoflow-row").length;
+
+                    return rows === testChildren.length;
                 }
 
-                function emitEvent(mockEmitter, type, event) {
-                    mockEmitter.on.calls.all().forEach(function (call) {
-                        if (call.args[0] === type) {
-                            call.args[1](event);
-                        }
-                    });
+                it("shows one row per child object", () => {
+                    return domObserver.when(rowsMatch);
+                });
+
+                // it("adds rows on composition change", () => {
+                //     const child = {
+                //         identifier: {
+                //             namespace: "test",
+                //             key: "123"
+                //         },
+                //         name: "Object 123"
+                //     };
+                //     testChildren.push(child);
+                //     emitEvent(mockComposition, 'add', child);
+
+                //     return domObserver.when(rowsMatch);
+                // });
+
+                it("removes rows on composition change", () => {
+                    const child = testChildren.pop();
+                    emitEvent(mockComposition, 'remove', child.identifier);
+
+                    return domObserver.when(rowsMatch);
+                });
+            });
+
+            it("removes subscriptions when destroyed", () => {
+                testKeys.forEach((key) => {
+                    expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
+                });
+                view.destroy();
+                testKeys.forEach((key) => {
+                    expect(mockUnsubscribes[key]).toHaveBeenCalled();
+                });
+            });
+
+            it("provides a button to change column width", () => {
+                const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
+                const nextWidth =
+                    initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;
+
+                expect($(testContainer).find('.l-autoflow-col').css('width'))
+                    .toEqual(initialWidth + 'px');
+
+                $(testContainer).find('.change-column-width').click();
+
+                function widthHasChanged() {
+                    const width = $(testContainer).find('.l-autoflow-col').css('width');
+
+                    return width !== initialWidth + 'px';
                 }
 
-                beforeEach(function () {
-                    callbacks = {};
-
-                    testObject = { type: 'some-type' };
-                    testKeys = ['abc', 'def', 'xyz'];
-                    testChildren = testKeys.map(function (key) {
-                        return {
-                            identifier: {
-                                namespace: "test",
-                                key: key
-                            },
-                            name: "Object " + key
-                        };
+                return domObserver.when(widthHasChanged)
+                    .then(() => {
+                        expect($(testContainer).find('.l-autoflow-col').css('width'))
+                            .toEqual(nextWidth + 'px');
                     });
-                    testContainer = $('<div>')[0];
-                    domObserver = new DOMObserver(testContainer);
+            });
 
-                    testHistories = testKeys.reduce(function (histories, key, index) {
-                        histories[key] = {
-                            key: key,
-                            range: index + 10,
-                            domain: key + index
-                        };
+            it("subscribes to all child objects", () => {
+                testKeys.forEach((key) => {
+                    expect(callbacks[key]).toEqual(jasmine.any(Function));
+                });
+            });
 
-                        return histories;
-                    }, {});
+            it("displays historical telemetry", () => {
+                function rowTextDefined() {
+                    return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
+                }
 
-                    mockComposition =
-                        jasmine.createSpyObj('composition', ['load', 'on', 'off']);
-                    mockMetadata =
-                        jasmine.createSpyObj('metadata', ['valuesForHints']);
-
-                    mockEvaluator = jasmine.createSpyObj('evaluator', ['evaluate']);
-                    mockUnsubscribes = testKeys.reduce(function (map, key) {
-                        map[key] = jasmine.createSpy('unsubscribe-' + key);
-
-                        return map;
-                    }, {});
-
-                    mockmct.composition.get.and.returnValue(mockComposition);
-                    mockComposition.load.and.callFake(function () {
-                        testChildren.forEach(emitEvent.bind(null, mockComposition, 'add'));
-
-                        return Promise.resolve(testChildren);
+                return domObserver.when(rowTextDefined).then(() => {
+                    testKeys.forEach((key, index) => {
+                        const datum = testHistories[key];
+                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                        expect($cell.text()).toEqual(String(datum.range));
                     });
+                });
+            });
 
-                    mockmct.telemetry.getMetadata.and.returnValue(mockMetadata);
-                    mockmct.telemetry.getValueFormatter.and.callFake(function (metadatum) {
-                        const mockFormatter = jasmine.createSpyObj('formatter', ['format']);
-                        mockFormatter.format.and.callFake(function (datum) {
-                            return datum[metadatum.hint];
-                        });
-
-                        return mockFormatter;
-                    });
-                    mockmct.telemetry.limitEvaluator.and.returnValue(mockEvaluator);
-                    mockmct.telemetry.subscribe.and.callFake(function (obj, callback) {
-                        const key = obj.identifier.key;
-                        callbacks[key] = callback;
-
-                        return mockUnsubscribes[key];
-                    });
-                    mockmct.telemetry.request.and.callFake(function (obj, request) {
-                        const key = obj.identifier.key;
-
-                        return Promise.resolve([testHistories[key]]);
-                    });
-                    mockMetadata.valuesForHints.and.callFake(function (hints) {
-                        return [{ hint: hints[0] }];
-                    });
-
-                    view = provider.view(testObject);
-                    view.show(testContainer);
-
-                    return waitsForChange();
+            it("displays incoming telemetry", () => {
+                const testData = testKeys.map((key, index) => {
+                    return {
+                        key: key,
+                        range: index * 100,
+                        domain: key + index
+                    };
                 });
 
-                afterEach(function () {
-                    domObserver.destroy();
+                testData.forEach((datum) => {
+                    callbacks[datum.key](datum);
                 });
 
-                it("populates its container", function () {
-                    expect(testContainer.children.length > 0).toBe(true);
+                return waitsForChange().then(() => {
+                    testData.forEach((datum, index) => {
+                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                        expect($cell.text()).toEqual(String(datum.range));
+                    });
                 });
+            });
 
-                describe("when rows have been populated", function () {
-                    function rowsMatch() {
-                        const rows = $(testContainer).find(".l-autoflow-row").length;
-
-                        return rows === testChildren.length;
-                    }
-
-                    it("shows one row per child object", function () {
-                        return domObserver.when(rowsMatch);
-                    });
-
-                    it("adds rows on composition change", function () {
-                        const child = {
-                            identifier: {
-                                namespace: "test",
-                                key: "123"
-                            },
-                            name: "Object 123"
-                        };
-                        testChildren.push(child);
-                        emitEvent(mockComposition, 'add', child);
-
-                        return domObserver.when(rowsMatch);
-                    });
-
-                    it("removes rows on composition change", function () {
-                        const child = testChildren.pop();
-                        emitEvent(mockComposition, 'remove', child.identifier);
-
-                        return domObserver.when(rowsMatch);
+            it("updates classes for limit violations", () => {
+                const testClass = "some-limit-violation";
+                mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
+                testKeys.forEach((key) => {
+                    callbacks[key]({
+                        range: 'foo',
+                        domain: 'bar'
                     });
                 });
 
-                it("removes subscriptions when destroyed", function () {
-                    testKeys.forEach(function (key) {
-                        expect(mockUnsubscribes[key]).not.toHaveBeenCalled();
-                    });
-                    view.destroy();
-                    testKeys.forEach(function (key) {
-                        expect(mockUnsubscribes[key]).toHaveBeenCalled();
+                return waitsForChange().then(() => {
+                    testKeys.forEach((datum, index) => {
+                        const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
+                        expect($cell.hasClass(testClass)).toBe(true);
                     });
                 });
+            });
 
-                it("provides a button to change column width", function () {
-                    const initialWidth = AutoflowTabularConstants.INITIAL_COLUMN_WIDTH;
-                    const nextWidth =
-                        initialWidth + AutoflowTabularConstants.COLUMN_WIDTH_STEP;
+            it("automatically flows to new columns", () => {
+                const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
+                const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
+                const count = testKeys.length;
+                const $container = $(testContainer);
+                let promiseChain = Promise.resolve();
 
-                    expect($(testContainer).find('.l-autoflow-col').css('width'))
-                        .toEqual(initialWidth + 'px');
+                function columnsHaveAutoflowed() {
+                    const itemsHeight = $container.find('.l-autoflow-items').height();
+                    const availableHeight = itemsHeight - sliderHeight;
+                    const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
+                    const columns = Math.ceil(count / availableRows);
 
-                    $(testContainer).find('.change-column-width').click();
+                    return $container.find('.l-autoflow-col').length === columns;
+                }
 
-                    function widthHasChanged() {
-                        const width = $(testContainer).find('.l-autoflow-col').css('width');
-
-                        return width !== initialWidth + 'px';
-                    }
-
-                    return domObserver.when(widthHasChanged)
-                        .then(function () {
-                            expect($(testContainer).find('.l-autoflow-col').css('width'))
-                                .toEqual(nextWidth + 'px');
-                        });
+                $container.find('.abs').css({
+                    position: 'absolute',
+                    left: '0px',
+                    right: '0px',
+                    top: '0px',
+                    bottom: '0px'
                 });
+                $container.css({ position: 'absolute' });
 
-                it("subscribes to all child objects", function () {
-                    testKeys.forEach(function (key) {
-                        expect(callbacks[key]).toEqual(jasmine.any(Function));
-                    });
+                $container.appendTo(document.body);
+
+                function setHeight(height) {
+                    $container.css('height', height + 'px');
+
+                    return domObserver.when(columnsHaveAutoflowed);
+                }
+
+                for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
+                    // eslint-disable-next-line no-invalid-this
+                    promiseChain = promiseChain.then(setHeight.bind(this, height));
+                }
+
+                return promiseChain.then(() => {
+                    $container.remove();
                 });
+            });
 
-                it("displays historical telemetry", function () {
-                    function rowTextDefined() {
-                        return $(testContainer).find(".l-autoflow-item").filter(".r").text() !== "";
-                    }
-
-                    return domObserver.when(rowTextDefined).then(function () {
-                        testKeys.forEach(function (key, index) {
-                            const datum = testHistories[key];
-                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                            expect($cell.text()).toEqual(String(datum.range));
-                        });
-                    });
-                });
-
-                it("displays incoming telemetry", function () {
-                    const testData = testKeys.map(function (key, index) {
-                        return {
-                            key: key,
-                            range: index * 100,
-                            domain: key + index
-                        };
-                    });
-
-                    testData.forEach(function (datum) {
-                        callbacks[datum.key](datum);
-                    });
-
-                    return waitsForChange().then(function () {
-                        testData.forEach(function (datum, index) {
-                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                            expect($cell.text()).toEqual(String(datum.range));
-                        });
-                    });
-                });
-
-                it("updates classes for limit violations", function () {
-                    const testClass = "some-limit-violation";
-                    mockEvaluator.evaluate.and.returnValue({ cssClass: testClass });
-                    testKeys.forEach(function (key) {
-                        callbacks[key]({
-                            range: 'foo',
-                            domain: 'bar'
-                        });
-                    });
-
-                    return waitsForChange().then(function () {
-                        testKeys.forEach(function (datum, index) {
-                            const $cell = $(testContainer).find(".l-autoflow-row").eq(index).find(".r");
-                            expect($cell.hasClass(testClass)).toBe(true);
-                        });
-                    });
-                });
-
-                it("automatically flows to new columns", function () {
-                    const rowHeight = AutoflowTabularConstants.ROW_HEIGHT;
-                    const sliderHeight = AutoflowTabularConstants.SLIDER_HEIGHT;
-                    const count = testKeys.length;
-                    const $container = $(testContainer);
-                    let promiseChain = Promise.resolve();
-
-                    function columnsHaveAutoflowed() {
-                        const itemsHeight = $container.find('.l-autoflow-items').height();
-                        const availableHeight = itemsHeight - sliderHeight;
-                        const availableRows = Math.max(Math.floor(availableHeight / rowHeight), 1);
-                        const columns = Math.ceil(count / availableRows);
-
-                        return $container.find('.l-autoflow-col').length === columns;
-                    }
-
-                    $container.find('.abs').css({
-                        position: 'absolute',
-                        left: '0px',
-                        right: '0px',
-                        top: '0px',
-                        bottom: '0px'
-                    });
-                    $container.css({ position: 'absolute' });
-
-                    $container.appendTo(document.body);
-
-                    function setHeight(height) {
-                        $container.css('height', height + 'px');
-
-                        return domObserver.when(columnsHaveAutoflowed);
-                    }
-
-                    for (let height = 0; height < rowHeight * count * 2; height += rowHeight / 2) {
-                        // eslint-disable-next-line no-invalid-this
-                        promiseChain = promiseChain.then(setHeight.bind(this, height));
-                    }
-
-                    return promiseChain.then(function () {
-                        $container.remove();
-                    });
-                });
-
-                it("loads composition exactly once", function () {
-                    const testObj = testChildren.pop();
-                    emitEvent(mockComposition, 'remove', testObj.identifier);
-                    testChildren.push(testObj);
-                    emitEvent(mockComposition, 'add', testObj);
-                    expect(mockComposition.load.calls.count()).toEqual(1);
-                });
+            it("loads composition exactly once", () => {
+                const testObj = testChildren.pop();
+                emitEvent(mockComposition, 'remove', testObj.identifier);
+                testChildren.push(testObj);
+                emitEvent(mockComposition, 'add', testObj);
+                expect(mockComposition.load.calls.count()).toEqual(1);
             });
         });
     });

src/plugins/condition/Condition.js

@@ -75,7 +75,8 @@ export default class Condition extends EventEmitter {
             return;
         }
 
-        if (this.isTelemetryUsed(datum.id)) {
+        // if all the criteria in this condition have no telemetry, we want to force the condition result to evaluate
+        if (this.hasNoTelemetry() || this.isTelemetryUsed(datum.id)) {
 
             this.criteria.forEach(criterion => {
                 if (this.isAnyOrAllTelemetry(criterion)) {
@@ -93,6 +94,12 @@ export default class Condition extends EventEmitter {
         return (criterion.telemetry && (criterion.telemetry === 'all' || criterion.telemetry === 'any'));
     }
 
+    hasNoTelemetry() {
+        return this.criteria.every((criterion) => {
+            return !this.isAnyOrAllTelemetry(criterion) && criterion.telemetry === '';
+        });
+    }
+
     isTelemetryUsed(id) {
         return this.criteria.some(criterion => {
             return this.isAnyOrAllTelemetry(criterion) || criterion.telemetryObjectIdAsString === id;
@@ -250,10 +257,17 @@ export default class Condition extends EventEmitter {
     }
 
     getTriggerDescription() {
-        return {
-            conjunction: TRIGGER_CONJUNCTION[this.trigger],
-            prefix: `${TRIGGER_LABEL[this.trigger]}: `
-        };
+        if (this.trigger) {
+            return {
+                conjunction: TRIGGER_CONJUNCTION[this.trigger],
+                prefix: `${TRIGGER_LABEL[this.trigger]}: `
+            };
+        } else {
+            return {
+                conjunction: '',
+                prefix: ''
+            };
+        }
     }
 
     requestLADConditionResult() {

src/plugins/condition/ConditionManager.js

@@ -79,6 +79,17 @@ export default class ConditionManager extends EventEmitter {
         delete this.subscriptions[id];
         delete this.telemetryObjects[id];
         this.removeConditionTelemetryObjects();
+
+        //force re-computation of condition set result as we might be in a state where
+        // there is no telemetry datum coming in for a while or at all.
+        let latestTimestamp = getLatestTimestamp(
+            {},
+            {},
+            this.timeSystems,
+            this.openmct.time.timeSystem()
+        );
+        this.updateConditionResults({id: id});
+        this.updateCurrentCondition(latestTimestamp);
     }
 
     initialize() {
@@ -336,14 +347,17 @@ export default class ConditionManager extends EventEmitter {
         let timestamp = {};
         timestamp[timeSystemKey] = normalizedDatum[timeSystemKey];
 
+        this.updateConditionResults(normalizedDatum);
+        this.updateCurrentCondition(timestamp);
+    }
+
+    updateConditionResults(normalizedDatum) {
         //We want to stop when the first condition evaluates to true.
         this.conditions.some((condition) => {
             condition.updateResult(normalizedDatum);
 
             return condition.result === true;
         });
-
-        this.updateCurrentCondition(timestamp);
     }
 
     updateCurrentCondition(timestamp) {

src/plugins/condition/StyleRuleManager.js

@@ -86,6 +86,7 @@ export default class StyleRuleManager extends EventEmitter {
     updateObjectStyleConfig(styleConfiguration) {
         if (!styleConfiguration || !styleConfiguration.conditionSetIdentifier) {
             this.initialize(styleConfiguration || {});
+            this.applyStaticStyle();
             this.destroy();
         } else {
             let isNewConditionSet = !this.conditionSetIdentifier
@@ -158,7 +159,6 @@ export default class StyleRuleManager extends EventEmitter {
     }
 
     destroy() {
-        this.applyStaticStyle();
         if (this.stopProvidingTelemetry) {
             this.stopProvidingTelemetry();
             delete this.stopProvidingTelemetry;

src/plugins/condition/pluginSpec.js

@@ -22,6 +22,7 @@
 
 import { createOpenMct, resetApplicationState } from "utils/testing";
 import ConditionPlugin from "./plugin";
+import stylesManager from '@/ui/inspector/styles/StylesManager';
 import StylesView from "./components/inspector/StylesView.vue";
 import Vue from 'vue';
 import {getApplicableStylesForItem} from "./utils/styleUtils";
@@ -402,7 +403,8 @@ describe('the plugin', function () {
             component = new Vue({
                 provide: {
                     openmct: openmct,
-                    selection: selection
+                    selection: selection,
+                    stylesManager
                 },
                 el: viewContainer,
                 components: {

src/plugins/displayLayout/components/TelemetryView.vue

@@ -30,7 +30,7 @@
 >
     <div
         v-if="domainObject"
-        class="c-telemetry-view"
+        class="c-telemetry-view u-style-receiver"
         :class="[statusClass]"
         :style="styleObject"
         :data-font-size="item.fontSize"
@@ -233,8 +233,9 @@ export default {
         formattedValueForCopy() {
             const timeFormatterKey = this.openmct.time.timeSystem().key;
             const timeFormatter = this.formats[timeFormatterKey];
+            const unit = this.unit ? ` ${this.unit}` : '';
 
-            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue} ${this.unit}`;
+            return `At ${timeFormatter.format(this.datum)} ${this.domainObject.name} had a value of ${this.telemetryValue}${unit}`;
         },
         requestHistoricalData() {
             let bounds = this.openmct.time.bounds();

src/plugins/duplicate/DuplicateAction.js

@@ -0,0 +1,159 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import DuplicateTask from './DuplicateTask';
+
+export default class DuplicateAction {
+    constructor(openmct) {
+        this.name = 'Duplicate';
+        this.key = 'duplicate';
+        this.description = 'Duplicate this object.';
+        this.cssClass = "icon-duplicate";
+        this.group = "action";
+        this.priority = 7;
+
+        this.openmct = openmct;
+    }
+
+    async invoke(objectPath) {
+        let duplicationTask = new DuplicateTask(this.openmct);
+        let originalObject = objectPath[0];
+        let parent = objectPath[1];
+        let userInput = await this.getUserInput(originalObject, parent);
+        let newParent = userInput.location;
+        let inNavigationPath = this.inNavigationPath(originalObject);
+
+        // legacy check
+        if (this.isLegacyDomainObject(newParent)) {
+            newParent = await this.convertFromLegacy(newParent);
+        }
+
+        // if editing, save
+        if (inNavigationPath && this.openmct.editor.isEditing()) {
+            this.openmct.editor.save();
+        }
+
+        // duplicate
+        let newObject = await duplicationTask.duplicate(originalObject, newParent);
+        this.updateNameCheck(newObject, userInput.name);
+
+        return;
+    }
+
+    async getUserInput(originalObject, parent) {
+        let dialogService = this.openmct.$injector.get('dialogService');
+        let dialogForm = this.getDialogForm(originalObject, parent);
+        let formState = {
+            name: originalObject.name
+        };
+        let userInput = await dialogService.getUserInput(dialogForm, formState);
+
+        return userInput;
+    }
+
+    updateNameCheck(object, name) {
+        if (object.name !== name) {
+            this.openmct.objects.mutate(object, 'name', name);
+        }
+    }
+
+    inNavigationPath(object) {
+        return this.openmct.router.path
+            .some(objectInPath => this.openmct.objects.areIdsEqual(objectInPath.identifier, object.identifier));
+    }
+
+    getDialogForm(object, parent) {
+        return {
+            name: "Duplicate Item",
+            sections: [
+                {
+                    rows: [
+                        {
+                            key: "name",
+                            control: "textfield",
+                            name: "Name",
+                            pattern: "\\S+",
+                            required: true,
+                            cssClass: "l-input-lg"
+                        },
+                        {
+                            name: "location",
+                            cssClass: "grows",
+                            control: "locator",
+                            validate: this.validate(object, parent),
+                            key: 'location'
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+
+    validate(object, currentParent) {
+        return (parentCandidate) => {
+            let currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
+            let parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.getId());
+            let objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
+
+            if (!parentCandidate || !currentParentKeystring) {
+                return false;
+            }
+
+            if (parentCandidateKeystring === objectKeystring) {
+                return false;
+            }
+
+            return this.openmct.composition.checkPolicy(
+                parentCandidate.useCapability('adapter'),
+                object
+            );
+        };
+    }
+
+    isLegacyDomainObject(domainObject) {
+        return domainObject.getCapability !== undefined;
+    }
+
+    async convertFromLegacy(legacyDomainObject) {
+        let objectContext = legacyDomainObject.getCapability('context');
+        let domainObject = await this.openmct.objects.get(objectContext.domainObject.id);
+
+        return domainObject;
+    }
+
+    appliesTo(objectPath) {
+        let parent = objectPath[1];
+        let parentType = parent && this.openmct.types.get(parent.type);
+        let child = objectPath[0];
+        let childType = child && this.openmct.types.get(child.type);
+        let locked = child.locked ? child.locked : parent && parent.locked;
+
+        if (locked) {
+            return false;
+        }
+
+        return childType
+            && childType.definition.creatable
+            && parentType
+            && parentType.definition.creatable
+            && Array.isArray(parent.composition);
+    }
+}

src/plugins/duplicate/DuplicateTask.js

@@ -0,0 +1,273 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+import uuid from 'uuid';
+
+/**
+ * This class encapsulates the process of  duplicating/copying a domain object
+ * and all of its children.
+ *
+ * @param {DomainObject} domainObject The object to duplicate
+ * @param {DomainObject} parent The new location of the cloned object tree
+ * @param {src/plugins/duplicate.DuplicateService~filter} filter
+ *        a function used to filter out objects from
+ *        the cloning process
+ * @constructor
+ */
+export default class DuplicateTask {
+
+    constructor(openmct) {
+        this.domainObject = undefined;
+        this.parent = undefined;
+        this.firstClone = undefined;
+        this.filter = undefined;
+        this.persisted = 0;
+        this.clones = [];
+        this.idMap = {};
+
+        this.openmct = openmct;
+    }
+
+    /**
+     * Execute the duplicate/copy task with the objects provided.
+     * @returns {promise} Which will resolve with a clone of the object
+     * once complete.
+     */
+    async duplicate(domainObject, parent, filter) {
+        this.domainObject = domainObject;
+        this.parent = parent;
+        this.namespace = parent.identifier.namespace;
+        this.filter = filter || this.isCreatable;
+
+        await this.buildDuplicationPlan();
+        await this.persistObjects();
+        await this.addClonesToParent();
+
+        return this.firstClone;
+    }
+
+    /**
+     * Will build a graph of an object and all of its child objects in
+     * memory
+     * @private
+     * @param domainObject The original object to be copied
+     * @param parent The parent of the original object to be copied
+     * @returns {Promise} resolved with an array of clones of the models
+     * of the object tree being copied. Duplicating is done in a bottom-up
+     * fashion, so that the last member in the array is a clone of the model
+     * object being copied. The clones are all full composed with
+     * references to their own children.
+     */
+    async buildDuplicationPlan() {
+        let domainObjectClone = await this.duplicateObject(this.domainObject);
+
+        if (domainObjectClone !== this.domainObject) {
+            domainObjectClone.location = this.getKeyString(this.parent);
+        }
+
+        this.firstClone = domainObjectClone;
+
+        return;
+    }
+
+    /**
+     * Will persist a list of {@link objectClones}. It will persist all
+     * simultaneously, irrespective of order in the list. This may
+     * result in automatic request batching by the browser.
+     */
+    async persistObjects() {
+        let initialCount = this.clones.length;
+        let dialog = this.openmct.overlays.progressDialog({
+            progressPerc: 0,
+            message: `Duplicating ${initialCount} objects.`,
+            iconClass: 'info',
+            title: 'Duplicating'
+        });
+
+        let clonesDone = Promise.all(this.clones.map((clone) => {
+            let percentPersisted = Math.ceil(100 * (++this.persisted / initialCount));
+            let message = `Duplicating ${initialCount - this.persisted} objects.`;
+
+            dialog.updateProgress(percentPersisted, message);
+
+            return this.openmct.objects.save(clone);
+        }));
+
+        await clonesDone;
+
+        dialog.dismiss();
+        this.openmct.notifications.info(`Duplicated ${this.persisted} objects.`);
+
+        return;
+    }
+
+    /**
+     * Will add a list of clones to the specified parent's composition
+     */
+    async addClonesToParent() {
+        let parentComposition = this.openmct.composition.get(this.parent);
+        await parentComposition.load();
+        parentComposition.add(this.firstClone);
+
+        return;
+    }
+
+    /**
+     * A recursive function that will perform a bottom-up duplicate of
+     * the object tree with originalObject at the root. Recurses to
+     * the farthest leaf, then works its way back up again,
+     * cloning objects, and composing them with their child clones
+     * as it goes
+     * @private
+     * @returns {DomainObject} If the type of the original object allows for
+     * duplication, then a duplicate of the object, otherwise the object
+     * itself (to allow linking to non duplicatable objects).
+     */
+    async duplicateObject(originalObject) {
+        // Check if the creatable (or other passed in filter).
+        if (this.filter(originalObject)) {
+            let clone = this.cloneObjectModel(originalObject);
+            let composeesCollection = this.openmct.composition.get(originalObject);
+            let composees;
+
+            if (composeesCollection) {
+                composees = await composeesCollection.load();
+            }
+
+            return this.duplicateComposees(clone, composees);
+        }
+
+        // Not creatable, creating a link, no need to iterate children
+        return originalObject;
+    }
+
+    /**
+     * Given an array of objects composed by a parent, clone them, then
+     * add them to the parent.
+     * @private
+     * @returns {*}
+     */
+    async duplicateComposees(clonedParent, composees = []) {
+        let idMappings = [];
+        let allComposeesDuplicated = composees.reduce(async (previousPromise, nextComposee) => {
+            await previousPromise;
+
+            let clonedComposee = await this.duplicateObject(nextComposee);
+
+            if (clonedComposee) {
+                idMappings.push({
+                    newId: clonedComposee.identifier,
+                    oldId: nextComposee.identifier
+                });
+                this.composeChild(clonedComposee, clonedParent, clonedComposee !== nextComposee);
+            }
+
+            return;
+        }, Promise.resolve());
+
+        await allComposeesDuplicated;
+
+        clonedParent = this.rewriteIdentifiers(clonedParent, idMappings);
+        this.clones.push(clonedParent);
+
+        return clonedParent;
+    }
+
+    /**
+     * Update identifiers in a cloned object model (or part of
+     * a cloned object model) to reflect new identifiers after
+     * duplicating.
+     * @private
+     */
+    rewriteIdentifiers(clonedParent, childIdMappings) {
+        for (let { newId, oldId } of childIdMappings) {
+            let newIdKeyString = this.openmct.objects.makeKeyString(newId);
+            let oldIdKeyString = this.openmct.objects.makeKeyString(oldId);
+
+            // regex replace keystrings
+            clonedParent = JSON.stringify(clonedParent).replace(new RegExp(oldIdKeyString, 'g'), newIdKeyString);
+
+            // parse reviver to replace identifiers
+            clonedParent = JSON.parse(clonedParent, (key, value) => {
+                if (Object.prototype.hasOwnProperty.call(value, 'key')
+                    && Object.prototype.hasOwnProperty.call(value, 'namespace')
+                    && value.key === oldId.key
+                    && value.namespace === oldId.namespace) {
+                    return newId;
+                } else {
+                    return value;
+                }
+            });
+        }
+
+        return clonedParent;
+    }
+
+    composeChild(child, parent, setLocation) {
+        parent.composition.push(child.identifier);
+
+        //If a location is not specified, set it.
+        if (setLocation && child.location === undefined) {
+            let parentKeyString = this.getKeyString(parent);
+            child.location = parentKeyString;
+        }
+    }
+
+    getTypeDefinition(domainObject, definition) {
+        let typeDefinitions = this.openmct.types.get(domainObject.type).definition;
+
+        return typeDefinitions[definition] || false;
+    }
+
+    cloneObjectModel(domainObject) {
+        let clone = JSON.parse(JSON.stringify(domainObject));
+        let identifier = {
+            key: uuid(),
+            namespace: this.namespace // set to NEW parent's namespace
+        };
+
+        if (clone.modified || clone.persisted || clone.location) {
+            clone.modified = undefined;
+            clone.persisted = undefined;
+            clone.location = undefined;
+            delete clone.modified;
+            delete clone.persisted;
+            delete clone.location;
+        }
+
+        if (clone.composition) {
+            clone.composition = [];
+        }
+
+        clone.identifier = identifier;
+
+        return clone;
+    }
+
+    getKeyString(domainObject) {
+        return this.openmct.objects.makeKeyString(domainObject.identifier);
+    }
+
+    isCreatable(domainObject) {
+        return this.getTypeDefinition(domainObject, 'creatable');
+    }
+}

src/plugins/duplicate/plugin.js

@@ -0,0 +1,28 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2019, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import DuplicateAction from "./DuplicateAction";
+
+export default function () {
+    return function (openmct) {
+        openmct.actions.register(new DuplicateAction(openmct));
+    };
+}

src/plugins/duplicate/pluginSpec.js

@@ -0,0 +1,157 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import DuplicateActionPlugin from './plugin.js';
+import DuplicateAction from './DuplicateAction.js';
+import DuplicateTask from './DuplicateTask.js';
+import {
+    createOpenMct,
+    resetApplicationState,
+    getMockObjects
+} from 'utils/testing';
+
+describe("The Duplicate Action plugin", () => {
+
+    let openmct;
+    let duplicateTask;
+    let childObject;
+    let parentObject;
+    let anotherParentObject;
+
+    // this setups up the app
+    beforeEach((done) => {
+        openmct = createOpenMct();
+
+        childObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Child Folder",
+                    identifier: {
+                        namespace: "",
+                        key: "child-folder-object"
+                    }
+                }
+            }
+        }).folder;
+        parentObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Parent Folder",
+                    composition: [childObject.identifier]
+                }
+            }
+        }).folder;
+        anotherParentObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Another Parent Folder"
+                }
+            }
+        }).folder;
+
+        let objectGet = openmct.objects.get.bind(openmct.objects);
+        spyOn(openmct.objects, 'get').and.callFake((identifier) => {
+            let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === identifier.key);
+
+            if (!obj) {
+                // not one of the mocked objs, callthrough basically
+                return objectGet(identifier);
+            }
+
+            return Promise.resolve(obj);
+        });
+
+        spyOn(openmct.composition, 'get').and.callFake((domainObject) => {
+            return {
+                load: async () => {
+                    let obj = [childObject, parentObject, anotherParentObject].find((ob) => ob.identifier.key === domainObject.identifier.key);
+                    let children = [];
+
+                    if (obj) {
+                        for (let i = 0; i < obj.composition.length; i++) {
+                            children.push(await openmct.objects.get(obj.composition[i]));
+                        }
+                    }
+
+                    return Promise.resolve(children);
+                },
+                add: (child) => {
+                    domainObject.composition.push(child.identifier);
+                }
+            };
+        });
+
+        // already installed by default, but never hurts, just adds to context menu
+        openmct.install(DuplicateActionPlugin());
+
+        openmct.on('start', done);
+        openmct.startHeadless();
+    });
+
+    afterEach(() => {
+        resetApplicationState(openmct);
+    });
+
+    it("should be defined", () => {
+        expect(DuplicateActionPlugin).toBeDefined();
+    });
+
+    describe("when moving an object to a new parent", () => {
+
+        beforeEach(async (done) => {
+            duplicateTask = new DuplicateTask(openmct);
+            await duplicateTask.duplicate(parentObject, anotherParentObject);
+            done();
+        });
+
+        it("the duplicate child object's name (when not changing) should be the same as the original object", async () => {
+            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
+            let duplicatedObject = await openmct.objects.get(duplicatedObjectIdentifier);
+            let duplicateObjectName = duplicatedObject.name;
+
+            expect(duplicateObjectName).toEqual(parentObject.name);
+        });
+
+        it("the duplicate child object's identifier should be new", () => {
+            let duplicatedObjectIdentifier = anotherParentObject.composition[0];
+
+            expect(duplicatedObjectIdentifier.key).not.toEqual(parentObject.identifier.key);
+        });
+    });
+
+    describe("when a new name is provided for the duplicated object", () => {
+        const NEW_NAME = 'New Name';
+
+        beforeEach(() => {
+            duplicateTask = new DuplicateAction(openmct);
+            duplicateTask.updateNameCheck(parentObject, NEW_NAME);
+        });
+
+        it("the name is updated", () => {
+            let childName = parentObject.name;
+            expect(childName).toEqual(NEW_NAME);
+        });
+    });
+
+});

src/plugins/folderView/components/grid-item.scss

@@ -1,121 +0,0 @@
-/******************************* GRID ITEMS */
-.c-grid-item {
-    // Mobile-first
-    @include button($bg: $colorItemBg, $fg: $colorItemFg);
-    cursor: pointer;
-    display: flex;
-    padding: $interiorMarginLg;
-
-    &__type-icon {
-        filter: $colorKeyFilter;
-        flex: 0 0 $gridItemMobile;
-        font-size: floor($gridItemMobile / 2);
-        margin-right: $interiorMarginLg;
-    }
-
-    &.is-alias {
-        // Object is an alias to an original.
-        [class*='__type-icon'] {
-            @include isAlias();
-            color: $colorIconAliasForKeyFilter;
-        }
-    }
-
-    &__details {
-        display: flex;
-        flex-flow: column nowrap;
-        flex: 1 1 auto;
-    }
-
-    &__name {
-        @include ellipsize();
-        color: $colorItemFg;
-        @include headerFont(1.2em);
-        margin-bottom: $interiorMarginSm;
-    }
-
-    &__metadata {
-        color: $colorItemFgDetails;
-        font-size: 0.9em;
-
-        body.mobile & {
-            [class*='__item-count'] {
-                &:before {
-                    content: ' - ';
-                }
-            }
-        }
-    }
-
-    &__controls {
-        color: $colorItemFgDetails;
-        flex: 0 0 64px;
-        font-size: 1.2em;
-        display: flex;
-        align-items: center;
-        justify-content: flex-end;
-
-        > * + * {
-            margin-left: $interiorMargin;
-        }
-    }
-
-    body.desktop & {
-        $transOutMs: 300ms;
-        flex-flow: column nowrap;
-        transition: background $transOutMs ease-in-out;
-
-        &:hover {
-            background: $colorItemBgHov;
-            transition: $transIn;
-
-            .c-grid-item__type-icon {
-                filter: $colorKeyFilterHov;
-                transform: scale(1);
-                transition: $transInBounce;
-            }
-        }
-
-        > * {
-            margin: 0; // Reset from mobile
-        }
-
-        &__controls {
-            align-items: start;
-            flex: 0 0 auto;
-            order: 1;
-            .c-info-button,
-            .c-pointer-icon { display: none; }
-        }
-
-        &__type-icon {
-            flex: 1 1 auto;
-            font-size: floor($gridItemDesk / 3);
-            margin: $interiorMargin 22.5% $interiorMargin * 3 22.5%;
-            order: 2;
-            transform: scale(0.9);
-            transform-origin: center;
-            transition: all $transOutMs ease-in-out;
-        }
-
-        &__details {
-            flex: 0 0 auto;
-            justify-content: flex-end;
-            order: 3;
-        }
-
-        &__metadata {
-            display: flex;
-
-            &__type {
-                flex: 1 1 auto;
-                @include ellipsize();
-            }
-
-            &__item-count {
-                opacity: 0.7;
-                flex: 0 0 auto;
-            }
-        }
-    }
-}

src/plugins/folderView/components/grid-view.scss

@@ -43,7 +43,20 @@
         }
     }
 
-    &[class*='is-status'] {
+    &.is-status--notebook-default {
+        .is-status__indicator {
+            display: block;
+
+            &:before {
+                color: $colorFilter;
+                content: $glyph-icon-notebook-page;
+                font-family: symbolsfont;
+            }
+        }
+    }
+
+    &[class*='is-status--missing'],
+    &[class*='is-status--suspect']{
         [class*='__type-icon'],
         [class*='__details'] {
             opacity: $opacityMissing;

src/plugins/imagery/components/ImageryViewLayout.vue

@@ -36,7 +36,7 @@
         <div class="c-imagery__main-image__bg"
              :class="{'paused unnsynced': isPaused,'stale':false }"
         >
-            <div class="c-imagery__main-image__image"
+            <div class="c-imagery__main-image__image js-imageryView-image"
                  :style="{
                      'background-image': imageUrl ? `url(${imageUrl})` : 'none',
                      'filter': `brightness(${filters.brightness}%) contrast(${filters.contrast}%)`

src/plugins/imagery/pluginSpec.js

@@ -0,0 +1,306 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import ImageryPlugin from './plugin.js';
+import Vue from 'vue';
+import {
+    createOpenMct,
+    resetApplicationState,
+    simulateKeyEvent
+} from 'utils/testing';
+
+const ONE_MINUTE = 1000 * 60;
+const TEN_MINUTES = ONE_MINUTE * 10;
+const MAIN_IMAGE_CLASS = '.js-imageryView-image';
+const NEW_IMAGE_CLASS = '.c-imagery__age.c-imagery--new';
+const REFRESH_CSS_MS = 500;
+
+function getImageInfo(doc) {
+    let imageElement = doc.querySelectorAll(MAIN_IMAGE_CLASS)[0];
+    let timestamp = imageElement.dataset.openmctImageTimestamp;
+    let identifier = imageElement.dataset.openmctObjectKeystring;
+    let url = imageElement.style.backgroundImage;
+
+    return {
+        timestamp,
+        identifier,
+        url
+    };
+}
+
+function isNew(doc) {
+    let newIcon = doc.querySelectorAll(NEW_IMAGE_CLASS);
+
+    return newIcon.length !== 0;
+}
+
+function generateTelemetry(start, count) {
+    let telemetry = [];
+
+    for (let i = 1, l = count + 1; i < l; i++) {
+        let stringRep = i + 'minute';
+        let logo = 'images/logo-openmct.svg';
+
+        telemetry.push({
+            "name": stringRep + " Imagery",
+            "utc": start + (i * ONE_MINUTE),
+            "url": location.host + '/' + logo + '?time=' + stringRep,
+            "timeId": stringRep
+        });
+    }
+
+    return telemetry;
+}
+
+describe("The Imagery View Layout", () => {
+    const imageryKey = 'example.imagery';
+    const START = Date.now();
+    const COUNT = 10;
+
+    let openmct;
+    let imageryPlugin;
+    let parent;
+    let child;
+    let timeFormat = 'utc';
+    let bounds = {
+        start: START - TEN_MINUTES,
+        end: START
+    };
+    let imageTelemetry = generateTelemetry(START - TEN_MINUTES, COUNT);
+    let imageryObject = {
+        identifier: {
+            namespace: "",
+            key: "imageryId"
+        },
+        name: "Example Imagery",
+        type: "example.imagery",
+        location: "parentId",
+        modified: 0,
+        persisted: 0,
+        telemetry: {
+            values: [
+                {
+                    "name": "Image",
+                    "key": "url",
+                    "format": "image",
+                    "hints": {
+                        "image": 1,
+                        "priority": 3
+                    },
+                    "source": "url"
+                },
+                {
+                    "name": "Name",
+                    "key": "name",
+                    "source": "name",
+                    "hints": {
+                        "priority": 0
+                    }
+                },
+                {
+                    "name": "Time",
+                    "key": "utc",
+                    "format": "utc",
+                    "hints": {
+                        "domain": 2,
+                        "priority": 1
+                    },
+                    "source": "utc"
+                },
+                {
+                    "name": "Local Time",
+                    "key": "local",
+                    "format": "local-format",
+                    "hints": {
+                        "domain": 1,
+                        "priority": 2
+                    },
+                    "source": "local"
+                }
+            ]
+        }
+    };
+
+    // this setups up the app
+    beforeEach((done) => {
+        const appHolder = document.createElement('div');
+        appHolder.style.width = '640px';
+        appHolder.style.height = '480px';
+
+        openmct = createOpenMct();
+
+        parent = document.createElement('div');
+        child = document.createElement('div');
+        parent.appendChild(child);
+
+        spyOn(openmct.telemetry, 'request').and.returnValue(Promise.resolve([]));
+
+        imageryPlugin = new ImageryPlugin();
+        openmct.install(imageryPlugin);
+
+        spyOn(openmct.objects, 'get').and.returnValue(Promise.resolve({}));
+
+        openmct.time.timeSystem(timeFormat, {
+            start: 0,
+            end: 4
+        });
+
+        openmct.on('start', done);
+        openmct.startHeadless(appHolder);
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it("should provide an imagery view only for imagery producing objects", () => {
+        let applicableViews = openmct.objectViews.get(imageryObject);
+        let imageryView = applicableViews.find(
+            viewProvider => viewProvider.key === imageryKey
+        );
+
+        expect(imageryView).toBeDefined();
+    });
+
+    describe("imagery view", () => {
+        let applicableViews;
+        let imageryViewProvider;
+        let imageryView;
+
+        beforeEach(async (done) => {
+            let telemetryRequestResolve;
+            let telemetryRequestPromise = new Promise((resolve) => {
+                telemetryRequestResolve = resolve;
+            });
+
+            openmct.telemetry.request.and.callFake(() => {
+                telemetryRequestResolve(imageTelemetry);
+
+                return telemetryRequestPromise;
+            });
+
+            openmct.time.clock('local', {
+                start: bounds.start,
+                end: bounds.end + 100
+            });
+
+            applicableViews = openmct.objectViews.get(imageryObject);
+            imageryViewProvider = applicableViews.find(viewProvider => viewProvider.key === imageryKey);
+            imageryView = imageryViewProvider.view(imageryObject);
+            imageryView.show(child);
+
+            await telemetryRequestPromise;
+            await Vue.nextTick();
+
+            return done();
+        });
+
+        it("on mount should show the the most recent image", () => {
+            const imageInfo = getImageInfo(parent);
+
+            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 1].timeId)).not.toEqual(-1);
+        });
+
+        it("should show the clicked thumbnail as the main image", async () => {
+            const target = imageTelemetry[5].url;
+            parent.querySelectorAll(`img[src='${target}']`)[0].click();
+            await Vue.nextTick();
+            const imageInfo = getImageInfo(parent);
+
+            expect(imageInfo.url.indexOf(imageTelemetry[5].timeId)).not.toEqual(-1);
+        });
+
+        it("should show that an image is new", async (done) => {
+            await Vue.nextTick();
+
+            // used in code, need to wait to the 500ms here too
+            setTimeout(() => {
+                const imageIsNew = isNew(parent);
+
+                expect(imageIsNew).toBeTrue();
+                done();
+            }, REFRESH_CSS_MS);
+        });
+
+        it("should show that an image is not new", async (done) => {
+            const target = imageTelemetry[2].url;
+            parent.querySelectorAll(`img[src='${target}']`)[0].click();
+
+            await Vue.nextTick();
+
+            // used in code, need to wait to the 500ms here too
+            setTimeout(() => {
+                const imageIsNew = isNew(parent);
+
+                expect(imageIsNew).toBeFalse();
+                done();
+            }, REFRESH_CSS_MS);
+        });
+
+        it("should navigate via arrow keys", async () => {
+            let keyOpts = {
+                element: parent.querySelector('.c-imagery'),
+                key: 'ArrowLeft',
+                keyCode: 37,
+                type: 'keyup'
+            };
+
+            simulateKeyEvent(keyOpts);
+
+            await Vue.nextTick();
+
+            const imageInfo = getImageInfo(parent);
+
+            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 2].timeId)).not.toEqual(-1);
+        });
+
+        it("should navigate via numerous arrow keys", async () => {
+            let element = parent.querySelector('.c-imagery');
+            let type = 'keyup';
+            let leftKeyOpts = {
+                element,
+                type,
+                key: 'ArrowLeft',
+                keyCode: 37
+            };
+            let rightKeyOpts = {
+                element,
+                type,
+                key: 'ArrowRight',
+                keyCode: 39
+            };
+
+            // left thrice
+            simulateKeyEvent(leftKeyOpts);
+            simulateKeyEvent(leftKeyOpts);
+            simulateKeyEvent(leftKeyOpts);
+            // right once
+            simulateKeyEvent(rightKeyOpts);
+
+            await Vue.nextTick();
+
+            const imageInfo = getImageInfo(parent);
+
+            expect(imageInfo.url.indexOf(imageTelemetry[COUNT - 3].timeId)).not.toEqual(-1);
+        });
+
+    });
+});

src/plugins/interceptors/missingObjectInterceptor.js

@@ -20,40 +20,21 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define(
-    ['./AbstractComposeAction'],
-    function (AbstractComposeAction) {
-
-        /**
-         * The MoveAction is available from context menus and allows a user to
-         * move an object to another location of their choosing.
-         *
-         * @implements {Action}
-         * @constructor
-         * @memberof platform/entanglement
-         */
-        function MoveAction(policyService, locationService, moveService, context) {
-            AbstractComposeAction.apply(
-                this,
-                [policyService, locationService, moveService, context, "Move"]
-            );
-        }
-
-        MoveAction.prototype = Object.create(AbstractComposeAction.prototype);
-
-        MoveAction.appliesTo = function (context) {
-            var applicableObject =
-                context.selectedObject || context.domainObject;
-
-            if (applicableObject && applicableObject.model.locked) {
-                return false;
+export default function MissingObjectInterceptor(openmct) {
+    openmct.objects.addGetInterceptor({
+        appliesTo: (identifier, domainObject) => {
+            return identifier.key !== 'mine';
+        },
+        invoke: (identifier, object) => {
+            if (object === undefined) {
+                return {
+                    identifier,
+                    type: 'unknown',
+                    name: 'Missing: ' + openmct.objects.makeKeyString(identifier)
+                };
             }
 
-            return Boolean(applicableObject
-                && applicableObject.hasCapability('context'));
-        };
-
-        return MoveAction;
-    }
-);
-
+            return object;
+        }
+    });
+}

src/plugins/interceptors/myItemsInterceptor.js

@@ -20,44 +20,24 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-define([], function () {
+export default function MyItemsInterceptor(openmct) {
 
-    /**
-     * Disallow moves when either the parent or the child are not
-     * modifiable by users.
-     * @constructor
-     * @implements {Policy}
-     * @memberof platform/entanglement
-     */
-    function MovePolicy() {
-    }
+    openmct.objects.addGetInterceptor({
+        appliesTo: (identifier, domainObject) => {
+            return identifier.key === 'mine';
+        },
+        invoke: (identifier, object) => {
+            if (object === undefined) {
+                return {
+                    identifier,
+                    "name": "My Items",
+                    "type": "folder",
+                    "composition": [],
+                    "location": "ROOT"
+                };
+            }
 
-    function parentOf(domainObject) {
-        var context = domainObject.getCapability('context');
-
-        return context && context.getParent();
-    }
-
-    function allowMutation(domainObject) {
-        var type = domainObject && domainObject.getCapability('type');
-
-        return Boolean(type && type.hasFeature('creation'));
-    }
-
-    function selectedObject(context) {
-        return context.selectedObject || context.domainObject;
-    }
-
-    MovePolicy.prototype.allow = function (action, context) {
-        var key = action.getMetadata().key;
-
-        if (key === 'move') {
-            return allowMutation(selectedObject(context))
-                && allowMutation(parentOf(selectedObject(context)));
+            return object;
         }
-
-        return true;
-    };
-
-    return MovePolicy;
-});
+    });
+}

src/plugins/interceptors/plugin.js

@@ -0,0 +1,9 @@
+import missingObjectInterceptor from "./missingObjectInterceptor";
+import myItemsInterceptor from "./myItemsInterceptor";
+
+export default function plugin() {
+    return function install(openmct) {
+        myItemsInterceptor(openmct);
+        missingObjectInterceptor(openmct);
+    };
+}

src/plugins/localTimeSystem/pluginSpec.js

@@ -0,0 +1,114 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+
+import {
+    createOpenMct,
+    resetApplicationState
+} from 'utils/testing';
+
+describe("The local time", () => {
+    const LOCAL_FORMAT_KEY = 'local-format';
+    const LOCAL_SYSTEM_KEY = 'local';
+    const JUNK = "junk";
+    const TIMESTAMP = -14256000000;
+    const DATESTRING = '1969-07-20 12:00:00.000 am';
+    let openmct;
+
+    beforeEach((done) => {
+
+        openmct = createOpenMct();
+
+        openmct.install(openmct.plugins.LocalTimeSystem());
+
+        openmct.on('start', done);
+        openmct.startHeadless();
+
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    describe("system", function () {
+
+        let localTimeSystem;
+
+        beforeEach(() => {
+            localTimeSystem = openmct.time.timeSystem(LOCAL_SYSTEM_KEY, {
+                start: 0,
+                end: 4
+            });
+        });
+
+        it("is installed", () => {
+            let timeSystems = openmct.time.getAllTimeSystems();
+            let local = timeSystems.find(ts => ts.key === LOCAL_SYSTEM_KEY);
+
+            expect(local).not.toEqual(-1);
+        });
+
+        it("can be set to be the main time system", () => {
+            expect(openmct.time.timeSystem().key).toBe(LOCAL_SYSTEM_KEY);
+        });
+
+        it("uses the local-format time format", () => {
+            expect(localTimeSystem.timeFormat).toBe(LOCAL_FORMAT_KEY);
+        });
+
+        it("is UTC based", () => {
+            expect(localTimeSystem.isUTCBased).toBe(true);
+        });
+
+        it("defines expected metadata", () => {
+            expect(localTimeSystem.key).toBe(LOCAL_SYSTEM_KEY);
+            expect(localTimeSystem.name).toBeDefined();
+            expect(localTimeSystem.cssClass).toBeDefined();
+            expect(localTimeSystem.durationFormat).toBeDefined();
+        });
+    });
+
+    describe("formatter can be obtained from the telemetry API and", () => {
+
+        let localTimeFormatter;
+        let dateString;
+        let timeStamp;
+
+        beforeEach(() => {
+            localTimeFormatter = openmct.telemetry.getFormatter(LOCAL_FORMAT_KEY);
+            dateString = localTimeFormatter.format(TIMESTAMP);
+            timeStamp = localTimeFormatter.parse(DATESTRING);
+        });
+
+        it("will format a timestamp in local time format", () => {
+            expect(localTimeFormatter.format(TIMESTAMP)).toBe(dateString);
+        });
+
+        it("will parse an local time Date String into milliseconds", () => {
+            expect(localTimeFormatter.parse(DATESTRING)).toBe(timeStamp);
+        });
+
+        it("will validate correctly", () => {
+            expect(localTimeFormatter.validate(DATESTRING)).toBe(true);
+            expect(localTimeFormatter.validate(JUNK)).toBe(false);
+        });
+    });
+});

src/plugins/move/MoveAction.js

@@ -0,0 +1,169 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+export default class MoveAction {
+    constructor(openmct) {
+        this.name = 'Move';
+        this.key = 'move';
+        this.description = 'Move this object from its containing object to another object.';
+        this.cssClass = "icon-move";
+        this.group = "action";
+        this.priority = 7;
+
+        this.openmct = openmct;
+    }
+
+    async invoke(objectPath) {
+        let object = objectPath[0];
+        let inNavigationPath = this.inNavigationPath(object);
+        let oldParent = objectPath[1];
+        let dialogService = this.openmct.$injector.get('dialogService');
+        let dialogForm = this.getDialogForm(object, oldParent);
+        let userInput = await dialogService.getUserInput(dialogForm, { name: object.name });
+
+        // if we need to update name
+        if (object.name !== userInput.name) {
+            this.openmct.objects.mutate(object, 'name', userInput.name);
+        }
+
+        let parentContext = userInput.location.getCapability('context');
+        let newParent = await this.openmct.objects.get(parentContext.domainObject.id);
+
+        if (inNavigationPath && this.openmct.editor.isEditing()) {
+            this.openmct.editor.save();
+        }
+
+        this.addToNewParent(object, newParent);
+        this.removeFromOldParent(oldParent, object);
+
+        if (inNavigationPath) {
+            let newObjectPath = await this.openmct.objects.getOriginalPath(object.identifier);
+            let root = await this.openmct.objects.getRoot();
+            let rootChildCount = root.composition.length;
+
+            // if not multiple root children, remove root from path
+            if (rootChildCount < 2) {
+                newObjectPath.pop(); // remove ROOT
+            }
+
+            this.navigateTo(newObjectPath);
+        }
+    }
+
+    inNavigationPath(object) {
+        return this.openmct.router.path
+            .some(objectInPath => this.openmct.objects.areIdsEqual(objectInPath.identifier, object.identifier));
+    }
+
+    navigateTo(objectPath) {
+        let urlPath = objectPath.reverse()
+            .map(object => this.openmct.objects.makeKeyString(object.identifier))
+            .join("/");
+
+        window.location.href = '#/browse/' + urlPath;
+    }
+
+    addToNewParent(child, newParent) {
+        let newParentKeyString = this.openmct.objects.makeKeyString(newParent.identifier);
+        let compositionCollection = this.openmct.composition.get(newParent);
+
+        this.openmct.objects.mutate(child, 'location', newParentKeyString);
+        compositionCollection.add(child);
+    }
+
+    removeFromOldParent(parent, child) {
+        let compositionCollection = this.openmct.composition.get(parent);
+
+        compositionCollection.remove(child);
+    }
+
+    getDialogForm(object, parent) {
+        return {
+            name: "Move Item",
+            sections: [
+                {
+                    rows: [
+                        {
+                            key: "name",
+                            control: "textfield",
+                            name: "Folder Name",
+                            pattern: "\\S+",
+                            required: true,
+                            cssClass: "l-input-lg"
+                        },
+                        {
+                            name: "location",
+                            control: "locator",
+                            validate: this.validate(object, parent),
+                            key: 'location'
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+
+    validate(object, currentParent) {
+        return (parentCandidate) => {
+            let currentParentKeystring = this.openmct.objects.makeKeyString(currentParent.identifier);
+            let parentCandidateKeystring = this.openmct.objects.makeKeyString(parentCandidate.getId());
+            let objectKeystring = this.openmct.objects.makeKeyString(object.identifier);
+
+            if (!parentCandidateKeystring || !currentParentKeystring) {
+                return false;
+            }
+
+            if (parentCandidateKeystring === currentParentKeystring) {
+                return false;
+            }
+
+            if (parentCandidateKeystring === objectKeystring) {
+                return false;
+            }
+
+            if (parentCandidate.getModel().composition.indexOf(objectKeystring) !== -1) {
+                return false;
+            }
+
+            return this.openmct.composition.checkPolicy(
+                parentCandidate.useCapability('adapter'),
+                object
+            );
+        };
+    }
+
+    appliesTo(objectPath) {
+        let parent = objectPath[1];
+        let parentType = parent && this.openmct.types.get(parent.type);
+        let child = objectPath[0];
+        let childType = child && this.openmct.types.get(child.type);
+
+        if (child.locked || (parent && parent.locked)) {
+            return false;
+        }
+
+        return parentType
+            && parentType.definition.creatable
+            && childType
+            && childType.definition.creatable
+            && Array.isArray(parent.composition);
+    }
+}

src/plugins/move/plugin.js

@@ -0,0 +1,28 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import MoveAction from "./MoveAction";
+
+export default function () {
+    return function (openmct) {
+        openmct.actions.register(new MoveAction(openmct));
+    };
+}

src/plugins/move/pluginSpec.js

@@ -0,0 +1,110 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import MoveActionPlugin from './plugin.js';
+import MoveAction from './MoveAction.js';
+import {
+    createOpenMct,
+    resetApplicationState,
+    getMockObjects
+} from 'utils/testing';
+
+describe("The Move Action plugin", () => {
+
+    let openmct;
+    let moveAction;
+    let childObject;
+    let parentObject;
+    let anotherParentObject;
+
+    // this setups up the app
+    beforeEach((done) => {
+        const appHolder = document.createElement('div');
+        appHolder.style.width = '640px';
+        appHolder.style.height = '480px';
+
+        openmct = createOpenMct();
+
+        childObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Child Folder",
+                    identifier: {
+                        namespace: "",
+                        key: "child-folder-object"
+                    }
+                }
+            }
+        }).folder;
+        parentObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Parent Folder",
+                    composition: [childObject.identifier]
+                }
+            }
+        }).folder;
+        anotherParentObject = getMockObjects({
+            objectKeyStrings: ['folder'],
+            overwrite: {
+                folder: {
+                    name: "Another Parent Folder"
+                }
+            }
+        }).folder;
+
+        // already installed by default, but never hurts, just adds to context menu
+        openmct.install(MoveActionPlugin());
+
+        openmct.on('start', done);
+        openmct.startHeadless(appHolder);
+    });
+
+    afterEach(() => {
+        resetApplicationState(openmct);
+    });
+
+    it("should be defined", () => {
+        expect(MoveActionPlugin).toBeDefined();
+    });
+
+    describe("when moving an object to a new parent and removing from the old parent", () => {
+
+        beforeEach(() => {
+            moveAction = new MoveAction(openmct);
+            moveAction.addToNewParent(childObject, anotherParentObject);
+            moveAction.removeFromOldParent(parentObject, childObject);
+        });
+
+        it("the child object's identifier should be in the new parent's composition", () => {
+            let newParentChild = anotherParentObject.composition[0];
+            expect(newParentChild).toEqual(childObject.identifier);
+        });
+
+        it("the child object's identifier should be removed from the old parent's composition", () => {
+            let oldParentComposition = parentObject.composition;
+            expect(oldParentComposition.length).toEqual(0);
+        });
+    });
+
+});

src/plugins/notebook/components/NotebookEmbed.vue

@@ -118,7 +118,7 @@ export default {
             painterroInstance.show(this.embed.snapshot.src);
         },
         changeLocation() {
-            const link = this.embed.historicLink;
+            const hash = this.embed.historicLink;
 
             const bounds = this.openmct.time.bounds();
             const isTimeBoundChanged = this.embed.bounds.start !== bounds.start
@@ -143,8 +143,9 @@ export default {
                 this.openmct.notifications.alert(message);
             }
 
-            const url = new URL(link);
-            window.location.href = url.hash;
+            const relativeHash = hash.slice(hash.indexOf('#'));
+            const url = new URL(relativeHash, `${location.protocol}//${location.host}${location.pathname}`);
+            window.location.hash = url.hash;
         },
         formatTime(unixTime, timeFormat) {
             return Moment.utc(unixTime).format(timeFormat);

src/plugins/notebook/components/NotebookMenuSwitcher.vue

@@ -17,7 +17,7 @@
 
 <script>
 import Snapshot from '../snapshot';
-import { getDefaultNotebook } from '../utils/notebook-storage';
+import { getDefaultNotebook, validateNotebookStorageObject } from '../utils/notebook-storage';
 import { NOTEBOOK_DEFAULT, NOTEBOOK_SNAPSHOT } from '../notebook-constants';
 
 export default {
@@ -49,6 +49,8 @@ export default {
         };
     },
     mounted() {
+        validateNotebookStorageObject();
+
         this.notebookSnapshot = new Snapshot(this.openmct);
         this.setDefaultNotebookStatus();
     },

src/plugins/notebook/pluginSpec.js

@@ -20,7 +20,7 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-import { createOpenMct, resetApplicationState } from 'utils/testing';
+import { createOpenMct, createMouseEvent, resetApplicationState } from 'utils/testing';
 import NotebookPlugin from './plugin';
 import Vue from 'vue';
 
@@ -133,4 +133,89 @@ describe("Notebook plugin:", () => {
             expect(hasMajorElements).toBe(true);
         });
     });
+
+    describe("Notebook Snapshots view:", () => {
+        let snapshotIndicator;
+        let drawerElement;
+
+        function clickSnapshotIndicator() {
+            const indicator = element.querySelector('.icon-camera');
+            const button = indicator.querySelector('button');
+            const clickEvent = createMouseEvent('click');
+
+            button.dispatchEvent(clickEvent);
+        }
+
+        beforeAll(() => {
+            snapshotIndicator = openmct.indicators.indicatorObjects
+                .find(indicator => indicator.key === 'notebook-snapshot-indicator').element;
+
+            element.append(snapshotIndicator);
+
+            return Vue.nextTick();
+        });
+
+        afterAll(() => {
+            snapshotIndicator.remove();
+            snapshotIndicator = undefined;
+
+            if (drawerElement) {
+                drawerElement.remove();
+                drawerElement = undefined;
+            }
+        });
+
+        beforeEach(() => {
+            drawerElement = document.querySelector('.l-shell__drawer');
+        });
+
+        afterEach(() => {
+            if (drawerElement) {
+                drawerElement.classList.remove('is-expanded');
+            }
+        });
+
+        it("has Snapshots indicator", () => {
+            const hasSnapshotIndicator = snapshotIndicator !== null && snapshotIndicator !== undefined;
+            expect(hasSnapshotIndicator).toBe(true);
+        });
+
+        it("snapshots container has class isExpanded", () => {
+            let classes = drawerElement.classList;
+            const isExpandedBefore = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterFirstClick = classes.contains('is-expanded');
+
+            expect(isExpandedBefore).toBeFalse();
+            expect(isExpandedAfterFirstClick).toBeTrue();
+        });
+
+        it("snapshots container does not have class isExpanded", () => {
+            let classes = drawerElement.classList;
+            const isExpandedBefore = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterFirstClick = classes.contains('is-expanded');
+
+            clickSnapshotIndicator();
+            classes = drawerElement.classList;
+            const isExpandedAfterSecondClick = classes.contains('is-expanded');
+
+            expect(isExpandedBefore).toBeFalse();
+            expect(isExpandedAfterFirstClick).toBeTrue();
+            expect(isExpandedAfterSecondClick).toBeFalse();
+        });
+
+        it("show notebook snapshots container text", () => {
+            clickSnapshotIndicator();
+
+            const notebookSnapshots = drawerElement.querySelector('.l-browse-bar__object-name');
+            const snapshotsText = notebookSnapshots.textContent.trim();
+
+            expect(snapshotsText).toBe('Notebook Snapshots');
+        });
+    });
 });

src/plugins/notebook/snapshot.js

@@ -7,15 +7,14 @@ export default class Snapshot {
     constructor(openmct) {
         this.openmct = openmct;
         this.snapshotContainer = new SnapshotContainer(openmct);
-        this.exportImageService = openmct.$injector.get('exportImageService');
-        this.dialogService = openmct.$injector.get('dialogService');
 
         this.capture = this.capture.bind(this);
         this._saveSnapShot = this._saveSnapShot.bind(this);
     }
 
     capture(snapshotMeta, notebookType, domElement) {
-        this.exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
+        const exportImageService = this.openmct.$injector.get('exportImageService');
+        exportImageService.exportPNGtoSRC(domElement, 's-status-taking-snapshot')
             .then(function (blob) {
                 const reader = new window.FileReader();
                 reader.readAsDataURL(blob);

src/plugins/notebook/utils/notebook-storage.js

@@ -67,3 +67,24 @@ export function setDefaultNotebookPage(page) {
     notebookStorage.page = page;
     saveDefaultNotebook(notebookStorage);
 }
+
+export function validateNotebookStorageObject() {
+    const notebookStorage = getDefaultNotebook();
+
+    let valid = false;
+    if (notebookStorage) {
+        Object.entries(notebookStorage).forEach(([key, value]) => {
+            const validKey = key !== undefined && key !== null;
+            const validValue = value !== undefined && value !== null;
+            valid = validKey && validValue;
+        });
+    }
+
+    if (valid) {
+        return notebookStorage;
+    }
+
+    console.warn('Invalid Notebook object, clearing default notebook storage');
+
+    clearDefaultNotebook();
+}

src/plugins/performanceIndicator/README.md

@@ -0,0 +1,9 @@
+# URL Indicator
+Adds an indicator which shows the number of frames that the browser is able to render per second. This is a useful proxy for the maximum number of updates that any telemetry display can perform per second. This may be useful during performance testing, but probably should not be enabled by default. 
+
+This indicator adds adds about 3% points to CPU usage in the Chrome task manager.
+
+## Installation
+```js
+openmct.install(openmct.plugins.PerformanceIndicator());
+```

src/plugins/performanceIndicator/plugin.js

@@ -0,0 +1,62 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+export default function PerformanceIndicator() {
+    return function install(openmct) {
+        let frames = 0;
+        let lastCalculated = performance.now();
+        const indicator = openmct.indicators.simpleIndicator();
+
+        indicator.text('~ fps');
+        indicator.statusClass('s-status-info');
+        openmct.indicators.add(indicator);
+
+        let rafHandle = requestAnimationFrame(incremementFrames);
+
+        openmct.on('destroy', () => {
+            cancelAnimationFrame(rafHandle);
+        });
+
+        function incremementFrames() {
+            let now = performance.now();
+            if ((now - lastCalculated) < 1000) {
+                frames++;
+            } else {
+                updateFPS(frames);
+                lastCalculated = now;
+                frames = 1;
+            }
+
+            rafHandle = requestAnimationFrame(incremementFrames);
+        }
+
+        function updateFPS(fps) {
+            indicator.text(`${fps} fps`);
+            if (fps >= 40) {
+                indicator.statusClass('s-status-on');
+            } else if (fps < 40 && fps >= 20) {
+                indicator.statusClass('s-status-warning');
+            } else {
+                indicator.statusClass('s-status-error');
+            }
+        }
+    };
+}

src/plugins/performanceIndicator/pluginSpec.js

@@ -0,0 +1,87 @@
+/*****************************************************************************
+ * Open MCT, Copyright (c) 2014-2020, United States Government
+ * as represented by the Administrator of the National Aeronautics and Space
+ * Administration. All rights reserved.
+ *
+ * Open MCT is licensed under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Open MCT includes source code licensed under additional open source
+ * licenses. See the Open Source Licenses file (LICENSES.md) included with
+ * this source code distribution or the Licensing information page available
+ * at runtime from the About dialog for additional information.
+ *****************************************************************************/
+import PerformancePlugin from './plugin.js';
+import {
+    createOpenMct,
+    resetApplicationState
+} from 'utils/testing';
+
+describe('the plugin', () => {
+    let openmct;
+    let element;
+    let child;
+
+    let performanceIndicator;
+    let countFramesPromise;
+
+    beforeEach((done) => {
+        openmct = createOpenMct(false);
+
+        element = document.createElement('div');
+        child = document.createElement('div');
+        element.appendChild(child);
+
+        openmct.install(new PerformancePlugin());
+
+        countFramesPromise = countFrames();
+
+        openmct.on('start', done);
+
+        performanceIndicator = openmct.indicators.indicatorObjects.find((indicator) => {
+            return indicator.text && indicator.text() === '~ fps';
+        });
+
+        openmct.startHeadless();
+    });
+
+    afterEach(() => {
+        return resetApplicationState(openmct);
+    });
+
+    it('installs the performance indicator', () => {
+        expect(performanceIndicator).toBeDefined();
+    });
+
+    it('correctly calculates fps', () => {
+        return countFramesPromise.then((frames) => {
+            expect(performanceIndicator.text()).toEqual(`${frames} fps`);
+        });
+    });
+
+    function countFrames() {
+        let startTime = performance.now();
+        let frames = 0;
+
+        return new Promise((resolve) => {
+            requestAnimationFrame(function incrementCount() {
+                let now = performance.now();
+
+                if ((now - startTime) < 1000) {
+                    frames++;
+                    requestAnimationFrame(incrementCount);
+                } else {
+                    resolve(frames);
+                }
+            });
+        });
+    }
+});

src/plugins/persistence/couch/CouchObjectProvider.js

@@ -87,7 +87,8 @@ export default class CouchObjectProvider {
             }
 
             //Sometimes CouchDB returns the old rev which fetching the object if there is a document update in progress
-            if (!this.objectQueue[key].pending) {
+            //Only update the rev if it's the first time we're getting the object from CouchDB. Subsequent revs should only be updated by updates.
+            if (!this.objectQueue[key].pending && !this.objectQueue[key].rev) {
                 this.objectQueue[key].updateRevision(response[REV]);
             }
 

src/plugins/plot/src/services/ExportImageService.js

@@ -117,8 +117,10 @@ define(
          * @returns {promise}
          */
         ExportImageService.prototype.exportJPG = function (element, filename, className) {
+            const processedFilename = replaceDotsWithUnderscores(filename);
+
             return this.renderElement(element, "jpg", className).then(function (img) {
-                saveAs(img, filename);
+                saveAs(img, processedFilename);
             });
         };
 
@@ -130,8 +132,10 @@ define(
          * @returns {promise}
          */
         ExportImageService.prototype.exportPNG = function (element, filename, className) {
+            const processedFilename = replaceDotsWithUnderscores(filename);
+
             return this.renderElement(element, "png", className).then(function (img) {
-                saveAs(img, filename);
+                saveAs(img, processedFilename);
             });
         };
 
@@ -146,6 +150,12 @@ define(
             return this.renderElement(element, "png", className);
         };
 
+        function replaceDotsWithUnderscores(filename) {
+            const regex = /\./gi;
+
+            return filename.replace(regex, '_');
+        }
+
         /**
          * canvas.toBlob() not supported in IE < 10, Opera, and Safari. This polyfill
          * implements the method in browsers that would not otherwise support it.

src/plugins/plot/src/telemetry/StackedPlotController.js

@@ -39,10 +39,11 @@ define([], function () {
             const thisRequest = {
                 pending: 0
             };
-            currentRequest = thisRequest;
-            $scope.currentRequest = thisRequest;
             const telemetryObjects = $scope.telemetryObjects = [];
             const thisTickWidthMap = {};
+
+            currentRequest = thisRequest;
+            $scope.currentRequest = thisRequest;
             tickWidthMap = thisTickWidthMap;
 
             if (unlisten) {
@@ -52,14 +53,10 @@ define([], function () {
 
             function addChild(child) {
                 const id = openmct.objects.makeKeyString(child.identifier);
+                const legacyObject = openmct.legacyObject(child);
+
                 thisTickWidthMap[id] = 0;
-                thisRequest.pending += 1;
-                objectService.getObjects([id])
-                    .then(function (objects) {
-                        thisRequest.pending -= 1;
-                        const childObj = objects[id];
-                        telemetryObjects.push(childObj);
-                    });
+                telemetryObjects.push(legacyObject);
             }
 
             function removeChild(childIdentifier) {
@@ -84,6 +81,7 @@ define([], function () {
             }
 
             thisRequest.pending += 1;
+
             openmct.objects.get(domainObject.getId())
                 .then(function (obj) {
                     thisRequest.pending -= 1;

src/plugins/plugins.js

@@ -59,7 +59,9 @@ define([
     './persistence/couch/plugin',
     './defaultRootName/plugin',
     './timeline/plugin',
-    './viewDatumAction/plugin'
+    './viewDatumAction/plugin',
+    './interceptors/plugin',
+    './performanceIndicator/plugin'
 ], function (
     _,
     UTCTimeSystem,
@@ -99,7 +101,9 @@ define([
     CouchDBPlugin,
     DefaultRootName,
     Timeline,
-    ViewDatumAction
+    ViewDatumAction,
+    ObjectInterceptors,
+    PerformanceIndicator
 ) {
     const bundleMap = {
         LocalStorage: 'platform/persistence/local',
@@ -194,6 +198,8 @@ define([
     plugins.DefaultRootName = DefaultRootName.default;
     plugins.Timeline = Timeline.default;
     plugins.ViewDatumAction = ViewDatumAction.default;
+    plugins.ObjectInterceptors = ObjectInterceptors.default;
+    plugins.PerformanceIndicator = PerformanceIndicator.default;
 
     return plugins;
 });

src/plugins/telemetryTable/ViewActions.js

@@ -30,13 +30,13 @@ let exportCSV = {
     },
     group: 'view'
 };
-let exportMarkedRows = {
+let exportMarkedDataAsCSV = {
     name: 'Export Marked Rows',
     key: 'export-csv-marked',
     description: "Export marked rows as CSV",
     cssClass: 'icon-download labeled',
     invoke: (objectPath, viewProvider) => {
-        viewProvider.getViewContext().exportMarkedRows();
+        viewProvider.getViewContext().exportMarkedDataAsCSV();
     },
     group: 'view'
 };
@@ -98,7 +98,7 @@ let autosizeColumns = {
 
 let viewActions = [
     exportCSV,
-    exportMarkedRows,
+    exportMarkedDataAsCSV,
     unmarkAllRows,
     pause,
     play,

src/plugins/telemetryTable/components/table.vue

@@ -960,7 +960,7 @@ export default {
             return {
                 type: 'telemetry-table',
                 exportAllDataAsCSV: this.exportAllDataAsCSV,
-                exportMarkedRows: this.exportMarkedRows,
+                exportMarkedDataAsCSV: this.exportMarkedDataAsCSV,
                 unmarkAllRows: this.unmarkAllRows,
                 togglePauseByButton: this.togglePauseByButton,
                 expandColumns: this.recalculateColumnWidths,

src/plugins/timeline/pluginSpec.js

@@ -98,6 +98,10 @@ describe('the plugin', function () {
 
         beforeEach((done) => {
             planDomainObject = {
+                identifier: {
+                    key: 'test-object',
+                    namespace: ''
+                },
                 type: 'plan',
                 id: "test-object",
                 selectFile: {

src/selection/Selection.js

@@ -70,11 +70,8 @@ define(
             if (multiSelect) {
                 this.handleMultiSelect(selectable);
             } else {
-                this.setSelectionStyles(selectable);
-                this.selected = [selectable];
+                this.handleSingleSelect(selectable);
             }
-
-            this.emit('change', this.selected);
         };
 
         /**
@@ -87,6 +84,20 @@ define(
                 this.addSelectionAttributes(selectable);
                 this.selected.push(selectable);
             }
+
+            this.emit('change', this.selected);
+        };
+
+        /**
+         * @private
+         */
+        Selection.prototype.handleSingleSelect = function (selectable) {
+            if (!_.isEqual([selectable], this.selected)) {
+                this.setSelectionStyles(selectable);
+                this.selected = [selectable];
+
+                this.emit('change', this.selected);
+            }
         };
 
         /**

src/styles/_controls.scss

@@ -126,7 +126,7 @@ button {
 
 .c-icon-button {
     [class*='label'] {
-        opacity: 0.6;
+        opacity: 0.8;
     }
 
     &--mixed {
@@ -468,9 +468,6 @@ select {
 
     > * {
         flex: 0 0 auto;
-        //+ * {
-        //    margin-top: $interiorMarginSm;
-        //}
     }
 }
 
@@ -485,7 +482,7 @@ select {
         transition: $transIn;
         white-space: nowrap;
 
-        &:hover {
+        @include hover {
             background: $colorMenuHovBg;
             color: $colorMenuHovFg;
             &:before {
@@ -500,8 +497,12 @@ select {
             min-width: 1em;
         }
 
-        &:not([class]):before {
-             content: ''; // Add this element so that menu items without an icon still indent properly
+        &:not([class*='icon']):before {
+             content: ''; // Enable :before so that menu items without an icon still indent properly
+        }
+
+        .menus-no-icon & {
+            &:before { display: none; }
         }
     }
 }
@@ -734,7 +735,6 @@ select {
 .c-toolbar {
     display: flex;
     align-items: center;
-    justify-content: space-between;
 
     > * {
         // First level items

src/styles/_legacy-plots.scss

@@ -47,6 +47,7 @@ mct-plot {
 .c-plot,
 .gl-plot {
     overflow: hidden;
+    min-height: 100px;
 
         .s-status-taking-snapshot & {
         .c-control-bar {
@@ -79,7 +80,8 @@ mct-plot {
         display: flex;
         flex: 1 1 auto;
         flex-direction: column;
-        overflow: hidden;
+        overflow-y: auto;
+        overflow-x: hidden;
     }
 
     &--stacked {

src/styles/_mixins.scss

@@ -129,7 +129,7 @@
     }
 }
 
-@mixin isStatus($absPos: false) {
+@mixin isStatus($absPos: false, $glyph: '', $color: $colorBodyFg) {
     // Supports CSS classing as follows:
     // is-status--missing, is-status--suspect, etc.
     // Common styles to be applied to tree items, object labels, grid and list item views
@@ -143,6 +143,11 @@
             position: absolute;
             z-index: 3;
         }
+
+        &:before {
+            color: $color;
+            content: $glyph;
+        }
     }
 }
 
@@ -547,7 +552,8 @@
         }
     }
 
-    &[class*='--menus-left'] {
+    &[class*='--menus-left'],
+    &[class*='menus-to-left'] {
         .c-menu {
             left: auto; right: 0;
         }

src/styles/_status.scss

@@ -205,20 +205,10 @@ tr {
     }
 
     &--missing {
-        @include isStatus();
-
-        .is-status__indicator:before {
-            color: $colorAlert;
-            content: $glyph-icon-alert-triangle;
-        }
+        @include isStatus($glyph: $glyph-icon-alert-triangle, $color: $colorAlert);
     }
 
     &--suspect {
-        @include isStatus();
-
-        .is-status__indicator:before {
-            color: $colorWarningLo;
-            content: $glyph-icon-alert-rect;
-        }
+        @include isStatus($glyph: $glyph-icon-alert-rect, $color: $colorWarningLo);
     }
 }

src/styles/notebook.scss

@@ -217,14 +217,12 @@
 .is-status--notebook-default {
     &:after {
         color: $colorFilter;
-        content: $glyph-icon-notebook-page;
-        display: block;
         font-family: symbolsfont;
         font-size: 0.9em;
-        margin-left: $interiorMargin;
     }
 
     &.c-list__item:after {
+        content: $glyph-icon-notebook-page;
         flex: 1 0 auto;
         text-align: right;
     }

src/ui/components/object-frame.scss

@@ -9,6 +9,7 @@
         justify-content: space-between;
         align-items: center;
         margin-bottom: $interiorMarginSm;
+        overflow: hidden;
         padding: 3px;
 
         .c-object-label {
@@ -35,6 +36,7 @@
     /*************************** FRAME CONTROLS */
     &__frame-controls {
         display: flex;
+        flex: 0 0 auto;
 
         &__btns,
         &__more {
@@ -160,5 +162,5 @@
     // This element is the recipient for object styling; cannot be display: contents
     flex: 1 1 auto;
     overflow: hidden;
-    display: contents;
+    display: block;
 }

src/ui/components/object-label.scss

@@ -29,8 +29,8 @@
         transform: scale(0.5);
     }
 
-    &[class*='is-status--missing'],
-    &[class*='is-status--suspect'] {
+    &.is-status--missing,
+    &.is-status--suspect {
         [class*='__type-icon'] {
             &:before,
             &:after {
@@ -38,6 +38,14 @@
             }
         }
     }
+
+    &.is-status--notebook-default {
+        &:after {
+            content: $glyph-icon-notebook-page;
+            display: block;
+            margin-left: $interiorMargin;
+        }
+    }
 }
 
 .c-tree .c-object-label {

src/ui/inspector/ObjectName.vue

@@ -97,9 +97,12 @@ export default {
             } else {
                 this.multiSelect = false;
                 this.domainObject = selection[0][0].context.item;
-                this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
-                this.status = this.openmct.status.get(this.keyString);
-                this.statusUnsubscribe = this.openmct.status.observe(this.keyString, this.updateStatus);
+
+                if (this.domainObject) {
+                    this.keyString = this.openmct.objects.makeKeyString(this.domainObject.identifier);
+                    this.status = this.openmct.status.get(this.keyString);
+                    this.statusUnsubscribe = this.openmct.status.observe(this.keyString, this.updateStatus);
+                }
             }
         },
         resetDomainObject() {

src/ui/inspector/styles/FontStyleEditor.vue

@@ -3,11 +3,13 @@
     <toolbar-select-menu
         :options="fontSizeMenuOptions"
         @change="setFontSize"
+        class="menus-to-left menus-no-icon"
     />
     <div class="c-toolbar__separator"></div>
     <toolbar-select-menu
         :options="fontMenuOptions"
         @change="setFont"
+        class="menus-to-left menus-no-icon"
     />
 </div>
 </template>

src/ui/layout/BrowseBar.vue

@@ -20,7 +20,7 @@
             </div>
             <span
                 class="l-browse-bar__object-name c-object-label__name c-input-inline"
-                contenteditable
+                :contenteditable="type.creatable"
                 @blur="updateName"
                 @keydown.enter.prevent
                 @keyup.enter.prevent="updateNameOnEnterKeyPress"

src/ui/layout/layout.scss

@@ -279,10 +279,12 @@
     }
 
     &__toolbar {
+        // Toolbar in the main shell, used by Display Layouts
         $p: $interiorMargin;
         background: $editUIBaseColor;
         border-radius: $basicCr;
         height: $p + 24px; // Need to standardize the height
+        justify-content: space-between;
         padding: $p;
     }
 }

src/utils/testing.js

@@ -90,6 +90,28 @@ export function resetApplicationState(openmct) {
     return promise;
 }
 
+// required: key
+// optional: element, keyCode, type
+export function simulateKeyEvent(opts) {
+
+    if (!opts.key) {
+        console.warn('simulateKeyEvent needs a key');
+
+        return;
+    }
+
+    const el = opts.element || document;
+    const key = opts.key;
+    const keyCode = opts.keyCode || key;
+    const type = opts.type || 'keydown';
+    const event = new Event(type);
+
+    event.keyCode = keyCode;
+    event.key = key;
+
+    el.dispatchEvent(event);
+}
+
 function clearBuiltinSpy(funcDefinition) {
     funcDefinition.object[funcDefinition.functionName] = funcDefinition.nativeFunction;
 }