react 0.6.2 → 0.8.0

package/test/exec-options.mocha.js

@@ -1,48 +0,0 @@
-'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

@@ -1,58 +0,0 @@
-'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, 'callback is not a function');
-    done();
-  });
-
-  test('null cb  throws exception', function (done) {
-    var fn = function () {
-      var finalTask = taskUtil.createOutTask({}, null);
-    };
-    t.throws(fn, '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, '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

@@ -1,86 +0,0 @@
-'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

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

package/test/module-use.mocha.js

@@ -1,147 +0,0 @@
-'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

@@ -1,68 +0,0 @@
-'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

@@ -1,220 +0,0 @@
-'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();
-  });
-
-}());