react 0.5.2 → 0.6.0

package/lib/dsl.js

@@ -1,133 +1,138 @@
 'use strict';
-/*jshint regexp: false */
+/*global define:true */
 
-var sprintf = require('sprintf').sprintf;
-var core = require('./core.js');
-var parse = require('./parse.js');
-var tutil = require('./task.js');
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var MISSING_NAME = 'first flow parameter should be the flow name, but found in/out def: %s';
-var INOUT_PARAMS_NO_MATCH = 'params in wrong format, wanted "foo, bar, cb -> err, baz" - found: %s';
-var MISSING_ERR = 'callback specified, but first out param was not "err", use for clarity. Found in/out def: %s';
-var MISSING_CB = 'found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: %s';
-var EXTRA_TASKARG = 'extra unmatched task arg: %s';
+define(['./sprintf', './core', './parse', './task'],
+       function (sprintf, core, parse, taskUtil) {
+         /*jshint regexp: false */
 
-var INOUT_RE = /\->/;  // used to detect missing name, in/out as first arg
-var CB_NAMES_RE = /^cb|callback$/i;  //cb, Cb, CB, callback, Callback
-var ERR_NAMES_RE = /^err$/i; // err, ERR, Err, ...
+  var MISSING_NAME = 'first flow parameter should be the flow name, but found in/out def: %s';
+  var INOUT_PARAMS_NO_MATCH = 'params in wrong format, wanted "foo, bar, cb -> err, baz" - found: %s';
+  var MISSING_ERR = 'callback specified, but first out param was not "err", use for clarity. Found in/out def: %s';
+  var MISSING_CB = 'found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: %s';
+  var EXTRA_TASKARG = 'extra unmatched task arg: %s';
 
-function filterOutTrailingCbParam(args) { // if has trailing cb | callback param, filter it out
-  if (args.length && args[args.length - 1].match(CB_NAMES_RE)) args.pop();
-  return args;
-}
+  var INOUT_RE = /\->/;  // used to detect missing name, in/out as first arg
+  var CB_NAMES_RE = /^cb|callback$/i;  //cb, Cb, CB, callback, Callback
+  var ERR_NAMES_RE = /^err$/i; // err, ERR, Err, ...
 
-function filterOutLeadingErrParam(args) { // if leading err param, filter it out
-  if (args.length && args[0].match(ERR_NAMES_RE)) args.shift();
-  return args;
-}
+  function filterOutTrailingCbParam(args) { // if has trailing cb | callback param, filter it out
+    if (args.length && args[args.length - 1].match(CB_NAMES_RE)) args.pop();
+    return args;
+  }
 
-var inOutDefParse = {
-  splitStr: '->',
-  fn: function (m, origStr) {
-    var inParams = parse.splitTrimFilterArgs(m[0]);
-    var lastParam = inParams[inParams.length - 1];
-    var type = (lastParam && CB_NAMES_RE.test(lastParam)) ? 'cb' : 'ret';
-    var outParams = parse.splitTrimFilterArgs(m[1]);
-    var firstOutParam = outParams[0];
-    if (type === 'cb' && (!firstOutParam || !ERR_NAMES_RE.test(firstOutParam))) {
-      throw new Error(sprintf(MISSING_ERR, origStr));  // found cb, but no err param
-    } else if (type === 'ret' && firstOutParam && ERR_NAMES_RE.test(firstOutParam)) {
-      throw new Error(sprintf(MISSING_CB, origStr));  // found err but not cb param
-    }
-    return {
-      type: type,
-      inDef: filterOutTrailingCbParam(inParams),
-      outDef: filterOutLeadingErrParam(outParams)
-    };
+  function filterOutLeadingErrParam(args) { // if leading err param, filter it out
+    if (args.length && args[0].match(ERR_NAMES_RE)) args.shift();
+    return args;
   }
-};
 
-function parseInOutParams(str) {
-  var objDef = parse.parseStr(str, [inOutDefParse], INOUT_PARAMS_NO_MATCH);
-  objDef.inDef = filterOutTrailingCbParam(objDef.inDef);
-  return objDef;
-}
+  var inOutDefParse = {
+    splitStr: '->',
+      fn: function (m, origStr) {
+        var inParams = parse.splitTrimFilterArgs(m[0]);
+        var lastParam = inParams[inParams.length - 1];
+        var type = (lastParam && CB_NAMES_RE.test(lastParam)) ? 'cb' : 'ret';
+          var outParams = parse.splitTrimFilterArgs(m[1]);
+        var firstOutParam = outParams[0];
+        if (type === 'cb' && (!firstOutParam || !ERR_NAMES_RE.test(firstOutParam))) {
+          throw new Error(sprintf(MISSING_ERR, origStr));  // found cb, but no err param
+        } else if (type === 'ret' && firstOutParam && ERR_NAMES_RE.test(firstOutParam)) {
+          throw new Error(sprintf(MISSING_CB, origStr));  // found err but not cb param
+        }
+        return {
+          type: type,
+          inDef: filterOutTrailingCbParam(inParams),
+            outDef: filterOutLeadingErrParam(outParams)
+        };
+      }
+  };
 
-function parseTasks(arr) {
-  var tasks = [];
-  var fn, obj, result;
-  while (arr.length >= 2) {
-    obj = {};
-    fn = arr.shift();
-    result = parseInOutParams(arr.shift());
-    if (typeof(arr[0]) === 'object') obj = arr.shift(); // has options, use as obj
-    obj.f = fn;
-    obj.a = result.inDef;
-    var type = result.type;
-    obj.out = result.outDef;
-    obj.type = type;
-    tasks.push(obj);
+  function parseInOutParams(str) {
+    var objDef = parse.parseStr(str, [inOutDefParse], INOUT_PARAMS_NO_MATCH);
+    objDef.inDef = filterOutTrailingCbParam(objDef.inDef);
+    return objDef;
+  }
+
+  function parseTasks(arr) {
+    var tasks = [];
+    var fn, obj, result;
+    while (arr.length >= 2) {
+      obj = {};
+      fn = arr.shift();
+      result = parseInOutParams(arr.shift());
+      if (typeof(arr[0]) === 'object') obj = arr.shift(); // has options, use as obj
+      obj.f = fn;
+      obj.a = result.inDef;
+      var type = result.type;
+      obj.out = result.outDef;
+      obj.type = type;
+      tasks.push(obj);
+    }
+    if (arr.length) throw new Error(sprintf(EXTRA_TASKARG, arr[0]));
+    return tasks;
   }
-  if (arr.length) throw new Error(sprintf(EXTRA_TASKARG, arr[0]));
-  return tasks;
-}
 
-/**
-   Parse the variable arguments into in/out params, options, tasks
+  /**
+     Parse the variable arguments into in/out params, options, tasks
   */
-function parseVargs(vargs) {
-  var inOutParamStr = vargs.shift() || '';
-  // if next arg is object, shift it off as options
-  var options = (vargs.length && typeof(vargs[0]) === 'object') ? vargs.shift() : { };
-  var taskDefArr = vargs; // rest are for the tasks
-  var defObj = {  
-    inOutParamStr: inOutParamStr,
-    taskDefArr: taskDefArr,
-    options: options
-  };
-  return defObj;
-}
+  function parseVargs(vargs) {
+    var inOutParamStr = vargs.shift() || '';
+    // if next arg is object, shift it off as options
+    var options = (vargs.length && typeof(vargs[0]) === 'object') ? vargs.shift() : { };
+    var taskDefArr = vargs; // rest are for the tasks
+    var defObj = {  
+      inOutParamStr: inOutParamStr,
+      taskDefArr: taskDefArr,
+      options: options
+      };
+    return defObj;
+  }
 
 
-function dslDefine(name, arg1, arg2, argN) {
-  var reactFn = core();
-  if (name && INOUT_RE.test(name)) throw new Error(sprintf(MISSING_NAME, name));
-  var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
-  var inOutDef = parseInOutParams(defObj.inOutParamStr);
-  var ast = {
-    name: name,
-    inParams: inOutDef.inDef,
-    tasks: parseTasks(defObj.taskDefArr),
-    outTask: { a: inOutDef.outDef }
-  };
-  if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });
-  var errors = reactFn.setAndValidateAST(ast);
-  if (errors.length) {
-    var errorStr = errors.join('\n');
-    throw new Error(errorStr);
-  }
-  return reactFn;
-}
+  function dslDefine(name, arg1, arg2, argN) {
+    var reactFn = core();
+    if (name && INOUT_RE.test(name)) throw new Error(sprintf(MISSING_NAME, name));
+    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
+    var inOutDef = parseInOutParams(defObj.inOutParamStr);
+    var ast = {
+      name: name,
+      inParams: inOutDef.inDef,
+      tasks: parseTasks(defObj.taskDefArr),
+      outTask: { a: inOutDef.outDef }
+    };
+    if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });
+      var errors = reactFn.setAndValidateAST(ast);
+    if (errors.length) {
+      var errorStr = errors.join('\n');
+        throw new Error(errorStr);
+    }
+    return reactFn;
+    }
 
-function selectFirst(name, arg1, arg2, argN) {
-  var reactFn = core();
-  var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
-  var inOutDef = parseInOutParams(defObj.inOutParamStr);  
-  var tasks = tutil.serializeTasks(parseTasks(defObj.taskDefArr));
-  var ast = {
-    name: name,
-    inParams: inOutDef.inDef,
-    tasks: tasks,
-    outTask: { type: 'finalcbFirst', a: inOutDef.outDef },
-  };
-  if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });  
-  var errors = reactFn.setAndValidateAST(ast);
-  if (errors.length) {
-    var errorStr = errors.join('\n');
-    throw new Error(errorStr);
+  function selectFirst(name, arg1, arg2, argN) {
+    var reactFn = core();
+    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
+    var inOutDef = parseInOutParams(defObj.inOutParamStr);  
+    var tasks = taskUtil.serializeTasks(parseTasks(defObj.taskDefArr));
+    var ast = {
+      name: name,
+      inParams: inOutDef.inDef,
+      tasks: tasks,
+      outTask: { type: 'finalcbFirst', a: inOutDef.outDef },
+    };
+    if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });  
+    var errors = reactFn.setAndValidateAST(ast);
+    if (errors.length) {
+      var errorStr = errors.join('\n');
+      throw new Error(errorStr);
+    }
+    return reactFn;
   }
-  return reactFn;
-}
 
-module.exports = dslDefine;
-module.exports.selectFirst = selectFirst;
+  dslDefine.selectFirst = selectFirst;
+  return dslDefine;
+  
+});  

package/lib/error.js

@@ -1,47 +1,55 @@
 'use strict';
+/*global define:true */
 
-var util = require('util');
-
-function ensureStackTraceLimitSet(stackTraceLimit) {
-  if (!Error.stackTraceLimit || Error.stackTraceLimit < stackTraceLimit) {
-    Error.stackTraceLimit = stackTraceLimit;
-  }
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-function fName(fn) {
-  if (!fn) return 'undefined';
-  return (fn && fn.name) ? fn.name : fn;
-}
+define(['util'], function (util) {
 
-function formatErrorMeta(err) {
-  if (!err.meta) return;
-  var vcon = err.meta.vcon;
-  var task = err.meta.task;
-  var errString = '\n\n';
-  if (task && task.f && task.a) {
-    errString += ('Error occurs in Task function: ' + fName(task.f) + '(' + task.a.join(',') + ')\n\n');
+  function ensureStackTraceLimitSet(stackTraceLimit) {
+    if (!Error.stackTraceLimit || Error.stackTraceLimit < stackTraceLimit) {
+      Error.stackTraceLimit = stackTraceLimit;
+    }
   }
-  if (vcon) {
-    errString += 'Variable Context: \n';
-    errString += util.inspect(vcon);
-    errString +=  '\n\n';
+
+  function fName(fn) {
+    if (!fn) return 'undefined';
+    return (fn && fn.name) ? fn.name : fn;
   }
-  if (task && task.f) {
-    errString += 'Task Source:\n\n';
-    errString += task.f.toString(); //TODO need to pretty print function, gets collapsed
-    errString += '\n\n';
+
+  function formatErrorMeta(err) {
+    if (!err.meta) return;
+    var vcon = err.meta.vcon;
+    var task = err.meta.task;
+    var errString = '\n\n';
+    if (task && task.f && task.a) {
+      errString += ('Error occurs in Task function: ' + fName(task.f) + '(' + task.a.join(',') + ')\n\n');
+    }
+    if (vcon) {
+      errString += 'Variable Context: \n';
+      errString += util.inspect(vcon);
+      errString +=  '\n\n';
+    }
+    if (task && task.f) {
+      errString += 'Task Source:\n\n';
+      errString += task.f.toString(); //TODO need to pretty print function, gets collapsed
+      errString += '\n\n';
+    }
+    return errString;    
   }
-  return errString;    
-}
 
-function augmentError(err, meta) {
-  if (typeof(err) === 'string') { err = new Error(err); } //props will be lost on non-objects
-  var origMsg = err.toString();
-  err.meta = meta;
-  err.toString = function () { return origMsg + formatErrorMeta(err); };
-  return err;
-}
+  function augmentError(err, meta) {
+    if (typeof(err) === 'string') { err = new Error(err); } //props will be lost on non-objects
+    var origMsg = err.toString();
+    err.meta = meta;
+    err.toString = function () { return origMsg + formatErrorMeta(err); };
+    return err;
+  }
 
+  return {
+    ensureStackTraceLimitSet: ensureStackTraceLimitSet,
+    augmentError: augmentError    
+  };
 
-exports.ensureStackTraceLimitSet = ensureStackTraceLimitSet;
-exports.augmentError = augmentError;
+});  

package/lib/event-collector.js

@@ -1,68 +1,81 @@
 'use strict';
+/*global define:true */
 
-var react = require('../');  // require('react');
-react.trackTasks(); // enable task tracking
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var AST_EVENTS_RE = /^ast\./;
-var TASK_EVENTS_RE = /^task\./;
-var FLOW_EVENTS_RE = /^flow\./;
+define([], function () {
 
-/**
-   Accumulator to make it easy to capture events
+  /**
+     create an instance of the event collector
+  */
+  function instantiate(react) {
+    react.trackTasks(); // enable task tracking
 
-   @example
-   var EventCollector = require('react/lib/event-collector');
-   var collector = new EventCollector();
+    var AST_EVENTS_RE = /^ast\./;
+    var TASK_EVENTS_RE = /^task\./;
+    var FLOW_EVENTS_RE = /^flow\./;
 
-   collector.capture(); // capture all flow and task events for all react flows
-   collector.capture('flow.*'); // capture all flow events for all react flows
-   collector.capture(flowFn, 'task.*'); // capture task events on a flow
-   collector.capture(flowFn, 'flow.*'); // add capture flow events on a flow
+    /**
+       Accumulator to make it easy to capture events
 
-   var events = collector.list();  // retrieve the list of events
-   collector.clear();  // clear the list of events;
-*/
-function EventCollector() {
-  this.events = [];
-}
+       @example
+       var react = require('react');
+       var collector = react.createEventCollector();
+       collector.capture(); // capture all flow and task events for all react flows
+       collector.capture('flow.*'); // capture all flow events for all react flows
+       collector.capture(flowFn, 'task.*'); // capture task events on a flow
+       collector.capture(flowFn, 'flow.*'); // add capture flow events on a flow
+       var events = collector.list();  // retrieve the list of events
+       collector.clear();  // clear the list of events;
+    */
+    function EventCollector() {
+      this.events = [];
+    }
 
-/**
-   register listener to capture events for a specific flow
-   @param flowFn the react flow function or can pass global react
-   @param eventId event id or wildcarded id
-  */
-EventCollector.prototype.capture = function (flowFn, eventId) {
-  /*jshint validthis: true */
-  if (!eventId && typeof(flowFn) === 'string') { // only eventId provided
-    eventId = flowFn;
-    flowFn = react; // global react
-  } else if (!flowFn) flowFn = react; // global react
-  if (!eventId) eventId = '*'; // default to all
-  var emitter = flowFn.events;
-  var self = this;
-  function accumEvents(obj) {
-    var eventObject = {
-      event: this.event,
-      time: Date.now()
+    /**
+       register listener to capture events for a specific flow
+       @param flowFn the react flow function or can pass global react
+       @param eventId event id or wildcarded id
+    */
+    EventCollector.prototype.capture = function (flowFn, eventId) {
+      /*jshint validthis: true */
+      if (!eventId && typeof(flowFn) === 'string') { // only eventId provided
+        eventId = flowFn;
+        flowFn = react; // global react
+      } else if (!flowFn) flowFn = react; // global react
+      if (!eventId) eventId = '*'; // default to all
+      var emitter = flowFn.events;
+      var self = this;
+      function accumEvents(obj) {
+        var eventObject = {
+          event: this.event,
+          time: Date.now()
+        };
+        if (FLOW_EVENTS_RE.test(this.event)) {
+          eventObject.env = obj;
+        } else if (TASK_EVENTS_RE.test(this.event)) {
+          eventObject.task = obj;
+        } else if (AST_EVENTS_RE.test(this.event)) {
+          eventObject.ast = obj;      
+        }
+        self.events.push(eventObject);      
+      }
+      emitter.on(eventId, accumEvents);
     };
-    if (FLOW_EVENTS_RE.test(this.event)) {
-      eventObject.env = obj;
-    } else if (TASK_EVENTS_RE.test(this.event)) {
-      eventObject.task = obj;
-    } else if (AST_EVENTS_RE.test(this.event)) {
-      eventObject.ast = obj;      
-    }
-    self.events.push(eventObject);      
-  }
-  emitter.on(eventId, accumEvents);
-};
 
-EventCollector.prototype.list = function () {
-  return this.events;
-};
+    EventCollector.prototype.list = function () {
+      return this.events;
+    };
 
-EventCollector.prototype.clear = function () {
-  this.events = []; // clear
-};
+    EventCollector.prototype.clear = function () {
+      this.events = []; // clear
+    };
+
+    return new EventCollector();  
+  }
 
-module.exports = EventCollector;
+  return instantiate; // return the factory for creating EventCollector
+  
+});