react 0.5.0 → 0.6.1

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,26 @@
 {
   "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.5.0",
+  "version": "0.6.1",
   "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"
+    "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();
+    });
+  });
+
+}());

package/test/cb-task.mocha.js

@@ -0,0 +1,220 @@
+'use strict';
+/*global react:true CbTask:true VContext:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(CbTask) === 'undefined') {
+  var CbTask = require('../lib/cb-task.js');
+}
+
+if (typeof(VContext) === 'undefined') {
+  var VContext = require('../lib/vcon.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing callback tasks
+  */
+
+  suite('cb-task');
+
+  function foo() { }
+  function bar() { }
+  function cat() { }
+
+  test('new task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: []});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('ready task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'ready'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('running task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'running'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('complete task is complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+    t.equal(task.isComplete(), true);
+    done();
+  });
+
+  test('task with any status is not ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+    var vCon = VContext.create([], []);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false);
+    task.status = 'ready';
+    t.equal(task.isReady(vCon, tasksByName), false);
+    task.status = 'running';
+    t.equal(task.isReady(vCon, tasksByName), false);
+    task.status = null;
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();  
+  });
+
+  test('no args defined, no after -> not ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b'], out: [] });
+    var vCon = VContext.create([], []);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false);
+    done();
+  });
+
+  test('objprop undefined -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+    var vCon = VContext.create([1, {}], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false);
+    done();  
+  });
+
+  test('all args defined, no after, out no obj parent -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d.e'] });
+    var vCon = VContext.create([1, null], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+    done();  
+  });
+
+  test('all args defined, no after, out no obj.par.par -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+    var vCon = VContext.create([1, { }], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+    done();  
+  });
+
+  test('all args defined, no after, out null obj parent -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e'] });
+    var vCon = VContext.create([1, null], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+    done();  
+  });
+
+  test('all args defined, no after, out null obj.par.par -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+    var vCon = VContext.create([1, { e: null }], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+    done();  
+  });
+
+  test('all args defined, no after -> ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d'] });
+    var vCon = VContext.create([1, null], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();  
+  });
+
+  test('all args defined, objprop null, no after -> ready', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+    var vCon = VContext.create([1, { prop: null }], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();  
+  });
+
+  test('all args defined, after not complete -> NOT ready', function (done) {
+    var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'running' });
+    var task = new CbTask(
+      { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+    var vCon = VContext.create([1, 2], ['b', 'c']);
+    var tasksByName = { foo: task, bar: tbar, cat: tcat };
+    t.equal(task.isReady(vCon, tasksByName), false);  
+    done();  
+  });
+
+  test('all args defined, after all complete -> ready', function (done) {
+    var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'complete' });
+    var task = new CbTask(
+      { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+    var vCon = VContext.create([1, 2], ['b', 'c']);
+    var tasksByName = { foo: task, bar: tbar, cat: tcat };
+    t.equal(task.isReady(vCon, tasksByName), true);  
+    done();  
+  });
+
+  test('string without . is not method call', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+    t.equal(task.isMethodCall(), false);
+    task.f = null;
+    t.equal(task.isMethodCall(), false);
+    done();
+  });
+
+  test('string with . is method call', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.bar', a: [], out: [] });
+    t.equal(task.isMethodCall(), true);
+    task.f = 'foo.bar.baz';
+    t.equal(task.isMethodCall(), true);
+    done();
+  });
+
+  test('undefined or null fn - functionExists', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+    var vCon = VContext.create([], []);
+    task.f = null;
+    t.isFalse(task.functionExists(vCon));
+    task.f = undefined;
+    t.isFalse(task.functionExists(vCon));
+    task.f = 'foo';
+    t.isFalse(task.functionExists(vCon));
+    vCon.values.foo = { };
+    task.f = 'foo.bar';
+    t.isFalse(task.functionExists(vCon));
+    done();
+  });
+
+  test('functionExists', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [] });
+    var vCon = VContext.create([], []);
+    t.isTrue(task.functionExists(vCon));
+    done();
+  });
+
+  test('method functionExists', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.isTrue(task.functionExists(vCon));
+    task.f = 'foo.bar.cat';
+    vCon.values.foo = { bar: { cat: cat}};
+    t.isNotNull(task.functionExists(vCon));
+    done();
+  });
+
+  test('getMethodObj non-existent return undefined', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b.c', a: [], out: [] });
+    var vCon = VContext.create([{}], ['foo']);
+    t.equal(task.getMethodObj(vCon), undefined);
+    done();
+  });
+
+  test('getMethodObj returns object', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.deepEqual(task.getMethodObj(vCon), { b: bar});
+    done();
+  });
+
+}());