Changed the system of observers based absolute paths instead of storing inside of the object

Author: Josema

README.md

@@ -2,7 +2,7 @@
 <p align="center"><a href="https://distributedobjectprotocol.org"><img width="200"src="https://distributedobjectprotocol.org/img/logo.svg"></a></p>
 
 <p align="center">
-    <a href="https://www.npmjs.com/package/dop"><img alt="npm version" src="https://img.shields.io/npm/v/dop.svg"></a>
+    <a href="https://www.npmjs.com/package/dop"><img alt="npm version" src="https://badge.fury.io/js/dop.svg"></a>
     <a href="https://travis-ci.org/DistributedObjectProtocol/dop"><img alt="Build Status" src="https://travis-ci.org/DistributedObjectProtocol/dop.svg?branch=master"></a>
     <a href="https://www.npmjs.com/package/dop"><img alt="license" src="https://img.shields.io/npm/l/dop.svg"></a>
     <a href="https://gitter.im/DistributedObjectProtocol/dop?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img alt="Join the chat at" src="https://badges.gitter.im/DistributedObjectProtocol/dop.svg"></a>

package.json

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

src/api/observe.js

@@ -1,9 +1,16 @@
 
-dop.observe = function(object, callback) {
+dop.observe = function(object, property) {
     dop.util.invariant(dop.isRegistered(object), 'dop.observe needs a registered object as first parameter');
+    var args = arguments;
+        callback = args[args.length-1];
     dop.util.invariant(isFunction(callback), 'dop.observe needs a callback as second parameter');
 
     var observer = dop.createObserver(callback);
-    observer.observe(object);
+    
+    (args.length===2) ?
+        observer.observe(object)
+    :
+        observer.observe(object, property);
+        
     return observer;
 };

src/api/observeProperty.js

@@ -2,81 +2,65 @@
 dop.core.observer = function(callback, id) {
     this.callback = callback;
     this.id = id;
-    this.objects = [];
-    this.properties = {};
+    this.observers = {}; // need it for destroy()
+    this.observers_prop = {}; // need it for destroy()
 };
 
 
-dop.core.observer.prototype.observe = function(object) {
+dop.core.observer.prototype.observe = function(object, property) {
     dop.util.invariant(dop.isRegistered(object), 'observer.observe needs a registered object as first parameter');
-    var object_dop = dop.getObjectDop(object);
-    if (object_dop.om[this.id] === undefined) {
-        // Storing in object
-        object_dop.om[this.id] = true;
-        // Storing in observer
-        this.objects.push(object); // using for .destroy()
+    
+    var path_id = dop.core.getPathId(dop.getObjectPath(object, false)),
+        data_path = dop.data.path,
+        type = 'observers';
+
+    // is observeProperty
+    if (arguments.length === 2) {
+        type = 'observers_prop';
+        path_id += dop.core.pathSeparator(property);
     }
-};
-dop.core.observer.prototype.unobserve = function(object) {
-    dop.util.invariant(dop.isRegistered(object), 'observer.unobserve needs a registered object as first parameter');
-    // Removing from object
-    delete dop.getObjectDop(object).om[this.id];
-    // Removing from observer
-    var index = this.objects.indexOf(object);  // using for .destroy()
-    if (index > -1)
-        this.objects.splice(index,1); // using for .destroy()
+
+    if (data_path[path_id] === undefined)
+        data_path[path_id] = {};
+
+    if (data_path[path_id][type] === undefined)
+        data_path[path_id][type] = {};
+
+    data_path[path_id][type][this.id] = true;
+    this[type][path_id] = true;
 };
 
 
+dop.core.observer.prototype.unobserve = function(object, property) {
+    dop.util.invariant(dop.isRegistered(object), 'observer.unobserve needs a registered object as first parameter');
+    
+    var path_id = dop.core.getPathId(dop.getObjectPath(object, false)),
+        data_path = dop.data.path,
+        type = 'observers';
 
-dop.core.observer.prototype.observeProperty = function(object, property) {
-    dop.util.invariant(dop.isRegistered(object), 'observer.observeProperty needs a registered object as first parameter');
-    // Storing in object
-    var object_dop = dop.getObjectDop(object);
-    if (object_dop.omp[property] === undefined)
-        object_dop.omp[property] = {};
-    if (object_dop.omp[property][this.id] === undefined) {
-        object_dop.omp[property][this.id] = true;
-        // Storing in observer
-        if (this.properties[property] === undefined)
-            this.properties[property] = [];
-        this.properties[property].push(object); // using for .destroy()
+    // is observeProperty
+    if (arguments.length === 2) {
+        type = 'observers_prop';
+        path_id += dop.core.pathSeparator(property);
     }
-};
-dop.core.observer.prototype.unobserveProperty = function(object, property) {
-    dop.util.invariant(dop.isRegistered(object), 'observer.unobserveProperty needs a registered object as first parameter');
-    var object_dop = dop.getObjectDop(object),
-        properties = this.properties[property],
-        index;
-    // Removing from object
-    if (object_dop.omp[property] !== undefined)
-        delete object_dop.omp[property][this.id];
-    // Removing from observer
-    if (properties !== undefined) {
-        index = properties.indexOf(object);  // using for .destroy()
-        if (index > -1)
-            properties.splice(index,1); // using for .destroy()
+
+    if (data_path[path_id] !== undefined && data_path[path_id][type] !== undefined) {
+        delete data_path[path_id][type][this.id];
+        delete this[type][path_id];
     }
 };
 
 
 dop.core.observer.prototype.destroy = function() {
-    var index=0,
-        objectsandproperties = this.objects,
-        total=objectsandproperties.length,
-        property;
-    
-    // Deleting objects
-    for (;index<total; ++index)
-        delete dop.getObjectDop(objectsandproperties[index]).om[this.id];
+    var path_id,
+        data_path = dop.data.path;
+        
+    delete dop.data.observers[this.id];
 
-    // Deleting properties
-    objectsandproperties = this.properties;
-    for (property in objectsandproperties)
-        for (index=0,total=objectsandproperties[property].length; index<total; ++index)
-            delete dop.getObjectDop(objectsandproperties[property][index]).omp[property][this.id];
+    for (path_id in this.observers)
+        delete data_path[path_id].observers[this.id];
 
-    // Deleting from dop.data
-    delete dop.data.observers[this.id];
+    for (path_id in this.observers_prop)
+        delete data_path[path_id].observers_prop[this.id];
 };
 

src/core/constructors/observer.js

@@ -18,9 +18,7 @@ dop.core.configureObject = function(object, propertyParent, parent) {
     var object_dop = {}, object_proxy, object_target;
     object_dop._ = parent; // parent
     object_dop.pr = propertyParent; // property
-    object_dop.om = {}; // observers multiple
-    object_dop.omp = {}; // observers multiple property
-    object_dop.m = []; // temporal mutations before will be emitted
+    
     // Making proxy object
     if (canWeProxy) {
         object_proxy = object_dop.p = new Proxy(object, dop.core.proxyObjectHandler);

src/core/objects/configureObject.js

@@ -0,0 +1,50 @@
+
+dop.core.emitToObservers = function(mutations) {
+
+    var mutation,
+        path_id,
+        observer_id,
+        observers = {},
+        mutationsWithSubscribers = false,
+        data_path = dop.data.path,
+        index = 0,
+        total = mutations.length;
+
+    for (;index<total; ++index) {
+        mutation = mutations[index];
+        path_id = mutation.path_id;
+
+        if (!mutationsWithSubscribers && isObject(dop.data.object[dop.getObjectId(mutation.object)]))
+            mutationsWithSubscribers = true;
+
+
+        if (data_path[path_id] !== undefined && data_path[path_id].observers !== undefined) {
+            for (observer_id in data_path[path_id].observers) {
+                if (observers[observer_id] === undefined)
+                    observers[observer_id] = [];
+                observers[observer_id].push(mutation);
+            }
+        }
+
+        // If mutation is swap type we should skip
+        if (mutation.swaps === undefined) {
+            path_id += dop.core.pathSeparator(mutation.splice===undefined ? mutation.prop : 'length');
+            if (data_path[path_id] !== undefined && data_path[path_id].observers_prop !== undefined) {
+                for (observer_id in data_path[path_id].observers_prop) {
+                    if (observers[observer_id] === undefined)
+                        observers[observer_id] = [];
+                    // We have to check this because we dont want to duplicate
+                    if (observers[observer_id].indexOf(mutation) == -1)
+                        observers[observer_id].push(mutation);
+                }
+            }
+        }
+
+    }
+
+    // Emiting
+    for (observer_id in observers)
+        dop.data.observers[observer_id].callback(observers[observer_id]);
+
+    return mutationsWithSubscribers;
+};

src/core/objects/emitObservers.js

@@ -8,7 +8,7 @@ dop.core.proxyObjectHandler = {
         return dop.core.delete(dop.getObjectProxy(object), property) !== undefined;
     },
     get: function(object, property) {
-        if (dop.data.gets_collecting && typeof property == 'string' && property !== dop.cons.DOP && object[property] !== Object.prototype[property])
+        if (dop.data.gets_collecting && typeof property == 'string' && property !== dop.cons.DOP && object[property] !== Array.prototype[property])
             dop.data.gets_paths.push(dop.getObjectPath(object, false).concat(property));
 
         return object[property];

src/core/objects/emitToObservers.js

@@ -17,16 +17,19 @@ var dop = {
         gets_collecting: false,
         gets_paths: [],
 
-        observers_inc: 0,
-        observers: {},
-
         computed_inc: 0,
         computed: {},
 
+        observers_inc: 0,
+        observers: {},
+
         path: {
-            // computeds: []
-            // derivations: []
-            // observers: []
+            // "1.thepath.value": {
+                // observers: {},
+                // observers_prop: {},
+                // computeds: [],
+                // derivations: [],
+            // }
         }
     },