react 0.3.5 → 0.6.0

package/test/exec-options.mocha.js

@@ -0,0 +1,48 @@
+'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 exec options
+  */
+
+  suite('exec-options');
+
+  function multiply(x, y, cb) { cb(null, x * y); }
+
+  test('execOptions as first param', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [    
+        { f: multiply, a: ['a', 'b'], out: ['c'] }
+      ],
+      outTask: { a: ['c'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    var execOptions = {
+      reactExecOptions: true,
+      outputStyle: 'cb'
+    };
+    
+    fn(execOptions, 2, 3, function (err, c) {
+      t.equal(err, null);
+      t.equal(c, 6);
+      done();
+    });
+  });  
+
+
+}());

package/test/finalcb-task.mocha.js

@@ -0,0 +1,58 @@
+'use strict';
+/*global react:true taskUtil:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(taskUtil) === 'undefined') {
+  var taskUtil = require('../lib/task.js');  
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing final cb task
+  */
+
+  suite('finalcb-task');
+
+  test('undefined cb throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, undefined);
+    };
+    t.throws(fn, new Error('callback is not a function'));
+    done();
+  });
+
+  test('null cb  throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, null);
+    };
+    t.throws(fn, new Error('callback is not a function'));
+    done();
+  });
+
+  test('cb needs to be a function or throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, 'foo');
+    };
+    t.throws(fn, new Error('callback is not a function'));
+    done();
+  });
+
+  test('valid fn creates outTask', function (done) {
+    function foo() { }
+    var finalTask = taskUtil.createOutTask({ a: ['bar', 'baz']}, foo);
+    t.equal(finalTask.f, foo);
+    t.deepEqual(finalTask.a, ['bar', 'baz']);
+    done();
+  });
+
+}());  

package/test/input-parser.mocha.js

@@ -0,0 +1,86 @@
+'use strict';
+/*global react:true inputParser:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(inputParser) === 'undefined') {
+  var inputParser = require('../lib/input-parser.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing ...
+  */
+
+  suite('input-parser');
+
+  test('parser parses input args', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with cb', function (done) {
+    function foo() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, foo], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.cb, foo);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with cb and extra args', function (done) {
+    function foo() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, foo, 30, 40], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.cb, foo);
+    t.deepEqual(parsedInput.extraArgs, [30, 40]);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with extra args', function (done) {
+    var ast = { inParams: [] };
+    var execOptions = { reactExecOptions: true, outputStyle: 'none' };
+    var parsedInput = inputParser([execOptions, 10, 20], ast);
+    t.deepEqual(parsedInput.args, []);
+    t.deepEqual(parsedInput.extraArgs, [10, 20]);
+    done();
+  });
+
+  test('parser pulls react exec option off arg list', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var execOptions = { reactExecOptions: true, foo: 10 };
+    var parsedInput = inputParser([execOptions, 10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 10 });
+    done();
+  });
+
+  test('parser pulls react exec options off arg list and merges from left to right', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var execOptions = { reactExecOptions: true, foo: 12, bar: 24 };
+    var execOptions2 = { reactExecOptions: true, bar: 36, baz: 'hello' };
+    var parsedInput = inputParser([execOptions, execOptions2, 10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 12, bar: 36, baz: 'hello' });
+    done();
+  });
+
+}());

package/test/mocha.opts

@@ -0,0 +1,2 @@
+--reporter spec
+--ui qunit

package/test/module-use.mocha.js

@@ -0,0 +1,147 @@
+'use strict';
+/*global react:true BaseTask:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(BaseTask) === 'undefined') {
+  var BaseTask = require('../lib/base-task.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing the general use of react
+  */
+
+  suite('module-use');
+
+  /**
+     @example
+     var react = require('react');
+     react.options.an_option = 'something';
+
+     // define function
+     var loadAndSave = react('myName', 'one, two, cb -> err, result1, result2',
+     foo, 'one, cb      -> err, cat',
+     bar, 'two, cat, cb -> err, dog',
+     baz, 'dog, cb      -> err, result1',
+     bum, 'dog, cb      -> err, result2');
+
+     // OR using AST
+     
+     var loadAndSave = react();
+     loadAndSave.setAndValidateAST({
+     inParams: ['one', 'two'],
+     tasks: { },
+     outTask: { a: ['three'] }
+     });
+
+     //if you want to listen to task completion events
+     loadAndSave.events.on('task.complete', function (taskObj) { });
+
+     loadAndSave(1,2,cb); // execute like any other function
+  */
+
+  test('module exports an function object with properties', function (done) {
+    t.isFunction(react, 'is a core constructor and default dsl function');
+    t.isObject(react.options, 'has property for global react options');
+    t.isObject(react.events, 'has global react event manager');
+    t.isFunction(react.logEvents, 'has function to enable event logging');
+    t.isFunction(react.trackTasks, 'has function to enable task and flow tracking');
+    t.isFunction(react.resolvePromises, 'has fn to enable promise detection & resolution');
+    done();
+  });
+
+  function foo() { }
+  function bar() { }
+
+  test('calling react constructor function creates new function with ast', function (done) {
+    var r = react();
+    t.isFunction(r, 'is a function ready to execute flow');
+    t.isObject(r.ast, 'is object for inspecting AST');
+    t.deepEqual(r.ast.inParams, [],              'ast.inParams should return empty array');
+    t.deepEqual(r.ast.tasks, [],                 'ast.tasks() should return empty array');
+    t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+    done();
+  });
+
+  test('setAndValidateAST sets the ast and validates returning errors', function (done) {
+    var r = react();
+    var errors = r.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [
+        { f: foo, a: ['a'], out: ['c'] },
+        { f: bar, a: ['b'], out: ['d'] }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(r.ast.inParams, ['a', 'b'],      'ast.inParams() should match array just set');
+    t.deepEqual(r.ast.tasks, [
+      { f: foo, a: ['a'], out: ['c'], type: 'cb', name: 'foo' },
+      { f: bar, a: ['b'], out: ['d'], type: 'cb', name: 'bar' }
+    ]);
+    t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' },      'should return obj just set'); 
+    done();
+  });
+
+  test('use react() default DSL from module', function (done) {
+    function multiply(a, b, cb) { cb(null, a * b); }
+    function add(a, b, cb) { cb(null, a + b); }
+    var fn = react('multiplyAdd', 'a, b, cb -> err, m, s',
+                   multiply, 'a, b, cb -> err, m',
+                   add, 'm, a, cb -> err, s'
+                  );
+
+    
+    fn(2, 3, function (err, m, s) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(m, 6);
+      t.equal(s, 8);
+      done();
+    });
+  });
+
+  test('use react.selectFirst() default DSL with events', function (done) {
+    function noSuccess(a, b, cb) {
+      setTimeout(function () { cb(null); }, 100); // returns undefined result
+    }
+    function noSuccessNull(a, b, cb) { cb(null, null); } // returns null result
+    function add(a, b, cb) { cb(null, a + b); }
+
+    
+    var fn = react.selectFirst('mySelectFirst', 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c',
+                               noSuccessNull, 'a, b, cb -> err, c',
+                               add, 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c'                             
+                              );
+
+    var collector = react.createEventCollector();
+    collector.capture(fn, 'task.complete');
+    
+    fn(2, 3, function (err, c) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(c, 5);
+      var events = collector.list();
+      t.equal(events.length, 3, 'should have seen two task compl events');
+      t.equal(events[0].task.name, 'noSuccess', 'name matches');
+      t.equal(events[1].task.name, 'noSuccessNull', 'name matches');
+      t.equal(events[2].task.name, 'add', 'name matches');
+      t.deepEqual(events[2].task.results, [5], 'results match');
+      done();
+    });
+  });
+
+}());
+
+
+
+

package/test/promise-auto-resolve.mocha.js

@@ -0,0 +1,68 @@
+'use strict';
+/*global react:true Deferred:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(Deferred) === 'undefined') {
+  var Deferred = require('Deferred');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  suite('promise-auto-resolve');
+
+  /**
+     Test that arguments which are promises are automatically resolved
+     before calling react functions
+  */
+
+  react.resolvePromises(); // enable promise resolving
+
+  function multiply(x, y, cb) { cb(null, x * y); }
+  function add(x, y, cb) { cb(null, x + y); }
+  // function badF2(a, b, cb) { cb('my-error'); }
+
+  test('auto resolve promises passed as args', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [    
+        { f: multiply, a: ['a', 'b'], out: ['c'] },
+        { f: add, a: ['c', 'b'], out: ['d'] }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    function retAP() {
+      var deferred = new Deferred();
+      setTimeout(function () { deferred.resolve(2); }, 10);
+      return deferred.promise();
+    }
+
+    function retBP() {
+      var deferred = new Deferred();
+      setTimeout(function () { deferred.resolve(3); }, 10);
+      return deferred.promise();      
+    }
+
+    var ap = retAP();
+    var bp = retBP();
+
+    fn(ap, bp, function (err, c, d) {
+      t.equal(err, null);
+      t.equal(c, 6);
+      t.equal(d, 9);
+      done();
+    });
+  });
+
+}());  

package/test/ret-task.mocha.js

@@ -0,0 +1,220 @@
+'use strict';
+/*global react:true RetTask:true VContext:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(RetTask) === 'undefined') {
+  var RetTask = require('../lib/ret-task.js');
+}
+
+if (typeof(VContext) === 'undefined') {
+  var VContext = require('../lib/vcon.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing VContext
+  */
+
+  suite('ret-task');
+
+  function foo() { }
+  function bar() { }
+  function cat() { }
+
+  test('new task is not complete', function (done) {
+    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [] });
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('ready task is not complete', function (done) {
+    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'ready'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('running task is not complete', function (done) {
+    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'running'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('complete task is complete', function (done) {
+    var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: foo, a: ['b'], out: [] });
+    var vCon = VContext.create([], []);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false);
+    done();
+  });
+
+  test('obj prop undefined -> NOT ready', function (done) {
+    var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: foo, a: ['b', 'c'], out: [] });
+    var vCon = VContext.create([1, null], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();  
+  });
+
+  test('all args defined, obj prop null, no after -> ready', function (done) {
+    var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new RetTask({ type: 'ret', f: bar, a: [], out: [], status: 'running' });
+    var task = new RetTask(
+      { type: 'ret', 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 RetTask({ type: 'ret', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new RetTask({ type: 'ret', f: bar, a: [], out: [], status: 'complete' });
+    var task = new RetTask(
+      { type: 'ret', 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 RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
+    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 RetTask({ type: 'ret', f: 'foo.bar', a: [], out: ['b'] });
+    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 RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
+    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 RetTask({ type: 'ret', f: foo, a: [], out: ['b'] });
+    var vCon = VContext.create([], []);
+    t.isTrue(task.functionExists(vCon));
+    done();
+  });
+
+  test('method functionExists', function (done) {
+    var task = new RetTask({ type: 'ret', f: 'foo.b', a: [], out: ['b'] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.isTrue(task.functionExists(vCon));
+    task.f = 'foo.bar.cat';
+    vCon.values.foo = { bar: { cat: cat}};
+    t.isTrue(task.functionExists(vCon));
+    done();
+  });
+
+  test('getMethodObj non-existent return undefined', function (done) {
+    var task = new RetTask({ type: 'ret', f: 'foo.b.c', a: [], out: ['b'] });
+    var vCon = VContext.create([{}], ['foo']);
+    t.equal(task.getMethodObj(vCon), undefined);
+    done();
+  });
+
+  test('getMethodObj returns object', function (done) {
+    var task = new RetTask({ type: 'ret', f: 'foo.b', a: [], out: ['b'] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.deepEqual(task.getMethodObj(vCon), { b: bar});
+    done();
+  });
+
+}());