react 0.5.1 → 0.6.2

package/lib/track-tasks.js

@@ -1,60 +1,74 @@
 'use strict';
+/*global define:true */
 
-/**
-   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
-
-    @example
-    var react = require('react');
-    react.trackTasks(); // enable task and flow tracking
-  */
-
-
-var react = require('../');  // require('react');
-
-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
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
+
+define([], function () {
+  
+  /**
+     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
+
+     @example
+     var react = require('react');
+     react.trackTasks(); // enable task and flow tracking
+    */
+
+
+  var trackingTasks = false;
+
+  function trackTasks(react) {
+    if (trackingTasks) return;  // already tracking
+    trackingTasks = true;
+
+    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
+    });
+
+  }
+
+  return trackTasks; 
+
+});  

package/lib/validate.js

@@ -1,159 +1,159 @@
 'use strict';
+/*global define:true */
 
-var util = require('util');
-var sprintf = require('sprintf').sprintf;
-var array = require('ensure-array');
-var tutil = require('./task.js');
-
-var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
-var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
-var TASKS_ARR = 'ast.tasks must be an array of tasks';
-var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
-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;
-
-function format_error(errmsg, obj) {
-  return sprintf('%s - %s', errmsg, util.inspect(obj));
-}
-
-/**
-   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);
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
+define(['util', './sprintf', 'ensure-array', './task'], function (util, sprintf, array, taskUtil) {
+  /*jshint latedef:false */
+  
+  var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
+  var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
+  var TASKS_ARR = 'ast.tasks must be an array of tasks';
+  var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
+  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;  
+
+  function format_error(errmsg, obj) {
+    return sprintf('%s - %s', errmsg, util.inspect(obj));
+  }
 
+  /**
+     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
-   var validate = require('./validate');
-   var errors = validate(ast);
-   @returns array of errors, could be empty
+  /**
+     validate the AST return Errors
+     @example
+     var validate = require('./validate');
+     var errors = validate(ast);
+     @returns array of errors, could be empty
   */
-function validate(ast) {
-  if (!ast || !ast.inParams || !ast.tasks || !ast.outTask) return [AST_IS_OBJECT];
-  var errors = [];
-  errors = errors.concat(validateInParams(ast.inParams));
-  errors = errors.concat(validateTasks(ast.tasks));
-  errors = errors.concat(validateTaskNamesUnique(ast.tasks));
-  errors = errors.concat(tutil.validateOutTask(ast.outTask));
-  errors = errors.concat(validateLocals(ast.locals));
-  if (errors.length === 0) { // if no errors do additional validation
-    if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
-    errors = errors.concat(tutil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
-    errors = errors.concat(validateNoMissingNames(ast));
+  function validate(ast) {
+    if (!ast || !ast.inParams || !ast.tasks || !ast.outTask) return [AST_IS_OBJECT];
+    var errors = [];
+    errors = errors.concat(validateInParams(ast.inParams));
+    errors = errors.concat(validateTasks(ast.tasks));
+    errors = errors.concat(validateTaskNamesUnique(ast.tasks));
+    errors = errors.concat(taskUtil.validateOutTask(ast.outTask));
+    errors = errors.concat(validateLocals(ast.locals));
+    if (errors.length === 0) { // if no errors do additional validation
+      if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
+      errors = errors.concat(taskUtil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
+      errors = errors.concat(validateNoMissingNames(ast));
+    }
+    return errors;
   }
-  return errors;
-}
 
-/**
-   @returns array of errors, could be empty
- */
-function validateInParams(inParams) {
-  if (!Array.isArray(inParams) ||
-      !inParams.every(function (x) { return (typeof(x) === 'string'); })) {
-    return [INPARAMS_ARR_STR];
+  /**
+     @returns array of errors, could be empty
+  */
+  function validateInParams(inParams) {
+    if (!Array.isArray(inParams) ||
+        !inParams.every(function (x) { return (typeof(x) === 'string'); })) {
+      return [INPARAMS_ARR_STR];
+    }
+    return [];
   }
-  return [];
-}
 
-/**
-   @returns array of errors, could be empty
- */
-function validateTasks(tasks) {
-  if (!Array.isArray(tasks)) return [TASKS_ARR];
-  var errors = [];
-  tasks.forEach(function (t) {
-    errors = errors.concat(tutil.validate(t));
-  });
-  return errors;
-}
+  /**
+     @returns array of errors, could be empty
+  */
+  function validateTasks(tasks) {
+    if (!Array.isArray(tasks)) return [TASKS_ARR];
+    var errors = [];
+    tasks.forEach(function (t) {
+      errors = errors.concat(taskUtil.validate(t));
+    });
+      return errors;
+  }
 
-function validateTaskNamesUnique(tasks) {
-  if (!Array.isArray(tasks)) return [];
-  var errors = [];
-  var namedTasks = tasks.filter(function (t) { return (t.name); });
-  var names = namedTasks.map(function (t) { return t.name; });
-  names.reduce(function (accum, name) {
-    if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
-    else accum[name] = true;
-    return accum;
-  }, {});                             
-  return errors;
-}
+  function validateTaskNamesUnique(tasks) {
+      if (!Array.isArray(tasks)) return [];
+    var errors = [];
+    var namedTasks = tasks.filter(function (t) { return (t.name); });
+    var names = namedTasks.map(function (t) { return t.name; });
+    names.reduce(function (accum, name) {
+      if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
+      else accum[name] = true;
+      return accum;
+    }, {});                             
+    return errors;
+  }
 
-function validateLocals(locals) {
-  var errors = [];
-  if (locals === null) errors.push(LOCALS_NOTNULL);
-  return errors;
-}
+  function validateLocals(locals) {
+    var errors = [];
+    if (locals === null) errors.push(LOCALS_NOTNULL);
+    return errors;
+  }
 
-function getOutputParams(taskDef) {
-  return array(taskDef.out); //ensure array
-}
+  function getOutputParams(taskDef) {
+    return array(taskDef.out); //ensure array
+  }
 
-function validateOuputsUnique(taskDefs) {
-  var errors = [];
-  taskDefs.reduce(function (accum, t) {
-    getOutputParams(t).forEach(function (param) {
-      if (accum[param] !== undefined) errors.push(sprintf('%s: %s', DUP_OUTPUTS, param));
-      else accum[param] = true;
-    });
-    return accum;
-  }, {});
-  return errors;
-}
+  function validateOuputsUnique(taskDefs) {
+    var errors = [];
+    taskDefs.reduce(function (accum, t) {
+      getOutputParams(t).forEach(function (param) {
+        if (accum[param] !== undefined) errors.push(sprintf('%s: %s', DUP_OUTPUTS, param));
+        else accum[param] = true;
+      });
+      return accum;
+    }, {});
+    return errors;
+  }
 
 
-/**
-   validate there are no missing or mispelled param names in any task inputs
-   or the final task output
+  /**
+     validate there are no missing or mispelled param names in any task inputs
+     or the final task output
 
-   @return array of errors, or empty array if none
+     @return array of errors, or empty array if none
   */
-function validateNoMissingNames(ast) {
-  var errors = [];
-  var names = {};
-  if (ast.locals) {
-    names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
-      accum[k] = true;
+  function validateNoMissingNames(ast) {
+    var errors = [];
+    var names = {};
+    if (ast.locals) {
+      names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
+        accum[k] = true;
+        return accum;
+      }, names);
+    }
+    ast.inParams.reduce(function (accum, p) {  // add input params
+      accum[p] = true;
       return accum;
     }, names);
+    ast.tasks.reduce(function (accum, t) { // add task outputs
+      return t.out.reduce(function (innerAccum, p) {
+        innerAccum[p] = true;
+        return innerAccum;
+      }, accum);
+    }, names);
+
+    // 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 (!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 (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+      return accum;
+    }, errors);
+    return errors;  
   }
-  ast.inParams.reduce(function (accum, p) {  // add input params
-    accum[p] = true;
-    return accum;
-  }, names);
-  ast.tasks.reduce(function (accum, t) { // add task outputs
-    return t.out.reduce(function (innerAccum, p) {
-      innerAccum[p] = true;
-      return innerAccum;
-    }, accum);
-  }, names);
-
-  // 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 (!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 (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
-    return accum;
-  }, errors);
-  return errors;  
-}
 
-module.exports = validate;
+  return validate;
+
+});  

package/lib/vcon.js

@@ -1,81 +1,90 @@
 'use strict';
+/*global define:true */
 
-var LAST_RESULTS_KEY = ':LAST_RESULTS';
-
-function VContext() {
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
-VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
+define([], function () {
+  
+  var LAST_RESULTS_KEY = ':LAST_RESULTS';
+
+  function VContext() {
+  }
 
-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 '
-  if (m) return m[2]; // if is quoted str, return inside of the quotes
-  var nameAndProps = name.split('.');
-  return nameAndProps.reduce(function (accObj, prop) {
-    if (accObj === undefined || accObj === null) return undefined; // prevent exception
-    return accObj[prop];
-  }, vConValues);   // vCon['foo']['bar']
-};
+  VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
+  VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
 
-/**
-   Saves all the results from a task as a unit, also sets special
-   variable :LAST_RESULTS which keeps an array of the last values
-   which can be used for chaining and testing last results, etc.
+  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 '
+    if (m) return m[2]; // if is quoted str, return inside of the quotes
+    var nameAndProps = name.split('.');
+    return nameAndProps.reduce(function (accObj, prop) {
+      if (accObj === undefined || accObj === null) return undefined; // prevent exception
+      return accObj[prop];
+    }, vConValues);   // vCon['foo']['bar']
+  };
+
+  /**
+     Saves all the results from a task as a unit, also sets special
+     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
-  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.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
-  var vConValues = this.values;
-  var nameAndProps = name.split('.');
-  var lastProp = nameAndProps.pop();
-  var obj = nameAndProps.reduce(function (accObj, prop) {
-    var o = accObj[prop];
-    if (o === undefined || o === null) {  // if doesn't exist create it
-      o = accObj[prop] = { };
-    }
-    return o;
-  }, vConValues);   // vCon['foo']['bar']
-  obj[lastProp] = value;
-};
+  VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
+    if (!name) return;  // if name is undefined or null, then discard
+    var vConValues = this.values;
+    var nameAndProps = name.split('.');
+    var lastProp = nameAndProps.pop();
+    var obj = nameAndProps.reduce(function (accObj, prop) {
+      var o = accObj[prop];
+      if (o === undefined || o === null) {  // if doesn't exist create it
+        o = accObj[prop] = { };
+      }
+      return o;
+    }, vConValues);   // vCon['foo']['bar']
+    obj[lastProp] = value;
+  };
   
 
-/**
-   Create Variable Context using arguments passed in.
-   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, 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
-    var param = inParams[idx];
-    if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
-    return vcon;
-  }, initValues);
-  return vContext;
-};
+  /**
+     Create Variable Context using arguments passed in.
+     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, 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
+      var param = inParams[idx];
+      if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
+      return vcon;
+    }, initValues);
+    return vContext;
+  };
+
 
+  return VContext;
 
-module.exports = VContext;
+});