react 0.2.6 → 0.3.0

package/promise-resolve.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+   Auto resolve promises passed in as arguments to the flow
+
+    - Detects promises by checking for .then()
+    - Create promise name for param (param__promise)
+    - moves existing vCon promise into the param__promise
+    - creates WhenTask which resolves param__promise into param
+  */
+
+
+var react = require('./');  // require('react');
+
+var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
+
+react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (taskEnv) {
+  var vConValues = taskEnv.vCon.values;
+  var promiseParams = taskEnv.ast.inParams.filter(function (p) {
+    var value = vConValues[p];
+    return (value && typeof(value.then) === 'function');
+  });
+  promiseParams.forEach(function (p) {
+    var promiseName = p + PROMISE_SUFFIX;
+    vConValues[promiseName] = vConValues[p];
+    vConValues[p] = undefined;
+    taskEnv.taskDefs.push({
+      type: 'when',
+      a: [promiseName],
+      out: [p]
+    });
+  });
+});
+
+module.exports = react;  // return react

package/react.js

@@ -6,7 +6,3 @@ module.exports = require('./lib/dsl.js');  // core + default dsl
 module.exports.options = core.options; // global react options
 module.exports.events = core.events;   // global react event emitter
 
-// additional interfaces
-module.exports.fstrDefine = require('./lib/fstr.js');
-module.exports.pcodeDefine = require('./lib/pcode.js');
-module.exports.chainDefine = require('./lib/chain.js');

package/test/core-deferred.test.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+   Test core PromiseTasks using Deferred - jquery style promises
+  */
+
+
+var test = require('tap').test;
+var Deferred = require('Deferred');
+//var when = Deferred.when;
+
+
+var react = require('../');  //require('react');
+
+function multiply(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x * y);
+  }, 10);
+  return deferred.promise();
+}
+function add(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x + y);
+  }, 10);
+  return deferred.promise();
+}
+
+function badFunc(a, b) {
+  throw new Error('badFuncThrow');
+}
+
+function badF2(a, b) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.reject(new Error('my-error'));
+  }, 10);
+  return deferred.promise();
+}
+
+
+test('multi-step', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 9);
+    t.end();
+  });
+});  
+
+test('using "this" in a cb function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    var deferred = new Deferred();
+    var self = this;
+    setTimeout(function () {
+      deferred.resolve(self.a);
+    }, 10);
+    return deferred.promise();
+  }
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'], type: 'promise' }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+
+test('throws error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'badFuncThrow');
+    t.end();
+  });
+});
+
+test('rejects with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});

package/test/core-promised.test.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+   Test core PromiseTasks using promised-io
+  */
+
+var test = require('tap').test;
+//var when = require('promised-io/promise');
+var Deferred = require('promised-io/promise').Deferred;
+
+var react = require('../');  //require('react');
+
+
+function multiply(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x * y);
+  }, 10);
+  return deferred.promise;
+}
+function add(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x + y);
+  }, 10);
+  return deferred.promise;
+}
+
+function badFunc(a, b) {
+  throw new Error('badFuncThrow');
+}
+
+function badF2(a, b) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.reject(new Error('my-error'));
+  }, 10);
+  return deferred.promise;
+}
+
+
+test('multi-step', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 9);
+    t.end();
+  });
+});  
+
+test('using "this" in a cb function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    var deferred = new Deferred();
+    var self = this;
+    setTimeout(function () {
+      deferred.resolve(self.a);
+    }, 10);
+    return deferred.promise;
+  }
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'], type: 'promise' }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+test('throws error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'badFuncThrow');
+    t.end();
+  });
+});
+
+test('rejects with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});

package/test/core-when.test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+   Test core WhenTasks using promised-io
+  */
+
+var test = require('tap').test;
+//var when = require('promised-io/promise');
+var Deferred = require('promised-io/promise').Deferred;
+
+var react = require('../');  //require('react');
+
+
+function multiply(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x * y);
+  }, 10);
+  return deferred.promise;
+}
+function add(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x + y);
+  }, 10);
+  return deferred.promise;
+}
+
+function badF2(a, b) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.reject(new Error('my-error'));
+  }, 10);
+  return deferred.promise;
+}
+
+
+test('multi-step', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['pm', 'pa'],
+    tasks: [    
+      { a: ['pm'], out: ['m'], type: 'when' },
+      { a: ['pa'], out: ['a'], type: 'when' }
+    ],
+    outTask: { a: ['m', 'a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var pm = multiply(2, 3);
+  var pa = add(4, 5);
+  
+  fn(pm, pa, function (err, m, a) {
+    t.equal(err, null);
+    t.equal(m, 6);
+    t.equal(a, 9);
+    t.end();
+  });
+});  
+
+
+test('rejects with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['pm', 'pa'],
+    tasks: [    
+      { a: ['pm'], out: ['m'], type: 'when' },
+      { a: ['pa'], out: ['a'], type: 'when' }
+    ],
+    outTask: { a: ['m', 'a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var pm = badF2(2, 3);
+  var pa = add(4, 5);
+
+  
+  fn(pm, pa, function (err, m, a) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});

package/test/core.test.js

@@ -377,7 +377,66 @@ test('multi-step func cb err, cb with error', function (t) {
     t.end();
   });
 });  
+
+test('using "this" in a cb function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    cb(null, this.a);
+  }
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'] }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+test('using "this" in a sync function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    return this.a;
+  }
   
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'], type: 'ret' }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+
+// Select first tests
+
 
 test('selectFirst with first succeeding', function (t) {
   t.plan(6);
@@ -398,7 +457,7 @@ test('selectFirst with first succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(events.length, 1, 'should have seen one task compl events');
@@ -431,7 +490,7 @@ test('selectFirst with third succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');
@@ -468,7 +527,7 @@ test('selectFirst forces order with third succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');
@@ -507,7 +566,7 @@ test('selectFirst using direct returns', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');