react 0.3.4 → 0.5.2

package/examples/pcode1.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var pcodeDefine = require('../dsl/pcode'); // require('react/dsl/pcode');
-
-function multiply(a, b, cb) { cb(null, a * b); }
-function add(a, b) { return a + b; }
-var locals = {   // since pcodeDefine uses strings, need references to functions passed into react
-  multiply: multiply,
-  add: add
-};
-
-var fn = pcodeDefine('a, b, cb', [  // input params
-  'm := multiply(a, b)',   // using a callback function, use :=
-  's = add(m, a)',        // using a sync function, use =
-  'cb(err, m, s)'     // output params for final callback
-], locals);    // hash of functions that will be used
-
-fn(2, 3, function (err, m, s) {
-  console.error('err:', err); // null
-  console.error('m:', m);  // 2 * 3 = 6
-  console.error('s:', s);  // 6 + 2 = 8
-});

package/jake-tasks/jake-test.js

@@ -1,64 +0,0 @@
-
-var watch = require('watch');
-var cp = require('child_process'); 
-
-namespace('test', function () {
-
-  var watchdir = '.';
-  var cmd = 'tapper ./test';
-
-  var alreadyExecuting = false;
-
-  function execAndOutput(cmd){
-    if(!alreadyExecuting){
-      alreadyExecuting = true;
-      console.log("Executing cmd:", cmd);
-      cp.exec(cmd, function(err, stdout, stderr){
-        if(err && err.message) console.log(err.message);
-        console.log(stdout); 
-        console.error(stderr);
-        alreadyExecuting = false;
-      });
-    }
-  }
-  
-  function filterWatch(f){
-    if(/flymake/.test(f)) return false;    //ignore flymake files
-    if(/^\.|\/\./.test(f)) return false;   //ignore hidden files or dirs
-    console.log(f);
-    return true;  
-  }
-  
-  desc('watch and run tests');
-  task('watch', ['test:run'], function () {
-    // watch the watchdir and if anything changes, rerun the command
-    watch.createMonitor(watchdir, { ignoreDotFiles: true }, function(monitor) {
-      monitor.on("created", function(f, stat){ if(filterWatch(f)) execAndOutput(cmd); });
-      monitor.on("changed", function(f, curr, prev){ 
-        if(filterWatch(f) && curr.mtime > prev.mtime) {
-          //console.log(prev.mtime);
-          console.log(curr.mtime);
-          execAndOutput(cmd); 
-        }
-      });
-      monitor.on("removed", function(f, stat){ if(filterWatch(f)) execAndOutput(cmd); });
-    });
-  });
-
-
-  desc('run tests');
-  task('run', [], function (cmdarg1, cmdarg2, cmdargN) {
-    execAndOutput(cmd);
-  });
-
-});
-
-
-
-
-
-
-
-
-
-

package/test/dsl/chain.test.js

@@ -1,324 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-var sprintf = require('sprintf').sprintf;
-
-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() { }
-
-test('module exports a function', function (t) {
-  t.type(chainDefine, 'function', 'has define by chain method');
-  t.type(chainDefine(), 'object', 'has define by chain method');
-  t.type(chainDefine().selectFirst, 'function', 'has selectFirst def');
-  t.type(chainDefine().in, 'function', 'has input param def');
-  t.type(chainDefine().out, 'function', 'has output param def');
-  t.type(chainDefine().async, 'function', 'has async - cb type task def');
-  t.type(chainDefine().sync, 'function', 'has sync - ret type task def');
-  t.type(chainDefine().after, 'function', 'has after prereq def');
-  t.type(chainDefine().end, 'function', 'has end to complete flow and validate');
-  t.end();
-});
-
-test('no arguments -> empty inParams, tasks, outTask', function (t) {
-  var fn = chainDefine().end();
-  t.deepEqual(fn.ast.inParams, []);
-  t.deepEqual(fn.ast.tasks, []);
-  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
-  t.end();
-});
-
-
-test('in only -> inParams["foo"], empty tasks, outTask', function (t) {
-  var fn = chainDefine()
-    .in('foo')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['foo']);
-  t.deepEqual(fn.ast.tasks, []);
-  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
-  t.end();
-});
-
-test('in empty  -> inParams["foo"], empty tasks, outTask', function (t) {
-  var fn = chainDefine()
-    .in()
-    .end();
-  t.deepEqual(fn.ast.inParams, []);
-  t.deepEqual(fn.ast.tasks, []);
-  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
-  t.end();
-});
-
-
-test('in triple first param -> inParams["foo", "bar", "baz"]', function (t) {
-  var fn = chainDefine()
-    .in('foo', 'bar', 'baz')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['foo', 'bar', 'baz']);
-  t.deepEqual(fn.ast.tasks, []);
-  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
-  t.end();
-});
-
-test('single task, single out params', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b')
-    .out('c')
-    .async(falpha).in('a', 'b').out('c')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
-  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')
-    .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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('single task, ERR and out params', function (t) {
-  var fn = chainDefine()
-    .out('ERR', 'c')
-    .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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('cb used in defs is simply ignored', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'cb')
-    .out('err', 'c')
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('callback used in defs is simply ignored', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'callback')
-    .out('err', 'c')
-    .async(falpha).in('a', 'b', 'callback').out('err', 'c')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('two inputs, two tasks, two out params', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'cb')
-    .out('err', 'c', 'd')
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
-    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
-    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'], name: 'fbeta'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-  t.end();  
-});
-
-test('two inputs, two tasks, two out params, name, options', function (t) {
-  var fn = chainDefine()
-    .name('myflow')
-    .in('a', 'b', 'cb')
-    .out('err', 'c', 'd')
-    .options({ otherOptFoo: 'foo'})
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c').name('myalpha')
-    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e').options({ bar: 'bar'})
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'myalpha'},
-    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'],
-      bar: 'bar', name: 'fbeta' }
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-  t.equal(fn.ast.name, 'myflow', 'name should match if supplied');
-  t.equal(fn.ast.otherOptFoo, 'foo', 'other options should pass through');
-  t.end();  
-});
-
-test('two inputs, two mixed tasks, two out params', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'cb')
-    .out('err', 'c', 'd')
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
-    .sync(fbeta).in('a', 'b').out('d')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
-    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-  t.end();  
-});
-
-test('two inputs, two mixed tasks, two out params, opts', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'cb')
-    .out('err', 'c', 'd')
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c').after(fbeta)
-    .sync(fbeta).in('a', 'b').out('d')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], after: ['fbeta'], name: 'falpha'},
-    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-  t.end();  
-});
-
-// Object use
-test('object prop task params', function (t) {
-  var fn = chainDefine()
-    .in('a', 'b', 'cb')
-    .out('err', 'c', 'e')
-    .async(falpha).in('a', 'b.cat', 'cb').out('err', 'c')
-    .sync(fbeta).in('c.dog', 'b').out('d')
-    .async('d.egg').in('c').out('err', 'e')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b.cat'], out: ['c'], name: 'falpha'},
-    { f: fbeta, type: 'ret', a: ['c.dog', 'b'], out: ['d'], name: 'fbeta'},
-    { f: 'd.egg', type: 'cb', a: ['c'], out: ['e'], name: 'd.egg'}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
-  t.end();  
-});
-
-
-// selectFirst 
-
-test('selectFirst', function (t) {
-  var fn = chainDefine()
-    .selectFirst()
-    .in('a', 'b', 'cb')
-    .out('err', 'c')
-    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
-    .sync(fbeta).in('a', 'b').out('c')
-    .end();
-  t.deepEqual(fn.ast.inParams, ['a', 'b']);
-  t.deepEqual(fn.ast.tasks, [
-    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
-    { f: fbeta,  type: 'ret', a: ['a', 'b'], out: ['c'], name: 'fbeta', after: ['falpha']}
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcbFirst' });
-  t.end();  
-});
-
-
-// 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/dsl/fstr.test.js

@@ -1,300 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-var sprintf = require('sprintf').sprintf;
-
-var fstrDefine = require('../../dsl/fstr'); // require('react/dsl/fstr');
-
-function falpha() { }
-function fbeta() { }
-
-test('module exports an object', function (t) {
-  t.type(fstrDefine, 'function', 'has define by DSL method');
-  t.end();
-});
-
-test('no arguments -> empty inParams, tasks, outTask', function (t) {
-  var r = fstrDefine();
-  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 = fstrDefine('');
-  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 = fstrDefine('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 = fstrDefine(' 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 r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c'
-  ], 'c');
-  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: ['c'], type: 'finalcb' });
-  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'
-  ], 'err, c');
-  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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('single task, ERR and out params', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> ERR, c'
-  ], 'ERR, c');
-  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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('cb used in defs is simply ignored', function (t) {
-  var r = fstrDefine('a, b, cb', [
-    falpha, 'a, b, cb -> err, c'
-  ], 'err, c');
-  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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('callback used in defs is simply ignored', function (t) {
-  var r = fstrDefine('a, b, callback', [
-    falpha, 'a, b, callback -> err, c'
-  ], 'err, c');
-  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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('two inputs, two tasks, two out params', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> err, d, e'
-  ], 'c, d');
-  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 r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> err, d, e'
-  ], 'c, d', { 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 r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> returns d'
-  ], 'c, d');
-  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('uses return', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> return d'
-  ], 'c, d');
-  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('uses Return', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> Return d'
-  ], 'c, d');
-  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('uses RETURN', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> RETURN d'
-  ], 'c, d');
-  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('uses RETURNS', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> RETURNS d'
-  ], 'c, d');
-  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('two inputs, two mixed tasks, two out params, opts', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a -> err, c', { after: fbeta },
-    fbeta,  'a, b -> returns d'
-  ], 'c, d');
-  t.deepEqual(r.ast.inParams, ['a', 'b']);
-  t.deepEqual(r.ast.tasks, [
-    { after: ['fbeta'], f: falpha, a: ['a'], 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();  
-});
-
-
-// Object use
-test('object prop task params', function (t) {
-  var r = fstrDefine('a, b', [
-    falpha, 'a, b.cat -> err, c',
-    fbeta,  'c.dog, b -> returns d',
-    'd.egg', 'c -> e'
-  ], 'c, e');
-  t.deepEqual(r.ast.inParams, ['a', 'b']);
-  t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: ['a', 'b.cat'], out: ['c'], type: 'cb', name: 'falpha'},
-    { f: fbeta,  a: ['c.dog', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
-    { f: 'd.egg', a: ['c'], out: ['e'], type: 'cb', name: 'd.egg'}
-  ]);
-  t.deepEqual(r.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
-  t.end();  
-});
-
-
-
-
-
-test('extra arg throws error', function (t) {
-  var fn = function () {
-    var r = fstrDefine('a, b', [
-      falpha, 'a -> err, c', { after: fbeta },
-      fbeta,  'a, b -> returns d',
-      'extraBadArg'
-    ], 'c, d');
-  };
-  t.throws(fn, new Error('extra unmatched task arg: extraBadArg'));
-  t.end();  
-});
-
-test('not enough args throws error', function (t) {
-  var fn = function () {
-    var r = fstrDefine('a, b', [
-      falpha, 'a -> err, c', { after: fbeta },
-      fbeta
-    ], 'c, d');
-  };
-  t.throws(fn, new Error(sprintf('extra unmatched task arg: %s', fbeta)));
-  t.end();  
-});
-
-
-
-/* selectFirst */
-
-test('selectFirst', function (t) {
-  var r = fstrDefine.selectFirst('a, b', [
-    falpha, 'a, b -> err, c',
-    fbeta,  'a, b -> returns c'
-  ], 'c', { 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();  
-});
-