react 0.5.2 → 0.6.0

package/lib/log-events.js

@@ -1,86 +1,92 @@
 'use strict';
+/*global define:true */
 
-/**
-   Log events to console.error
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-   @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
-  */
+define(['util'], function (util) { // TODO replace util.inspect with something portable to browser
 
-var util = require('util'); // TODO replace inspect with something portable to browser
+  var logEventsMod = { };
+  
+  /**
+     Log events to console.error
 
-var react = require('../'); // require('react');
-react.trackTasks(); // enable task and flow tracking
+     @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 ALL_FLOW_EVENTS = 'flow.*';
-var ALL_TASK_EVENTS = 'task.*';
-var FLOW_RE = /^flow\./;
+    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 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:%s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
-                  this.event, task.env.name, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
-  } else {
-    var name = obj.name;
-    var args = obj.args;
-    console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.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:%s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
+                    this.event, task.env.name, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
+    } else {
+      var name = obj.name;
+      var args = obj.args;
+      console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.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.*
+  /**
+     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);      
+  function logEvents(flowFn, eventWildcard) {
+    if (!flowFn) throw new Error('flowFn is required');
+    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;
+  logEventsMod.logEvents = logEvents;
+  return logEventsMod;
+
+});  

package/lib/parse.js

@@ -1,32 +1,41 @@
 'use strict';
+/*global define:true */
 
-var sprintf = require('sprintf').sprintf;
-
-function splitTrimFilterArgs(commaSepArgs) { //parse 'one, two' into ['one', 'two']
-  if (!commaSepArgs) return [];
-  return commaSepArgs.split(',')            //split on commas
-    .map(function (s) { return s.trim(); }) //trim
-    .filter(function (s) { return (s); });  //filter out empty strings
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-/**
-   @param patternFn regex + fn or splitStr + fn
+define(['./sprintf'], function (sprintf) {
+
+  function splitTrimFilterArgs(commaSepArgs) { //parse 'one, two' into ['one', 'two']
+    if (!commaSepArgs) return [];
+    return commaSepArgs.split(',')            //split on commas
+      .map(function (s) { return s.trim(); }) //trim
+      .filter(function (s) { return (s); });  //filter out empty strings
+  }
+
+  /**
+     @param patternFn regex + fn or splitStr + fn
   */
-function parseReduce(accum, patternFn) {
-  if (typeof(accum) !== 'string') return accum; // already matched
-  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
-}
+  function parseReduce(accum, patternFn) {
+    if (typeof(accum) !== 'string') return accum; // already matched
+    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
+  }
 
-function parseStr(str, parseMatchers, errStr) {
-  var result = parseMatchers.reduce(parseReduce, str);
-  if (typeof(result) !== 'string') { // matched
-    return result;
-  } else { // no match
-    throw new Error(sprintf(errStr, str));
-  }  
-}
+  function parseStr(str, parseMatchers, errStr) {
+    var result = parseMatchers.reduce(parseReduce, str);
+    if (typeof(result) !== 'string') { // matched
+      return result;
+    } else { // no match
+      throw new Error(sprintf(errStr, str));
+    }  
+  }
+
+  return {
+    splitTrimFilterArgs: splitTrimFilterArgs,
+    parseStr: parseStr
+  };
 
-exports.splitTrimFilterArgs = splitTrimFilterArgs;
-exports.parseStr = parseStr;
+});  

package/lib/promise-resolve.js

@@ -1,35 +1,50 @@
 'use strict';
+/*global define:true */
 
-/**
-   Auto resolve promises passed in as arguments to the flow
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-    - 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
+define([], function () {
+
+  /**
+     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]
+    var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
+
+    var resolvingPromises = false;
+
+  function resolvePromises(react) {
+    if (resolvingPromises) return; // already resolving
+    resolvingPromises = true;
+
+    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
+  }
+
+  return resolvePromises;
+
+});  

package/lib/promise-task.js

@@ -1,89 +1,93 @@
 'use strict';
+/*global define:true */
 
-/**
-   PromiseTask is a task which executes a fn that returns a promise
-   and when it completes it sets the values in vCon
-  */
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var util = require('util');
-var sprintf = require('sprintf').sprintf;
+define(['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
 
-var BaseTask = require('./base-task.js');
+  /**
+     PromiseTask is a task which executes a fn that returns a promise
+     and when it completes it sets the values in vCon
+  */
 
-function format_error(errmsg, obj) {
-  return sprintf('%s - %s', errmsg, util.inspect(obj));
-}
+  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';
+  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]; });
-}
+  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.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));
+  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));
+      }
     }
-    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;
-};
+    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();
+  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);
+    };
   };
-  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);
+    }    
   };
-};
 
-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);
-  }    
-};
+  return PromiseTask;
 
-module.exports = PromiseTask;
+});