react 0.2.4 → 0.3.4

package/test/dsl.test.js

@@ -77,6 +77,18 @@ test('single task, err and out params', function (t) {
   t.end();  
 });
 
+test('using - with literal string', function (t) {
+  var r = react('myName', '"hello-world", cb -> err, c',
+    falpha, '"another-string", cb -> err, c'
+  );
+  t.deepEqual(r.ast.inParams, ['"hello-world"']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['"another-string"'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, ERR and out params', function (t) {
   var r = react('myName', 'cb -> ERR, c', 
     falpha, 'cb -> ERR, c'
@@ -199,15 +211,54 @@ test('missing name, throws error', function (t) {
                   falpha, 'cb -> err, c'
                  );
   };
-  t.throws(fn, new Error('param[0] should be the flow name, instead found in/out def: cb -> err, c'));
+  t.throws(fn, new Error('first flow parameter should be the flow name, but found in/out def: cb -> err, c'));
+  t.end();
+});
+
+test('missing err in flow in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> c',  // missing err
+                  falpha, 'cb -> err, c'
+                 );
+  };
+  t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+  t.end();
+});
+
+test('missing err in task in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> err, c',
+                  falpha, 'cb -> c'  // missing err
+                 );
+  };
+  t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+  t.end();
+});
+
+test('found err, but missing cb/callback in flow in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'a -> err, c', // missing cb
+                  falpha, 'cb -> err, c'
+                 );
+  };
+  t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
   t.end();
 });
 
+test('found err, but missing cb/callback in task in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> err, c',
+                  falpha, 'a -> err, c'  // missing cb
+                 );
+  };
+  t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
+  t.end();
+});
 
 test('extra arg throws error', function (t) {
   var fn = function () {
     var r = react('myName', 'a, b, cb -> err, c, d', 
-      falpha, 'a -> err, c', { after: fbeta },
+      falpha, 'a, cb -> err, c', { after: fbeta },
       fbeta,  'a, b -> returns d',
       'extraBadArg'
     );
@@ -218,8 +269,8 @@ test('extra arg throws error', function (t) {
 
 test('not enough args throws error', function (t) {
   var fn = function () {
-    var r = react('myName', 'a, b, cb -> c, d', 
-      falpha, 'a -> err, c', { after: fbeta },
+    var r = react('myName', 'a, b, cb -> err, c, d', 
+      falpha, 'a, cb -> err, c', { after: fbeta },
       fbeta
     );
   };
@@ -228,6 +279,7 @@ test('not enough args throws error', function (t) {
 });
 
 test('long example', function (t) {
+  /*jshint white: false */
   t.plan(4);
   function loadUser(uid, cb){ setTimeout(cb, 100, null, "User"+uid); }
   function loadFile(filename, cb){ setTimeout(cb, 100, null, 'Filedata'+filename); }
@@ -260,7 +312,7 @@ test('long example', function (t) {
 // selectFirst 
 
 test('selectFirst', function (t) {
-  var r = react.selectFirst('myName', 'a, b, cb -> c',
+  var r = react.selectFirst('myName', 'a, b, cb -> err, c',
     { otherOptFoo: 'foo'},  // main options                            
     falpha, 'a, b, cb -> err, c',
     fbeta,  'a, b -> c'
@@ -275,4 +327,4 @@ test('selectFirst', function (t) {
   t.equal(r.ast.name, 'myName', 'name should match if supplied');
   t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
   t.end();  
-});
+});

package/test/{chain.test.js → dsl/chain.test.js}

@@ -3,7 +3,8 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var chainDefine = require('../lib/chain.js');
+var chainDefine = require('../../dsl/chain'); // require('react/dsl/chain');
+require('../../lib/track-tasks');  // require('react/lib/track-tasks'); // turn on tracking
 
 function falpha() { }
 function fbeta() { }
@@ -75,6 +76,19 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, err params', function (t) {
+  var fn = chainDefine()
+    .out('err')
+    .async(falpha).in().out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: [], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var fn = chainDefine()
     .out('err', 'c')
@@ -238,3 +252,73 @@ test('selectFirst', function (t) {
 });
 
 
+// full integration tests
+
+test('chainDefine use', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'm', 's')
+    .async(multiply).in('a', 'b', 'cb').out('err', 'm')
+    .async(add).in('m', 'a', 'cb').out('err', 's')
+    .end();
+
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].name, 'multiply', 'name matches');
+    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[1].name, 'add', 'name matches');
+    t.deepEqual(events[1].results, [8], 'results match');
+    t.end();
+  });
+});
+
+test('use chainDefine selectFirst with events', function (t) {
+  t.plan(7);
+  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 events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+
+  var fn = chainDefine()
+    .selectFirst()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(noSuccess).in('a', 'b', 'cb').out('err', 'c')
+    .async(noSuccessNull).in('a', 'b', 'cb').out('err', 'c')
+    .async(add).in('a', 'b', 'cb').out('err', 'c')
+    .async(noSuccess).in('a', 'b', 'cb').out('err', 'c')
+    .end();
+  
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, c) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(c, 5);
+    t.equal(events.length, 3, 'should have seen two task compl events');
+    t.equal(events[0].name, 'noSuccess', 'name matches');
+    t.equal(events[1].name, 'noSuccessNull', 'name matches');
+    t.equal(events[2].name, 'add', 'name matches');
+    t.deepEqual(events[2].results, [5], 'results match');
+    t.end();
+  });
+});

package/test/{fstr.test.js → dsl/fstr.test.js}

@@ -3,7 +3,7 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var fstrDefine = require('../lib/fstr.js');
+var fstrDefine = require('../../dsl/fstr'); // require('react/dsl/fstr');
 
 function falpha() { }
 function fbeta() { }
@@ -59,6 +59,18 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, err params', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c'
+  ], 'err');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var r = fstrDefine('a, b', [
     falpha, 'a, b -> err, c'

package/test/{pcode.test.js → dsl/pcode.test.js}

@@ -3,7 +3,8 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var pcode = require('../lib/pcode.js');
+var pcode = require('../../dsl/pcode'); // require('react/dsl/pcode');
+var EventCollector = require('../../lib/track-tasks').EventCollector;  // require('react/lib/track-tasks'); // turn on tracking
 
 function falpha() { }
 function fbeta() { }
@@ -62,6 +63,20 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, single out params, cb(err)', function (t) {
+  var locals = { falpha: falpha };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'cb(err)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var locals = { falpha: falpha };
   var r = pcode('a, b', [
@@ -319,3 +334,115 @@ test('selectFirst', function (t) {
   t.end();  
 });
 
+// full integration tests
+
+test('use pcodeDefine from module', function (t) {
+  t.plan(3);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.end();
+  });
+});
+
+test('use pcodeDefine with events', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    var events = collector.list();
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].task.name, 'multiply', 'name matches');
+    t.deepEqual(events[0].task.results, [6], 'results match');
+    t.equal(events[1].task.name, 'add', 'name matches');
+    t.deepEqual(events[1].task.results, [8], 'results match');
+    t.end();
+  });
+});
+
+test('use pcodeDefine.selectFirst with events', function (t) {
+  t.plan(7);
+  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 locals = { noSuccess: noSuccess, noSuccessNull: noSuccessNull, add: add };
+  var fn = pcode.selectFirst('a, b, cb', [
+    'c := noSuccess(a, b)',
+    'c := noSuccessNull(a, b)',
+    'c := add(a, b)',
+    'c := noSuccess(a, b)',    
+    'cb(err, c)'
+  ], locals);
+
+  var collector = new EventCollector();
+  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');
+    t.end();
+  });
+});
+
+test('use pcodeDefine events emit to global emitter', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  var collector = new EventCollector();
+  collector.capture(pcode, 'task.complete'); // the global react emitter
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    var events = collector.list();
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].task.name, 'multiply', 'name matches');
+    t.deepEqual(events[0].task.results, [6], 'results match');
+    t.equal(events[1].task.name, 'add', 'name matches');
+    t.deepEqual(events[1].task.results, [8], 'results match');
+    t.end();
+  });
+});
+

package/test/exec-options.test.js

@@ -20,7 +20,7 @@ test('execOptions as first param', function (t) {
 
   var execOptions = {
     reactExecOptions: true,
-    outputStyle: 'callback'
+    outputStyle: 'cb'
   };
   
   fn(execOptions, 2, 3, function (err, c) {
@@ -30,3 +30,4 @@ test('execOptions as first param', function (t) {
   });
 });  
 
+

package/test/finalcb-task.test.js

@@ -2,11 +2,12 @@
 
 var test = require('tap').test;
 
-var FinalCbTask = require('../lib/finalcb-task.js');
+var tskutil = require('../lib/task.js');
+
 
 test('undefined cb throws exception', function (t) {
   var fn = function () {
-    var finalTask = FinalCbTask.create({}, undefined);
+    var finalTask = tskutil.createOutTask({}, undefined);
   };
   t.throws(fn, new Error('callback is not a function'));
   t.end();
@@ -14,7 +15,7 @@ test('undefined cb throws exception', function (t) {
 
 test('null cb  throws exception', function (t) {
   var fn = function () {
-    var finalTask = FinalCbTask.create({}, null);
+    var finalTask = tskutil.createOutTask({}, null);
   };
   t.throws(fn, new Error('callback is not a function'));
   t.end();
@@ -22,7 +23,7 @@ test('null cb  throws exception', function (t) {
 
 test('cb needs to be a function or throws exception', function (t) {
   var fn = function () {
-    var finalTask = FinalCbTask.create({}, 'foo');
+    var finalTask = tskutil.createOutTask({}, 'foo');
   };
   t.throws(fn, new Error('callback is not a function'));
   t.end();
@@ -30,7 +31,7 @@ test('cb needs to be a function or throws exception', function (t) {
 
 test('valid fn creates outTask', function (t) {
   function foo() { }
-  var finalTask = FinalCbTask.create({ a: ['bar', 'baz']}, foo);
+  var finalTask = tskutil.createOutTask({ a: ['bar', 'baz']}, foo);
   t.equal(finalTask.f, foo);
   t.deepEqual(finalTask.a, ['bar', 'baz']);
   t.end();

package/test/input-parser.test.js

@@ -5,8 +5,9 @@ var test = require('tap').test;
 var inputParser = require('../lib/input-parser.js');
 
 test('parser parses input args', function (t) {
+  function myCb() { }
   var ast = { inParams: ['a', 'b'] };
-  var parsedInput = inputParser([10, 20], ast);
+  var parsedInput = inputParser([10, 20, myCb], ast);
   t.deepEqual(parsedInput.args, [10, 20]);
   t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
   t.end();
@@ -43,20 +44,23 @@ test('parser parses input args with extra args', function (t) {
 });
 
 test('parser pulls react exec option off arg list', function (t) {
+  function myCb() { }
   var ast = { inParams: ['a', 'b'] };
   var execOptions = { reactExecOptions: true, foo: 10 };
-  var parsedInput = inputParser([execOptions, 10, 20], ast);
+  var parsedInput = inputParser([execOptions, 10, 20, myCb], ast);
   t.deepEqual(parsedInput.args, [10, 20]);
-  t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'callback', foo: 10 });
+  t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 10 });
   t.end();
 });
 
 test('parser pulls react exec options off arg list and merges from left to right', function (t) {
+  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], ast);
+  var parsedInput = inputParser([execOptions, execOptions2, 10, 20, myCb], ast);
   t.deepEqual(parsedInput.args, [10, 20]);
-  t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'callback', foo: 12, bar: 36, baz: 'hello' });
+  t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 12, bar: 36, baz: 'hello' });
   t.end();
-});
+});
+