Big refactor removing dop.data.object

Author: Josema

src/core/protocol/emitToNode.js

@@ -1,3 +1,7 @@
 dop.core.registerOwner = function(node, object, object_owner_id) {
-    node.owner[object_owner_id] = object
+    node.owner[object_owner_id] = {
+        object: object,
+        applied_version: 0, // last patch version applied correctly
+        applied: {}
+    }
 }

src/core/protocol/registerOwner.js

@@ -1,17 +1,25 @@
 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)
+        var object_id,
+            chunks,
+            patch = dop.core.getPatch(mutations)
+        for (object_id in patch) {
+            chunks = patch[object_id].chunks
+            dop.protocol.patch(node, object_path_id, chunks, subscriber)
+        }
     })
-    observer.observeAll(object)
-    node.subscriber[object_path_id] = {
+    var subscriber = {
         observer: observer,
-        object: object
+        object: object,
+        version: 0, // incremental integer for new patches
+        pending: []
     }
+    observer.observeAll(object)
+    node.subscriber[object_path_id] = subscriber
 }
 
 // object_data.node[node.token] = {
-//     version: 0, // incremental integer for new patches
+//     version: 0,
 //     pending: [],
 //     applied_version: 0, // last patch version applied correctly
 //     applied: {}

src/core/protocol/registerSubscriber.js

@@ -1,3 +1,5 @@
 dop.core.unregisterNode = function(node) {
     delete dop.data.node[node.token]
+    for (var object_path_id in node.subscriber)
+        node.subscriber[object_path_id].observer.destroy()
 }

src/core/protocol/unregisterNode.js

@@ -1,9 +1,9 @@
 dop.protocol._onpatch = function(node, request_id, request, response) {
     var rejection = response[0],
-        object_id = request[2],
-        object_node = dop.data.object[object_id].node[node.token],
+        object_id_owner = request[2],
+        subscriber = node.subscriber[object_id_owner],
         version = request[3],
-        pending_list = object_node.pending,
+        pending_list = subscriber.pending,
         promise = request.promise,
         index = 0,
         total = pending_list.length,
@@ -22,7 +22,7 @@ dop.protocol._onpatch = function(node, request_id, request, response) {
                 else
                     dop.protocol.patchSend(
                         node,
-                        object_id,
+                        object_id_owner,
                         version_item,
                         pending_list[index][1]
                     )

src/protocol/_onpatch.js

@@ -1,36 +1,29 @@
 dop.protocol.onpatch = function(node, request_id, request) {
     var object_id_owner = request[1],
-        object_id = node.owner[object_id_owner],
         version = request[2],
         patch = request[3],
+        owner = node.owner[object_id_owner],
         response = dop.core.createResponse(request_id),
-        object_data = dop.data.object[object_id],
-        object_node,
         collector
 
-    if (
-        isObject(object_data) &&
-        isObject(object_data.node[node.token]) &&
-        object_data.node[node.token].owner === object_id_owner
-    ) {
-        object_node = object_data.node[node.token]
+    if (owner !== undefined) {
         // Storing patch
         if (
-            object_node.applied_version < version &&
-            object_node.applied[version] === undefined
+            owner.applied_version < version &&
+            owner.applied[version] === undefined
         ) {
             // Storing patch
-            object_node.applied[version] = patch
+            owner.applied[version] = patch
             // Applying
             collector = dop.collect()
-            while (object_node.applied[object_node.applied_version + 1]) {
-                object_node.applied_version += 1
+            while (owner.applied[owner.applied_version + 1]) {
+                owner.applied_version += 1
                 dop.core.setPatch(
-                    object_data.object,
-                    object_node.applied[object_node.applied_version],
+                    owner.object,
+                    owner.applied[owner.applied_version],
                     dop.core.setPatchFunctionMutator
                 )
-                delete object_node.applied[object_node.applied_version]
+                delete owner.applied[owner.applied_version]
             }
             collector.emit()
         }

src/protocol/onpatch.js

@@ -1,18 +1,17 @@
-dop.protocol.patch = function(node, object_id, patch) {
-    var object_node = dop.data.object[object_id].node[node.token],
-        version = ++object_node.version
-    object_node.pending.push([version, dop.util.merge({}, patch)]) // Making a copy because this object is exposed to the api users and can be mutated
-    return dop.protocol.patchSend(node, object_id, version, patch)
+dop.protocol.patch = function(node, object_path_id, chunks, subscriber) {
+    var version = ++subscriber.version
+    subscriber.pending.push([version, chunks])
+    return dop.protocol.patchSend(node, object_path_id, version, chunks)
 }
 
 // Also used by dop.protocol._onpatch
-dop.protocol.patchSend = function(node, object_id, version, patch) {
+dop.protocol.patchSend = function(node, object_path_id, version, chunks) {
     var request = dop.core.createRequest(
         node,
         dop.protocol.instructions.patch,
-        object_id,
+        object_path_id,
         version,
-        patch
+        chunks
     )
     dop.core.storeAndSendRequests(node, request, dop.encodeFunction)
     return request.promise