react 0.2.6 → 0.3.0

package/lib/finalcb-first-task.js

@@ -8,12 +8,20 @@ var VContext = require('./vcon.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;
+  var cbFunc = outTaskOptions.cbFunc;
+  var tasks = outTaskOptions.tasks;
+  var vCon = outTaskOptions.vCon;
+  var execOptions = outTaskOptions.execOptions;
+  var retValue = outTaskOptions.retValue;
+  if (typeof(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;
+  this.retValue = retValue;
 }
 
 function format_error(errmsg, obj) {
@@ -27,11 +35,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);
 };
 
 /**

package/lib/finalcb-task.js

@@ -7,12 +7,20 @@ var STATUS = require('./status.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;
+  var cbFunc = outTaskOptions.cbFunc;
+  var tasks = outTaskOptions.tasks;
+  var vCon = outTaskOptions.vCon;
+  var execOptions = outTaskOptions.execOptions;
+  var retValue = outTaskOptions.retValue;
+  if (typeof(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;
+  this.retValue = retValue;
 }
 
 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); }));
 };

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/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-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);

package/lib/task.js

@@ -4,16 +4,21 @@ var util = require('util');
 var sprintf = require('sprintf').sprintf;
 var array = require('ensure-array');
 var CbTask = require('./cb-task.js');
+var PromiseTask = require('./promise-task.js');
 var RetTask = require('./ret-task.js');
+var WhenTask = require('./when-task.js');
 var FinalCbTask = require('./finalcb-task.js');
 var FinalCbFirstSuccTask = require('./finalcb-first-task.js');
 var STATUS = require('./status.js');
 var error = require('./error.js');
 var VContext = require('./vcon.js');
+var EventManager = require('./event-manager.js');
 
 var TASK_TYPES = {
   cb: CbTask,
-  ret: RetTask
+  ret: RetTask,
+  promise: PromiseTask,
+  when: WhenTask
 };
 function taskTypeKeys() { return Object.keys(TASK_TYPES); }
 
@@ -106,7 +111,8 @@ function validateLocalFunctions(inParams, taskDefs, locals) {
   var mock_args = inParams.map(function (p) { return foo; }); //mock args with fns
   var vCon = VContext.create(mock_args, inParams, locals);
   var tasks = taskDefs.map(create);
-  tasks.forEach(function (t, idx) {
+  var tasksWFunctions = tasks.filter(function (t) { return (t.type !== 'when'); }); // non-when tasks need f
+  tasksWFunctions.forEach(function (t, idx) {
     if (!t.functionExists(vCon)) {   // error if function doesnt exist AND
       if (!t.isMethodCall()) errors.push(sprintf(LOCAL_FN_MISSING, t.f, idx)); // not method OR
       else {
@@ -121,7 +127,9 @@ function validateLocalFunctions(inParams, taskDefs, locals) {
 }
 
 function fName(fn) {
-  return (typeof(fn) === 'string') ? fn : fn.name;
+  return (fn) ?
+    ((fn.name) ? fn.name : fn) :  // if defined, try name, otherwise toString()
+    'undefined';  // not defined, use undefined
 }
 
 /**
@@ -155,24 +163,21 @@ function create(taskDef) {
   return new TaskConstructor(taskDef);
 }
 
-function createOutTask(taskDef, cbFinal, tasks, vCon) {
+function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions) {
   setMissingOutTaskType(taskDef);
-  var TaskConstructor = OUT_TASK_TYPES[taskDef.type];
-  return new TaskConstructor(taskDef, cbFinal, tasks, vCon);
-}
-  
-function createCallback(task, handleTaskError, vCon, contExec) {
-  return function (err, arg0, arg1, argn) {
-    var args = Array.prototype.slice.call(arguments, 1);
-    if (err) { handleTaskError(task, err); return; } //handle error and return, we are done
-
-    //no error, save callback args to vCon context, then continue execution
-    vCon.saveResults(task.out, args);
-    task.complete(args);
-    contExec();
+  var outTaskOptions = {
+    taskDef: taskDef,
+    cbFunc: cbFunc,
+    tasks: tasks,
+    vCon: vCon,
+    execOptions: execOptions,
+    TaskConstructor: OUT_TASK_TYPES[taskDef.type]
   };
+  EventManager.global.emit(EventManager.TYPES.EXEC_OUTTASK_CREATE, outTaskOptions); // hook
+  var TaskConstructor = outTaskOptions.TaskConstructor;  // hook could have changed
+  return new TaskConstructor(outTaskOptions);
 }
-
+  
 function createErrorHandler(vCon, outTask) {
   return function handleError(task, err) {
     task.status = STATUS.ERRORED;
@@ -234,6 +239,5 @@ exports.validateLocalFunctions = validateLocalFunctions;
 exports.nameTasks = nameTasks;
 exports.create = create;
 exports.createOutTask = createOutTask;
-exports.createCallback = createCallback;
 exports.createErrorHandler = createErrorHandler;
 exports.findReadyAndExec = findReadyAndExec;

package/lib/validate.js

@@ -13,8 +13,8 @@ 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)
-var LITERAL_OR_PROP_RE = /^(true|false|\-?[0-9\.]+)$|'|"|\./i;  
+// 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;
@@ -153,7 +153,7 @@ function validateNoMissingNames(ast) {
     if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
     return accum;
   }, errors);
-  return errors;  //TODO reenable
+  return errors;  
 }
 
 module.exports = validate;

package/lib/vcon.js

@@ -16,6 +16,7 @@ VContext.prototype.getVar = function (name) { //name might be simple or obj.prop
   // 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 '
@@ -32,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
@@ -61,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.6",
+  "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"