Merge pull request #1515 from nasa/open1498

Removed contextualization warning.

platform/core/bundle.js

@@ -49,7 +49,6 @@ define([
     "./src/services/Now",
     "./src/services/Throttle",
     "./src/services/Topic",
-    "./src/services/Contextualize",
     "./src/services/Instantiate",
     'legacyRegistry'
 ], function (
@@ -81,7 +80,6 @@ define([
     Now,
     Throttle,
     Topic,
-    Contextualize,
     Instantiate,
     legacyRegistry
 ) {
@@ -284,8 +282,7 @@ define([
                     "key": "composition",
                     "implementation": CompositionCapability,
                     "depends": [
-                        "$injector",
+                        "$injector"
-                        "contextualize"
                     ]
                 },
                 {
@@ -380,13 +377,6 @@ define([
                         "$log"
                     ]
                 },
-                {
-                    "key": "contextualize",
-                    "implementation": Contextualize,
-                    "depends": [
-                        "$log"
-                    ]
-                },
                 {
                     "key": "instantiate",
                     "implementation": Instantiate,

platform/core/src/capabilities/CompositionCapability.js

@@ -24,7 +24,8 @@
  * Module defining CompositionCapability. Created by vwoeltje on 11/7/14.
  */
 define(
-    function () {
+    ['./ContextualDomainObject'],
+    function (ContextualDomainObject) {
 
         /**
          * Composition capability. A domain object's composition is the set of
@@ -38,13 +39,12 @@ define(
          * @constructor
          * @implements {Capability}
          */
-        function CompositionCapability($injector, contextualize, domainObject) {
+        function CompositionCapability($injector, domainObject) {
             // Get a reference to the object service from $injector
             this.injectObjectService = function () {
                 this.objectService = $injector.get("objectService");
             };
 
-            this.contextualize = contextualize;
             this.domainObject = domainObject;
         }
 
@@ -115,7 +115,6 @@ define(
         CompositionCapability.prototype.invoke = function () {
             var domainObject = this.domainObject,
                 model = domainObject.getModel(),
-                contextualize = this.contextualize,
                 ids;
 
             // Then filter out non-existent objects,
@@ -125,7 +124,7 @@ define(
                 return ids.filter(function (id) {
                     return objects[id];
                 }).map(function (id) {
-                    return contextualize(objects[id], domainObject);
+                    return new ContextualDomainObject(objects[id], domainObject);
                 });
             }
 

platform/core/src/capabilities/InstantiationCapability.js

@@ -21,8 +21,8 @@
  *****************************************************************************/
 
 define(
-    [],
+    ['./ContextualDomainObject'],
-    function () {
+    function (ContextualDomainObject) {
 
         /**
          * Implements the `instantiation` capability. This allows new domain
@@ -70,11 +70,7 @@ define(
 
             var newObject = this.instantiateFn(model, id);
 
-            this.contextualizeFn = this.contextualizeFn ||
+            return new ContextualDomainObject(newObject, this.domainObject);
-                this.$injector.get("contextualize");
-
-
-            return this.contextualizeFn(newObject, this.domainObject);
         };
 
         /**

platform/core/src/services/Contextualize.js

@@ -1,82 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, 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(
-    ['../capabilities/ContextualDomainObject'],
-    function (ContextualDomainObject) {
-
-        /**
-         * Wrap a domain object such that it has a `context` capability
-         * referring to a specific parent.
-         *
-         * Usage:
-         *
-         *     contextualize(domainObject, parentObject)
-         *
-         * Attempting to contextualize an object with a parent that does
-         * not include that object in its composition may have
-         * unpredictable results; a warning will be logged if this occurs.
-         *
-         * @returns {Function}
-         * @memberof platform/core
-         */
-        function Contextualize($log) {
-            function validate(id, parentObject) {
-                var model = parentObject && parentObject.getModel(),
-                    composition = (model || {}).composition || [];
-                if (composition.indexOf(id) === -1) {
-                    $log.warn([
-                        "Attempted to contextualize",
-                        id,
-                        "in",
-                        parentObject && parentObject.getId(),
-                        "but that object does not contain",
-                        id,
-                        "in its composition.",
-                        "Unexpected behavior may follow."
-                    ].join(" "));
-                }
-            }
-
-            /**
-             * Contextualize this domain object.
-             * @param {DomainObject} domainObject the domain object
-             *        to wrap with a context
-             * @param {DomainObject} parentObject the domain object
-             *        which should appear as the contextual parent
-             */
-            return function (domainObject, parentObject) {
-                // Don't validate while editing; consistency is not
-                // necessarily expected due to unsaved changes.
-                var editor = domainObject.getCapability('editor');
-                if (!editor || !editor.inEditContext()) {
-                    validate(domainObject.getId(), parentObject);
-                }
-
-                return new ContextualDomainObject(domainObject, parentObject);
-            };
-        }
-
-        return Contextualize;
-    }
-);
-

platform/core/test/capabilities/CompositionCapabilitySpec.js

@@ -41,7 +41,6 @@ define(
         describe("The composition capability", function () {
             var mockDomainObject,
                 mockInjector,
-                mockContextualize,
                 mockObjectService,
                 composition;
 
@@ -72,19 +71,11 @@ define(
                         return (name === "objectService") && mockObjectService;
                     }
                 };
-                mockContextualize = jasmine.createSpy('contextualize');
-
-                // Provide a minimal (e.g. no error-checking) implementation
-                // of contextualize for simplicity
-                mockContextualize.andCallFake(function (domainObject, parentObject) {
-                    return new ContextualDomainObject(domainObject, parentObject);
-                });
 
                 mockObjectService.getObjects.andReturn(mockPromise([]));
 
                 composition = new CompositionCapability(
                     mockInjector,
-                    mockContextualize,
                     mockDomainObject
                 );
             });

platform/core/test/capabilities/InstantiationCapabilitySpec.js

@@ -28,7 +28,6 @@ define(
             var mockInjector,
                 mockIdentifierService,
                 mockInstantiate,
-                mockContextualize,
                 mockIdentifier,
                 mockNow,
                 mockDomainObject,
@@ -37,7 +36,6 @@ define(
             beforeEach(function () {
                 mockInjector = jasmine.createSpyObj("$injector", ["get"]);
                 mockInstantiate = jasmine.createSpy("instantiate");
-                mockContextualize = jasmine.createSpy("contextualize");
                 mockIdentifierService = jasmine.createSpyObj(
                     'identifierService',
                     ['parse', 'generate']
@@ -53,8 +51,7 @@ define(
 
                 mockInjector.get.andCallFake(function (key) {
                     return {
-                        'instantiate': mockInstantiate,
+                        'instantiate': mockInstantiate
-                        'contextualize': mockContextualize
                     }[key];
                 });
                 mockIdentifierService.parse.andReturn(mockIdentifier);
@@ -85,18 +82,12 @@ define(
                     'hasCapability'
                 ]), testModel = { someKey: "some value" };
                 mockInstantiate.andReturn(mockDomainObj);
-                mockContextualize.andCallFake(function (x) {
+                instantiation.instantiate(testModel);
-                    return x;
-                });
-                expect(instantiation.instantiate(testModel))
-                    .toBe(mockDomainObj);
                 expect(mockInstantiate)
                     .toHaveBeenCalledWith({
                         someKey: "some value",
                         modified: mockNow()
                     }, jasmine.any(String));
-                expect(mockContextualize)
-                    .toHaveBeenCalledWith(mockDomainObj, mockDomainObject);
             });
 
         });

platform/core/test/services/ContextualizeSpec.js

@@ -1,103 +0,0 @@
-/*****************************************************************************
- * Open MCT, Copyright (c) 2014-2016, 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/Contextualize"],
-    function (Contextualize) {
-
-        var DOMAIN_OBJECT_METHODS = [
-            'getId',
-            'getModel',
-            'getCapability',
-            'hasCapability',
-            'useCapability'
-        ];
-
-        describe("The 'contextualize' service", function () {
-            var mockLog,
-                mockDomainObject,
-                mockParentObject,
-                mockEditor,
-                testParentModel,
-                contextualize;
-
-            beforeEach(function () {
-                testParentModel = { composition: ["abc"] };
-
-                mockLog = jasmine.createSpyObj(
-                    "$log",
-                    ["error", "warn", "info", "debug"]
-                );
-
-                mockDomainObject =
-                    jasmine.createSpyObj('domainObject', DOMAIN_OBJECT_METHODS);
-                mockParentObject =
-                    jasmine.createSpyObj('parentObject', DOMAIN_OBJECT_METHODS);
-
-                mockEditor =
-                    jasmine.createSpyObj('editor', ['inEditContext']);
-
-                mockDomainObject.getId.andReturn("abc");
-                mockDomainObject.getModel.andReturn({});
-                mockParentObject.getId.andReturn("parent");
-                mockParentObject.getModel.andReturn(testParentModel);
-
-                mockEditor.inEditContext.andReturn(false);
-                mockDomainObject.getCapability.andCallFake(function (c) {
-                    return c === 'editor' && mockEditor;
-                });
-
-                contextualize = new Contextualize(mockLog);
-            });
-
-            it("attaches a context capability", function () {
-                var contextualizedObject =
-                    contextualize(mockDomainObject, mockParentObject);
-
-                expect(contextualizedObject.getId()).toEqual("abc");
-                expect(contextualizedObject.getCapability("context"))
-                    .toBeDefined();
-                expect(contextualizedObject.getCapability("context").getParent())
-                    .toBe(mockParentObject);
-            });
-
-            it("issues a warning if composition does not match", function () {
-                // Precondition - normally it should not issue a warning
-                contextualize(mockDomainObject, mockParentObject);
-                expect(mockLog.warn).not.toHaveBeenCalled();
-
-                testParentModel.composition = ["xyz"];
-
-                contextualize(mockDomainObject, mockParentObject);
-                expect(mockLog.warn).toHaveBeenCalled();
-            });
-
-            it("does not issue warnings for objects being edited", function () {
-                mockEditor.inEditContext.andReturn(true);
-                testParentModel.composition = ["xyz"];
-                contextualize(mockDomainObject, mockParentObject);
-                expect(mockLog.warn).not.toHaveBeenCalled();
-            });
-
-        });
-    }
-);

platform/entanglement/bundle.js

@@ -132,7 +132,6 @@ define([
                     "provides": "objectService",
                     "implementation": LocatingObjectDecorator,
                     "depends": [
-                        "contextualize",
                         "$q",
                         "$log"
                     ]

platform/entanglement/src/services/LocatingObjectDecorator.js

@@ -22,7 +22,8 @@
 
 
 define(
-    function () {
+    ['../../../core/src/capabilities/ContextualDomainObject'],
+    function (ContextualDomainObject) {
 
         /**
          * Ensures that domain objects are loaded with a context capability
@@ -31,8 +32,7 @@ define(
          * @implements {ObjectService}
          * @memberof platform/entanglement
          */
-        function LocatingObjectDecorator(contextualize, $q, $log, objectService) {
+        function LocatingObjectDecorator($q, $log, objectService) {
-            this.contextualize = contextualize;
             this.$log = $log;
             this.objectService = objectService;
             this.$q = $q;
@@ -41,7 +41,6 @@ define(
         LocatingObjectDecorator.prototype.getObjects = function (ids) {
             var $q = this.$q,
                 $log = this.$log,
-                contextualize = this.contextualize,
                 objectService = this.objectService,
                 result = {};
 
@@ -76,7 +75,7 @@ define(
                     return loadObjectInContext(location, exclude)
                         .then(function (parent) {
                             // ...and then contextualize with it!
-                            return contextualize(domainObject, parent);
+                            return new ContextualDomainObject(domainObject, parent);
                         });
                 }
 

platform/entanglement/test/services/LocatingObjectDecoratorSpec.js

@@ -23,13 +23,13 @@
 
 define(
     [
-        '../../src/services/LocatingObjectDecorator'
+        '../../src/services/LocatingObjectDecorator',
+        '../../../core/src/capabilities/ContextualDomainObject'
     ],
-    function (LocatingObjectDecorator) {
+    function (LocatingObjectDecorator, ContextualDomainObject) {
 
         describe("LocatingObjectDecorator", function () {
-            var mockContextualize,
+            var mockQ,
-                mockQ,
                 mockLog,
                 mockObjectService,
                 mockCallback,
@@ -57,21 +57,12 @@ define(
                 };
                 testObjects = {};
 
-                mockContextualize = jasmine.createSpy("contextualize");
                 mockQ = jasmine.createSpyObj("$q", ["when", "all"]);
                 mockLog =
                     jasmine.createSpyObj("$log", ["error", "warn", "info", "debug"]);
                 mockObjectService =
                     jasmine.createSpyObj("objectService", ["getObjects"]);
 
-                mockContextualize.andCallFake(function (domainObject, parentObject) {
-                    // Not really what contextualize does, but easy to test!
-                    return {
-                        testObject: domainObject,
-                        testParent: parentObject
-                    };
-                });
-
                 mockQ.when.andCallFake(testPromise);
                 mockQ.all.andCallFake(function (promises) {
                     var result = {};
@@ -97,28 +88,21 @@ define(
                 });
 
                 decorator = new LocatingObjectDecorator(
-                    mockContextualize,
                     mockQ,
                     mockLog,
                     mockObjectService
                 );
             });
 
-            it("contextualizes domain objects by location", function () {
+            it("contextualizes domain objects", function () {
                 decorator.getObjects(['b', 'c']).then(mockCallback);
-                expect(mockCallback).toHaveBeenCalledWith({
+                expect(mockCallback).toHaveBeenCalled();
-                    b: {
+
-                        testObject: testObjects.b,
+                var callbackObj = mockCallback.mostRecentCall.args[0];
-                        testParent: testObjects.a
+                expect(testObjects.b.getCapability('context')).not.toBeDefined();
-                    },
+                expect(testObjects.c.getCapability('context')).not.toBeDefined();
-                    c: {
+                expect(callbackObj.b.getCapability('context')).toBeDefined();
-                        testObject: testObjects.c,
+                expect(callbackObj.c.getCapability('context')).toBeDefined();
-                        testParent: {
-                            testObject: testObjects.b,
-                            testParent: testObjects.a
-                        }
-                    }
-                });
             });
 
             it("warns on cycle detection", function () {

src/adapter/capabilities/AlternateCompositionCapability.js

@@ -24,13 +24,13 @@
  * Module defining AlternateCompositionCapability. Created by vwoeltje on 11/7/14.
  */
 define([
-    '../../api/objects/object-utils'
+    '../../api/objects/object-utils',
-], function (objectUtils) {
+    '../../../platform/core/src/capabilities/ContextualDomainObject'
+], function (objectUtils, ContextualDomainObject) {
         function AlternateCompositionCapability($injector, domainObject) {
             this.domainObject = domainObject;
             this.getDependencies = function () {
                 this.instantiate = $injector.get("instantiate");
-                this.contextualize = $injector.get("contextualize");
                 this.getDependencies = undefined;
                 this.openmct = $injector.get("openmct");
             }.bind(this);
@@ -74,7 +74,7 @@ define([
             var keyString = objectUtils.makeKeyString(child.identifier);
             var oldModel = objectUtils.toOldFormat(child);
             var newDO = this.instantiate(oldModel, keyString);
-            return this.contextualize(newDO, this.domainObject);
+            return new ContextualDomainObject(newDO, this.domainObject);
 
         };