diff --git a/platform/core/bundle.js b/platform/core/bundle.js index 30b2609c92..a25ad3ff1a 100644 --- a/platform/core/bundle.js +++ b/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", - "contextualize" + "$injector" ] }, { @@ -380,13 +377,6 @@ define([ "$log" ] }, - { - "key": "contextualize", - "implementation": Contextualize, - "depends": [ - "$log" - ] - }, { "key": "instantiate", "implementation": Instantiate, diff --git a/platform/core/src/capabilities/CompositionCapability.js b/platform/core/src/capabilities/CompositionCapability.js index 3f5769005f..c77aea4e86 100644 --- a/platform/core/src/capabilities/CompositionCapability.js +++ b/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); }); } diff --git a/platform/core/src/capabilities/InstantiationCapability.js b/platform/core/src/capabilities/InstantiationCapability.js index 81b2f954e4..6005b8c9bb 100644 --- a/platform/core/src/capabilities/InstantiationCapability.js +++ b/platform/core/src/capabilities/InstantiationCapability.js @@ -21,8 +21,8 @@ *****************************************************************************/ define( - [], - function () { + ['./ContextualDomainObject'], + 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 || - this.$injector.get("contextualize"); - - - return this.contextualizeFn(newObject, this.domainObject); + return new ContextualDomainObject(newObject, this.domainObject); }; /** diff --git a/platform/core/src/services/Contextualize.js b/platform/core/src/services/Contextualize.js deleted file mode 100644 index ff4571782a..0000000000 --- a/platform/core/src/services/Contextualize.js +++ /dev/null @@ -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; - } -); - diff --git a/platform/core/test/capabilities/CompositionCapabilitySpec.js b/platform/core/test/capabilities/CompositionCapabilitySpec.js index 0ec32fb881..e95f566aee 100644 --- a/platform/core/test/capabilities/CompositionCapabilitySpec.js +++ b/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 ); }); diff --git a/platform/core/test/capabilities/InstantiationCapabilitySpec.js b/platform/core/test/capabilities/InstantiationCapabilitySpec.js index 90c9341fcf..54f0612ea5 100644 --- a/platform/core/test/capabilities/InstantiationCapabilitySpec.js +++ b/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, - 'contextualize': mockContextualize + 'instantiate': mockInstantiate }[key]; }); mockIdentifierService.parse.andReturn(mockIdentifier); @@ -85,18 +82,12 @@ define( 'hasCapability' ]), testModel = { someKey: "some value" }; mockInstantiate.andReturn(mockDomainObj); - mockContextualize.andCallFake(function (x) { - return x; - }); - expect(instantiation.instantiate(testModel)) - .toBe(mockDomainObj); + instantiation.instantiate(testModel); expect(mockInstantiate) .toHaveBeenCalledWith({ someKey: "some value", modified: mockNow() }, jasmine.any(String)); - expect(mockContextualize) - .toHaveBeenCalledWith(mockDomainObj, mockDomainObject); }); }); diff --git a/platform/core/test/services/ContextualizeSpec.js b/platform/core/test/services/ContextualizeSpec.js deleted file mode 100644 index 64f929f217..0000000000 --- a/platform/core/test/services/ContextualizeSpec.js +++ /dev/null @@ -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(); - }); - - }); - } -); diff --git a/platform/entanglement/bundle.js b/platform/entanglement/bundle.js index 135a31d38b..7cf7322d9f 100644 --- a/platform/entanglement/bundle.js +++ b/platform/entanglement/bundle.js @@ -132,7 +132,6 @@ define([ "provides": "objectService", "implementation": LocatingObjectDecorator, "depends": [ - "contextualize", "$q", "$log" ] diff --git a/platform/entanglement/src/services/LocatingObjectDecorator.js b/platform/entanglement/src/services/LocatingObjectDecorator.js index 25f997d6ba..ca9d42535e 100644 --- a/platform/entanglement/src/services/LocatingObjectDecorator.js +++ b/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) { - this.contextualize = contextualize; + function LocatingObjectDecorator($q, $log, objectService) { 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); }); } diff --git a/platform/entanglement/test/services/LocatingObjectDecoratorSpec.js b/platform/entanglement/test/services/LocatingObjectDecoratorSpec.js index 01438d1134..bef181172e 100644 --- a/platform/entanglement/test/services/LocatingObjectDecoratorSpec.js +++ b/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, - mockQ, + var 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({ - b: { - testObject: testObjects.b, - testParent: testObjects.a - }, - c: { - testObject: testObjects.c, - testParent: { - testObject: testObjects.b, - testParent: testObjects.a - } - } - }); + expect(mockCallback).toHaveBeenCalled(); + + var callbackObj = mockCallback.mostRecentCall.args[0]; + expect(testObjects.b.getCapability('context')).not.toBeDefined(); + expect(testObjects.c.getCapability('context')).not.toBeDefined(); + expect(callbackObj.b.getCapability('context')).toBeDefined(); + expect(callbackObj.c.getCapability('context')).toBeDefined(); }); it("warns on cycle detection", function () { diff --git a/src/adapter/capabilities/AlternateCompositionCapability.js b/src/adapter/capabilities/AlternateCompositionCapability.js index f85ef2d57c..4e639424d1 100644 --- a/src/adapter/capabilities/AlternateCompositionCapability.js +++ b/src/adapter/capabilities/AlternateCompositionCapability.js @@ -24,13 +24,13 @@ * Module defining AlternateCompositionCapability. Created by vwoeltje on 11/7/14. */ define([ - '../../api/objects/object-utils' -], function (objectUtils) { + '../../api/objects/object-utils', + '../../../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); };