react 0.3.5 → 0.6.0

package/lib/track-tasks.js

@@ -1,117 +1,74 @@
 'use strict';
+/*global define:true */
 
-/**
-   Track the tasks, start, complete, args, results, elapsed time
-   Emits events that can be monitored
-
-    - track start and complete
-    - record args each task was called with
-    - record results at completion
-    - record start, end, and calc elapsed time
-    - emits flow.begin with flowEnv
-    - emits task.begin with task
-    - emits task.complete with task
-    - emits flow complete with flowEnv
-    - emits flow errored with flowEnv
-  */
-
-
-var react = require('../');  // require('react');
-
-var TASK_EVENTS_RE = /^task\./;
-var FLOW_EVENTS_RE = /^flow\./;
-
-/**
-   Accumulator to make it easy to capture events
-
-   @example
-   var EventCollector = require('react/lib/track-tasks').EventCollector;
-   var collector = new EventCollector();
-   
-   collector.captureGlobal('*'); // capture all react events for all flows
-
-   // OR
-   
-   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
-  */
-function EventCollector() {
-  this.events = [];
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-/**
-   register listener to capture all events
-   @param eventId event id or wildcarded id
-  */
-EventCollector.prototype.captureGlobal = function (eventId) {
-  this.capture(react, eventId);
-};
-
-/**
-   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) {
-  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;
-    }
-    self.events.push(eventObject);      
-  }
-  emitter.on(eventId, accumEvents);
-};
-
-EventCollector.prototype.list = function () {
-  return this.events;
-};
-
-react.events.on(react.events.TYPES.EXEC_FLOW_START, function (env){
-  env.startTime = Date.now();
-  env.flowEmitter.emit(react.events.TYPES.FLOW_BEGIN, env); //fire public ev
-});
-
-react.events.on(react.events.TYPES.EXEC_TASK_START, function (task) {
-  task.startTime = Date.now();
-  task.env.flowEmitter.emit(react.events.TYPES.TASK_BEGIN, task); //fire public ev
-});
-
-react.events.on(react.events.TYPES.EXEC_TASK_COMPLETE, function (task) {
-  task.endTime = Date.now();
-  task.elapsedTime = task.endTime - task.startTime;
-  task.env.flowEmitter.emit(react.events.TYPES.TASK_COMPLETE, task); // fire public ev
-});
-
-react.events.on(react.events.TYPES.EXEC_TASK_ERRORED, function (task) {
-  task.endTime = Date.now();
-  task.elapsedTime = task.endTime - task.startTime;
-  task.env.flowEmitter.emit(react.events.TYPES.TASK_ERRORED, task); // fire public ev
-});
-
-react.events.on(react.events.TYPES.EXEC_FLOW_COMPLETE, function (env) {
-  env.endTime = Date.now();
-  env.elapsedTime = env.endTime - env.startTime;
-  env.flowEmitter.emit(react.events.TYPES.FLOW_COMPLETE, env); //fire public ev
-});
-
-react.events.on(react.events.TYPES.EXEC_FLOW_ERRORED, function (env) {
-  env.endTime = Date.now();
-  env.elapsedTime = env.endTime - env.startTime;
-  env.flowEmitter.emit(react.events.TYPES.FLOW_ERRORED, env); //fire public ev
-});
-
+define([], function () {
+  
+  /**
+     Track the tasks, start, complete, args, results, elapsed time
+     Emits events that can be monitored
+
+     - track start and complete
+     - record args each task was called with
+     - record results at completion
+     - record start, end, and calc elapsed time
+     - emits flow.begin with flowEnv
+     - emits task.begin with task
+     - emits task.complete with task
+     - emits flow complete with flowEnv
+     - emits flow errored with flowEnv
+
+     @example
+     var react = require('react');
+     react.trackTasks(); // enable task and flow tracking
+    */
+
+
+  var trackingTasks = false;
+
+  function trackTasks(react) {
+    if (trackingTasks) return;  // already tracking
+    trackingTasks = true;
+
+    react.events.on(react.events.TYPES.EXEC_FLOW_START, function (env) {
+      env.startTime = Date.now();
+      env.flowEmitter.emit(react.events.TYPES.FLOW_BEGIN, env); //fire public ev
+    });
+
+    react.events.on(react.events.TYPES.EXEC_TASK_START, function (task) {
+      task.startTime = Date.now();
+      task.env.flowEmitter.emit(react.events.TYPES.TASK_BEGIN, task); //fire public ev
+    });
+
+    react.events.on(react.events.TYPES.EXEC_TASK_COMPLETE, function (task) {
+      task.endTime = Date.now();
+      task.elapsedTime = task.endTime - task.startTime;
+      task.env.flowEmitter.emit(react.events.TYPES.TASK_COMPLETE, task); // fire public ev
+    });
+
+    react.events.on(react.events.TYPES.EXEC_TASK_ERRORED, function (task) {
+      task.endTime = Date.now();
+      task.elapsedTime = task.endTime - task.startTime;
+      task.env.flowEmitter.emit(react.events.TYPES.TASK_ERRORED, task); // fire public ev
+    });
+
+    react.events.on(react.events.TYPES.EXEC_FLOW_COMPLETE, function (env) {
+      env.endTime = Date.now();
+      env.elapsedTime = env.endTime - env.startTime;
+      env.flowEmitter.emit(react.events.TYPES.FLOW_COMPLETE, env); //fire public ev
+    });
+
+    react.events.on(react.events.TYPES.EXEC_FLOW_ERRORED, function (env) {
+      env.endTime = Date.now();
+      env.elapsedTime = env.endTime - env.startTime;
+      env.flowEmitter.emit(react.events.TYPES.FLOW_ERRORED, env); //fire public ev
+    });
 
+  }
 
+  return trackTasks; 
 
-module.exports = react;  // return react
-module.exports.EventCollector = EventCollector;
+});  

package/lib/validate.js

@@ -1,159 +1,159 @@
 'use strict';
+/*global define:true */
 
-var util = require('util');
-var sprintf = require('sprintf').sprintf;
-var array = require('ensure-array');
-var tutil = require('./task.js');
-
-var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
-var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
-var TASKS_ARR = 'ast.tasks must be an array of tasks';
-var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
-var LOCALS_NOTNULL = 'ast.locals should not be null';
-var DUP_OUTPUTS = 'multiple tasks output the same param, must be unique. param';
-var MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
-
-// match any of our literals true, false, int, float, quoted strings, or is property (has dot), match vcon.js
-var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;  
-
-var validateInParams, validateTasks, validateOutTask, validateTaskNamesUnique;
-var validateLocals, validateOuputsUnique, validateNoMissingNames;
-
-function format_error(errmsg, obj) {
-  return sprintf('%s - %s', errmsg, util.inspect(obj));
-}
-
-/**
-   true if is a literal name
-  */
-function isLiteralOrProp(name) {  // need to match what is in vcon.js, TODO consolidate?
-  return LITERAL_OR_PROP_RE.test(name);
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
+define(['util', './sprintf', 'ensure-array', './task'], function (util, sprintf, array, taskUtil) {
+  /*jshint latedef:false */
+  
+  var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
+  var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
+  var TASKS_ARR = 'ast.tasks must be an array of tasks';
+  var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
+  var LOCALS_NOTNULL = 'ast.locals should not be null';
+  var DUP_OUTPUTS = 'multiple tasks output the same param, must be unique. param';
+  var MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
+
+  // match any of our literals true, false, int, float, quoted strings, or is property (has dot), match vcon.js
+  var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;  
+
+  function format_error(errmsg, obj) {
+    return sprintf('%s - %s', errmsg, util.inspect(obj));
+  }
 
+  /**
+     true if is a literal name
+  */
+  function isLiteralOrProp(name) {  // need to match what is in vcon.js, TODO consolidate?
+    return LITERAL_OR_PROP_RE.test(name);
+  }
 
-/**
-   validate the AST return Errors
-   @example
-   var validate = require('./validate');
-   var errors = validate(ast);
-   @returns array of errors, could be empty
+  /**
+     validate the AST return Errors
+     @example
+     var validate = require('./validate');
+     var errors = validate(ast);
+     @returns array of errors, could be empty
   */
-function validate(ast) {
-  if (!ast || !ast.inParams || !ast.tasks || !ast.outTask) return [AST_IS_OBJECT];
-  var errors = [];
-  errors = errors.concat(validateInParams(ast.inParams));
-  errors = errors.concat(validateTasks(ast.tasks));
-  errors = errors.concat(validateTaskNamesUnique(ast.tasks));
-  errors = errors.concat(tutil.validateOutTask(ast.outTask));
-  errors = errors.concat(validateLocals(ast.locals));
-  if (errors.length === 0) { // if no errors do additional validation
-    if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
-    errors = errors.concat(tutil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
-    errors = errors.concat(validateNoMissingNames(ast));
+  function validate(ast) {
+    if (!ast || !ast.inParams || !ast.tasks || !ast.outTask) return [AST_IS_OBJECT];
+    var errors = [];
+    errors = errors.concat(validateInParams(ast.inParams));
+    errors = errors.concat(validateTasks(ast.tasks));
+    errors = errors.concat(validateTaskNamesUnique(ast.tasks));
+    errors = errors.concat(taskUtil.validateOutTask(ast.outTask));
+    errors = errors.concat(validateLocals(ast.locals));
+    if (errors.length === 0) { // if no errors do additional validation
+      if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
+      errors = errors.concat(taskUtil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
+      errors = errors.concat(validateNoMissingNames(ast));
+    }
+    return errors;
   }
-  return errors;
-}
 
-/**
-   @returns array of errors, could be empty
- */
-function validateInParams(inParams) {
-  if (!Array.isArray(inParams) ||
-      !inParams.every(function (x) { return (typeof(x) === 'string'); })) {
-    return [INPARAMS_ARR_STR];
+  /**
+     @returns array of errors, could be empty
+  */
+  function validateInParams(inParams) {
+    if (!Array.isArray(inParams) ||
+        !inParams.every(function (x) { return (typeof(x) === 'string'); })) {
+      return [INPARAMS_ARR_STR];
+    }
+    return [];
   }
-  return [];
-}
 
-/**
-   @returns array of errors, could be empty
- */
-function validateTasks(tasks) {
-  if (!Array.isArray(tasks)) return [TASKS_ARR];
-  var errors = [];
-  tasks.forEach(function (t) {
-    errors = errors.concat(tutil.validate(t));
-  });
-  return errors;
-}
+  /**
+     @returns array of errors, could be empty
+  */
+  function validateTasks(tasks) {
+    if (!Array.isArray(tasks)) return [TASKS_ARR];
+    var errors = [];
+    tasks.forEach(function (t) {
+      errors = errors.concat(taskUtil.validate(t));
+    });
+      return errors;
+  }
 
-function validateTaskNamesUnique(tasks) {
-  if (!Array.isArray(tasks)) return [];
-  var errors = [];
-  var namedTasks = tasks.filter(function (t) { return (t.name); });
-  var names = namedTasks.map(function (t) { return t.name; });
-  names.reduce(function (accum, name) {
-    if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
-    else accum[name] = true;
-    return accum;
-  }, {});                             
-  return errors;
-}
+  function validateTaskNamesUnique(tasks) {
+      if (!Array.isArray(tasks)) return [];
+    var errors = [];
+    var namedTasks = tasks.filter(function (t) { return (t.name); });
+    var names = namedTasks.map(function (t) { return t.name; });
+    names.reduce(function (accum, name) {
+      if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
+      else accum[name] = true;
+      return accum;
+    }, {});                             
+    return errors;
+  }
 
-function validateLocals(locals) {
-  var errors = [];
-  if (locals === null) errors.push(LOCALS_NOTNULL);
-  return errors;
-}
+  function validateLocals(locals) {
+    var errors = [];
+    if (locals === null) errors.push(LOCALS_NOTNULL);
+    return errors;
+  }
 
-function getOutputParams(taskDef) {
-  return array(taskDef.out); //ensure array
-}
+  function getOutputParams(taskDef) {
+    return array(taskDef.out); //ensure array
+  }
 
-function validateOuputsUnique(taskDefs) {
-  var errors = [];
-  taskDefs.reduce(function (accum, t) {
-    getOutputParams(t).forEach(function (param) {
-      if (accum[param] !== undefined) errors.push(sprintf('%s: %s', DUP_OUTPUTS, param));
-      else accum[param] = true;
-    });
-    return accum;
-  }, {});
-  return errors;
-}
+  function validateOuputsUnique(taskDefs) {
+    var errors = [];
+    taskDefs.reduce(function (accum, t) {
+      getOutputParams(t).forEach(function (param) {
+        if (accum[param] !== undefined) errors.push(sprintf('%s: %s', DUP_OUTPUTS, param));
+        else accum[param] = true;
+      });
+      return accum;
+    }, {});
+    return errors;
+  }
 
 
-/**
-   validate there are no missing or mispelled param names in any task inputs
-   or the final task output
+  /**
+     validate there are no missing or mispelled param names in any task inputs
+     or the final task output
 
-   @return array of errors, or empty array if none
+     @return array of errors, or empty array if none
   */
-function validateNoMissingNames(ast) {
-  var errors = [];
-  var names = {};
-  if (ast.locals) {
-    names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
-      accum[k] = true;
+  function validateNoMissingNames(ast) {
+    var errors = [];
+    var names = {};
+    if (ast.locals) {
+      names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
+        accum[k] = true;
+        return accum;
+      }, names);
+    }
+    ast.inParams.reduce(function (accum, p) {  // add input params
+      accum[p] = true;
       return accum;
     }, names);
+    ast.tasks.reduce(function (accum, t) { // add task outputs
+      return t.out.reduce(function (innerAccum, p) {
+        innerAccum[p] = true;
+        return innerAccum;
+      }, accum);
+    }, names);
+
+    // now we have all possible provided vars, check task inputs are accounted for
+    ast.tasks.reduce(function (accum, t) {  // for all tasks
+      return t.a.reduce(function (innerAccum, p) { // for all in params, except property
+        if (!isLiteralOrProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+        return innerAccum;
+      }, accum);
+    }, errors);
+
+    // now check the final task outputs
+    ast.outTask.a.reduce(function (accum, p) { // for final task out params
+      if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+      return accum;
+    }, errors);
+    return errors;  
   }
-  ast.inParams.reduce(function (accum, p) {  // add input params
-    accum[p] = true;
-    return accum;
-  }, names);
-  ast.tasks.reduce(function (accum, t) { // add task outputs
-    return t.out.reduce(function (innerAccum, p) {
-      innerAccum[p] = true;
-      return innerAccum;
-    }, accum);
-  }, names);
-
-  // now we have all possible provided vars, check task inputs are accounted for
-  ast.tasks.reduce(function (accum, t) {  // for all tasks
-    return t.a.reduce(function (innerAccum, p) { // for all in params, except property
-      if (!isLiteralOrProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
-      return innerAccum;
-    }, accum);
-  }, errors);
-
-  // now check the final task outputs
-  ast.outTask.a.reduce(function (accum, p) { // for final task out params
-    if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
-    return accum;
-  }, errors);
-  return errors;  
-}
 
-module.exports = validate;
+  return validate;
+
+});