Building call instruction

Author: Josema

src/core/objects/setActionLocal.js src/core/objects/setAction.jssrc/core/objects/setActionLocal.js renamed to src/core/objects/setAction.js

@@ -1,5 +1,5 @@
 
-dop.core.setActionLocal = function(object, action) {
+dop.core.setAction = function(object, action) {
     dop.util.path({a:action}, null, {a:object}, dop.core.setActionMutator);
     return object;
 };

src/core/objects/setActionRemote.js src/core/objects/setActionFunction.jssrc/core/objects/setActionRemote.js renamed to src/core/objects/setActionFunction.js

@@ -1,5 +1,5 @@
 
-dop.core.setActionRemote = function(object, action) {
+dop.core.setActionFunction = function(object, action) {
     dop.util.path({a:action}, null, {a:object}, function(destiny, prop, value, typeofValue, path){
         if (isFunction(value) && value.name==dop.core.createRemoteFunction.name)
             dop.set(destiny, prop, value(dop.getObjectDop(object)[0], path.slice(1)));

src/core/protocol/localProcedureCall.js

@@ -1,12 +1,12 @@
 
-dop.core.localProcedureCall = function(f, args, resolve, reject, compose) {
+dop.core.localProcedureCall = function(f, args, resolve, reject, configureReq, scope) {
     var req = dop.core.createAsync(), output;
-    if (isFunction(compose))
-        req = compose(req);
+    if (isFunction(configureReq))
+        req = configureReq(req);
 
     args.push(req);
     req.then(resolve).catch(reject);
-    output = f.apply(req, args);
+    output = f.apply(scope||req, args);
 
     // Is sync
     if (output !== req)

src/protocol/_onsubscribe.js

@@ -19,12 +19,12 @@ dop.protocol._onsubscribe = function(node, request_id, request, response) {
                 if (node.owner[object_owner_id] === undefined) {
                     collector = dop.collectFirst();
                     if (dop.isRegistered(request.into))
-                        object = dop.core.setActionRemote(request.into, object_owner);
+                        object = dop.core.setActionFunction(request.into, object_owner);
                     else
                         object = dop.register((request.into===undefined) ? 
                             object_owner
                         :
-                            dop.core.setActionLocal(request.into, object_owner)
+                            dop.core.setAction(request.into, object_owner)
                         );
                     dop.core.registerOwner(node, object, object_owner_id);
                     collector.emitAndDestroy();

src/protocol/call.js

@@ -27,7 +27,9 @@ dop.protocol.oncall = function(node, request_id, request) {
         object_data = dop.data.object[object_id];
 
     if (isObject(object_data) && isObject(object_data.node[node.token]) && object_data.node[node.token].subscriber) {
-        var f = dop.util.get(object_data.object, path);
+        var functionName = path.pop(),
+            object = dop.util.get(object_data.object, path),
+            f = object[functionName];
         if (isFunction(f)) {
             function resolve(value) {
                 var response = dop.core.createResponse(request_id, 0);
@@ -45,7 +47,7 @@ dop.protocol.oncall = function(node, request_id, request) {
                 dop.core.localProcedureCall(f, params, resolve, reject, function(req) {
                     req.node = node;
                     return req;
-                });
+                }, object);
         }
     }
 };

test/transports/call.js

@@ -17,26 +17,83 @@ server.on('connect', function(node) {
         serverClient = node;
 })
 
+var obj = {
+    string: function(){
+        return 'Hello world';
+    },
+    undefined: function(){
+        // returning nothing
+    },
+    object: function() {
+        return {hola:"mundo"}
+    },
+    sum: function(a, b) {
+        return a+b;
+    },
+    resolve: function(req) {
+        req.resolve('resolved');
+    },
+    resolveAsync: function(req) {
+        setTimeout(function() {
+            req.resolve('resolveAsync');
+        }, 100);
+        return req;
+    },
+    reject: function(req) {
+        req.reject('rejected');
+    },
+    reject0: function(req) {
+        req.reject(0);
+    }
+};
 
 
-test('', function(t) {
-    var objectServer = {
-        deep: {
-            login: function() {
-                console.log( 'arguments', arguments );
-            }
-        }
-    };
-    
-    dopServer.onsubscribe(function() {
-        return objectServer;
-    })
+dopServer.onsubscribe(function() {
+    return obj;
+})
 
-    client.subscribe().then(function(obj) {
-        obj.deep.login('hola', 'mundo');
-        console.log( obj.deep.login.name );
-        t.end();
+test('TESTING RESOLVE AN REJECTS', function(t) {
+
+client.subscribe().then(function(obj) {
+    obj.string()
+    .then(function(value){
+        t.equal('Hello world', value, 'Returning a string');
+        return obj.undefined();
+    })
+    .then(function(value){
+        t.equal(undefined, value, 'Returning nothing');
+        return obj.object();
+    })
+    .then(function(value){
+        t.equal(value.hola, 'mundo', 'Returning an object');
+        return obj.sum(2, 2);
+    })
+    .then(function(value){
+        t.equal(value, 4, 'Passing two parameters');
+        return obj.resolve();
+    })
+    .then(function(value){
+        t.equal(value, 'resolved', 'req.resolve instead of return');
+        return obj.resolveAsync();
     })
+    .then(function(value){
+        t.equal(value, 'resolveAsync', 'Resolved async');
+        return obj.reject();
+    })
+    .catch(function(value){
+        t.equal(value, 'rejected', 'req.reject');
+        return obj.reject0();
+    })
+    .then(function(value){
+        console.log( 'then' );
+        // return obj.sum(2, 2);
+    })
+    .catch(function(value){
+        console.log( 'catch' );
+        // return obj.sum(2, 2);
+    })
+})
 
 })
 
+