react 0.0.1 → 0.2.0

package/test/input-parser.test.js

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

package/test/module-use.test.js

@@ -0,0 +1,317 @@
+'use strict';
+
+var test = require('tap').test;
+var BaseTask = require('../lib/base-task.js');
+
+var react = require('../react');
+
+/**
+  @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 (t) {
+  t.type(react, 'function', 'is a core constructor and default dsl function');
+  t.type(react.options, 'object', 'has property for global react options');
+  t.type(react.fstrDefine, 'function', 'has fn property for using fstr dsl');
+  t.type(react.pcodeDefine, 'function', 'has fn property for using pcode dsl');
+  t.type(react.chainDefine, 'function', 'has fn property for chain define');
+  t.end();
+});
+
+function foo() { }
+function bar() { }
+
+test('calling react constructor function creates new function with ast', function (t) {
+  var r = react();
+  t.type(r, 'function', 'is a function ready to execute flow');
+  t.type(r.ast, 'object', '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' });
+  t.end();
+});
+
+test('setAndValidateAST sets the ast and validates returning errors', function (t) {
+  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'); 
+  t.end();
+});
+
+test('use react() default DSL 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 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);
+    t.end();
+  });
+});
+
+test('use react.selectFirst() default DSL 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 = 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'                             
+  );
+
+  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();
+  });
+});
+
+
+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 = react.pcodeDefine('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 events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { multiply: multiply, add: add };
+  var fn = react.pcodeDefine('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  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 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 events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { noSuccess: noSuccess, noSuccessNull: noSuccessNull, add: add };
+  var fn = react.pcodeDefine.selectFirst('a, b, cb', [
+    'c := noSuccess(a, b)',
+    'c := noSuccessNull(a, b)',
+    'c := add(a, b)',
+    'c := noSuccess(a, b)',    
+    'cb(err, c)'
+  ], locals);
+
+  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();
+  });
+});
+
+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 events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { multiply: multiply, add: add };
+  var fn = react.pcodeDefine('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  react.events.on('task.complete', accumEvents);  // 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);
+    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('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 = react.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 = react.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/pcode.test.js

@@ -0,0 +1,321 @@
+'use strict';
+
+var test = require('tap').test;
+var sprintf = require('sprintf').sprintf;
+
+var pcode = require('../lib/pcode.js');
+
+function falpha() { }
+function fbeta() { }
+function fcharlie() { }
+
+test('module exports an object', function (t) {
+  t.type(pcode, 'function', 'has define by DSL method');
+  t.end();
+});
+
+test('no arguments -> empty inParams, tasks, outTask', function (t) {
+  var r = pcode();
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('empty first string -> empty inParams, tasks, outTask', function (t) {
+  var r = pcode('');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('single first string -> inParams["foo"], empty tasks, outTask', function (t) {
+  var r = pcode('foo');
+  t.deepEqual(r.ast.inParams, ['foo']);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask',
+     function (t) {
+  var r = pcode(' foo,   bar,baz  ');
+  t.deepEqual(r.ast.inParams, ['foo', 'bar', 'baz']);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('single task, single out params', function (t) {
+  var locals = { falpha: falpha };
+  var r = pcode('', [
+    'c := falpha(a, b)',
+    'cb(err, c)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], 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 locals = { falpha: falpha };
+  var r = pcode('', [
+    'c := falpha(a, b)',
+    'cb(err, c)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'd, e := fbeta(a, b)',
+    'cb(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params, options', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'd, e := fbeta(a, b)',
+    'cb(err, c, d)'
+  ], locals, { name: 'myflow', otherOptFoo: 'foo'});
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.equal(r.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+
+
+
+test('two inputs, two mixed tasks, two out params', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'd = fbeta(a, b)',
+    'cb(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('allow cb in the definitions', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b, cb', [
+    'c := falpha(a, b, cb)',
+    'd = fbeta(a, b)',
+    'cb(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('allow Cb in the definitions', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b, Cb', [
+    'c := falpha(a, b, Cb)',
+    'd = fbeta(a, b)',
+    'cb(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('allow callback in the definitions', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b, callback', [
+    'c := falpha(a, b, callback)',
+    'd = fbeta(a, b)',
+    'callback(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('allow Callback in the definitions', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b, Callback', [
+    'c := falpha(a, b, Callback)',
+    'd = fbeta(a, b)',
+    'Callback(err, c, d)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+
+
+
+
+test('var prefix two inputs, two mixed tasks, two out params', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'var c := falpha(a, b);',
+    'var d = fbeta(a, b);',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('when single ret fn:done', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'd = fbeta(a, b) when falpha:done',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', after: ['falpha'], name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('when single cb fn:done', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta };
+  var r = pcode('a, b', [
+    'c := falpha(a, b) when fbeta:done',
+    'd = fbeta(a, b)',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', after: ['fbeta'], name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('when multiple fn:done cb', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta, fcharlie: fcharlie };
+  var r = pcode('a, b', [
+    'd = fbeta(a, b)',
+    'e = fcharlie(a, b)',
+    'c := falpha(a, b) when fbeta:done and fcharlie:done',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
+    { f: 'fcharlie',  a: ['a', 'b'], out: ['e'], type: 'ret', name: 'fcharlie'},
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', after: ['fbeta', 'fcharlie'], name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('when multiple fn:done ret', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta, fcharlie: fcharlie };
+  var r = pcode('a, b', [
+    'd = fbeta(a, b)',
+    'e = fcharlie(a, b)',
+    'c = falpha(a, b) when fbeta:done and fcharlie:done',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
+    { f: 'fcharlie',  a: ['a', 'b'], out: ['e'], type: 'ret', name: 'fcharlie'},
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'ret', after: ['fbeta', 'fcharlie'], name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('when mixed multiple fn:done', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta, fcharlie: fcharlie };
+  var r = pcode('a, b', [
+    'd = fbeta(a, b)',
+    'e = fcharlie(a, b) when fbeta;',
+    'c = falpha(a, b) when fbeta and fcharlie;',
+    'cb(err, c, d);'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'fbeta',  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
+    { f: 'fcharlie',  a: ['a', 'b'], out: ['e'], type: 'ret', after: ['fbeta'], name: 'fcharlie'},
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'ret', after: ['fbeta', 'fcharlie'], name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+
+/* selectFirst */
+
+test('selectFirst', function (t) {
+  var locals = { falpha: falpha, fbeta: fbeta, fcharlie: fcharlie };
+  var r = pcode.selectFirst('a, b', [
+    'c := falpha(a, b)',
+    'c = fbeta(a, b)',
+    'cb(err, c)'
+  ], locals, { name: 'myflow', otherOptFoo: 'foo'});
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: 'fbeta',  a: ['a', 'b'], out: ['c'], type: 'ret', name: 'fbeta', after: ['falpha']}
+  ]);
+  t.deepEqual(r.ast.outTask, { type: 'finalcbFirst', a: ['c'] });
+  t.equal(r.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+