react 0.3.5 → 0.6.0

package/doc/simple.dot

@@ -0,0 +1,25 @@
+digraph loadRender {
+  loadRender_input [ shape = box, style = filled, fillcolor = aquamarine ];
+  fooPath [ style = filled, fillcolor = gainsboro ];
+  barPath [ style = filled, fillcolor = gainsboro ];
+  barP2 [ style = filled, fillcolor = gainsboro ];
+  loadFoo [ shape = box, color = blue, fillcolor = beige, style = filled ];
+  foo [ style = filled, fillcolor = gainsboro ];
+  loadBar [ shape = box, color = blue, fillcolor = beige, style = filled ];
+  bar [ style = filled, fillcolor = gainsboro ];
+  render [ shape = box, color = blue, fillcolor = beige, style = filled ];
+  renderedOut [ style = filled, fillcolor = gainsboro ];
+  loadRender_output [ shape = box, style = filled, fillcolor = aquamarine ];
+  loadRender_input -> fooPath;
+  loadRender_input -> barPath;
+  loadRender_input -> barP2;
+  fooPath -> loadFoo;
+  loadFoo -> foo;
+  barPath -> loadBar;
+  barP2 -> loadBar;
+  loadBar -> bar;
+  foo -> render;
+  bar -> render;
+  render -> renderedOut;
+  renderedOut -> loadRender_output;
+}

package/examples/{ast1.js → using-ast-directly.js}

@@ -1,5 +1,9 @@
 'use strict';
 
+/**
+   Advanced example using the AST directly which most users will not do.
+   For general use, see other examples like simple.js
+  */
 var react = require('../'); // require('react');
 
 function load(res, cb) { setTimeout(cb, 100, null, res + '-loaded'); }

package/examples/{default-events1.js → using-events1.js}

@@ -6,7 +6,7 @@
   */
 
 var react = require('../'); // require('react');
-require('../lib/track-tasks');  // require('react/lib/track-tasks'); // turn on tracking
+react.trackTasks();  // turn on flow and task tracking events
 
 //output events as tasks start and complete
 react.events.on('flow.*', function (obj) {

package/examples/{default-log-events.js → using-log-events.js}

@@ -6,7 +6,7 @@
   */
 
 var react = require('../'); // require('react');
-require('../lib/log-events').logEvents(react);  // require('react/lib/log-events').logEvents(react); // turn on logging
+react.logEvents(); // turn on logging of all flow and task events for all react functions
 
 
 function loadUser(uid, cb){ setTimeout(cb, 100, null, "User"+uid); }

package/lib/base-task.js

@@ -1,117 +1,123 @@
 'use strict';
+/*global define:true */
 
-var array = require('ensure-array');
-var STATUS = require('./status.js');
-var EventManager = require('./event-manager.js');
-
-function BaseTask() {
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-/**
-   Getter Fn to retrieveAn array of the output param names for this task.
-  */
-BaseTask.prototype.getOutParams = function () {
-  return array(this.out); // ensure array
-};
-
-BaseTask.prototype.isComplete = function () {
-  return (this.status === STATUS.COMPLETE);
-};
-
-BaseTask.prototype.start = function (args) { // mark task as started with args and note time
-  /*jshint validthis: true */
-  this.args = args;
-  this.env.currentTask = this;
-  this.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_START, this);
-};
-
-BaseTask.prototype.complete = function (args) { //args that were used are available
-/*jshint validthis: true */
-  this.status = STATUS.COMPLETE;
-  this.results = args;
-  this.env.currentTask = this;
-  this.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_COMPLETE, this);
-};
-
-BaseTask.prototype.functionExists = function (vCon) {
-  var fn = this.f;
-  if (!fn) return false;
-  if (fn instanceof Function) return true;
-  if (typeof(fn) === 'string') {
-    var f = vCon.getVar(fn);  // fn/method by string
-    if (f && f instanceof Function) return true;
+define(['ensure-array', './status', './event-manager'],
+       function (array, STATUS, EventManager) {
+  
+  function BaseTask() {
   }
-  return false;
-};
-
-BaseTask.prototype.areAllDepArgsDefined = function (vCon) {
-  return this.a.every(function (k) { return (vCon.getVar(k) !== undefined); });
-};
-
-BaseTask.prototype.depTasksAreDone = function (tasksByName) {
-  return (!this.after || !this.after.length || // no dep tasks OR
-          this.after.every(function (n) { return tasksByName[n].isComplete(); }));  //all done
-};
-
-function isObjProperty(str) { return (str.indexOf('.') !== -1); }
-
-/**
-   check that obj parent is def and not null so writing to obj.prop
-   will not fail. ex: 'b.c' checks that b is def and not null.
-   Also returns true if not obj.prop but simple var ex: 'b'.
-   Tasks will implement outParentsExist() passing each out str
-   to this if they want to do this check.
+
+  /**
+     Getter Fn to retrieveAn array of the output param names for this task.
+  */
+  BaseTask.prototype.getOutParams = function () {
+    return array(this.out); // ensure array
+  };
+
+  BaseTask.prototype.isComplete = function () {
+    return (this.status === STATUS.COMPLETE);
+  };
+
+  BaseTask.prototype.start = function (args) { // mark task as started with args and note time
+    /*jshint validthis: true */
+    this.args = args;
+    this.env.currentTask = this;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_START, this);
+  };
+
+  BaseTask.prototype.complete = function (args) { //args that were used are available
+    /*jshint validthis: true */
+    this.status = STATUS.COMPLETE;
+    this.results = args;
+    this.env.currentTask = this;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_COMPLETE, this);
+  };
+
+  BaseTask.prototype.functionExists = function (vCon) {
+    var fn = this.f;
+    if (!fn) return false;
+    if (fn instanceof Function) return true;
+    if (typeof(fn) === 'string') {
+      var f = vCon.getVar(fn);  // fn/method by string
+      if (f && f instanceof Function) return true;
+    }
+    return false;
+  };
+
+  BaseTask.prototype.areAllDepArgsDefined = function (vCon) {
+    return this.a.every(function (k) { return (vCon.getVar(k) !== undefined); });
+  };
+
+  BaseTask.prototype.depTasksAreDone = function (tasksByName) {
+    return (!this.after || !this.after.length || // no dep tasks OR
+            this.after.every(function (n) { return tasksByName[n].isComplete(); }));  //all done
+  };
+
+  function isObjProperty(str) { return (str.indexOf('.') !== -1); }
+
+  /**
+     check that obj parent is def and not null so writing to obj.prop
+     will not fail. ex: 'b.c' checks that b is def and not null.
+     Also returns true if not obj.prop but simple var ex: 'b'.
+     Tasks will implement outParentsExist() passing each out str
+     to this if they want to do this check.
   */
-BaseTask.prototype.parentExists = function (objPropStr, vCon) {
-  if (!isObjProperty(objPropStr)) return true; // NOT obj prop, just simple arg, ret true
-  var nameAndProps = objPropStr.split('.');
-  nameAndProps.pop(); // pop off final prop
-  var parent = nameAndProps.reduce(function (accObj, prop) {
-    if (accObj === undefined || accObj === null) return undefined; // prevent exception
-    return accObj[prop];
-  }, vCon.values);   // vCon['foo']['bar']
-  return (parent !== undefined && parent !== null);
-};
-
-/**
-   If params are obj property writes make sure the dst objects
-   are defined and not null. cb: ['b.c'] -> b is def and not null.
-   If null is specified then param is valid and will be ignored.
-   @returns true if all obj prop parents are def and non null
+  BaseTask.prototype.parentExists = function (objPropStr, vCon) {
+      if (!isObjProperty(objPropStr)) return true; // NOT obj prop, just simple arg, ret true
+    var nameAndProps = objPropStr.split('.');
+    nameAndProps.pop(); // pop off final prop
+    var parent = nameAndProps.reduce(function (accObj, prop) {
+      if (accObj === undefined || accObj === null) return undefined; // prevent exception
+      return accObj[prop];
+    }, vCon.values);   // vCon['foo']['bar']
+    return (parent !== undefined && parent !== null);
+  };
+
+  /**
+     If params are obj property writes make sure the dst objects
+     are defined and not null. cb: ['b.c'] -> b is def and not null.
+     If null is specified then param is valid and will be ignored.
+       @returns true if all obj prop parents are def and non null
   */
-BaseTask.prototype.outParentsExist = function (vCon) {
-  var self = this;
-  return this.getOutParams().every(function (x) {
-    if (x === null) return true;
-    return self.parentExists(x, vCon);
-  });
-};
-
-BaseTask.prototype.isReady = function (vCon, tasksByName) {
-  return !this.status &&                  // not started AND
-  this.functionExists(vCon) &&            // function/method exists AND
-  this.areAllDepArgsDefined(vCon) &&      // all dep vars defined AND
-  this.depTasksAreDone(tasksByName) &&    // all dep tasks are done AND
-  (!this.outParentsExist ||               // (task does not implement outParentsExist method OR
-   this.outParentsExist(vCon));          //  output parents exists (for obj property writes)
-};
-
-BaseTask.prototype.isMethodCall = function () {
-  /*jshint regexp: false */
-  return (typeof(this.f) === 'string' && /^.*\..*$/.test(this.f));  //str contains .
-};
-
-BaseTask.prototype.getMethodObj =  function (vCon) { //obj.prop.prop2, returns obj.prop or undefined
-  var name = this.f;
-  if (!name) return undefined;
-  var nameAndProps = name.split('.');
-  nameAndProps.pop(); // pop off last one
-  if (!nameAndProps.length) return undefined;
-  var result = nameAndProps.reduce(function (accObj, prop) {
-    if (accObj === undefined || accObj === null) return undefined; // prevent exception
-    return accObj[prop];
-  }, vCon.values); // vCon['foo']['bar']
-  return result;
-};
-
-module.exports = BaseTask;
+  BaseTask.prototype.outParentsExist = function (vCon) {
+    var self = this;
+    return this.getOutParams().every(function (x) {
+      if (x === null) return true;
+      return self.parentExists(x, vCon);
+    });
+  };
+
+  BaseTask.prototype.isReady = function (vCon, tasksByName) {
+    return !this.status &&                  // not started AND
+    this.functionExists(vCon) &&            // function/method exists AND
+    this.areAllDepArgsDefined(vCon) &&      // all dep vars defined AND
+    this.depTasksAreDone(tasksByName) &&    // all dep tasks are done AND
+    (!this.outParentsExist ||               // (task does not implement outParentsExist method OR
+     this.outParentsExist(vCon));          //  output parents exists (for obj property writes)
+  };
+
+  BaseTask.prototype.isMethodCall = function () {
+    /*jshint regexp: false */
+    return (typeof(this.f) === 'string' && /^.*\..*$/.test(this.f));  //str contains .
+    };
+
+    BaseTask.prototype.getMethodObj =  function (vCon) { //obj.prop.prop2, returns obj.prop or undefined
+      var name = this.f;
+      if (!name) return undefined;
+      var nameAndProps = name.split('.');
+      nameAndProps.pop(); // pop off last one
+      if (!nameAndProps.length) return undefined;
+      var result = nameAndProps.reduce(function (accObj, prop) {
+        if (accObj === undefined || accObj === null) return undefined; // prevent exception
+        return accObj[prop];
+      }, vCon.values); // vCon['foo']['bar']
+      return result;
+    };
+
+  return BaseTask;
+  
+});

package/lib/cb-task.js

@@ -1,80 +1,84 @@
 '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 = 'cbTask requires f, a, out';
-var FN_REQ = 'cbTask requires f to be a function or string';
-var A_REQ = 'cbTask requires a to be an array of string param names';
-var CB_REQ = 'cbTask requires out to be an array of string param names';
+  var REQ = 'cbTask requires f, a, out';
+  var FN_REQ = 'cbTask requires f to be a function or string';
+  var A_REQ = 'cbTask requires a to be an array of string param names';
+  var CB_REQ = 'cbTask requires out to be an array of string param names';
 
-function CbTask(taskDef) {
-  var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-}
+  function CbTask(taskDef) {
+    var self = this;
+    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  }
 
-CbTask.prototype = new BaseTask();
-CbTask.prototype.constructor = CbTask;
+  CbTask.prototype = new BaseTask();
+  CbTask.prototype.constructor = CbTask;
 
-CbTask.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));
+  CbTask.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.every(function (x) { return (typeof(x) === 'string'); }))) {
+        errors.push(format_error(CB_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.every(function (x) { return (typeof(x) === 'string'); }))) {
-      errors.push(format_error(CB_REQ, taskDef));
-    }
-  }
-  return errors;
-};
+    return errors;
+  };
 
-CbTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
-  var self = this;
-  this.cbFun = function (err, arg0, arg1, argn) {
-    var args = Array.prototype.slice.call(arguments, 1);
-    if (err) { handleTaskError(self, err); return; } //handle error and return, we are done
+  CbTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
+    var self = this;
+    this.cbFun = function (err, arg0, arg1, argn) {
+      var args = Array.prototype.slice.call(arguments, 1);
+      if (err) { handleTaskError(self, err); return; } //handle error and return, we are done
 
-    //no error, save callback args to vCon context, then continue execution
-    vCon.saveResults(self.out, args);
-    self.complete(args);
-    contExec();
-  };    
-};
+      //no error, save callback args to vCon context, then continue execution
+      vCon.saveResults(self.out, args);
+      self.complete(args);
+      contExec();
+    };    
+  };
 
-CbTask.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('CbTask.exec.args=', args);
-    //console.error('CbTask.exec.vCon=', vCon);
-    this.start(args); //note the start time, args
-    args.push(this.cbFun);   // push callback fn on end
-    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
-    }
-    func.apply(bindObj, args); 
-  } catch (err) { //catch and handle the task error, calling final cb
-    handleError(this, err);
-  }    
-};
+  CbTask.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('CbTask.exec.args=', args);
+      //console.error('CbTask.exec.vCon=', vCon);
+      this.start(args); //note the start time, args
+      args.push(this.cbFun);   // push callback fn on end
+      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
+      }
+      func.apply(bindObj, args); 
+    } catch (err) { //catch and handle the task error, calling final cb
+      handleError(this, err);
+    }    
+  };
+
+  return CbTask;
 
-module.exports = CbTask;
+});