react 0.5.2 → 0.6.0

package/lib/event-manager.js

@@ -1,75 +1,82 @@
 'use strict';
+/*global define:true process:false*/
 
-var EventEmitter2 = require('eventemitter2').EventEmitter2;
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
+
+define(['./eventemitter'], function (EventEmitter) {
 
-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 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 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
+  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
-};
+    // 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.
+  /**
+     Event manager which emits events up to its parent if exists.
+     Allows a hierarchy of emitters, which communicate up the
+     chain.
   */
-function EventManager() {
-}
+  function EventManager() {
+  }
 
-EventManager.create = function () { return new EventManager(); };
+  EventManager.create = function () { return new EventManager(); };
 
-EventManager.TYPES = TYPES;
-EventManager.prototype.TYPES = TYPES;
+  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()));
-};
+  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
+  /**
+     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 EventEmitter2(EVENT_EMITTER2_CONFIG);
-  if (event === '*') this.emitter.onAny(listener);
-  else this.emitter.on(event, listener);
-};
+  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) && process) process.emit.apply(process, arguments);  // pass some to process
-};
+  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) && process && 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.removeListener = function (event, listener) {
+    if (this.emitter) this.emitter.removeListener.apply(this.emitter, arguments);
+  };
 
 
-module.exports = EventManager;
-module.exports.global = EventManager.create(); // create one top level emitter
+  EventManager.global = EventManager.create(); // create one top level emitter
+  return EventManager;
+  
+});  

package/lib/eventemitter.js

@@ -0,0 +1,20 @@
+'use strict';
+/*global define:true EventEmitter2:true */
+
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
+
+define(['eventemitter2'], function (EventEmitterMod) {
+
+  /**
+     Abstract the details of getting an EventEmitter
+    */
+
+  // EventEmitter doesn't return itself in browser so need to get the global
+  // EventEmitter api changed, so accomodate which ever version is available
+  var EventEmitter = (EventEmitterMod) ?
+    ((EventEmitterMod.EventEmitter2) ? EventEmitterMod.EventEmitter2 : EventEmitterMod) : EventEmitter2;
+  return EventEmitter;
+  
+});  

package/lib/finalcb-first-task.js

@@ -1,65 +1,68 @@
 '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 VContext = require('./vcon.js');
-var EventManager = require('./event-manager.js');
+define(['./sprintf', 'util', './status', './vcon', './event-manager'],
+       function (sprintf, util, STATUS, VContext, 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 FinalCbFirstSuccTask(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 FinalCbFirstSuccTask(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.env = outTaskOptions.env;
   }
-  this.f = outTaskOptions.cbFunc;
-  this.tasks = outTaskOptions.tasks;
-  this.vCon = outTaskOptions.vCon;
-  this.retValue = outTaskOptions.retValue;
-  this.env = outTaskOptions.env;
-}
-
-function format_error(errmsg, obj) {
-  return sprintf('%s - %s', errmsg, util.inspect(obj));
-}
 
-FinalCbFirstSuccTask.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));
+  function format_error(errmsg, obj) {
+    return sprintf('%s - %s', errmsg, util.inspect(obj));
   }
-  return errors;
-};
 
-/**
-   is ready to exit when any task comes back with non-null defined value
+  FinalCbFirstSuccTask.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;
+  };
+
+  /**
+     is ready to exit when any task comes back with non-null defined value
   */
-FinalCbFirstSuccTask.prototype.isReady = function () {
-  var lastres = this.vCon.getLastResults();
-  if (!lastres) return false; // no results yet
-  return (lastres.some(function (v) { return (v !== undefined && v !== null); }));
-};
+  FinalCbFirstSuccTask.prototype.isReady = function () {
+    var lastres = this.vCon.getLastResults();
+    if (!lastres) return false; // no results yet
+    return (lastres.some(function (v) { return (v !== undefined && v !== null); }));
+  };
 
-FinalCbFirstSuccTask.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
-};
+  FinalCbFirstSuccTask.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 FinalCbFirstSuccTask;
 
-module.exports = FinalCbFirstSuccTask;
+});  

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,11 +1,22 @@
 'use strict';
+/*global define:true */
 
-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;
+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;
+});