react 0.2.4 → 0.3.4

package/lib/track-tasks.js

@@ -0,0 +1,117 @@
+'use strict';
+
+/**
+   Track the tasks, start, complete, args, results, elapsed time
+   Emits events that can be monitored
+
+    - track start and complete
+    - record args each task was called with
+    - record results at completion
+    - record start, end, and calc elapsed time
+    - emits flow.begin with flowEnv
+    - emits task.begin with task
+    - emits task.complete with task
+    - emits flow complete with flowEnv
+    - emits flow errored with flowEnv
+  */
+
+
+var react = require('../');  // require('react');
+
+var TASK_EVENTS_RE = /^task\./;
+var FLOW_EVENTS_RE = /^flow\./;
+
+/**
+   Accumulator to make it easy to capture events
+
+   @example
+   var EventCollector = require('react/lib/track-tasks').EventCollector;
+   var collector = new EventCollector();
+   
+   collector.captureGlobal('*'); // capture all react events for all flows
+
+   // OR
+   
+   collector.capture(flowFn, 'task.'); // capture task events on a flow
+   collector.capture(flowFn, 'flow.'); // add capture flow events on a flow
+
+   var events = collector.list();  // retrieve the list of events
+  */
+function EventCollector() {
+  this.events = [];
+}
+
+/**
+   register listener to capture all events
+   @param eventId event id or wildcarded id
+  */
+EventCollector.prototype.captureGlobal = function (eventId) {
+  this.capture(react, eventId);
+};
+
+/**
+   register listener to capture events for a specific flow
+   @param flowFn the react flow function or can pass global react
+   @param eventId event id or wildcarded id
+  */
+EventCollector.prototype.capture = function (flowFn, eventId) {
+  var emitter = flowFn.events;
+  var self = this;
+  function accumEvents(obj) {
+    var eventObject = {
+      event: this.event,
+      time: Date.now()
+    };
+    if (FLOW_EVENTS_RE.test(this.event)) {
+      eventObject.env = obj;
+    } else if (TASK_EVENTS_RE.test(this.event)) {
+      eventObject.task = obj;
+    }
+    self.events.push(eventObject);      
+  }
+  emitter.on(eventId, accumEvents);
+};
+
+EventCollector.prototype.list = function () {
+  return this.events;
+};
+
+react.events.on(react.events.TYPES.EXEC_FLOW_START, function (env){
+  env.startTime = Date.now();
+  env.flowEmitter.emit(react.events.TYPES.FLOW_BEGIN, env); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_START, function (task) {
+  task.startTime = Date.now();
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_BEGIN, task); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_COMPLETE, function (task) {
+  task.endTime = Date.now();
+  task.elapsedTime = task.endTime - task.startTime;
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_COMPLETE, task); // fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_ERRORED, function (task) {
+  task.endTime = Date.now();
+  task.elapsedTime = task.endTime - task.startTime;
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_ERRORED, task); // fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_FLOW_COMPLETE, function (env) {
+  env.endTime = Date.now();
+  env.elapsedTime = env.endTime - env.startTime;
+  env.flowEmitter.emit(react.events.TYPES.FLOW_COMPLETE, env); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_FLOW_ERRORED, function (env) {
+  env.endTime = Date.now();
+  env.elapsedTime = env.endTime - env.startTime;
+  env.flowEmitter.emit(react.events.TYPES.FLOW_ERRORED, env); //fire public ev
+});
+
+
+
+
+module.exports = react;  // return react
+module.exports.EventCollector = EventCollector;

package/lib/validate.js

@@ -13,6 +13,9 @@ var LOCALS_NOTNULL = 'ast.locals should not be null';
 var DUP_OUTPUTS = 'multiple tasks output the same param, must be unique. param';
 var MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
 
+// match any of our literals true, false, int, float, quoted strings, or is property (has dot), match vcon.js
+var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;  
+
 var validateInParams, validateTasks, validateOutTask, validateTaskNamesUnique;
 var validateLocals, validateOuputsUnique, validateNoMissingNames;
 
@@ -20,10 +23,15 @@ function format_error(errmsg, obj) {
   return sprintf('%s - %s', errmsg, util.inspect(obj));
 }
 
-function isProp(str) { // true if is a property name (contains a dot)
-  return (str.indexOf('.') !== -1);
+/**
+   true if is a literal name
+  */
+function isLiteralOrProp(name) {  // need to match what is in vcon.js, TODO consolidate?
+  return LITERAL_OR_PROP_RE.test(name);
 }
 
+
+
 /**
    validate the AST return Errors
    @example
@@ -105,6 +113,7 @@ function validateOuputsUnique(taskDefs) {
   return errors;
 }
 
+
 /**
    validate there are no missing or mispelled param names in any task inputs
    or the final task output
@@ -134,17 +143,17 @@ function validateNoMissingNames(ast) {
   // now we have all possible provided vars, check task inputs are accounted for
   ast.tasks.reduce(function (accum, t) {  // for all tasks
     return t.a.reduce(function (innerAccum, p) { // for all in params, except property
-      if (!isProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+      if (!isLiteralOrProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
       return innerAccum;
     }, accum);
   }, errors);
 
   // now check the final task outputs
   ast.outTask.a.reduce(function (accum, p) { // for final task out params
-    if (!isProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+    if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
     return accum;
   }, errors);
-  return errors;
+  return errors;  
 }
 
 module.exports = validate;

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.4",
+  "version": "0.3.4",
   "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 (env) {
+  var vConValues = env.vCon.values;
+  var promiseParams = env.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;
+    env.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();
+  });
+});