fixes after new invalidation logic

Author: sbazerque

src/data/model/MutableObject.ts

@@ -12,6 +12,7 @@ import { HashReference } from './HashReference';
 import { Lock } from 'util/concurrency';
 import { MultiMap } from 'util/multimap';
 import { Resources } from 'spaces/Resources';
+import { CascadedInvalidateOp } from './CascadedInvalidateOp';
 //import { ObjectStateAgent } from 'sync/agents/state/ObjectStateAgent';
 //import { TerminalOpsStateAgent } from 'sync/agents/state/TerminalOpsStateAgent';
 
@@ -27,7 +28,7 @@ abstract class MutableObject extends HashedObject {
 
     _allAppliedOps : Set<Hash>;
     _terminalOps   : Map<Hash, HashReference<MutationOp>>;
-    _undoOpsPerOp       : MultiMap<Hash, Hash>;
+    _activeUndosOpsPerOp       : MultiMap<Hash, Hash>;
 
 
     _unsavedOps      : Array<MutationOp>;
@@ -47,11 +48,8 @@ abstract class MutableObject extends HashedObject {
         this._supportsUndo = supportsUndo;
 
         if (supportsUndo) {
-            if (acceptedOpClasses.indexOf(UndoOp.className) < 0) {
-                acceptedOpClasses.push(UndoOp.className);
-            }
-            if (acceptedOpClasses.indexOf(RedoOp.className) < 0) {
-                acceptedOpClasses.push(RedoOp.className);
+            if (acceptedOpClasses.indexOf(CascadedInvalidateOp.className) < 0) {
+                acceptedOpClasses.push(CascadedInvalidateOp.className);
             }
         }
 
@@ -60,7 +58,7 @@ abstract class MutableObject extends HashedObject {
 
         this._allAppliedOps = new Set();
         this._terminalOps   = new Map();
-        this._undoOpsPerOp  = new MultiMap();
+        this._activeUndosOpsPerOp  = new MultiMap();
 
         this._unsavedOps      = [];
         this._unappliedOps    = new Map();
@@ -76,12 +74,6 @@ abstract class MutableObject extends HashedObject {
 
     abstract mutate(op: MutationOp, isNew: boolean): Promise<boolean>;
 
-    async undo(op: MutationOp, isNew: boolean): Promise<boolean> {
-        op; isNew;
-
-        throw new Error('Class "' + this.getClassName() + '" does not support operation undo, yet one was received.');
-    }
-
     addMutationCallback(cb: (mut: MutationOp) => void) {
         this._externalMutationCallbacks.add(cb);
     }
@@ -298,68 +290,42 @@ abstract class MutableObject extends HashedObject {
 
         this._allAppliedOps.add(opHash);
 
-        
-        if (op instanceof UndoOp) {
-
-            const targetOp     = op.targetOp as MutationOp;
-            const targetOpHash = targetOp.hash();
-
-            const alreadyUndone = this._undoOpsPerOp.get(targetOpHash).size > 0;
+        let shouldMutate = true;
 
-            this._undoOpsPerOp.add(targetOpHash, opHash);
+        if (op instanceof CascadedInvalidateOp) {
 
-            if (!alreadyUndone) {
-                const done = this.undo(targetOp, isNew).then((mutated: boolean) => {
-                    if (mutated) {
-                        for (const cb of this._externalMutationCallbacks) {
-                            cb(op);
-                        }
-                    }
-                });
-    
-                return done;    
-            } else {
-                return Promise.resolve();
+            let currentOp = op;
+            while (currentOp.getTargetOp() instanceof CascadedInvalidateOp) {
+                currentOp = currentOp.getTargetOp() as CascadedInvalidateOp;
             }
 
-        } else {
-
-            let targetOp = op;
-            let needToApply = true;
-
-            if (op instanceof RedoOp) {
-
-                const targetUndoOp     = op.targetOp as UndoOp;
-                const targetUndoOpHash = targetUndoOp.hash();
+            const finalTargetOp     = currentOp.getTargetOp();
+            const finalTargetOpHash = finalTargetOp.hash();
 
-                targetOp = targetUndoOp.targetOp as MutationOp;
-
-                const targetOpHash = targetOp.hash();
-
-                const wasUndone = this._undoOpsPerOp.get(targetOpHash).size > 0;
-                
-                this._undoOpsPerOp.delete(targetOpHash, targetUndoOpHash);
-
-                const shouldRedo = wasUndone && this._undoOpsPerOp.get(targetOpHash).size === 0;
+            
+            const isUndone = this._activeUndosOpsPerOp.get(finalTargetOpHash).size > 0;
 
-                needToApply = shouldRedo;
+            shouldMutate = isUndone !== op.undo;
 
+            if (op.undo) {
+                this._activeUndosOpsPerOp.add(finalTargetOpHash, opHash);
+            } else { // redo
+                this._activeUndosOpsPerOp.delete(finalTargetOpHash, op.getTargetOp().hash());
             }
+        }
 
-            if (needToApply) {
-                const done = this.mutate(targetOp, isNew).then((mutated: boolean) => {
-                    if (mutated) {
-                        for (const cb of this._externalMutationCallbacks) {
-                            cb(targetOp);
-                        }
-                    }        
-                });
-        
-                return done;
-            } else {
-                return Promise.resolve();
-            }
-            
+        if (shouldMutate) {
+            const done = this.mutate(op, isNew).then((mutated: boolean) => {
+                if (mutated) {
+                    for (const cb of this._externalMutationCallbacks) {
+                        cb(op);
+                    }
+                }        
+            });
+    
+            return done;
+        } else {
+            return Promise.resolve();
         }
     }