react 0.3.5 → 0.6.0

package/lib/finalcb-task.js

@@ -1,61 +1,65 @@
 'use strict';
+/*global define:true */
 
-var sprintf = require('sprintf').sprintf;
-var util = require('util');
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var STATUS = require('./status.js');
-var EventManager = require('./event-manager.js');
+define(['./sprintf', 'util', './status', './event-manager'],
+       function (sprintf, util, STATUS, EventManager) {
 
-var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
+  var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
-function FinalCbTask(outTaskOptions) {
-  var taskDef = outTaskOptions.taskDef;
-  if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
-  var self = this;
-  for (var k in taskDef) {
-    if (true) self[k] = taskDef[k];  // if to make jshint happy
+  function FinalCbTask(outTaskOptions) {
+      var taskDef = outTaskOptions.taskDef;
+    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
+    var self = this;
+    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;
   }
-  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) {
-  return sprintf('%s - %s', errmsg, util.inspect(obj));
-}
+  function format_error(errmsg, obj) {
+    return sprintf('%s - %s', errmsg, util.inspect(obj));
+  }
 
 
-FinalCbTask.validate = function (taskDef) {
-  var errors = [];
-  if (! (Array.isArray(taskDef.a) &&
-         taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
-    errors.push(format_error(OUTTASK_A_REQ, taskDef));
-  }
-  return errors;
-};
-
-FinalCbTask.prototype.isReady = function () {
-  return (this.tasks.every(function (t) { return (t.status === STATUS.COMPLETE); }));
-};
-
-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
-};
+  FinalCbTask.validate = function (taskDef) {
+    var errors = [];
+    if (! (Array.isArray(taskDef.a) &&
+           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+      errors.push(format_error(OUTTASK_A_REQ, taskDef));
+    }
+    return errors;
+  };
+
+  FinalCbTask.prototype.isReady = function () {
+    return (this.tasks.every(function (t) { return (t.status === STATUS.COMPLETE); }));
+  };
+
+  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
+  };
+
+  return FinalCbTask;
 
-module.exports = FinalCbTask;
+});  

package/lib/id.js

@@ -1,10 +1,22 @@
 'use strict';
+/*global define:true */
 
-var startingId = 0;
-
-function createUniqueId() {
-  startingId += 1;
-  return startingId;
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-exports.createUniqueId = createUniqueId;
+define([], function () {
+  
+  var startingId = 0;
+
+  function createUniqueId() {
+    startingId += 1;
+    if (startingId === Number.MAX_VALUE) startingId = 0; // if hits this start over //TODO need something better?
+    return startingId;
+  }
+
+  return {
+    createUniqueId: createUniqueId
+  };
+
+});  

package/lib/input-parser.js

@@ -1,48 +1,56 @@
 'use strict';
+/*global define:true */
 
-var EventManager = require('./event-manager.js');
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var defaultExecOptions = {
-  reactExecOptions: true,
-  outputStyle: 'cb',
-};
+define(['./event-manager'], function (EventManager) {
 
-var OUTPUT_STYLES = {
-  CALLBACK: 'cb',
-  NONE: 'none'
-};
+  var defaultExecOptions = {
+    reactExecOptions: true,
+    outputStyle: 'cb',
+  };
 
-function isExecOptions(x) { return (x && x.reactExecOptions); }
-function execOptionsFilter(x) { return isExecOptions(x); }
-function nonExecOptionsFilter(x) { return !isExecOptions(x); }
-function mergeExecOptions(accum, options) {
-  Object.keys(options).forEach(function (k) { accum[k] = options[k]; });
-  return accum;
-}
+    var OUTPUT_STYLES = {
+      CALLBACK: 'cb',
+      NONE: 'none'
+    };
 
-function splitArgs(args, inParams, style) {
-  var result = { };
-  result.args = inParams.map(function (p) { return args.shift(); }); // take args for input params first
-  if (style === OUTPUT_STYLES.CALLBACK && args.length) result.cb = args.shift(); // next take the cb
-  result.extra = args; // these remaining were after the callback
-  return result;
-}
-  
-function inputParser(inputArgs, ast) {
-  var parsedInput = { };
-  var execOptionsArr = inputArgs.filter(execOptionsFilter);
-  execOptionsArr.unshift(defaultExecOptions);
-  parsedInput.options = execOptionsArr.reduce(mergeExecOptions, {});
-
-  var args = inputArgs.filter(nonExecOptionsFilter);
-  var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle); 
-  parsedInput.args = splitResult.args;
-  parsedInput.cb = splitResult.cb;
-  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;
-}
+  function isExecOptions(x) { return (x && x.reactExecOptions); }
+  function execOptionsFilter(x) { return isExecOptions(x); }
+  function nonExecOptionsFilter(x) { return !isExecOptions(x); }
+  function mergeExecOptions(accum, options) {
+    Object.keys(options).forEach(function (k) { accum[k] = options[k]; });
+    return accum;
+  }
+
+  function splitArgs(args, inParams, style) {
+    var result = { };
+    result.args = inParams.map(function (p) { return args.shift(); }); // take args for input params first
+    if (style === OUTPUT_STYLES.CALLBACK && args.length) result.cb = args.shift(); // next take the cb
+    result.extra = args; // these remaining were after the callback
+    return result;
+    }
+    
+  function inputParser(inputArgs, ast) {
+    var parsedInput = { };
+    var execOptionsArr = inputArgs.filter(execOptionsFilter);
+    execOptionsArr.unshift(defaultExecOptions);
+    parsedInput.options = execOptionsArr.reduce(mergeExecOptions, {});
+
+      var args = inputArgs.filter(nonExecOptionsFilter);
+    var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle); 
+    parsedInput.args = splitResult.args;
+    parsedInput.cb = splitResult.cb;
+    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;
+  }
+
+
+  inputParser.defaultExecOptions = defaultExecOptions;
+  return inputParser;
 
-module.exports = inputParser;
-module.exports.defaultExecOptions = defaultExecOptions;
+});  

package/lib/log-events.js

@@ -1,71 +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');
-   require('react/lib/log-events').logEvent(react);
-  */
+define(['util'], function (util) { // TODO replace util.inspect with something portable to browser
 
-var react = require('../lib/track-tasks');  // require('react/lib/track-tasks'); // turn on tracking
+  var logEventsMod = { };
+  
+  /**
+     Log events to console.error
 
-var ALL_FLOW_EVENTS = 'flow.*';
-var ALL_TASK_EVENTS = 'task.*';
+     @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
+    */
 
-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, argsNoCb, env.results);   
-  } else {
-    var name = obj.name;
-    var args = obj.args;
-    console.error('%s: %s \n\targs:(%s)\n', this.event, name, argsNoCb);
-  }    
-}
+    var ALL_FLOW_EVENTS = 'flow.*';
+  var ALL_TASK_EVENTS = 'task.*';
+  var FLOW_RE = /^flow\./;
 
-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, argsNoCb, task.results);
-  } else {
-    var name = obj.name;
-    var args = obj.args;
-    console.error('%s: %s \n\targs:(%s)\n', this.event, name, 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));
+    }    
   }
-  
-}
 
-/**
-   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');
-   require('react/lib/log-events').logEvents(flowFn); // pass flowFn or react
-   
-   @param flowFn Flow function or global react object
+  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.*
   */
-function logEvents(flowFn) {
-  //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);      
+    }
+  }
+
+  logEventsMod.logEvents = logEvents;
+  return logEventsMod;
 
-module.exports = react;
-module.exports.logEvents = logEvents;
+});  

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;
+});