react 0.6.1 → 0.7.1

package/test/event-manager.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true EventManager:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(EventManager) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -116,4 +116,4 @@ if (typeof(EventManager) === 'undefined') {
     em.emit('bar', 'hello');
   });
 
-}());  
+}());

package/test/exec-options.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;
 
@@ -25,7 +25,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] }
       ],
       outTask: { a: ['c'] }
@@ -36,13 +36,13 @@ if (typeof(react) === 'undefined') {
       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,4 +1,3 @@
-'use strict';
 /*global react:true taskUtil:true */
 
 if (typeof(chai) === 'undefined') {
@@ -10,10 +9,11 @@ if (typeof(react) === 'undefined') {
 }
 
 if (typeof(taskUtil) === 'undefined') {
-  var taskUtil = require('../lib/task.js');  
+  var taskUtil = require('../lib/task.js');
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -27,7 +27,7 @@ if (typeof(taskUtil) === 'undefined') {
     var fn = function () {
       var finalTask = taskUtil.createOutTask({}, undefined);
     };
-    t.throws(fn, new Error('callback is not a function'));
+    t.throws(fn, 'callback is not a function');
     done();
   });
 
@@ -35,7 +35,7 @@ if (typeof(taskUtil) === 'undefined') {
     var fn = function () {
       var finalTask = taskUtil.createOutTask({}, null);
     };
-    t.throws(fn, new Error('callback is not a function'));
+    t.throws(fn, 'callback is not a function');
     done();
   });
 
@@ -43,7 +43,7 @@ if (typeof(taskUtil) === 'undefined') {
     var fn = function () {
       var finalTask = taskUtil.createOutTask({}, 'foo');
     };
-    t.throws(fn, new Error('callback is not a function'));
+    t.throws(fn, 'callback is not a function');
     done();
   });
 
@@ -55,4 +55,4 @@ if (typeof(taskUtil) === 'undefined') {
     done();
   });
 
-}());  
+}());

package/test/input-parser.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true inputParser:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(inputParser) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 

package/test/log-events.mocha.js

@@ -0,0 +1,88 @@
+/*global react:true BaseTask:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+(function () {
+  'use strict';
+
+  var t = chai.assert;
+
+  /**
+     Testing turning on logging of events
+  */
+
+  suite('log-events');
+
+  /**
+     @example
+     var react = require('react');
+     react.logEvents(); // log to console
+  */
+
+  before(function () {
+    react.logEvents();
+  });
+
+  after(function () {
+    react.logEvents(false);
+  });
+
+  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/module-use.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true BaseTask:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(BaseTask) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -36,7 +36,7 @@ if (typeof(BaseTask) === 'undefined') {
      bum, 'dog, cb      -> err, result2');
 
      // OR using AST
-     
+
      var loadAndSave = react();
      loadAndSave.setAndValidateAST({
      inParams: ['one', 'two'],
@@ -88,7 +88,7 @@ if (typeof(BaseTask) === 'undefined') {
       { 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'); 
+    t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' },      'should return obj just set');
     done();
   });
 
@@ -100,7 +100,7 @@ if (typeof(BaseTask) === 'undefined') {
                    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);
@@ -116,17 +116,17 @@ if (typeof(BaseTask) === 'undefined') {
     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'                             
+                               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);
@@ -140,6 +140,23 @@ if (typeof(BaseTask) === 'undefined') {
     });
   });
 
+  test('reference local/global vars', function (done) {
+    function foo(cb) {
+      cb(null, 100);
+    }
+
+    var fn = react('refGlobal', 'cb -> err, result',
+      'console.log', '"using global/local ref to console" ->',
+      foo, 'cb -> err, result', { after: 'console.log' }
+    );
+
+    fn(function (err, result) {
+      if (err) return done(err);
+      t.equal(result, 100);
+      done();
+    });
+  });
+
 }());
 
 

package/test/promise-auto-resolve.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;
 
@@ -34,7 +34,7 @@ if (typeof(Deferred) === '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'] }
       ],
@@ -51,7 +51,7 @@ if (typeof(Deferred) === 'undefined') {
     function retBP() {
       var deferred = new Deferred();
       setTimeout(function () { deferred.resolve(3); }, 10);
-      return deferred.promise();      
+      return deferred.promise();
     }
 
     var ap = retAP();
@@ -65,4 +65,4 @@ if (typeof(Deferred) === 'undefined') {
     });
   });
 
-}());  
+}());

package/test/ret-task.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true RetTask: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 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();  
+    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();  
+    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();  
+    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();  
+    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, obj prop 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: '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();  
+    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: '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();  
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();
   });
 
   test('string without . is not method call', function (done) {
@@ -217,4 +217,4 @@ if (typeof(VContext) === 'undefined') {
     done();
   });
 
-}());  
+}());

package/test/task.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true taskUtil:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(taskUtil) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -28,7 +28,7 @@ if (typeof(taskUtil) === 'undefined') {
 
   test('missing types are guessed from params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [
         { f: foo, a: ['a'], out: ['baz'] },
       ],
@@ -39,4 +39,4 @@ if (typeof(taskUtil) === 'undefined') {
     done();
   });
 
-}());  
+}());