We update computed values after each recalculation to observe new derivations

Author: Josema

package.json

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

src/core/objects/createComputed.js

@@ -1,73 +1,30 @@
 
-dop.core.createComputed = function (object, property, f, shallWeSet, oldValue) {
-
-    var computed_id = dop.data.computed_inc++,
-        data_path = dop.data.path,
-        derived_paths,
-        derived_pathsids = [],
-        derived_path,
-        derived_pathid,
-        computed_path,
-        computed_pathid,
-        value,
-        index = 0,
-        total,
-        index2,
-        total2;
-
-
-    // Running function and saving paths from getters
-    dop.data.gets_collecting = true;
-    value = f.call(object, oldValue);
-    dop.data.gets_collecting = false;
-    derived_paths = dop.data.gets_paths;
-    dop.data.gets_paths = [];
-
-
-    // Generating and storing paths ids
-    for (total=derived_paths.length; index<total; ++index) {
-        derived_path = derived_paths[index];
-        derived_pathid = '';
-        for (index2=0,total2=derived_path.length; index2<total2; ++index2) {
-            derived_pathid += dop.core.pathSeparator(derived_path[index2]);
-            if (index2>0) {
-                if (data_path[derived_pathid] === undefined)
-                    data_path[derived_pathid] = {};
-                
-                if (data_path[derived_pathid].derivations === undefined)
-                    data_path[derived_pathid].derivations = [];
-                
-                if (data_path[derived_pathid].derivations.indexOf(computed_id) < 0) {
-                    data_path[derived_pathid].derivations.push(computed_id);
-                    derived_pathsids.push(derived_pathid);
-                }
-            }
-        }
-    }
+dop.core.createComputed = function (object, prop, f, shallWeSet, oldValue) {
+    var data_path = dop.data.path,
+    computed_id = dop.data.computed_inc++,
+    computed = {
+        object_root: dop.getObjectRoot(object),
+        prop: prop,
+        function: f,
+        derivations: []
+    },
+    path = dop.getObjectPath(object, false);
 
-    computed_path = dop.getObjectPath(object, false);
-    computed_pathid = dop.core.getPathId(computed_path.concat(property));
+    computed.path = path.slice(1);
+    computed.pathid = dop.core.getPathId(path.concat(prop));
 
-    // Storing computed in dop.data 
-    if (data_path[computed_pathid] === undefined)
-        data_path[computed_pathid] = {};
+    if (data_path[computed.pathid] === undefined)
+        data_path[computed.pathid] = {};
 
-    if (data_path[computed_pathid].computeds === undefined)
-        data_path[computed_pathid].computeds = [];
-
-    data_path[computed_pathid].computeds.push(computed_id);
+    if (data_path[computed.pathid].computeds === undefined)
+        data_path[computed.pathid].computeds = [];
 
-    dop.data.computed[computed_id] = {
-        object_root: dop.getObjectRoot(object),
-        path: computed_path.slice(1),
-        prop: property,
-        function: f,
-        derivations: derived_pathsids
-    };
+    dop.data.computed[computed_id] = computed;
+    value = dop.core.updateComputed(computed_id, computed, object, oldValue);
 
     // Setting value
     if (shallWeSet)
-        dop.core.set(object, property, value);
+        dop.core.set(object, prop, value);
 
     return value;
 };

src/core/objects/runDerivations.js

@@ -3,19 +3,22 @@ dop.core.runDerivations = function(path_id) {
     if (dop.data.path[path_id] !== undefined && dop.data.path[path_id].derivations !== undefined) {
         var derivations = dop.data.path[path_id].derivations,
             computed,
+            computed_id,
             object,
             value,
             total = derivations.length,
             index = 0;
 
         for (;index<total; ++index) {
-            computed = dop.data.computed[derivations[index]];
+            computed_id = derivations[index];
+            computed = dop.data.computed[computed_id];
             object = dop.util.get(computed.object_root, computed.path);
             if (object !== undefined)
                 dop.core.set(
                     object,
                     computed.prop,
-                    computed.function.call(object, object[computed.prop])
+                    // computed.function.call(object, object[computed.prop])
+                    dop.core.updateComputed(computed_id, computed, object, object[computed.prop])
                 );
         }
     }

src/core/objects/storeMutation.js

@@ -3,25 +3,23 @@ dop.core.storeMutation = function(mutation) {
 
     var collectors = dop.data.collectors,
         index=0,
-        total=collectors.length;
+        total=collectors.length,
+        path_id;
 
     // Saving path_id
-    mutation.path_id = dop.core.getPathId(
-        (mutation.splice!==undefined || mutation.swaps!==undefined) ?
-            mutation.path
-        :
-            mutation.path.concat(mutation.prop)
-    );
+    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
     for (;index<total; index++)
         if (collectors[index].add(mutation))
-            return dop.core.runDerivations(mutation.path_id);
+            return dop.core.runDerivations(path_id);
 
 
     var snapshot = new dop.core.snapshot([mutation]);
     snapshot.emit();
 
-    dop.core.runDerivations(mutation.path_id);
+    dop.core.runDerivations(path_id);
 };

src/core/objects/updateComputed.js

@@ -0,0 +1,52 @@
+
+dop.core.updateComputed = function (computed_id, computed, context, oldValue) {
+
+    var data_path = dop.data.path,
+        derived_paths,
+        derived_pathsids = computed.derivations,
+        derived_path,
+        derived_pathid,
+        value,
+        index = 0,
+        total,
+        index2,
+        total2;
+
+
+    // Running function and saving paths from getters
+    dop.data.gets_collecting = true;
+    value = computed.function.call(context, oldValue);
+    dop.data.gets_collecting = false;
+    derived_paths = dop.data.gets_paths;
+    dop.data.gets_paths = [];
+
+
+    // Generating and storing paths ids
+    for (total=derived_paths.length; index<total; ++index) {
+        derived_path = derived_paths[index];
+        derived_pathid = '';
+        for (index2=0,total2=derived_path.length; index2<total2; ++index2) {
+            derived_pathid += dop.core.pathSeparator(derived_path[index2]);
+            if (index2>0) {
+                if (data_path[derived_pathid] === undefined)
+                    data_path[derived_pathid] = {};
+                
+                if (data_path[derived_pathid].derivations === undefined)
+                    data_path[derived_pathid].derivations = [];
+                
+                if (data_path[derived_pathid].derivations.indexOf(computed_id) < 0) {
+                    data_path[derived_pathid].derivations.push(computed_id);
+                    derived_pathsids.push(derived_pathid);
+                }
+            }
+        }
+    }
+
+
+    // Storing computed in dop.data 
+    if (data_path[computed.pathid].computeds.indexOf(computed_id) === -1)
+        data_path[computed.pathid].computeds.push(computed_id);
+
+
+    return value;
+};