ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2024-12-21 06:03:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1515 from nasa/open1498

Browse Source 
Removed contextualization warning.
This commit is contained in:
Pete Richards 2017-04-04 15:44:16 -07:00 committed by GitHub
commit df0d4dff6f
11 changed files with 30 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
platform/core/bundle.js
View File

@ -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,

9
platform/core/src/capabilities/CompositionCapability.js
View File

@ -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);
});
}

10
platform/core/src/capabilities/InstantiationCapability.js
View File

@ -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);
};
/**

82
platform/core/src/services/Contextualize.js
View File

@ -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;
}
);

9
platform/core/test/capabilities/CompositionCapabilitySpec.js
View File

@ -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
);
});

13
platform/core/test/capabilities/InstantiationCapabilitySpec.js
View File

@ -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);
});
});

103
platform/core/test/services/ContextualizeSpec.js
View File

@ -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();
});
});
}
);

1
platform/entanglement/bundle.js
View File

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

9
platform/entanglement/src/services/LocatingObjectDecorator.js
View File

@ -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);
});
}

40
platform/entanglement/test/services/LocatingObjectDecoratorSpec.js
View File

@ -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 () {

8
src/adapter/capabilities/AlternateCompositionCapability.js
View File

@ -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);
};