Big refactor

Author: Josema

src/api/getObjectPathId.js

@@ -0,0 +1,3 @@
+dop.getObjectPathId = function(object) {
+    return dop.core.getPathId(dop.getObjectPath(object))
+}

src/core/constructors/collector.js

@@ -16,14 +16,14 @@ dop.core.collector.prototype.add = function(mutation) {
     return false
 }
 
-dop.core.collector.prototype.emit = function() {
+dop.core.collector.prototype.emit = function(shallWeEmitToNode) {
     this.destroy()
-    return this.emitWithoutDestroy()
+    return this.emitWithoutDestroy(shallWeEmitToNode)
 }
 
-dop.core.collector.prototype.emitWithoutDestroy = function() {
+dop.core.collector.prototype.emitWithoutDestroy = function(shallWeEmitToNode) {
     var snapshot = new dop.core.snapshot(this.mutations)
-    snapshot.emit()
+    snapshot.emit(shallWeEmitToNode)
     this.mutations = []
     return snapshot
 }

src/core/constructors/snapshot.js

@@ -17,11 +17,10 @@ dop.core.snapshot.prototype.redo = function() {
     }
 }
 
-dop.core.snapshot.prototype.emit = function() {
-    // This is true if we have nodes subscribed to those object/mutations
-    // Then we have to emit to nodes
-    if (this.mutations.length > 0 && dop.core.emitToObservers(this.mutations))
-        dop.core.emitNodes(this.forward ? this.getPatch() : this.getUnpatch())
+dop.core.snapshot.prototype.emit = function(shallWeEmitToNode) {
+    if (this.mutations.length > 0) {
+        dop.core.emitToObservers(this, shallWeEmitToNode)
+    }
 }
 
 dop.core.snapshot.prototype.getPatch = function() {

src/core/objects/emitToObservers.js

@@ -1,5 +1,6 @@
-dop.core.emitToObservers = function(mutations) {
-    var mutation,
+dop.core.emitToObservers = function(snapshot, shallWeEmitToNode) {
+    var mutations = snapshot.mutations,
+        mutation,
         path_id,
         observer_id,
         mutations_by_observers = {},
@@ -16,12 +17,6 @@ dop.core.emitToObservers = function(mutations) {
         path_id = mutation.path_id
         path = mutation.path
 
-        // if (
-        //     !mutations_with_subscribers &&
-        //     isObject(dop.data.object[dop.getObjectId(mutation.object)])
-        // )
-        //     mutations_with_subscribers = true
-
         // .observers_object
         if (
             data_path[path_id] !== undefined &&
@@ -78,7 +73,10 @@ dop.core.emitToObservers = function(mutations) {
         var observer = dop.data.observers[observer_id]
         if (observer !== undefined)
             // We need to make sure that the observer still exists, because maybe has been removed after calling previous observers
-            observer.callback(mutations_by_observers[observer_id])
+            observer.callback(
+                mutations_by_observers[observer_id],
+                shallWeEmitToNode
+            )
     }
 
     return mutations_with_subscribers

src/core/protocol/emitNodes.js

@@ -0,0 +1,11 @@
+dop.core.emitToNode = function(node, object_path_id, patch) {
+    var object_id, chunks
+    for (object_id in patch) {
+        chunks = patch[object_id].chunks
+        dop.protocol.patch(
+            node,
+            object_id,
+            chunks.length > 1 ? chunks : chunks[0]
+        )
+    }
+}

src/core/protocol/emitToNode.js

@@ -1,6 +1,3 @@
 dop.core.registerOwner = function(node, object, object_owner_id) {
-    var object_data = dop.core.registerObjectToNode(node, object),
-        object_id = dop.getObjectId(object_data.object)
-    object_data.node[node.token].owner = object_owner_id
-    node.owner[object_owner_id] = object_id
+    node.owner[object_owner_id] = object
 }

src/core/protocol/registerObjectToNode.js

@@ -1,10 +1,18 @@
-dop.core.registerSubscriber = function(node, object) {
-    var object_data = dop.core.registerObjectToNode(node, object),
-        object_id = dop.getObjectId(object_data.object)
-    node.subscriber[object_id] = true
-    if (object_data.node[node.token].subscriber) return false
-    else {
-        object_data.node[node.token].subscriber = 1
-        return true
+dop.core.registerSubscriber = function(node, object, object_path_id) {
+    var observer = dop.createObserver(function(mutations, shallWeEmitToNode) {
+        var patch = dop.core.getPatch(mutations)
+        dop.core.emitToNode(node, object_path_id, patch)
+    })
+    observer.observeAll(object)
+    node.subscriber[object_path_id] = {
+        observer: observer,
+        object: object
     }
 }
+
+// object_data.node[node.token] = {
+//     version: 0, // incremental integer for new patches
+//     pending: [],
+//     applied_version: 0, // last patch version applied correctly
+//     applied: {}
+// }

src/core/protocol/registerOwner.js

@@ -1,36 +1,3 @@
 dop.core.unregisterNode = function(node) {
-    var object_id, object_owner_id, object_data
-
-    for (object_id in node.subscriber) {
-        object_data = dop.data.object[object_id]
-        if (object_data !== undefined) {
-            // Removing subscriber objects
-            if (object_data.node[node.token] !== undefined) {
-                object_data.nodes_total -= 1
-                delete object_data.node[node.token]
-            }
-
-            // Simply remove all associated objects for which this node has subscription
-            // only if object node_total ==0; Added by Satyam Singh.
-            if (object_data.nodes_total === 0) {
-                delete dop.data.object[object_id]
-            }
-        }
-    }
-
-    // Removing owner objects
-    for (object_owner_id in node.owner) {
-        object_id = node.owner[object_owner_id]
-        object_data = dop.data.object[object_id]
-        if (
-            object_data !== undefined &&
-            object_data.node[node.token] !== undefined
-        ) {
-            object_data.nodes_total -= 1
-            delete object_data.node[node.token]
-        }
-    }
-
-    // Deleting node
     delete dop.data.node[node.token]
 }