dop.intercept implemented

Author: Josema

package.json

@@ -1,6 +1,6 @@
 {
   "name": "dop",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "main": "./dist/dop.nodejs.js",
   "browser": "./dist/dop.js",
   "unpkg": "./dist/dop.min.js",

src/api/intercept.js

@@ -0,0 +1,38 @@
+
+dop.intercept = function(object, property, callback) {
+
+    dop.util.invariant(dop.isRegistered(object), 'dop.intercept() needs a registered object as first parameter');
+    var path = dop.getObjectPath(object);
+    dop.util.invariant(isArray(path), 'dop.intercept() The object you are passing is not allocated to a registered object');
+    var type = 'interceptors';
+    if (arguments.length === 2)
+        callback = property;
+        
+    dop.util.invariant(isFunction(callback), 'dop.intercept() needs a callback as last parameter');
+
+    var path_id = dop.core.getPathId(path),
+        data_path = dop.data.path;
+
+    if (arguments.length === 3) {
+        type = 'interceptors_prop';
+        path_id += dop.core.pathSeparator(property);
+    }
+
+    if (data_path[path_id] === undefined)
+        data_path[path_id] = {};
+
+    if (data_path[path_id][type] === undefined)
+        data_path[path_id][type] = [];
+
+    var interceptors = data_path[path_id][type];
+    interceptors.push(callback);
+
+    return function dispose() {
+        // delete interceptors[interceptors.indexOf(callback)]; // we splice in dop.core.runInterceptors
+        interceptors.splice(interceptors.indexOf(callback), 1);
+    };
+
+};
+
+
+

src/core/objects/storeMutation.js

@@ -2,17 +2,30 @@
 dop.core.storeMutation = function(mutation) {
 
     var collectors = dop.data.collectors,
+        paths = dop.data.path,
         index=0,
         total=collectors.length,
+        path_id_parent,
         path_id;
 
     // Saving path_id
-    path_id = mutation.path_id = dop.core.getPathId(mutation.path);
+    path_id_parent = path_id = mutation.path_id = dop.core.getPathId(mutation.path);
 
     if (mutation.splice===undefined && mutation.swaps===undefined)
         path_id += dop.core.pathSeparator(mutation.prop);
 
-    // Running collectors
+
+    // Interceptors objects
+    if (!dop.core.runInterceptors(paths[path_id_parent], 'interceptors', mutation))
+        return
+
+
+    // Interceptors properties
+    if (!dop.core.runInterceptors(paths[path_id], 'interceptors_prop', mutation))
+        return
+
+
+    // Collectors
     for (;index<total; index++)
         if (collectors[index].add(mutation))
             return dop.core.runDerivations(path_id);
@@ -22,4 +35,30 @@ dop.core.storeMutation = function(mutation) {
     snapshot.emit();
 
     dop.core.runDerivations(path_id);
-};
+};
+
+
+dop.core.runInterceptors = function(interceptors, type, mutation) {
+    if (interceptors && (interceptors=interceptors[type]) && interceptors.length>0)
+        for (var index=0,total=interceptors.length; index<total; ++index)
+            if (interceptors[index](mutation) !== true)
+                return false;
+
+    return true;
+};
+
+
+// dop.core.runInterceptors = function(interceptors, type, mutation) {
+//     if (interceptors && (interceptors=interceptors[type]) && interceptors.length>0) {
+//         for (var index=0,total=interceptors.length, tosplice=[]; index<total; ++index) {
+//             if (interceptors[index] === undefined)
+//                 tosplice.push(index);
+//             else if (interceptors[index](mutation) !== true)
+//                 return false;
+//         }
+//         for (index=0,total=tosplice.length; index<total; ++index)
+//             tosplice.splice(tosplice[index], 1);
+//     }
+
+//     return true;
+// };

src/dop.js

@@ -27,6 +27,8 @@ var dop = {
             // "1.thepath.value": {
                 // observers: {},
                 // observers_prop: {},
+                // interceptors: {},
+                // interceptors_prop: {},
                 // computeds: [],
                 // derivations: [],
             // }

test/interceptors.js

@@ -0,0 +1,83 @@
+var test = require('tape');
+// require('tabe').createStream( test );
+dop = require('./.proxy').create()
+var set = dop.set
+
+
+
+var object = dop.register({name:'Enzo'});
+
+
+
+test('Passing wrong arguments', function(t) {
+
+    var disposer;
+    try {disposer = dop.intercept()}
+    catch(e){t.equal(e.message.indexOf('needs a registered object')>-1,true, e.message)}
+
+    try {disposer = dop.intercept(object)}
+    catch(e){t.equal(e.message.indexOf('needs a callback')>-1,true, e.message)}
+
+    try {disposer = dop.intercept(object, 'name')}
+    catch(e){t.equal(e.message.indexOf('needs a callback')>-1,true, e.message)}
+
+    var disposer = dop.intercept(object, function(){})
+    t.equal(typeof disposer, 'function')
+    disposer()
+  
+    disposer = dop.intercept(object, 'name', function(){})
+    t.equal(typeof disposer, 'function')
+    disposer()
+
+    t.end();
+})
+
+
+
+test('Multiple interceptors', function(t) {
+    var inc = 1
+    var disposer1 = dop.intercept(object, 'name', function(mutation) {
+        t.equal(inc++, 2)
+        return true
+    })
+    var disposer2 = dop.intercept(object, function(mutation) {
+        t.equal(inc++, 1)
+        return true
+    })
+    var disposer3 = dop.intercept(object, 'name', function(mutation) {
+        t.equal(inc++, 3)
+        return true
+    })
+    var observer = dop.createObserver(function(mutation) {
+        disposer1();
+        disposer2();
+        disposer3();
+        observer.destroy()
+        t.equal(inc++, 4, 'observer')
+        t.end();
+    })
+    observer.observe(object, 'name')
+    set(object, 'name', 'John')
+})
+
+
+
+
+test('Second interceptor do not return true', function(t) {
+    var inc = 1
+    var disposer1 = dop.intercept(object, function(mutation) {
+        t.equal(inc++, 1)
+        return true
+    })
+    var disposer2 = dop.intercept(object, 'name', function(mutation) {
+        disposer1()
+        disposer2();
+        t.equal(inc++, 2)
+        t.end();
+    })
+    var observer = dop.createObserver(function(mutation) {
+        t.end(false,true, 'this shouldnt happen')
+    })
+    observer.observe(object, 'name')
+    set(object, 'name', 'Josema')
+})

test/setpatchs.js

@@ -32,10 +32,10 @@ function makeTest(t, collector, objServer, objClient) {
 var objServer = dop.register({
     number:1,
     subobject:{value1:true},
-    array:[{value1:true}],
+    array:[{value1:true},'B','C',4],
     subobjectarray:{array:[{value1:true}]},
 })
-var objClient = dop.util.merge({}, objServer);
+var objClient = dop.register(dop.util.merge({}, objServer));
 
 
 
@@ -45,6 +45,94 @@ test('Same initial', function(t) {
     t.end()
 })
 
+test('Splice 1', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(1,1,'Mola1')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+test('Splice 2', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(0,0,'Mola2')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+test('Splice 3', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(100,100,'Mola3')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+test('Splice 4', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(1,1,'Mola4')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+test('Splice 5', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(1,-100,'Mola5')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+
+test('Splice 6', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.splice(-1,2,'Mola6')
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+
+
+
+
+test('Swap 1', function(t) {
+
+    var collector = dop.collect()
+    objServer.array.reverse()
+
+    t.notDeepEqual(objServer, objClient)
+    makeTest(t, collector, objServer, objClient)
+    t.deepEqual(objServer, objClient)
+    t.end()
+})
+
+
+
+
+
+
+
 
 test('Deleting an subobject on destiny', function(t) {
     delete objClient.subobject
@@ -112,4 +200,5 @@ test('Mutating deep array in server when objclient does not have that array', fu
     makeTest(t, collector, objServer, objClient)
     t.equal(objClient.subobjectarray, undefined)
     t.end()
-})
+})
+

test/undoredo.js

@@ -218,3 +218,18 @@ test('From string to array and mutations', function(t) {
 
     makeTest(t, snapshot, original, object, mutated) 
 });
+
+
+
+
+test('Negative splice', function(t) {
+
+    var object = dop.register({dos:[1,2,3]})
+    var original = dop.util.clone(object)
+    var collector = dop.collect()
+    object.dos.splice(1,-1,'!') 
+    var snapshot = collector.emit()
+    var mutated = dop.util.clone(object)
+    
+    makeTest(t, snapshot, original, object, mutated) 
+});