react 0.6.0 → 0.7.0

package/test/cb-task.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true CbTask:true VContext:true */
 
 if (typeof(chai) === 'undefined') {
@@ -18,6 +17,7 @@ if (typeof(VContext) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -66,7 +66,7 @@ if (typeof(VContext) === 'undefined') {
     t.equal(task.isReady(vCon, tasksByName), false);
     task.status = null;
     t.equal(task.isReady(vCon, tasksByName), true);
-    done();  
+    done();
   });
 
   test('no args defined, no after -> not ready', function (done) {
@@ -82,39 +82,39 @@ if (typeof(VContext) === 'undefined') {
     var vCon = VContext.create([1, {}], ['b', 'c']);
     var tasksByName = { foo: task };
     t.equal(task.isReady(vCon, tasksByName), false);
-    done();  
+    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();  
+    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();  
+    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();  
+    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();  
+    t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');
+    done();
   });
 
   test('all args defined, no after -> ready', function (done) {
@@ -122,7 +122,7 @@ if (typeof(VContext) === 'undefined') {
     var vCon = VContext.create([1, null], ['b', 'c']);
     var tasksByName = { foo: task };
     t.equal(task.isReady(vCon, tasksByName), true);
-    done();  
+    done();
   });
 
   test('all args defined, objprop null, no after -> ready', function (done) {
@@ -130,7 +130,7 @@ if (typeof(VContext) === 'undefined') {
     var vCon = VContext.create([1, { prop: null }], ['b', 'c']);
     var tasksByName = { foo: task };
     t.equal(task.isReady(vCon, tasksByName), true);
-    done();  
+    done();
   });
 
   test('all args defined, after not complete -> NOT ready', function (done) {
@@ -140,8 +140,8 @@ if (typeof(VContext) === 'undefined') {
       { 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();  
+    t.equal(task.isReady(vCon, tasksByName), false);
+    done();
   });
 
   test('all args defined, after all complete -> ready', function (done) {
@@ -151,8 +151,8 @@ if (typeof(VContext) === 'undefined') {
       { 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();  
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();
   });
 
   test('string without . is not method call', function (done) {

package/test/core-deferred.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true Deferred:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(Deferred) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -55,7 +55,7 @@ if (typeof(Deferred) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
         { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
       ],
@@ -69,7 +69,7 @@ if (typeof(Deferred) === 'undefined') {
       t.equal(d, 9);
       done();
     });
-  });  
+  });
 
   test('using "this" in a cb function', function (done) {
     function getA(cb) {
@@ -81,11 +81,11 @@ if (typeof(Deferred) === 'undefined') {
       }, 10);
       return deferred.promise();
     }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: [],
-      tasks: [    
+      tasks: [
         { f: getA, a: [], out: ['a'], type: 'promise' }
       ],
       outTask: { a: ['a'] }
@@ -108,7 +108,7 @@ if (typeof(Deferred) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
         { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
       ],
@@ -126,7 +126,7 @@ if (typeof(Deferred) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
         { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
       ],
@@ -140,4 +140,4 @@ if (typeof(Deferred) === 'undefined') {
     });
   });
 
-}());  
+}());

package/test/core-when.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true Deferred:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(Deferred) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -51,7 +51,7 @@ if (typeof(Deferred) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['pm', 'pa'],
-      tasks: [    
+      tasks: [
         { a: ['pm'], out: ['m'], type: 'when' },
         { a: ['pa'], out: ['a'], type: 'when' }
       ],
@@ -61,21 +61,21 @@ if (typeof(Deferred) === 'undefined') {
 
     var pm = multiply(2, 3);
     var pa = add(4, 5);
-    
+
     fn(pm, pa, function (err, m, a) {
       t.equal(err, null);
       t.equal(m, 6);
       t.equal(a, 9);
       done();
     });
-  });  
+  });
 
 
   test('rejects with error', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['pm', 'pa'],
-      tasks: [    
+      tasks: [
         { a: ['pm'], out: ['m'], type: 'when' },
         { a: ['pa'], out: ['a'], type: 'when' }
       ],
@@ -86,11 +86,11 @@ if (typeof(Deferred) === 'undefined') {
     var pm = badF2(2, 3);
     var pa = add(4, 5);
 
-    
+
     fn(pm, pa, function (err, m, a) {
       t.equal(err.message, 'my-error');
       done();
     });
   });
 
-}());  
+}());

package/test/core.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true */
 
 if (typeof(chai) === 'undefined') {
@@ -10,6 +9,7 @@ if (typeof(react) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -68,7 +68,7 @@ if (typeof(react) === 'undefined') {
       { f: multiply, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'multiply_0' },
       { f: multiply, a: ['a', 'b'], out: ['d'], name: 'multiply', type: 'cb' },
       { f: multiply, a: ['a', 'b'], out: ['e'], name: 'times', type: 'cb' },
-      { f: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret', name: 'task_3' },    
+      { f: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret', name: 'task_3' },
       { f: multiply, a: ['a', 'b'], out: ['f'], type: 'cb', name: 'multiply_4' }
     ]);
     done();
@@ -96,7 +96,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: add, a: ['c', 'b'], out: ['d'] }
       ],
@@ -110,13 +110,13 @@ if (typeof(react) === 'undefined') {
       t.equal(d, 9);
       done();
     });
-  });  
+  });
 
   test('multi-step with after as nonarr fn', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'], after: add },
         { f: add, a: ['a', 'b'], out: ['d'] }
       ],
@@ -126,7 +126,7 @@ if (typeof(react) === 'undefined') {
 
     var collector = react.createEventCollector();
     collector.capture(fn, 'task.complete');
-    
+
     fn(2, 3, function (err, c, d) {
       t.equal(err, null);
       t.equal(c, 6);
@@ -137,13 +137,13 @@ if (typeof(react) === 'undefined') {
       t.equal(events[1].task.name, 'multiply', 'name matches');
       done();
     });
-  });  
+  });
 
   test('mixed multi-step with after as nonarr fn w/events', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'], after: fnRetsSum },
         { f: fnRetsSum, a: ['a', 'b'], out: ['d'], type: 'ret' }
       ],
@@ -153,7 +153,7 @@ if (typeof(react) === 'undefined') {
 
     var collector = react.createEventCollector();
     collector.capture(fn, 'task.complete');
-    
+
     fn(2, 3, function (err, c, d) {
       t.equal(err, null);
       t.equal(c, 6);
@@ -164,19 +164,19 @@ if (typeof(react) === 'undefined') {
       t.isNotNull(events[0].task.id, 'has unique id');
       t.isNotNull(events[0].task.startTime, 'has startTime');
       t.isNotNull(events[0].task.endTime, 'has endTime');
-      t.isNotNull(events[0].task.elapsedTime !== undefined, 'has elapsedTime');    
+      t.isNotNull(events[0].task.elapsedTime !== undefined, 'has elapsedTime');
       t.isNotNull(events[0].task.args, 'has args');
       t.isNotNull(events[0].task.results, 'has results');
       t.equal(events[1].task.name, 'multiply', 'name matches');
       t.isNotNull(events[1].task.id, 'has unique id');
       t.isNotNull(events[1].task.startTime, 'has startTime');
       t.isNotNull(events[1].task.endTime, 'has endTime');
-      t.isNotNull(events[1].task.elapsedTime !== undefined, 'has elapsedTime');    
+      t.isNotNull(events[1].task.elapsedTime !== undefined, 'has elapsedTime');
       t.isNotNull(events[1].task.args, 'has args');
       t.isNotNull(events[1].task.results, 'has results');
       done();
     });
-  });  
+  });
 
 
 
@@ -185,7 +185,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'c'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
         { f: fnRetsSum, a: ['c.mult', 'b'], out: ['c.sum'], type: 'ret' }
       ],
@@ -200,13 +200,13 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(c, { foo: 1, mult: 6, sum: 9});
       done();
     });
-  });  
+  });
 
   test('error when cant complete', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'c'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
         { f: fnRetsSum, a: ['c.bad', 'b'], out: ['c.sum'], type: 'ret' },
         { f: add, a: ['c.sum', 'a'], out: ['d']}
@@ -225,11 +225,11 @@ if (typeof(react) === 'undefined') {
   test('objects', function (done) {
     function retObj(a, b, cb) { cb(null, { bar: a + b }); }
     function concat(a, b, cb) { cb(null, { result: a + b }); }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: retObj, a: ['a.foo', 'b'], out: ['c'] },
         { f: concat, a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -243,18 +243,18 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from container', function (done) {
     var C = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: C.retObj, a: ['a.foo', 'b'], out: ['c'] },
         { f: C.concat, a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -268,43 +268,43 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from container input arg', function (done) {
     var CONT = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'CONT'],
-      tasks: [    
+      tasks: [
         { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
       outTask: { a: ['c', 'd.result'] }
     });
     t.deepEqual(errors, [], 'no validation errors');
-    
+
     fn({ foo: 'FOO' }, 'B', CONT, function (err, c, dresult) {
       t.equal(err, null);
       t.deepEqual(c, { bar: 'FOOB' });
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('use locals for functions', function (done) {
     var locals = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: 'retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -319,18 +319,18 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from locals', function (done) {
     var CONT = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -345,13 +345,13 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
-  
+  });
+
   test('multi-step func throws, cb with error', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: badFunc, a: ['c', 'b'], out: ['d'] }
       ],
@@ -363,14 +363,14 @@ if (typeof(react) === 'undefined') {
       t.equal(err.message, 'badFuncThrow');
       done();
     });
-  });  
-  
+  });
+
   test('multi-step func cb err, cb with error', function (done) {
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: badF2, a: ['c', 'b'], out: ['d'] },
         { f: add, a: ['d', 'b'], out: ['e'] }
@@ -383,19 +383,19 @@ if (typeof(react) === 'undefined') {
       t.equal(err.message, 'my-error');
       done();
     });
-  });  
+  });
 
   test('using "this" in a cb function', function (done) {
-    
+
     function getA(cb) {
       /*jshint validthis: true */
       cb(null, this.a);
     }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: [],
-      tasks: [    
+      tasks: [
         { f: getA, a: [], out: ['a'] }
       ],
       outTask: { a: ['a'] }
@@ -418,11 +418,11 @@ if (typeof(react) === 'undefined') {
       /*jshint validthis: true */
       return this.a;
     }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: [],
-      tasks: [    
+      tasks: [
         { f: getA, a: [], out: ['a'], type: 'ret' }
       ],
       outTask: { a: ['a'] }
@@ -443,7 +443,7 @@ if (typeof(react) === 'undefined') {
   test('undefined input arguments will be upgraded from undefined to null', function (done) {
     var fn = react();
     function concat(a, b) {
-      return '' + a + b;    
+      return '' + a + b;
     }
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
@@ -469,7 +469,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: add, a: ['a', 'b'], out: ['c'], after: ['multiply'] }
       ],
@@ -489,7 +489,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[0].task.results, [6], 'results match');
       done();
     });
-  });  
+  });
 
   test('selectFirst with third succeeding', function (done) {
     function noSuccess(a, b, cb) { cb(null); } // returns undefined result
@@ -497,7 +497,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'] },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess'] },
         { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] }
@@ -518,7 +518,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
 
   test('selectFirst forces order with third succeeding', function (done) {
@@ -529,7 +529,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'] },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess']},
         { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] },
@@ -553,7 +553,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
   test('selectFirst using direct returns', function (done) {
     function noSuccess(a, b) {  } // returns undefined result
@@ -562,7 +562,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'], type: 'ret' },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccess'] },
         { f: addRet, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccessNull'] }
@@ -583,7 +583,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
 
 }());