Merge branch 'open1062' into open-master

Merge changes for WTD-1062

platform/commonUI/edit/bundle.json

@@ -41,7 +41,7 @@
             },
             {
                 "key": "properties",
-                "category": "contextual",
+                "category": ["contextual", "view-control"],
                 "implementation": "actions/PropertiesAction.js",
                 "glyph": "p",
                 "name": "Edit Properties...",
@@ -75,6 +75,16 @@
                 "depends": [ "$location" ]
             }
         ],
+        "policies": [
+            {
+                "category": "action",
+                "implementation": "policies/EditActionPolicy.js"
+            },
+            {
+                "category": "view",
+                "implementation": "policies/EditableViewPolicy.js"
+            }
+        ],
         "templates": [
             {
                 "key": "edit-library",

platform/commonUI/edit/src/policies/EditActionPolicy.js

@@ -0,0 +1,61 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Policy controlling when the `edit` and/or `properties` actions
+         * can appear as applicable actions of the `view-control` category
+         * (shown as buttons in the top-right of browse mode.)
+         * @constructor
+         */
+        function EditActionPolicy() {
+            // Get a count of views which are not flagged as non-editable.
+            function countEditableViews(context) {
+                var domainObject = (context || {}).domainObject,
+                    views = domainObject && domainObject.useCapability('view'),
+                    count = 0;
+
+                // A view is editable unless explicitly flagged as not
+                (views || []).forEach(function (view) {
+                    count += (view.editable !== false) ? 1 : 0;
+                });
+
+                return count;
+            }
+
+            return {
+                /**
+                 * Check whether or not a given action is allowed by this
+                 * policy.
+                 * @param {Action} action the action
+                 * @param context the context
+                 * @returns {boolean} true if not disallowed
+                 */
+                allow: function (action, context) {
+                    var key = action.getMetadata().key,
+                        category = (context || {}).category;
+
+                    // Only worry about actions in the view-control category
+                    if (category === 'view-control') {
+                        // Restrict 'edit' to cases where there are editable
+                        // views (similarly, restrict 'properties' to when
+                        // the converse is true)
+                        if (key === 'edit') {
+                            return countEditableViews(context) > 0;
+                        } else if (key === 'properties') {
+                            return countEditableViews(context) < 1;
+                        }
+                    }
+
+                    // Like all policies, allow by default.
+                    return true;
+                }
+            };
+        }
+
+        return EditActionPolicy;
+    }
+);

platform/commonUI/edit/src/policies/EditableViewPolicy.js

@@ -0,0 +1,36 @@
+/*global define*/
+
+define(
+    [],
+    function () {
+        "use strict";
+
+        /**
+         * Policy controlling which views should be visible in Edit mode.
+         * @constructor
+         */
+        function EditableViewPolicy() {
+            return {
+                /**
+                 * Check whether or not a given action is allowed by this
+                 * policy.
+                 * @param {Action} action the action
+                 * @param domainObject the domain object which will be viewed
+                 * @returns {boolean} true if not disallowed
+                 */
+                allow: function (view, domainObject) {
+                    // If a view is flagged as non-editable, only allow it
+                    // while we're not in Edit mode.
+                    if ((view || {}).editable === false) {
+                        return !domainObject.hasCapability('editor');
+                    }
+
+                    // Like all policies, allow by default.
+                    return true;
+                }
+            };
+        }
+
+        return EditableViewPolicy;
+    }
+);

platform/commonUI/edit/test/policies/EditActionPolicySpec.js

@@ -0,0 +1,78 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ["../../src/policies/EditActionPolicy"],
+    function (EditActionPolicy) {
+        "use strict";
+
+        describe("The Edit action policy", function () {
+            var editableView,
+                nonEditableView,
+                undefinedView,
+                testViews,
+                testContext,
+                mockDomainObject,
+                mockEditAction,
+                mockPropertiesAction,
+                policy;
+
+            beforeEach(function () {
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    [ 'useCapability' ]
+                );
+                mockEditAction = jasmine.createSpyObj('edit', ['getMetadata']);
+                mockPropertiesAction = jasmine.createSpyObj('edit', ['getMetadata']);
+
+                editableView = { editable: true };
+                nonEditableView = { editable: false };
+                undefinedView = { someKey: "some value" };
+                testViews = [];
+
+                mockDomainObject.useCapability.andCallFake(function (c) {
+                    // Provide test views, only for the view capability
+                    return c === 'view' && testViews;
+                });
+
+                mockEditAction.getMetadata.andReturn({ key: 'edit' });
+                mockPropertiesAction.getMetadata.andReturn({ key: 'properties' });
+
+                testContext = {
+                    domainObject: mockDomainObject,
+                    category: 'view-control'
+                };
+
+                policy = new EditActionPolicy();
+            });
+
+            it("allows the edit action when there are editable views", function () {
+                testViews = [ editableView ];
+                expect(policy.allow(mockEditAction, testContext)).toBeTruthy();
+                // No edit flag defined; should be treated as editable
+                testViews = [ undefinedView, undefinedView ];
+                expect(policy.allow(mockEditAction, testContext)).toBeTruthy();
+            });
+
+            it("allows the edit properties action when there are no editable views", function () {
+                testViews = [ nonEditableView, nonEditableView ];
+                expect(policy.allow(mockPropertiesAction, testContext)).toBeTruthy();
+            });
+
+            it("disallows the edit action when there are no editable views", function () {
+                testViews = [ nonEditableView, nonEditableView ];
+                expect(policy.allow(mockEditAction, testContext)).toBeFalsy();
+            });
+
+            it("disallows the edit properties action when there are editable views", function () {
+                testViews = [ editableView ];
+                expect(policy.allow(mockPropertiesAction, testContext)).toBeFalsy();
+            });
+
+            it("allows the edit properties outside of the 'view-control' category", function () {
+                testViews = [ nonEditableView ];
+                testContext.category = "something-else";
+                expect(policy.allow(mockPropertiesAction, testContext)).toBeTruthy();
+            });
+        });
+    }
+);

platform/commonUI/edit/test/policies/EditableViewPolicySpec.js

@@ -0,0 +1,56 @@
+/*global define,describe,it,expect,beforeEach,jasmine*/
+
+define(
+    ["../../src/policies/EditableViewPolicy"],
+    function (EditableViewPolicy) {
+        "use strict";
+
+        describe("The editable view policy", function () {
+            var testView,
+                mockDomainObject,
+                testMode,
+                policy;
+
+            beforeEach(function () {
+                testMode = true; // Act as if we're in Edit mode by default
+                mockDomainObject = jasmine.createSpyObj(
+                    'domainObject',
+                    ['hasCapability']
+                );
+                mockDomainObject.hasCapability.andCallFake(function (c) {
+                    return (c === 'editor') && testMode;
+                });
+
+                policy = new EditableViewPolicy();
+            });
+
+            it("disallows views in edit mode that are flagged as non-editable", function () {
+                expect(policy.allow({ editable: false }, mockDomainObject))
+                    .toBeFalsy();
+            });
+
+            it("allows views in edit mode that are flagged as editable", function () {
+                expect(policy.allow({ editable: true }, mockDomainObject))
+                    .toBeTruthy();
+            });
+
+            it("allows any view outside of edit mode", function () {
+                var testViews = [
+                    { editable: false },
+                    { editable: true },
+                    { someKey: "some value" }
+                ];
+                testMode = false; // Act as if we're not in Edit mode
+
+                testViews.forEach(function (testView) {
+                    expect(policy.allow(testView, mockDomainObject)).toBeTruthy();
+                });
+            });
+
+            it("treats views with no defined 'editable' property as editable", function () {
+                expect(policy.allow({ someKey: "some value" }, mockDomainObject))
+                    .toBeTruthy();
+            });
+        });
+    }
+);

platform/commonUI/edit/test/suite.json

@@ -18,6 +18,8 @@
     "objects/EditableDomainObject",
     "objects/EditableDomainObjectCache",
     "objects/EditableModelCache",
+    "policies/EditableViewPolicy",
+    "policies/EditActionPolicy",
     "representers/EditRepresenter",
     "representers/EditToolbar",
     "representers/EditToolbarRepresenter",