react 0.5.0 → 0.6.1

package/lib/promise-resolve.js

@@ -1,35 +1,50 @@
 'use strict';
+/*global define:true */
 
-/**
-   Auto resolve promises passed in as arguments to the flow
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-    - Detects promises by checking for .then()
-    - Create promise name for param (param__promise)
-    - moves existing vCon promise into the param__promise
-    - creates WhenTask which resolves param__promise into param
+define([], function () {
+
+  /**
+     Auto resolve promises passed in as arguments to the flow
+
+     - Detects promises by checking for .then()
+     - Create promise name for param (param__promise)
+     - moves existing vCon promise into the param__promise
+     - creates WhenTask which resolves param__promise into param
   */
 
 
-var react = require('../');  // require('react');
-
-var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
-
-react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (env) {
-  var vConValues = env.vCon.values;
-  var promiseParams = env.ast.inParams.filter(function (p) {
-    var value = vConValues[p];
-    return (value && typeof(value.then) === 'function');
-  });
-  promiseParams.forEach(function (p) {
-    var promiseName = p + PROMISE_SUFFIX;
-    vConValues[promiseName] = vConValues[p];
-    vConValues[p] = undefined;
-    env.taskDefs.push({
-      type: 'when',
-      a: [promiseName],
-      out: [p]
+    var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
+
+    var resolvingPromises = false;
+
+  function resolvePromises(react) {
+    if (resolvingPromises) return; // already resolving
+    resolvingPromises = true;
+
+    react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (env) {
+      var vConValues = env.vCon.values;
+      var promiseParams = env.ast.inParams.filter(function (p) {
+        var value = vConValues[p];
+        return (value && typeof(value.then) === 'function');
+      });
+      promiseParams.forEach(function (p) {
+        var promiseName = p + PROMISE_SUFFIX;
+        vConValues[promiseName] = vConValues[p];
+        vConValues[p] = undefined;
+        env.taskDefs.push({
+          type: 'when',
+          a: [promiseName],
+          out: [p]
+        });
+      });
     });
-  });
-});
 
-module.exports = react;  // return react
+  }
+
+  return resolvePromises;
+
+});  

package/lib/promise-task.js

@@ -1,89 +1,93 @@
 'use strict';
+/*global define:true */
 
-/**
-   PromiseTask is a task which executes a fn that returns a promise
-   and when it completes it sets the values in vCon
-  */
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var util = require('util');
-var sprintf = require('sprintf').sprintf;
+define(['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
 
-var BaseTask = require('./base-task.js');
+  /**
+     PromiseTask is a task which executes a fn that returns a promise
+     and when it completes it sets the values in vCon
+  */
 
-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));
+  }
 
-var REQ = 'promiseTask requires f, a, out';
-var FN_REQ = 'promiseTask requires f to be a function or string';
-var A_REQ = 'promiseTask requires a to be an array of string param names';
-var OUT_REQ = 'promiseTask requires out to be an array[1] of string param names';
+  var REQ = 'promiseTask requires f, a, out';
+  var FN_REQ = 'promiseTask requires f to be a function or string';
+  var A_REQ = 'promiseTask requires a to be an array of string param names';
+  var OUT_REQ = 'promiseTask requires out to be an array[1] of string param names';
 
-function PromiseTask(taskDef) {
-  var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-}
+  function PromiseTask(taskDef) {
+    var self = this;
+    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  }
 
-PromiseTask.prototype = new BaseTask();
-PromiseTask.prototype.constructor = PromiseTask;
+  PromiseTask.prototype = new BaseTask();
+  PromiseTask.prototype.constructor = PromiseTask;
 
-PromiseTask.validate = function (taskDef) {
-  var errors = [];
-  if (!taskDef.f || !taskDef.a || !taskDef.out) {
-    errors.push(format_error(REQ, taskDef));
-  } else {
-    var ftype = typeof(taskDef.f);
-    if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
-      errors.push(format_error(FN_REQ, taskDef));
+  PromiseTask.validate = function (taskDef) {
+    var errors = [];
+    if (!taskDef.f || !taskDef.a || !taskDef.out) {
+      errors.push(format_error(REQ, taskDef));
+    } else {
+      var ftype = typeof(taskDef.f);
+      if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
+        errors.push(format_error(FN_REQ, taskDef));
+      }
+      if (! (Array.isArray(taskDef.a) &&
+             taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+        errors.push(format_error(A_REQ, taskDef));
+      }
+      if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 && 
+             taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
+        errors.push(format_error(OUT_REQ, taskDef));
+      }
     }
-    if (! (Array.isArray(taskDef.a) &&
-           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
-      errors.push(format_error(A_REQ, taskDef));
-    }
-    if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 && 
-           taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
-      errors.push(format_error(OUT_REQ, taskDef));
-    }
-  }
-  return errors;
-};
+    return errors;
+  };
 
-PromiseTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
-  var self = this;
-  this.nextFn = function (arg) {
-    var args = Array.prototype.slice.call(arguments);
-    vCon.saveResults(self.out, args);
-    self.complete(args);
-    contExec();
+  PromiseTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
+    var self = this;
+    this.nextFn = function (arg) {
+      var args = Array.prototype.slice.call(arguments);
+      vCon.saveResults(self.out, args);
+      self.complete(args);
+      contExec();
+    };
+    this.failFn = function (err) {
+      handleTaskError(self, err);
+    };
   };
-  this.failFn = function (err) {
-    handleTaskError(self, err);
+
+  PromiseTask.prototype.exec = function exec(vCon, handleError, contExec) {
+    try {
+      var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
+      //console.error('PromiseTask.exec.args=', args);
+      //console.error('PromiseTask.exec.vCon=', vCon);
+      this.start(args); //note the start time, args
+      var func = this.f;
+      var bindObj = vCon.getVar('this'); //global space or the original this
+      if (this.isMethodCall()) { //if method call then reset func and bindObj
+        func = vCon.getVar(this.f);
+        bindObj = this.getMethodObj(vCon);
+      } else if (typeof(func) === 'string') {
+        func = vCon.getVar(func); // we want the actual fn from this string
+      }
+      var retValue = func.apply(bindObj, args);
+      if (retValue && typeof(retValue.then) === 'function') { // is a promise
+        retValue.then(this.nextFn, this.failFn);
+      } else { // just a value, proceed now
+        this.nextFn(retValue);
+      }
+    } catch (err) { //catch and handle the task error, calling final cb
+      handleError(this, err);
+    }    
   };
-};
 
-PromiseTask.prototype.exec = function exec(vCon, handleError, contExec) {
-  try {
-    var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
-    //console.error('PromiseTask.exec.args=', args);
-    //console.error('PromiseTask.exec.vCon=', vCon);
-    this.start(args); //note the start time, args
-    var func = this.f;
-    var bindObj = vCon.getVar('this'); //global space or the original this
-    if (this.isMethodCall()) { //if method call then reset func and bindObj
-      func = vCon.getVar(this.f);
-      bindObj = this.getMethodObj(vCon);
-    } else if (typeof(func) === 'string') {
-      func = vCon.getVar(func); // we want the actual fn from this string
-    }
-    var retValue = func.apply(bindObj, args);
-    if (retValue && typeof(retValue.then) === 'function') { // is a promise
-      retValue.then(this.nextFn, this.failFn);
-    } else { // just a value, proceed now
-      this.nextFn(retValue);
-    }
-  } catch (err) { //catch and handle the task error, calling final cb
-    handleError(this, err);
-  }    
-};
+  return PromiseTask;
 
-module.exports = PromiseTask;
+});  

package/lib/react.js

@@ -0,0 +1,59 @@
+'use strict';
+/*global define:true */
+
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
+
+define(['./core', './dsl', './track-tasks', './log-events', './promise-resolve', './event-collector'],
+       function (core, dsl, trackTasksFn, logEventsMod, resolvePromisesFn, eventCollectorFactory) {
+
+  var react = dsl; // core + default dsl
+         
+  /**
+     Enable detection of promises and resolution
+    */
+  function resolvePromises() {
+    resolvePromisesFn(react);
+  }
+
+  /**
+     Enable tracking of tasks and flow execution, emitting events and
+     tracking start, end, elapsed time
+    */
+  function trackTasks() {
+    trackTasksFn(react);
+  }  
+         
+  /**
+     If called, load the built-in plugin for log events and invoke
+
+     @param flowFn [function] if not provided uses global react
+     @param eventWildcard [string] pattern to log events for
+  */
+  function logEvents(flowFn, eventWildcard) {
+    if (!eventWildcard && typeof(flowFn) === 'string') { // only wildcard provided
+      eventWildcard = flowFn;
+      flowFn = undefined;
+    }
+    if (!flowFn) flowFn = react; // use global
+    trackTasks();
+    return logEventsMod.logEvents(flowFn, eventWildcard);
+  }
+
+  /**
+     Instantiate an event collector
+    */
+  function createEventCollector() {
+    return eventCollectorFactory(react);
+  }
+
+  react.options = core.options; // global react options
+  react.events = core.events;   // global react event emitter
+  react.logEvents = logEvents;  // enable event logging
+  react.resolvePromises = resolvePromises; // enable promise resolution
+  react.trackTasks = trackTasks; // enable tracking of tasks
+  react.createEventCollector = createEventCollector; // create instance of EventCollector       
+  return react;
+  
+});

package/lib/ret-task.js

@@ -1,67 +1,71 @@
 'use strict';
+/*global define:true */
 
-var util = require('util');
-var sprintf = require('sprintf').sprintf;
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
 
-var BaseTask = require('./base-task.js');
+define(['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
+  
+  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));
-}
+  var REQ = 'retTask requires f, a, out';
+  var FN_REQ = 'retTask requires f to be a function or string';
+  var A_REQ = 'retTask requires a to be an array of string param names';
+  var RET_REQ = 'retTask requires out to be an array with single string param name or []';
 
-var REQ = 'retTask requires f, a, out';
-var FN_REQ = 'retTask requires f to be a function or string';
-var A_REQ = 'retTask requires a to be an array of string param names';
-var RET_REQ = 'retTask requires out to be an array with single string param name or []';
+  function RetTask(taskDef) {
+    var self = this;
+    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  }
 
-function RetTask(taskDef) {
-  var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-}
+  RetTask.prototype = new BaseTask();
+  RetTask.prototype.constructor = RetTask;
 
-RetTask.prototype = new BaseTask();
-RetTask.prototype.constructor = RetTask;
+  RetTask.validate = function (taskDef) {
+    var errors = [];
+    if (!taskDef.f || !taskDef.a || !taskDef.out) {
+      errors.push(format_error(REQ, taskDef));
+    } else {
+      var ftype = typeof(taskDef.f);
+      if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
+        errors.push(format_error(FN_REQ, taskDef));
+      }
+      if (! (Array.isArray(taskDef.a) &&
+             taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+        errors.push(format_error(A_REQ, taskDef));
+      }
 
-RetTask.validate = function (taskDef) {
-  var errors = [];
-  if (!taskDef.f || !taskDef.a || !taskDef.out) {
-    errors.push(format_error(REQ, taskDef));
-  } else {
-    var ftype = typeof(taskDef.f);
-    if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
-      errors.push(format_error(FN_REQ, taskDef));
-    }
-    if (! (Array.isArray(taskDef.a) &&
-           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
-      errors.push(format_error(A_REQ, taskDef));
+      if (! (Array.isArray(taskDef.out) &&
+             (taskDef.out.length === 0 ||
+              (taskDef.out.length === 1 && typeof(taskDef.out[0] === 'string'))))) {
+        errors.push(format_error(RET_REQ, taskDef));
+      }
     }
+    return errors;
+  };
 
-    if (! (Array.isArray(taskDef.out) &&
-           (taskDef.out.length === 0 ||
-             (taskDef.out.length === 1 && typeof(taskDef.out[0] === 'string'))))) {
-      errors.push(format_error(RET_REQ, taskDef));
-    }
-  }
-  return errors;
-};
+  RetTask.prototype.exec = function exec(vCon, handleError, contExec) {
+    try {
+      var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
+      this.start(args); //note the start time, args    
+      var func = this.f;
+      var bindObj = vCon.getVar('this'); //global space or the original this
+      if (this.isMethodCall()) { //if method call then reset func and bindObj
+        func = vCon.getVar(this.f);
+        bindObj = this.getMethodObj(vCon);
+      } else if (typeof(func) === 'string') {
+        func = vCon.getVar(func); // we want the actual fn from this string
+      }
+      var results = [func.apply(bindObj, args)];
+      vCon.saveResults(this.out, results); // save retval, takes arrays
+      this.complete(results);
+      contExec();       // continue since no callback to run this
+    } catch (err) { handleError(this, err); }    // catch and handle the task error, calling final cb
+  };
 
-RetTask.prototype.exec = function exec(vCon, handleError, contExec) {
-  try {
-    var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
-    this.start(args); //note the start time, args    
-    var func = this.f;
-    var bindObj = vCon.getVar('this'); //global space or the original this
-    if (this.isMethodCall()) { //if method call then reset func and bindObj
-      func = vCon.getVar(this.f);
-      bindObj = this.getMethodObj(vCon);
-    } else if (typeof(func) === 'string') {
-      func = vCon.getVar(func); // we want the actual fn from this string
-    }
-    var results = [func.apply(bindObj, args)];
-    vCon.saveResults(this.out, results); // save retval, takes arrays
-    this.complete(results);
-    contExec();       // continue since no callback to run this
-  } catch (err) { handleError(this, err); }    // catch and handle the task error, calling final cb
-};
+  return RetTask;
 
-module.exports = RetTask;
+});  

package/lib/sprintf.js

@@ -0,0 +1,18 @@
+'use strict';
+/*global define:true sprint:true */
+
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
+}
+
+define(['util'], function (util) {
+
+  /**
+     Abstract the details of getting a sprintf function.
+     Currently using the simple format capabilities of node's util.format
+    */
+  
+  var sprintf = util.format;
+  return sprintf;
+  
+});