react 0.2.6 → 0.5.0

package/lib/event-manager.js

@@ -3,12 +3,30 @@
 var EventEmitter2 = require('eventemitter2').EventEmitter2;
 
 var EVENT_EMITTER2_CONFIG = {
-  wildcard: true
+  wildcard: true, // should the event emitter use wildcards.
+  delimiter: '.', // the delimiter used to segment namespaces, defaults to `.`.
+  maxListeners: 30 // the max number of listeners that can be assigned to an event, defaults to 10.
 };
 
 var TYPES = {
-  TASK_BEGIN: 'task.begin',
-  TASK_COMPLETE: 'task.complete'
+  // Flow monitoring events and their params
+  FLOW_BEGIN: 'flow.begin',                        // env
+  TASK_BEGIN: 'task.begin',                        // task
+  TASK_COMPLETE: 'task.complete',                  // task
+  TASK_ERRORED: 'task.errored',                    // task
+  FLOW_COMPLETE: 'flow.complete',                  // env
+  FLOW_ERRORED: 'flow.errored',                    // env
+
+  // Internal Hooks
+  EXEC_FLOW_START: 'exec.flow.start',              // env
+  EXEC_INPUT_PREPROCESS: 'exec.input.preprocess',  // parsedInput
+  EXEC_TASKS_PRECREATE: 'exec.tasks.precreate',    // env
+  EXEC_OUTTASK_CREATE: 'exec.outTask.create',      // outTaskOptions
+  EXEC_TASK_START: 'exec.task.start',              // task
+  EXEC_TASK_COMPLETE: 'exec.task.complete',        // task
+  EXEC_TASK_ERRORED: 'exec.task.errored',          // task
+  EXEC_FLOW_COMPLETE: 'exec.flow.complete',        // env
+  EXEC_FLOW_ERRORED: 'exec.flow.errored'           // env
 };
 
 /**
@@ -21,6 +39,9 @@ function EventManager() {
 
 EventManager.create = function () { return new EventManager(); };
 
+EventManager.TYPES = TYPES;
+EventManager.prototype.TYPES = TYPES;
+
 EventManager.prototype.isEnabled = function () { // if has listener or an ancestor has listener
   return (this.emitter || (this.parent && this.parent.isEnabled()));
 };
@@ -36,23 +57,15 @@ EventManager.prototype.on = function (event, listener) {
 };
 
 EventManager.prototype.emit = function (event, arg1, arg2, argN) {
+  if (event === undefined) throw new Error('event is undefined');
   if (this.emitter) this.emitter.emit.apply(this.emitter, arguments);
   if (this.parent && this.parent.isEnabled()) this.parent.emit.apply(this.parent, arguments);
 };
 
-/**
-   Emit an object augmented with standard fields.
-   Copies object and adds standard fields:
-    event: event type
-    time: current time
-  */
-EventManager.prototype.emitObject = function (event, object) {
-  var evObj = Object.create(object); // create inherited copy version so origin is untouched
-  evObj.event = event;     // augment with the event type
-  evObj.time = Date.now(); // augument with the time of the event
-  this.emit(event, evObj);
+EventManager.prototype.removeListener = function (event, listener) {
+  if (this.emitter) this.emitter.removeListener.apply(this.emitter, arguments);
 };
 
+
 module.exports = EventManager;
-module.exports.TYPES = TYPES;
-module.exports.globalEventManager = EventManager.create(); // create one top level emitter
+module.exports.global = EventManager.create(); // create one top level emitter

package/lib/finalcb-first-task.js

@@ -5,15 +5,22 @@ var util = require('util');
 
 var STATUS = require('./status.js');
 var VContext = require('./vcon.js');
+var EventManager = require('./event-manager.js');
 
 var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
-function FinalCbFirstSuccTask(taskDef, cbFunc, tasks, vCon) {
+function FinalCbFirstSuccTask(outTaskOptions) {
+  var taskDef = outTaskOptions.taskDef;
+  if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
   var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  this.f = cbFunc;
-  this.tasks = tasks;
-  this.vCon = vCon;
+  for (var k in taskDef) {
+    if (true) self[k] = taskDef[k];  // if to make jshint happy
+  }
+  this.f = outTaskOptions.cbFunc;
+  this.tasks = outTaskOptions.tasks;
+  this.vCon = outTaskOptions.vCon;
+  this.retValue = outTaskOptions.retValue;
+  this.env = outTaskOptions.env;
 }
 
 function format_error(errmsg, obj) {
@@ -27,11 +34,6 @@ FinalCbFirstSuccTask.validate = function (taskDef) {
     errors.push(format_error(OUTTASK_A_REQ, taskDef));
   }
   return errors;
-}
-
-FinalCbFirstSuccTask.create = function (taskDef, cbFunc, tasks, vCon) {
-  if (!(cbFunc && cbFunc instanceof Function)) throw new Error('callback is not a function'); 
-  return new FinalCbFirstSuccTask(taskDef, cbFunc, tasks, vCon);
 };
 
 /**
@@ -46,11 +48,15 @@ FinalCbFirstSuccTask.prototype.isReady = function () {
 FinalCbFirstSuccTask.prototype.exec = function (err) {
   if (!this.f) return;   //must have already been called
   if (err) {
+    this.env.error = err;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_ERRORED, this.env);
     this.f.call(null, err); //call the final callback with the first error hit
   } else { // no error, call with args
     var vCon = this.vCon;
     var finalArgs = this.a.map(function (k) { return vCon.getVar(k); });
     finalArgs.unshift(null);   //unshift err=null to front
+    this.env.results = finalArgs;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_COMPLETE, this.env);
     this.f.apply(null, finalArgs);
   }
   this.f = null;   // prevent multiple calls

package/lib/finalcb-task.js

@@ -4,15 +4,23 @@ var sprintf = require('sprintf').sprintf;
 var util = require('util');
 
 var STATUS = require('./status.js');
+var EventManager = require('./event-manager.js');
 
 var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
-function FinalCbTask(taskDef, cbFunc, tasks, vCon) {
+function FinalCbTask(outTaskOptions) {
+  var taskDef = outTaskOptions.taskDef;
+  if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
   var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  this.f = cbFunc;
-  this.tasks = tasks;
-  this.vCon = vCon;
+  for (var k in taskDef) {
+    if (true) self[k] = taskDef[k];  // if to make jshint happy
+  }
+  this.f = outTaskOptions.cbFunc;
+  this.tasks = outTaskOptions.tasks;
+  this.vCon = outTaskOptions.vCon;
+  this.retValue = outTaskOptions.retValue;
+  this.execOptions = outTaskOptions.execOptions;
+  this.env = outTaskOptions.env;
 }
 
 function format_error(errmsg, obj) {
@@ -29,11 +37,6 @@ FinalCbTask.validate = function (taskDef) {
   return errors;
 };
 
-FinalCbTask.create = function (taskDef, cbFunc, tasks, vCon) {
-  if (!(cbFunc && cbFunc instanceof Function)) throw new Error('callback is not a function'); 
-  return new FinalCbTask(taskDef, cbFunc, tasks, vCon);
-};
-
 FinalCbTask.prototype.isReady = function () {
   return (this.tasks.every(function (t) { return (t.status === STATUS.COMPLETE); }));
 };
@@ -41,11 +44,15 @@ FinalCbTask.prototype.isReady = function () {
 FinalCbTask.prototype.exec = function (err) {
   if (!this.f) return;   //must have already been called
   if (err) {
+    this.env.error = err;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_ERRORED, this.env);
     this.f.call(null, err); //call the final callback with the first error hit
   } else { // no error, call with args
     var vCon = this.vCon;
     var finalArgs = this.a.map(function (k) { return vCon.getVar(k); });
     finalArgs.unshift(null);   //unshift err=null to front
+    this.env.results = finalArgs;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_COMPLETE, this.env);
     this.f.apply(null, finalArgs);
   }
   this.f = null;   // prevent multiple calls

package/lib/input-parser.js

@@ -1,12 +1,14 @@
 'use strict';
 
+var EventManager = require('./event-manager.js');
+
 var defaultExecOptions = {
   reactExecOptions: true,
-  outputStyle: 'callback',
+  outputStyle: 'cb',
 };
 
 var OUTPUT_STYLES = {
-  CALLBACK: 'callback',
+  CALLBACK: 'cb',
   NONE: 'none'
 };
 
@@ -36,7 +38,9 @@ function inputParser(inputArgs, ast) {
   var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle); 
   parsedInput.args = splitResult.args;
   parsedInput.cb = splitResult.cb;
-  if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;  
+  if (splitResult.outputStyle) parsedInput.options.outputStyle = splitResult.outputStyle;
+  if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;
+  EventManager.global.emit(EventManager.TYPES.EXEC_INPUT_PREPROCESS, parsedInput);  // hook
   return parsedInput;
 }
 

package/lib/log-events.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+   Log events to console.error
+
+   @example
+   var react = require('react');
+   react.logEvents(); // log all task and flow events on all react functions
+   react.logEvents('task.*'); // log all task events on all react functions
+   react.logEvents(flowFn); // log all task and flow events on flowFn only
+   react.logEvents(flowFn, 'flow.*'); // log all flow events on flowFn only
+  */
+
+var util = require('util'); // TODO replace inspect with something portable to browser
+
+var react = require('../'); // require('react');
+react.trackTasks(); // enable task and flow tracking
+
+var ALL_FLOW_EVENTS = 'flow.*';
+var ALL_TASK_EVENTS = 'task.*';
+var FLOW_RE = /^flow\./;
+
+function flowLog(obj) {
+  /*jshint validthis: true */
+  var time = new Date();
+  time.setTime(obj.time);
+  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
+  var eventTimeStr = time.toISOString();
+  if (this.event === 'flow.complete') {
+    var env = obj; 
+    console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
+                  this.event, env.name, env.elapsedTime, util.inspect(argsNoCb), util.inspect(env.results));   
+  } else {
+    var name = obj.name;
+    var args = obj.args;
+    console.error('%s: %s \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
+  }    
+}
+
+function taskLog(obj) {
+  /*jshint validthis: true */
+  var time = new Date();
+  time.setTime(obj.time);
+  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
+  var eventTimeStr = time.toISOString();
+  if (this.event === 'task.complete') {
+    var task = obj;
+    console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
+                  this.event, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
+  } else {
+    var name = obj.name;
+    var args = obj.args;
+    console.error('%s: %s \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
+  }
+  
+}
+
+/**
+   Log flow and task events for a flowFn or all of react.
+   If called multiple times, remove previous listener (if any) before
+   adding.
+   
+   @example
+   var react = require('react');
+   react.logEvents(flowFn, eventWildcard); //log events on flowfn matching wildcard
+   
+   @param flowFn Flow function or global react object
+   @param eventWildcard wildcarded event type, if not provided use flow.* and task.*
+  */
+function logEvents(flowFn, eventWildcard) {
+  if (!flowFn) flowFn = react; // use global 
+  if (eventWildcard && eventWildcard !== '*') {
+    var logFn = (FLOW_RE.test(eventWildcard)) ? flowLog : taskLog;
+    flowFn.events.removeListener(eventWildcard, logFn);
+    flowFn.events.on(eventWildcard, logFn);
+  } else { // none provided, use flow.* and task.*
+    //output events as tasks start and complete
+    flowFn.events.removeListener(ALL_FLOW_EVENTS, flowLog);
+    flowFn.events.on(ALL_FLOW_EVENTS, flowLog);
+    flowFn.events.removeListener(ALL_TASK_EVENTS, taskLog);
+    flowFn.events.on(ALL_TASK_EVENTS, taskLog);      
+  }
+}
+
+module.exports = react;
+module.exports.logEvents = logEvents;

package/lib/parse.js

@@ -9,10 +9,13 @@ function splitTrimFilterArgs(commaSepArgs) { //parse 'one, two' into ['one', 'tw
     .filter(function (s) { return (s); });  //filter out empty strings
 }
 
-function parseReduce(accum, regexFn) {
+/**
+   @param patternFn regex + fn or splitStr + fn
+  */
+function parseReduce(accum, patternFn) {
   if (typeof(accum) !== 'string') return accum; // already matched
-  var m = regexFn.regex.exec(accum);
-  if (m) return regexFn.fn(m); // return result obj
+  var m = (patternFn.regex) ? patternFn.regex.exec(accum) : accum.split(patternFn.splitStr);
+  if (m) return patternFn.fn(m, accum); // pass in matches and origStr, return result obj
   return accum; // no match, return str, will try next matcher
 }
 

package/lib/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/lib/promise-task.js

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+   PromiseTask is a task which executes a fn that returns a promise
+   and when it completes it sets the values in vCon
+  */
+
+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 = 'promiseTask requires f, a, out';
+var FN_REQ = 'promiseTask requires f to be a function or string';
+var A_REQ = 'promiseTask requires a to be an array of string param names';
+var OUT_REQ = 'promiseTask requires out to be an array[1] of string param names';
+
+function PromiseTask(taskDef) {
+  var self = this;
+  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+}
+
+PromiseTask.prototype = new BaseTask();
+PromiseTask.prototype.constructor = PromiseTask;
+
+PromiseTask.validate = function (taskDef) {
+  var errors = [];
+  if (!taskDef.f || !taskDef.a || !taskDef.out) {
+    errors.push(format_error(REQ, taskDef));
+  } else {
+    var ftype = typeof(taskDef.f);
+    if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
+      errors.push(format_error(FN_REQ, taskDef));
+    }
+    if (! (Array.isArray(taskDef.a) &&
+           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;
+};
+
+PromiseTask.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);
+  };
+};
+
+PromiseTask.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('PromiseTask.exec.args=', args);
+    //console.error('PromiseTask.exec.vCon=', vCon);
+    this.start(args); //note the start time, args
+    var func = this.f;
+    var bindObj = vCon.getVar('this'); //global space or the original this
+    if (this.isMethodCall()) { //if method call then reset func and bindObj
+      func = vCon.getVar(this.f);
+      bindObj = this.getMethodObj(vCon);
+    } else if (typeof(func) === 'string') {
+      func = vCon.getVar(func); // we want the actual fn from this string
+    }
+    var retValue = func.apply(bindObj, args);
+    if (retValue && typeof(retValue.then) === 'function') { // is a promise
+      retValue.then(this.nextFn, this.failFn);
+    } else { // just a value, proceed now
+      this.nextFn(retValue);
+    }
+  } catch (err) { //catch and handle the task error, calling final cb
+    handleError(this, err);
+  }    
+};
+
+module.exports = PromiseTask;

package/lib/ret-task.js

@@ -50,7 +50,7 @@ RetTask.prototype.exec = function exec(vCon, handleError, contExec) {
     var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
     this.start(args); //note the start time, args    
     var func = this.f;
-    var bindObj = null; //global space
+    var bindObj = vCon.getVar('this'); //global space or the original this
     if (this.isMethodCall()) { //if method call then reset func and bindObj
       func = vCon.getVar(this.f);
       bindObj = this.getMethodObj(vCon);