[Entanglement] Add entanglement bundle

The entanglement bundle defines move, copy, and link actions, and
exposes them as context menu actions.

* The Move action moves an object from it's current parent to a new
parent object.
* The Copy action deep-copies an object to a new parent object.
* The Link action links an object to a new parent object.

These actions are implemented by three new services: moveService,
copyService, and linkService.

Mocks are provided for each service for easy testing of components
that depend on them.

Additionally, this bundle provides a DomainObjectFactory that simplifies
the construction of mockDomainObjects for tests.

These actions are exposed to the user as context menu options.

platform/entanglement/test/services/MoveServiceSpec.js

@@ -0,0 +1,154 @@
+/*global define,describe,beforeEach,it,jasmine,expect */
+define(
+    [
+        '../../src/services/MoveService',
+        '../services/MockLinkService',
+        '../DomainObjectFactory'
+    ],
+    function (MoveService, MockLinkService, domainObjectFactory) {
+        "use strict";
+
+        describe("MoveService", function () {
+
+            var moveService,
+                policyService,
+                linkService;
+
+            beforeEach(function () {
+                policyService = jasmine.createSpyObj(
+                    'policyService',
+                    ['allow']
+                );
+                linkService = new MockLinkService();
+                moveService = new MoveService(policyService, linkService);
+            });
+
+            describe("validate", function () {
+                var object,
+                    objectContextCapability,
+                    currentParent,
+                    parentCandidate,
+                    validate;
+
+                beforeEach(function () {
+
+                    objectContextCapability = jasmine.createSpyObj(
+                        'objectContextCapability',
+                        [
+                            'getParent'
+                        ]
+                    );
+
+                    object = domainObjectFactory({
+                        name: 'object',
+                        id: 'a',
+                        capabilities: {
+                            context: objectContextCapability
+                        }
+                    });
+
+                    currentParent = domainObjectFactory({
+                        name: 'currentParent',
+                        id: 'b'
+                    });
+
+                    objectContextCapability.getParent.andReturn(currentParent);
+
+                    parentCandidate = domainObjectFactory({
+                        name: 'parentCandidate',
+                        model: {composition: []},
+                        id: 'c'
+                    });
+
+                    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("and returns false", function () {
+                        policyService.allow.andReturn(false);
+                        expect(validate()).toBe(false);
+                    });
+
+                    it("and returns true", function () {
+                        policyService.allow.andReturn(true);
+                        expect(validate()).toBe(true);
+                    });
+                });
+            });
+
+            describe("perform", function () {
+
+                var object,
+                    parentObject,
+                    actionCapability;
+
+                beforeEach(function () {
+                    actionCapability = jasmine.createSpyObj(
+                        'actionCapability',
+                        ['perform']
+                    );
+
+                    object = domainObjectFactory({
+                        name: 'object',
+                        capabilities: {
+                            action: actionCapability
+                        }
+                    });
+
+                    parentObject = domainObjectFactory({
+                        name: 'parentObject'
+                    });
+
+                    moveService.perform(object, parentObject);
+                });
+
+                it("links object to parentObject", function () {
+                    expect(linkService.perform).toHaveBeenCalledWith(
+                        object,
+                        parentObject
+                    );
+                });
+
+                it("waits for result of link", function () {
+                    expect(linkService.perform.mostRecentCall.promise.then)
+                        .toHaveBeenCalledWith(jasmine.any(Function));
+                });
+
+                it("removes object when link is completed", function () {
+                    linkService.perform.mostRecentCall.resolve();
+                    expect(object.getCapability)
+                        .toHaveBeenCalledWith('action');
+                    expect(actionCapability.perform)
+                        .toHaveBeenCalledWith('remove');
+                });
+
+            });
+        });
+    }
+);