Merge pull request nasa#1515 from nasa/open1498

Removed contextualization warning.

Author: larkin

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,

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(
-    [],
-    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);
         };
 
         /**

platform/core/src/services/Contextualize.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/CompositionCapabilitySpec.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);
             });
 
         });

platform/core/test/capabilities/InstantiationCapabilitySpec.js

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