react 0.5.0 → 0.6.1

package/lib/core.js

@@ -1,127 +1,138 @@
 'use strict';
+/*global define:true */
 
-var EventEmitter = require('events').EventEmitter;
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var error = require('./error.js');
-var validate = require('./validate.js');
-var tskutil = require('./task.js');
-var STATUS = require('./status.js');
-var VContext = require('./vcon.js');
-var EventManager = require('./event-manager.js');
-var inputParser = require('./input-parser.js');
-var idGenerator = require('./id.js');
+define(['./eventemitter', './error', './validate', './task', './status',
+        './vcon', './event-manager', './input-parser', './id', './sprintf'],
+       function (EventEmitter, error, validate, taskUtil, STATUS,
+                 VContext, EventManager, inputParser, idGenerator, sprintf) {
 
-var reactOptions = {
-  stackTraceLimitMin: 30
-};
+  var reactOptions = {
+    stackTraceLimitMin: 30
+  };
 
-var reactEmitter = EventManager.global; // the top emitter
+  var reactEmitter = EventManager.global; // the top emitter
 
-/**
-   merge global react options with parsed options
+  /**
+     merge global react options with parsed options
   */
-function mergeOptions(parsedOptions) {
-  return Object.keys(reactOptions).reduce(function (accum, k) {
-    if (!accum[k]) accum[k] = reactOptions[k];
-    return accum;
-  }, parsedOptions);    
-}
+  function mergeOptions(parsedOptions) {
+    return Object.keys(reactOptions).reduce(function (accum, k) {
+      if (!accum[k]) accum[k] = reactOptions[k];
+      return accum;
+    }, parsedOptions);    
+  }
+
+  /**
+     generate a flow name when one is not provided
+  */
+  function generateFlowName() {
+    return sprintf('flow_%s', idGenerator.createUniqueId());
+  }
 
-/**
-   Creates react function which the AST can be manipulated and then
-   is ready to be executed. Can be used directly or a DSL can wrap this
-   to provide the AST.
+  /**
+     Creates react function which the AST can be manipulated and then
+     is ready to be executed. Can be used directly or a DSL can wrap this
+     to provide the AST.
 
-   @example
-   var react = require('react');
-   var fn = react();
-   var valid2 = fn.setAndValidateAST({
+     @example
+     var react = require('react');
+     var fn = react();
+     var valid2 = fn.setAndValidateAST({
      name: 'optionalName',
      inParams: ['a', 'b'],
      tasks: [
-      { type: 'cb', f: multiply, a: ['a', 'b'], out: ['c'] }
+     { type: 'cb', f: multiply, a: ['a', 'b'], out: ['c'] }
      ],
-    outTask: { a: ['c'] }
-   });
-   console.log(fn.ast); // view
-   fn(123, 456, cb);
- */
-function reactFactory() {
-  if (arguments.length) throw new Error('react() takes no args, check API');
-
-  error.ensureStackTraceLimitSet(reactOptions.stackTraceLimitMin);
-  var flowEmitter = EventManager.create();
-  flowEmitter.parent = reactEmitter;
-
-  var ast = {
-    name: undefined,
-    inParams: [],
-    tasks: [],
-    outTask: {},
-    locals: {}
-  };
+     outTask: { a: ['c'] }
+     });
+     console.log(fn.ast); // view
+     fn(123, 456, cb);
+  */
+  function reactFactory() {
+    if (arguments.length) throw new Error('react() takes no args, check API');
+
+    error.ensureStackTraceLimitSet(reactOptions.stackTraceLimitMin);
+    var flowEmitter = EventManager.create();
+    flowEmitter.parent = reactEmitter;
+
+    var ast = {
+      name: undefined,
+      inParams: [],
+      tasks: [],
+      outTask: {},
+      locals: {}
+    };
 
-  function setAndValidateAST(newAST) { //set AST then validate, ret error[]
-    Object.keys(newAST).forEach(function (k) { ast[k] = newAST[k]; }); // copy all properties
-    var errors = validate(ast);
-    if (!errors.length) tskutil.nameTasks(ast.tasks); //run this so names can be checked in ast
-    if (Object.freeze) { //lets freeze the AST so plugin writers don't accidentally manip the ast
-      Object.keys(newAST).forEach(function (k) {
-        if (typeof(newAST[k]) === 'object') Object.freeze(newAST[k]);
-      });
-      Object.freeze(newAST);
+    function setAndValidateAST(newAST) { //set AST then validate, ret error[]
+      Object.keys(newAST).forEach(function (k) { ast[k] = newAST[k]; }); // copy all properties
+      var errors = validate(ast);
+      if (!errors.length) {
+        if (!ast.name) ast.name = generateFlowName();
+        taskUtil.nameTasks(ast.tasks); //run this so names can be checked in ast
+      }
+      if (Object.freeze) { //lets freeze the AST so plugin writers don't accidentally manip the ast
+        Object.keys(newAST).forEach(function (k) {
+          if (typeof(newAST[k]) === 'object') Object.freeze(newAST[k]);
+        });
+        Object.freeze(newAST);
+      }
+      flowEmitter.emit(EventManager.TYPES.AST_DEFINED, ast); 
+      return errors;
     }
-    return errors;
-  }
 
-  function exec(arg1, arg2, argN, cb) { // called to execute the flow
-    /*jshint validthis: true */
-    var args = Array.prototype.slice.call(arguments);
-    var env = {
-      execId: idGenerator.createUniqueId(),
-      args: args,
-      ast: ast,
-      flowEmitter: flowEmitter
-    };
-    env.name = ast.name || env.execId;
-    flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_START, env);  // hook
-    var parsedInput = inputParser(args, ast);
-    var vCon = VContext.create(parsedInput.args, ast.inParams, ast.locals, this); // create var ctx with in args & locals
-
-    env.parsedInput = parsedInput;
-    env.options = mergeOptions(parsedInput.options);
-    env.vCon = vCon;
-    env.taskDefs = ast.tasks.slice(); // create copy
-    env.outTaskDef = Object.create(ast.outTask); // create copy
-    reactEmitter.emit(EventManager.TYPES.EXEC_TASKS_PRECREATE, env);  // hook
-    
-    var tasks = env.taskDefs.map(tskutil.create);
-    var tasksByName = tskutil.nameTasks(tasks); // map names to working tasks
-    var outTask = tskutil.createOutTask(env.outTaskDef, parsedInput.cb, tasks, vCon, env.options, env);
-    var handleError = tskutil.createErrorHandler(vCon, outTask);
-
-    function contExec() {
-      if (!outTask.f) { return; } //stop execution, we already hit an error, f was cleared
-      if (outTask.isReady()) return outTask.exec(); // all tasks done, exec cb, return
-      tskutil.findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec, env);  //exec tasks that ready to run
+    function exec(arg1, arg2, argN, cb) { // called to execute the flow
+      /*jshint validthis: true */
+      var args = Array.prototype.slice.call(arguments);
+      var env = {
+        execId: idGenerator.createUniqueId(),
+        args: args,
+        ast: ast,
+        flowEmitter: flowEmitter
+      };
+      env.name = ast.name || env.execId;
+      flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_START, env);  // hook
+      var parsedInput = inputParser(args, ast);
+      var vCon = VContext.create(parsedInput.args, ast.inParams, ast.locals, this); // create var ctx with in args & locals
+
+      env.parsedInput = parsedInput;
+      env.options = mergeOptions(parsedInput.options);
+      env.vCon = vCon;
+      env.taskDefs = ast.tasks.slice(); // create copy
+      env.outTaskDef = Object.create(ast.outTask); // create copy
+      reactEmitter.emit(EventManager.TYPES.EXEC_TASKS_PRECREATE, env);  // hook
+      
+      var tasks = env.taskDefs.map(taskUtil.create);
+      var tasksByName = taskUtil.nameTasks(tasks); // map names to working tasks
+      var outTask = taskUtil.createOutTask(env.outTaskDef, parsedInput.cb, tasks, vCon, env.options, env);
+      var handleError = taskUtil.createErrorHandler(vCon, outTask);
+
+      function contExec() {
+        if (!outTask.f) { return; } //stop execution, we already hit an error, f was cleared
+        if (outTask.isReady()) return outTask.exec(); // all tasks done, exec cb, return
+        taskUtil.findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec, env);  //exec tasks that ready to run
+      }
+
+      tasks.forEach(function (t) {
+        t.id = idGenerator.createUniqueId();
+        t.env = env;
+        if (t.prepare) t.prepare(handleError, vCon, contExec, flowEmitter);
+      }); // create callbacks
+      contExec();   // start things off
+      return outTask.retValue; // could return promise
     }
 
-    tasks.forEach(function (t) {
-      t.id = idGenerator.createUniqueId();
-      t.env = env;
-      if (t.prepare) t.prepare(handleError, vCon, contExec, flowEmitter);
-    }); // create callbacks
-    contExec();   // start things off
-    return outTask.retValue; // could return promise
+    var reactFn = exec;        // make the exec() the function returned
+    reactFn.ast  = ast;        // put AST hanging off the fn so it can be inspected
+    reactFn.setAndValidateAST = setAndValidateAST;   // call to set AST and then validate
+    reactFn.events = flowEmitter; // used to listen to execution events for this flow
+    return reactFn;
   }
 
-  var reactFn = exec;        // make the exec() the function returned
-  reactFn.ast  = ast;        // put AST hanging off the fn so it can be inspected
-  reactFn.setAndValidateAST = setAndValidateAST;   // call to set AST and then validate
-  reactFn.events = flowEmitter; // used to listen to execution events for this flow
-  return reactFn;
-}
-
-module.exports = reactFactory;           // module returns reactFactory to create a react fn
-module.exports.options = reactOptions;   // global react options
-module.exports.events = reactEmitter;    // global react emitter
+  reactFactory.options = reactOptions;   // global react options
+  reactFactory.events = reactEmitter;    // global react emitter
+  return reactFactory; // module returns reactFactory to create a react fn
+});  

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