react 0.6.3 → 0.9.0-rc1

package/lib/core.js

@@ -1,138 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-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 reactEmitter = EventManager.global; // the top emitter
-
-  /**
-     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);    
-  }
-
-  /**
-     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.
-
-     @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'] }
-     ],
-     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) {
-        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;
-    }
-
-    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
-    }
-
-    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;
-  }
-
-  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,138 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./sprintf', './core', './parse', './task'],
-       function (sprintf, core, parse, taskUtil) {
-         /*jshint regexp: false */
-
-  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';
-
-  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 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;
-  }
-
-  function filterOutLeadingErrParam(args) { // if leading err param, filter it out
-    if (args.length && args[0].match(ERR_NAMES_RE)) args.shift();
-    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 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;
-  }
-
-  /**
-     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 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 = 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;
-  }
-
-  dslDefine.selectFirst = selectFirst;
-  return dslDefine;
-  
-});  

package/lib/error.js

@@ -1,55 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util'], function (util) {
-
-  function ensureStackTraceLimitSet(stackTraceLimit) {
-    if (!Error.stackTraceLimit || Error.stackTraceLimit < stackTraceLimit) {
-      Error.stackTraceLimit = stackTraceLimit;
-    }
-  }
-
-  function fName(fn) {
-    if (!fn) return 'undefined';
-    return (fn && fn.name) ? fn.name : fn;
-  }
-
-  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;    
-  }
-
-  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    
-  };
-
-});  

package/lib/event-collector.js

@@ -1,81 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-
-  /**
-     create an instance of the event collector
-  */
-  function instantiate(react) {
-    react.trackTasks(); // enable task tracking
-
-    var AST_EVENTS_RE = /^ast\./;
-    var TASK_EVENTS_RE = /^task\./;
-    var FLOW_EVENTS_RE = /^flow\./;
-
-    /**
-       Accumulator to make it easy to capture 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()
-        };
-        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.clear = function () {
-      this.events = []; // clear
-    };
-
-    return new EventCollector();  
-  }
-
-  return instantiate; // return the factory for creating EventCollector
-  
-});  

package/lib/event-manager.js

@@ -1,89 +0,0 @@
-'use strict';
-/*global define:true process:false*/
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./eventemitter'], function (EventEmitter) {
-  /*jshint regexp:false */
-
-  var EVENT_EMITTER2_CONFIG = {
-    wildcard: true, // should the event emitter use wildcards.
-    delimiter: '.', // the delimiter used to segment namespaces, defaults to `.`.
-    maxListeners: 30 // the max number of listeners that can be assigned to an event, defaults to 10.
-  };
-
-  var PASS_EVENTS_PROCESS_RE = /^ast.defined$/;  // events to pass up to global process
-
-  var TYPES = {
-    // Flow monitoring events and their params
-    AST_DEFINED: 'ast.defined',                      // ast
-    FLOW_BEGIN: 'flow.begin',                        // env
-    TASK_BEGIN: 'task.begin',                        // task
-    TASK_COMPLETE: 'task.complete',                  // task
-    TASK_ERRORED: 'task.errored',                    // task
-    FLOW_COMPLETE: 'flow.complete',                  // env
-    FLOW_ERRORED: 'flow.errored',                    // env
-
-    // Internal Hooks
-    EXEC_FLOW_START: 'exec.flow.start',              // env
-    EXEC_INPUT_PREPROCESS: 'exec.input.preprocess',  // parsedInput
-    EXEC_TASKS_PRECREATE: 'exec.tasks.precreate',    // env
-    EXEC_OUTTASK_CREATE: 'exec.outTask.create',      // outTaskOptions
-    EXEC_TASK_START: 'exec.task.start',              // task
-    EXEC_TASK_COMPLETE: 'exec.task.complete',        // task
-    EXEC_TASK_ERRORED: 'exec.task.errored',          // task
-    EXEC_FLOW_COMPLETE: 'exec.flow.complete',        // env
-    EXEC_FLOW_ERRORED: 'exec.flow.errored'           // env
-  };
-
-  /**
-     Event manager which emits events up to its parent if exists.
-     Allows a hierarchy of emitters, which communicate up the
-     chain.
-  */
-  function EventManager() {
-  }
-
-  EventManager.create = function () { return new EventManager(); };
-
-  EventManager.TYPES = TYPES;
-  EventManager.prototype.TYPES = TYPES;
-
-  EventManager.prototype.isEnabled = function () { // if has listener or an ancestor has listener
-    return !!(this.emitter || (this.parent && this.parent.isEnabled()));
-  };
-
-  /**
-     Add listener. Wildcard events are allowed like 'foo.*'
-     Use '*' to listen to any event
-  */
-  EventManager.prototype.on = function (event, listener) {
-    if (!this.emitter) this.emitter = new EventEmitter(EVENT_EMITTER2_CONFIG);
-    if (event === '*') this.emitter.onAny(listener);
-    else this.emitter.on(event, listener);
-  };
-
-  EventManager.prototype.emit = function (event, arg1, arg2, argN) {
-    if (event === undefined) throw new Error('event is undefined');
-    if (this.emitter) this.emitter.emit.apply(this.emitter, arguments);
-    if (this.parent && this.parent.isEnabled()) this.parent.emit.apply(this.parent, arguments);
-    if (PASS_EVENTS_PROCESS_RE.test(event) && typeof(process) !== 'undefined' && process.emit) {
-      process.emit.apply(process, arguments);  // pass some to process
-    }
-  };
-
-  EventManager.prototype.removeListener = function (event, listener) {
-    if (this.emitter) this.emitter.removeListener.apply(this.emitter, arguments);
-  };
-
-  EventManager.prototype.removeAllListeners = function (event) {
-    if (this.emitter) this.emitter.removeAllListeners.apply(this.emitter, arguments);
-  };
-
-
-  EventManager.global = EventManager.create(); // create one top level emitter
-  return EventManager;
-
-});