react 0.3.5 → 0.6.0

package/lib/vcon.js

@@ -1,81 +1,90 @@
 'use strict';
+/*global define:true */
 
-var LAST_RESULTS_KEY = ':LAST_RESULTS';
-
-function VContext() {
+if (typeof define !== 'function') {
+  var define = require('amdefine')(module);
 }
 
-VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
-VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
+define([], function () {
+  
+  var LAST_RESULTS_KEY = ':LAST_RESULTS';
+
+  function VContext() {
+  }
 
-VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
-  /*jshint regexp: false */
-  var vConValues = this.values;
-  if (typeof(name) !== 'string') return name; // literal boolean or number
-  name = name.trim();
-  // literal checks need to match what is in validate.js
-  if (name === 'true') return true;
-  if (name === 'false') return false;
-  if (name === 'null') return null;
-  if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
-  if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
-  var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
-  if (m) return m[2]; // if is quoted str, return inside of the quotes
-  var nameAndProps = name.split('.');
-  return nameAndProps.reduce(function (accObj, prop) {
-    if (accObj === undefined || accObj === null) return undefined; // prevent exception
-    return accObj[prop];
-  }, vConValues);   // vCon['foo']['bar']
-};
+  VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
+  VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
 
-/**
-   Saves all the results from a task as a unit, also sets special
-   variable :LAST_RESULTS which keeps an array of the last values
-   which can be used for chaining and testing last results, etc.
+  VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
+    /*jshint regexp: false */
+    var vConValues = this.values;
+    if (typeof(name) !== 'string') return name; // literal boolean or number
+    name = name.trim();
+    // literal checks need to match what is in validate.js
+    if (name === 'true') return true;
+    if (name === 'false') return false;
+    if (name === 'null') return null;
+    if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
+    if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
+    var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
+    if (m) return m[2]; // if is quoted str, return inside of the quotes
+    var nameAndProps = name.split('.');
+    return nameAndProps.reduce(function (accObj, prop) {
+      if (accObj === undefined || accObj === null) return undefined; // prevent exception
+      return accObj[prop];
+    }, vConValues);   // vCon['foo']['bar']
+  };
+
+  /**
+     Saves all the results from a task as a unit, also sets special
+     variable :LAST_RESULTS which keeps an array of the last values
+     which can be used for chaining and testing last results, etc.
   */
-VContext.prototype.saveResults = function (paramArr, valuesArr) { // set values for params
-  var self = this;
-  paramArr.forEach(function (k, idx) { //save values to v context
-    self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
-  });
-  this.setLastResults(valuesArr);
-};
+  VContext.prototype.saveResults = function (paramArr, valuesArr) { // set values for params
+    var self = this;
+    paramArr.forEach(function (k, idx) { //save values to v context
+      self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
+    });
+    this.setLastResults(valuesArr);
+  };
 
-VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
-  if (!name) return;  // if name is undefined or null, then discard
-  var vConValues = this.values;
-  var nameAndProps = name.split('.');
-  var lastProp = nameAndProps.pop();
-  var obj = nameAndProps.reduce(function (accObj, prop) {
-    var o = accObj[prop];
-    if (o === undefined || o === null) {  // if doesn't exist create it
-      o = accObj[prop] = { };
-    }
-    return o;
-  }, vConValues);   // vCon['foo']['bar']
-  obj[lastProp] = value;
-};
+  VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
+      if (!name) return;  // if name is undefined or null, then discard
+      var vConValues = this.values;
+      var nameAndProps = name.split('.');
+    var lastProp = nameAndProps.pop();
+    var obj = nameAndProps.reduce(function (accObj, prop) {
+      var o = accObj[prop];
+      if (o === undefined || o === null) {  // if doesn't exist create it
+        o = accObj[prop] = { };
+      }
+      return o;
+    }, vConValues);   // vCon['foo']['bar']
+    obj[lastProp] = value;
+  };
   
 
-/**
-   Create Variable Context using arguments passed in.
-   Ignore extra arguments passed in. Locals can be
-   passed into seed the VContext otherwise empty {}
-   will be used
-   @param self used to pass 'this' context in
- */
-VContext.create = function (args, inParams, locals, self) {
-  var initValues = {};
-  if (self) initValues['this'] = self;
-  if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
-  var vContext = new VContext();
-  vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
-    var param = inParams[idx];
-    if (param) vcon[param] = x;
-    return vcon;
-  }, initValues);
-  return vContext;
-};
+  /**
+     Create Variable Context using arguments passed in.
+     Ignore extra arguments passed in. Locals can be
+     passed into seed the VContext otherwise empty {}
+     will be used
+       @param self used to pass 'this' context in
+  */
+  VContext.create = function (args, inParams, locals, self) {
+    var initValues = {};
+    if (self) initValues['this'] = self;
+    if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
+    var vContext = new VContext();
+    vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
+      var param = inParams[idx];
+      if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
+      return vcon;
+    }, initValues);
+    return vContext;
+  };
+
 
+  return VContext;
 
-module.exports = VContext;
+});  

package/lib/when-task.js

@@ -1,81 +1,85 @@
 'use strict';
+/*global define:true */
 
-/**
-   When task which checks if is a promise (has a then method)
-   and waits for it to resolve.
-
-   If argument does not have a then method, it resolves immediately
-  */
+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) {
+  
+  /**
+     When task which checks if is a promise (has a then method)
+     and waits for it to resolve.
 
-var BaseTask = require('./base-task.js');
+     If argument does not have a then method, it resolves immediately
+  */
 
-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 = 'whenTask requires a, out';
-var A_REQ = 'whenTask requires a to be an array[1] of string param names';
-var OUT_REQ = 'whenTask requires out to be an array[1] of string param names';
+  var REQ = 'whenTask requires a, out';
+  var A_REQ = 'whenTask requires a to be an array[1] of string param names';
+  var OUT_REQ = 'whenTask requires out to be an array[1] of string param names';
 
-function WhenTask(taskDef) {
-  var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-}
+  function WhenTask(taskDef) {
+    var self = this;
+    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  }
 
-WhenTask.prototype = new BaseTask();
-WhenTask.prototype.constructor = WhenTask;
+  WhenTask.prototype = new BaseTask();
+  WhenTask.prototype.constructor = WhenTask;
 
-WhenTask.prototype.f = function when() { // just here to keep validations happy 
-}
+  WhenTask.prototype.f = function when() { // just here to keep validations happy 
+  }
 
-WhenTask.validate = function (taskDef) {
-  var errors = [];
-  if (!taskDef.a || !taskDef.out) {
-    errors.push(format_error(REQ, taskDef));
-  } else {
-    if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 && 
-           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
-      errors.push(format_error(A_REQ, taskDef));
+  WhenTask.validate = function (taskDef) {
+    var errors = [];
+    if (!taskDef.a || !taskDef.out) {
+      errors.push(format_error(REQ, taskDef));
+    } else {
+      if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 && 
+             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.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;
+  };
 
-WhenTask.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();
+  WhenTask.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);
+
+  WhenTask.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('WhenTask.exec.args=', args);
+      //console.error('WhenTask.exec.vCon=', vCon);
+      this.start(args); //note the start time, args
+      var arg = args[0]; // one value allowed
+      if (arg && typeof(arg.then) === 'function') { // is a promise
+        arg.then(this.nextFn, this.failFn);
+      } else { // not a promise continue immediately
+        this.nextFn(arg);
+      }
+    } catch (err) { //catch and handle the task error, calling final cb
+      handleError(this, err);
+    } 
   };
-};
 
-WhenTask.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('WhenTask.exec.args=', args);
-    //console.error('WhenTask.exec.vCon=', vCon);
-    this.start(args); //note the start time, args
-    var arg = args[0]; // one value allowed
-    if (arg && typeof(arg.then) === 'function') { // is a promise
-      arg.then(this.nextFn, this.failFn);
-    } else { // not a promise continue immediately
-      this.nextFn(arg);
-    }
-  } catch (err) { //catch and handle the task error, calling final cb
-    handleError(this, err);
-  } 
-};
+  return WhenTask;
 
-module.exports = WhenTask;
+});  

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "react",
   "description": "React is a javascript module implementing a lightweight rules engine to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.3.5",
+  "version": "0.6.0",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
   "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
   "bugs" : { "url": "http://github.com/jeffbski/react/issues" },
   "licenses": [{ "type": "MIT", "url" : "http://github.com/jeffbski/react/raw/master/LICENSE" }],
-  "main": "react",
-  "engines": { "node": "*" },
+  "main": "lib/react",
+  "engines": { "node": ">=0.6" },
   "dependencies": {
+    "amdefine": "~0.0.2",
     "eventemitter2": "~0.4.1",
-    "sprintf": "~0.1.1",
-    "ensure-array": "~0.0.2"
+    "sprint": "~0.3.0",
+    "ensure-array": "~0.0.5"
   },
   "devDependencies": {
-    "tap" : "~0.1.0",
-    "tapr" : "~0.1.0",
-    "promised-io" : "~0.3.0",
+    "requirejs": "~1.0.7",
+    "mocha": "~0.14.1",
+    "chai": "~0.5.2",
+    "jake": "~0.2.31",
     "Deferred" : "~0.1.1"
   },
   "scripts": {
-    "test": "node_modules/.bin/tapr test"
+    "test": "./node_modules/mocha/bin/mocha ./test/*.mocha.js"
   }
 }

package/src/dist.build.requirejs

@@ -0,0 +1,20 @@
+({
+  baseUrl: "..",
+  optimize: "none",
+  packages: [
+    {
+      name: "react",
+      location: "lib",
+      main: "react"
+    }
+  ],
+  paths: {
+    jQuery: "empty:",
+    eventemitter2: "node_modules/eventemitter2/lib/eventemitter2",
+    util: "vendor/node/util",
+    sprint: "node_modules/sprint/lib/sprint",
+    "ensure-array": "node_modules/ensure-array/ensure-array"
+  },
+  name: "react",
+  out: "dist/react.js"
+})

package/test/ast.mocha.js

@@ -0,0 +1,136 @@
+'use strict';
+/*global react:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+/**
+   Testing ast
+  */
+
+
+  suite('ast');
+
+  function load(res, cb) { cb(null, res + '-loaded'); }
+  function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
+  function postfix(str, poststr, cb) { cb(null, str + poststr); }
+  function upper(str) { return str.toUpperCase(); }
+  function makeError(str, cb) { cb(new Error('makeErr-' + str)); }
+
+  test('mixed', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['res', 'prefstr', 'poststr'],
+      tasks: [
+        { f: load,    a: ['res'],              out: ['lres'] },
+        { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
+        { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
+        { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
+      ],
+      outTask: { a: ['plresp'] }
+    });
+
+    t.deepEqual(errors, []);
+
+    fn('foo', 'pre-', '-post', function cb(err, lres) {
+      t.equal(err, null);
+      t.equal(lres, 'pre-FOO-LOADED-post');
+    });
+
+    fn('bar', 'PRE-', '-POST', function cb(err, lres) {
+      t.equal(err, null);
+      t.equal(lres, 'PRE-BAR-LOADED-POST');
+      done();
+    });
+  });
+
+  test('ast.defined event called when ast is defined', function (done) {
+    var fn = react();
+    var collector = react.createEventCollector();
+    collector.capture(fn, 'ast.*');
+    
+    var errors = fn.setAndValidateAST({
+      inParams: ['res', 'prefstr', 'poststr'],
+      tasks: [
+        { f: load,    a: ['res'],              out: ['lres'] },
+        { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
+        { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
+        { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
+      ],
+      outTask: { a: ['plresp'] }
+    });
+
+    var events = collector.list();
+    t.equal(events.length, 1);
+    t.isObject(events[0].ast);
+    t.isNotNull(events[0].ast.inParams);
+    t.isNotNull(events[0].ast.tasks);
+    t.isNotNull(events[0].ast.outTask);
+    done();
+  });
+
+  test('ast.defined event is passed to process', function (done) {
+    // browser might not have this, so only if process is an eventemitter
+    if (process && process.once) {
+      var fn = react();
+      process.once('ast.defined', function (ast) {
+        t.isObject(ast);
+        t.isNotNull(ast.inParams);
+        t.isNotNull(ast.tasks);
+        t.isNotNull(ast.outTask);
+        t.deepEqual(ast.inParams, ['res', 'prefstr', 'poststr']);
+        done();
+      });
+      var errors = fn.setAndValidateAST({
+        inParams: ['res', 'prefstr', 'poststr'],
+        tasks: [
+          { f: load,    a: ['res'],              out: ['lres'] },
+          { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
+          { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
+          { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
+        ],
+        outTask: { a: ['plresp'] }
+      });      
+    } else {
+      done(); //skipping in browser
+    }
+  });
+
+  test('cb with err', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['res', 'prefstr', 'poststr'],
+      tasks: [
+        { f: load,      a: ['res'],               out: ['lres'] },
+        { f: upper,     a: ['lres'],              out: ['ulres'], type: 'ret' },
+        { f: makeError, a: ['ulres'],             out: ['na']  },
+        { f: prefix,    a: ['prefstr', 'na'],     out: ['plres'] },
+        { f: postfix,   a: ['plres', 'poststr'],  out: ['plresp'] }
+      ],
+      outTask: { a: ['plresp'] }
+    });
+
+    t.deepEqual(errors, []);
+
+    fn('foo', 'pre-', '-post', function cb(err, lres) {
+      t.equal(err.message, 'makeErr-FOO-LOADED');
+      t.equal(lres, undefined);
+    });
+
+    fn('bar', 'PRE-', '-POST', function cb(err, lres) {
+      t.equal(err.message, 'makeErr-BAR-LOADED');
+      t.equal(lres, undefined);
+      done();
+    });
+  });
+
+}());