react 0.2.3 → 0.3.0

package/lib/vcon.js

@@ -9,11 +9,14 @@ VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULT
 VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
 
 VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
+  /*jshint regexp: false */
   var vConValues = this.values;
   if (typeof(name) !== 'string') return name; // literal boolean or number
   name = name.trim();
+  // literal checks need to match what is in validate.js
   if (name === 'true') return true;
   if (name === 'false') return false;
+  if (name === 'null') return null;
   if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
   if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
   var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
@@ -30,13 +33,13 @@ VContext.prototype.getVar = function (name) { //name might be simple or obj.prop
    variable :LAST_RESULTS which keeps an array of the last values
    which can be used for chaining and testing last results, etc.
   */
-VContext.prototype.saveResults = function(paramArr, valuesArr) { // set values for params
+VContext.prototype.saveResults = function (paramArr, valuesArr) { // set values for params
   var self = this;
   paramArr.forEach(function (k, idx) { //save values to v context
     self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
   });
   this.setLastResults(valuesArr);
-}
+};
 
 VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
   if (!name) return;  // if name is undefined or null, then discard
@@ -59,9 +62,11 @@ VContext.prototype.setVar = function (name, value) { //name might be simple or o
    Ignore extra arguments passed in. Locals can be
    passed into seed the VContext otherwise empty {}
    will be used
+   @param self used to pass 'this' context in
  */
-VContext.create = function (args, inParams, locals) {
+VContext.create = function (args, inParams, locals, self) {
   var initValues = {};
+  if (self) initValues['this'] = self;
   if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
   var vContext = new VContext();
   vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args

package/lib/when-task.js

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+   When task which checks if is a promise (has a then method)
+   and waits for it to resolve.
+
+   If argument does not have a then method, it resolves immediately
+  */
+
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+
+var BaseTask = require('./base-task.js');
+
+function format_error(errmsg, obj) {
+  return sprintf('%s - %s', errmsg, util.inspect(obj));
+}
+
+var REQ = 'whenTask requires a, out';
+var A_REQ = 'whenTask requires a to be an array[1] of string param names';
+var OUT_REQ = 'whenTask requires out to be an array[1] of string param names';
+
+function WhenTask(taskDef) {
+  var self = this;
+  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+}
+
+WhenTask.prototype = new BaseTask();
+WhenTask.prototype.constructor = WhenTask;
+
+WhenTask.prototype.f = function when() { // just here to keep validations happy 
+}
+
+WhenTask.validate = function (taskDef) {
+  var errors = [];
+  if (!taskDef.a || !taskDef.out) {
+    errors.push(format_error(REQ, taskDef));
+  } else {
+    if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 && 
+           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+      errors.push(format_error(A_REQ, taskDef));
+    }
+    if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 && 
+           taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
+      errors.push(format_error(OUT_REQ, taskDef));
+    }
+  }
+  return errors;
+};
+
+WhenTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
+  var self = this;
+  this.nextFn = function (arg) {
+    var args = Array.prototype.slice.call(arguments);
+    vCon.saveResults(self.out, args);
+    self.complete(args);
+    contExec();
+  };
+  this.failFn = function (err) {
+    handleTaskError(self, err);
+  };
+};
+
+WhenTask.prototype.exec = function exec(vCon, handleError, contExec) {
+  try {
+    var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
+    //console.error('WhenTask.exec.args=', args);
+    //console.error('WhenTask.exec.vCon=', vCon);
+    this.start(args); //note the start time, args
+    var arg = args[0]; // one value allowed
+    if (arg && typeof(arg.then) === 'function') { // is a promise
+      arg.then(this.nextFn, this.failFn);
+    } else { // not a promise continue immediately
+      this.nextFn(arg);
+    }
+  } catch (err) { //catch and handle the task error, calling final cb
+    handleError(this, err);
+  } 
+};
+
+module.exports = WhenTask;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react",
   "description": "React is a javascript module to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
   "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
   "bugs" : { "url": "http://github.com/jeffbski/react/issues" },
@@ -15,7 +15,9 @@
   },
   "devDependencies": {
     "tap" : "~0.1.0",
-    "tapr" : "~0.1.0"
+    "tapr" : "~0.1.0",
+    "promised-io" : "~0.3.0",
+    "Deferred" : "~0.1.1"
   },
   "scripts": {
     "test": "node_modules/.bin/tapr test"

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();
+  });
+});