react 0.3.5 → 0.6.0

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

@@ -0,0 +1,81 @@
+'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,71 +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 TYPES = {
-  // Flow monitoring events and their params
-  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 PASS_EVENTS_PROCESS_RE = /^ast.defined$/;  // events to pass up to global process
 
-  // 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
-};
+  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
 
-/**
-   Event manager which emits events up to its parent if exists.
-   Allows a hierarchy of emitters, which communicate up the
-   chain.
+    // 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() {
-}
+  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);
-};
+  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;
+});