Add additional functions to TwoPhaseCore. Closes #1706 (#1707)

brollb · web-flow · commit e46b89a10930 · 2020-05-19T19:43:20.000-05:00
* Add additional functions to TwoPhaseCore. Closes #1706 * Added tests for TwoPhaseCore
diff --git a/src/plugins/TwoPhaseCommit/CreatedNode.js b/src/plugins/TwoPhaseCommit/CreatedNode.js
@@ -2,35 +2,87 @@
 define([
 ], function(
 ) {
-    CreatedNode.CREATE_PREFIX = 'created_node_';
     let counter = 0;
-    function CreatedNode(base, parent) {
-        this.id = CreatedNode.CREATE_PREFIX + (++counter);
-        this.base = base;
-        this.parent = parent;
-        this._nodeId = null;
+    class CreatedNode {
+        constructor(base, parent) {
+            this.id = CreatedNode.CREATE_PREFIX + (++counter);
+            this.base = base;
+            this.parent = parent;
+            this._nodeId = null;
+        }
+
+        static async getGMENode (rootNode, core, node) {
+            return !(node instanceof CreatedNode) ?
+                await core.loadByPath(rootNode, core.getPath(node)) :
+                await node.toGMENode(rootNode, core);
+        }
+
+        async toGMENode (rootNode, core) {
+            if (!this._nodeId) {
+                const parent = await CreatedNode.getGMENode(rootNode, core, this.parent);
+                const base = await CreatedNode.getGMENode(rootNode, core, this.base);
+                const node = core.createNode({base, parent});
+                this._nodeId = core.getPath(node);
+                return node;
+            }
+            return core.loadByPath(rootNode, this._nodeId);
+        }
+
+        async getInheritedChildren (core) {
+            if (this.base instanceof CreatedNode) {
+                return this.base.getInheritedChildren(core);
+            } else {
+                return (await core.loadChildren(this.base))
+                    .map(node => new InheritedNode(node, this));
+            }
+        }
+
+        static isCreateId (id) {
+            return (typeof id === 'string') && (id.indexOf(CreatedNode.CREATE_PREFIX) === 0);
+        }
     }
+    CreatedNode.CREATE_PREFIX = 'created_node_';
+
+    class InheritedNode extends CreatedNode {
+        async toGMENode (rootNode, core) {
+            if (!this._nodeId) {
+                const parent = await CreatedNode.getGMENode(rootNode, core, this.parent);
+                const base = await CreatedNode.getGMENode(rootNode, core, this.base);
+                const children = await core.loadChildren(parent);
+                const basePath = core.getPath(base);
+                const node = children
+                    .find(node => core.getPath(core.getBase(node)) === basePath);
 
-    CreatedNode.getGMENode = async function(rootNode, core, node) {
-        return !(node instanceof CreatedNode) ?
-            await core.loadByPath(rootNode, core.getPath(node)) :
-            await node.toGMENode(rootNode, core);
-    };
+                this._nodeId = core.getPath(node);
+                return node;
+            }
+            return core.loadByPath(rootNode, this._nodeId);
+        }
+    }
 
-    CreatedNode.prototype.toGMENode = async function(rootNode, core) {
-        if (!this._nodeId) {
-            const parent = await CreatedNode.getGMENode(rootNode, core, this.parent);
-            const base = await CreatedNode.getGMENode(rootNode, core, this.base);
-            const node = core.createNode({base, parent});
-            this._nodeId = core.getPath(node);
-            return node;
+    class CopiedNode extends CreatedNode {
+        constructor(original, parent) {
+            super(original, parent);
+            this.parent = parent;
+            this.original = original;
         }
-        return core.loadByPath(rootNode, this._nodeId);
-    };
 
-    CreatedNode.isCreateId = function (id) {
-        return (typeof id === 'string') && (id.indexOf(CreatedNode.CREATE_PREFIX) === 0);
-    };
+        async toGMENode (rootNode, core) {
+            if (!this._nodeId) {
+                const parent = await CreatedNode.getGMENode(rootNode, core, this.parent);
+                const original = await CreatedNode.getGMENode(rootNode, core, this.original);
+                const node = core.copyNode(original, parent);
+                this._nodeId = core.getPath(node);
+                return node;
+            }
+            return core.loadByPath(rootNode, this._nodeId);
+        }
+
+        async getInheritedChildren (/*core*/) {
+            throw new Error('Cannot get children of copied node');
+        }
+    }
 
+    CreatedNode.CopiedNode = CopiedNode;
     return CreatedNode;
 });
diff --git a/src/plugins/TwoPhaseCommit/TwoPhaseCore.js b/src/plugins/TwoPhaseCommit/TwoPhaseCore.js
@@ -3,10 +3,12 @@ define([
     './StagedChanges',
     './CreatedNode',
     'common/util/assert',
+    'underscore',
 ], function(
     StagedChanges,
     CreatedNode,
     assert,
+    _,
 ) {
     function TwoPhaseCore(logger, core) {
         this.logger = logger;
@@ -30,19 +32,110 @@ define([
 
     passToCore('persist');
     passToCore('loadRoot');
-    passToCore('loadByPath');
     passToCore('loadSubTree');
-    passToCore('getPointerPath');
     passToCore('getParent');
     passToCore('getNamespace');
-    passToCore('getMetaType');
     passToCore('getChildrenMeta');
     passToCore('getChildrenPaths');
     passToCore('addMember');
     passToCore('isMetaNode');
     passToCore('getOwnRegistry');
     passToCore('getOwnAttribute');
     passToCore('getAttributeNames');
+    passToCore('getValidAttributeNames');
+    passToCore('getValidPointerNames');
+
+    TwoPhaseCore.prototype.loadByPath = async function (node, id) {
+        ensureNode(node, 'loadByPath');
+        if (CreatedNode.isCreateId(id)) {
+            const changesets = this.queuedChanges.concat(this);
+            for (let i = 0; i < changesets.length; i++) {
+                const createdNodes = changesets[i].createdNodes;
+                const node = createdNodes.find(node => node.id === id);
+                if (node) {
+                    return node;
+                }
+            }
+        } else {
+            return this.core.loadByPath(node, id);
+        }
+    };
+
+    TwoPhaseCore.prototype.getMetaType = function (node) {
+        ensureNode(node, 'getMetaType');
+        while (node instanceof CreatedNode) {
+            node = node.base;
+        }
+        return this.core.getMetaType(node);
+    };
+
+    TwoPhaseCore.prototype.getOwnAttributeNames = function (node) {
+        ensureNode(node, 'getOwnAttributeNames');
+        const isNewNode = node instanceof CreatedNode;
+        let names = [];
+        if (!isNewNode) {
+            names = this.core.getOwnAttributeNames(node);
+        }
+
+        function updateAttributeNames(changes={attr:{}}, names) {
+            const [setAttrs, delAttrs] = Object.entries(changes.attr)
+                .reduce((setAndDel, attr) => {
+                    const [sets, dels] = setAndDel;
+                    const [name, value] = attr;
+                    if (value === null) {
+                        dels.push(name);
+                    } else {
+                        sets.push(name);
+                    }
+                    return setAndDel;
+                }, [[], []]);
+            names = _.union(names, setAttrs);
+            names = _.without(names, ...delAttrs);
+            return names;
+        }
+
+        this._forAllNodeChanges(
+            node,
+            changes => names = updateAttributeNames(changes, names)
+        );
+
+        return names;
+    };
+
+    TwoPhaseCore.prototype.getOwnPointerNames = function (node) {
+        ensureNode(node, 'getOwnPointerNames');
+        const isNewNode = node instanceof CreatedNode;
+        let names = [];
+        if (!isNewNode) {
+            names = this.core.getOwnPointerNames(node);
+        }
+
+        function updatePointerNames(changes={ptr:{}}, names) {
+            const ptrNames = Object.keys(changes.ptr);
+            return _.union(names, ptrNames);
+        }
+
+        this._forAllNodeChanges(
+            node,
+            changes => names = updatePointerNames(changes, names)
+        );
+
+        return names;
+    };
+
+    TwoPhaseCore.prototype._forAllNodeChanges = function (node, fn) {
+        const nodeId = this.getPath(node);
+        for (let i = 0; i < this.queuedChanges.length; i++) {
+            const changes = this.queuedChanges[i].getNodeEdits(nodeId);
+            if (changes) {
+                fn(changes);
+            }
+        }
+        const changes = this.getChangesForNode(node);
+        if (changes) {
+            fn(changes);
+        }
+    };
 
     TwoPhaseCore.prototype.getBase = function (node) {
         ensureNode(node, 'getBase');
@@ -100,6 +193,17 @@ define([
         return this.changes[nodeId];
     };
 
+    TwoPhaseCore.prototype.copyNode = function (node, parent) {
+        assert(node, 'Cannot copy invalid node');
+        assert(parent, 'Cannot copy node without parent');
+        ensureNode(node, 'copyNode');
+        ensureNode(parent, 'copyNode');
+
+        const newNode = new CreatedNode(node, parent);
+        this.createdNodes.push(newNode);
+        return newNode;
+    };
+
     TwoPhaseCore.prototype.createNode = function (desc) {
         const {parent, base} = desc;
         assert(parent, 'Cannot create node without parent');
@@ -128,7 +232,9 @@ define([
             .reduce((l1, l2) => l1.concat(l2));
 
         let children = allCreatedNodes.filter(node => getId(node.parent) === nodeId);
-        if (!(node instanceof CreatedNode)) {
+        if (node instanceof CreatedNode) {
+            children = children.concat(await node.getInheritedChildren(this.core));
+        } else {
             children = children.concat(await this.core.loadChildren(node));
         }
         return children;
@@ -151,6 +257,28 @@ define([
         changes.attr[attr] = value;
     };
 
+    TwoPhaseCore.prototype.getPointerPath = function (node, name) {
+        ensureNode(node, 'getPointerPath');
+        let path = null;
+        if (!(node instanceof CreatedNode)) {
+            path = this.core.getPointerPath(node, name);
+        } else if (name === 'base') {
+            path = this.getPath(node.base);
+        }
+
+        this._forAllNodeChanges(
+            node,
+            changes => {
+                if (changes.ptr.hasOwnProperty(name)) {
+                    const target = changes.ptr[name];
+                    path = target && this.getPath(target);
+                }
+            }
+        );
+
+        return path;
+    };
+
     TwoPhaseCore.prototype.getAttribute = function (node, attr) {
         ensureNode(node, 'getAttribute');
         var nodeId;
diff --git a/test/unit/plugins/TwoPhaseCommit/TwoPhaseCommit.spec.js b/test/unit/plugins/TwoPhaseCommit/TwoPhaseCommit.spec.js
@@ -547,32 +547,4 @@ describe('TwoPhaseCommit', function() {
             assert(!childNames.includes('goodbye'), 'Included node created after save.');
         });
     });
-
-    describe('argument validation', function() {
-        const methods = [
-            'getPath',
-            'getBase',
-            'setAttribute',
-            'isTypeOf',
-            'setPointer',
-            'deleteNode',
-            'delAttribute',
-        ];
-
-        methods.forEach(method => {
-            it(`should check node types on ${method}`, function() {
-                const invalidNode = {relid: 'h'};
-                assert.throws(() => plugin.core[method](invalidNode));
-            });
-        });
-
-        it('should check node types on loadChildren', async function() {
-            const invalidNode = {relid: 'h'};
-            try {
-                await plugin.core.loadChildren(invalidNode);
-                throw new Error('Did not throw exception.');
-            } catch (err) {
-            }
-        });
-    });
 });
diff --git a/test/unit/plugins/TwoPhaseCommit/TwoPhaseCore.spec.js b/test/unit/plugins/TwoPhaseCommit/TwoPhaseCore.spec.js
