react 0.2.1 → 0.2.5

package/README.md

@@ -242,7 +242,8 @@ fn(2, 3, function (err, m, s) {
 
 ## Status
 
- - 2012-01-10 - Create default DSL for react()
+ - 2012-01-11 - Provide warning/error when name is skipped in default DSL, literal check in validate (v0.2.5)
+ - 2012-01-10 - Create default DSL for react(), create error for missing variables, list remaining tasks when flow won't complete
  - 2011-12-21 - Refactor from ground up with tests, changes to the interfaces
  - 2011-10-26 - React is in active development and interface may change frequently in these early stages. Current code is functional but does not perform validation yet.  Additional interfaces are planned to make it easy to define flows in a variety of ways. Documentation and examples forthcoming.
 
@@ -253,7 +254,7 @@ ok ast.test.js .................... 10/10
 ok cb-task.test.js ................ 31/31
 ok chain.test.js .................. 56/56
 ok core.test.js ................... 98/98
-ok dsl.test.js .................... 58/58
+ok dsl.test.js .................... 63/63
 ok event-manager.test.js .......... 13/13
 ok exec-options.test.js ............. 3/3
 ok finalcb-task.test.js ............. 5/5
@@ -265,9 +266,9 @@ ok ret-task.test.js ............... 31/31
 ok task.test.js ..................... 1/1
 ok validate-cb-task.test.js ......... 6/6
 ok validate-ret-task.test.js ........ 7/7
-ok validate.test.js ............... 26/26
+ok validate.test.js ............... 31/31
 ok vcon.test.js ................... 42/42
-total ........................... 613/613
+total ........................... 623/623
 
 ok
 ```

package/examples/default-events1.js

@@ -24,7 +24,7 @@ function markdown(filedata) { return 'html'+filedata; }
 function prepareDirectory(outDirname, cb){ setTimeout(cb, 200, null, 'dircreated-'+outDirname); }
 function writeOutput(html, user, cb){  setTimeout(cb, 300, null, html+'_bytesWritten'); }
 function loadEmailTemplate(cb) { setTimeout(cb, 50, null, 'emailmd'); }
-function customizeEmail(user, emailHtml, cb) { return 'cust-'+user+emailHtml; }
+function customizeEmail(user, emailHtml) { return 'cust-'+user+emailHtml; }
 function deliverEmail(custEmailHtml, cb) { setTimeout(cb, 100, null, 'delivered-'+custEmailHtml); }
 
 function useHtml(err, html, user, bytesWritten) {
@@ -43,9 +43,9 @@ var loadAndSave = react('loadAndSave', 'filename, uid, outDirname, cb -> err, ht
   writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
   loadEmailTemplate, 'cb              -> err, emailmd',
   markdown,         'emailmd          -> emailHtml',   // using a sync function
-  customizeEmail,   'user, emailHtml, cb -> err, custEmailHtml',
+  customizeEmail,   'user, emailHtml  -> err, custEmailHtml', // sync fn
   deliverEmail,     'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
-); 
+);
 
 loadAndSave('file.md', 100, '/tmp/foo', useHtml);  // executing the flow
 

package/examples/default1.js

@@ -9,12 +9,13 @@ function markdown(filedata) { return 'html'+filedata; }
 function prepareDirectory(outDirname, cb){ setTimeout(cb, 200, null, 'dircreated-'+outDirname); }
 function writeOutput(html, user, cb){  setTimeout(cb, 300, null, html+'_bytesWritten'); }
 function loadEmailTemplate(cb) { setTimeout(cb, 50, null, 'emailmd'); }
-function customizeEmail(user, emailHtml, cb) { return 'cust-'+user+emailHtml; }
+function customizeEmail(user, emailHtml) { return 'cust-'+user+emailHtml; }
 function deliverEmail(custEmailHtml, cb) { setTimeout(cb, 100, null, 'delivered-'+custEmailHtml); }
 
 function useHtml(err, html, user, bytesWritten) {
   if (err) {
     console.log('***Error: %s', err);
+    console.error(err.stack);
     return;
   }
   console.log('final result: %s, user: %s, written:%s', html, user, bytesWritten);
@@ -22,15 +23,15 @@ function useHtml(err, html, user, bytesWritten) {
 
 // define fn, glue together with react, it will parallelize
 // starts with name and in/out params, then the tasks
-var loadAndSave = react('loadAndSave', 'fName, uid, outDir, cb -> err, html, user, bytes',  
+var loadAndSave = react('loadAndSave', 'filename, uid, outDir, cb -> err, html, user, bytes',  
   loadUser,         'uid, cb          -> err, user',     // calling async loadUser with uid, cb called with err and user
   loadFile,         'filename, cb     -> err, filedata',
   markdown,         'filedata         -> html',    // using a sync function
-  prepareDirectory, 'outDirname, cb   -> err, dircreated',
-  writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
+  prepareDirectory, 'outDir, cb   -> err, dircreated',
+  writeOutput,      'html, user, cb   -> err, bytes', { after: prepareDirectory },  // only after prepareDirectory done
   loadEmailTemplate, 'cb              -> err, emailmd',
   markdown,         'emailmd          -> emailHtml',   // using a sync function
-  customizeEmail,   'user, emailHtml, cb  -> custEmailHtml',
+  customizeEmail,   'user, emailHtml  -> custEmailHtml',  // sync function
   deliverEmail,     'custEmailHtml, cb    -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
 );
 

package/lib/.#event-manager.js

@@ -0,0 +1 @@
+barczewskij@ELSSTLM-184670.local.99357

package/lib/core.js

@@ -13,10 +13,10 @@ var inputParser = require('./input-parser.js');
 var idGenerator = require('./id.js');
 
 var reactOptions = {
-  stackTraceLimitMin: 30  
+  stackTraceLimitMin: 30
 };
 
-var reactEmitter = EventManager.create(); // the top emitter
+var reactEmitter = EventManager.globalEventManager; // the top emitter
 
 /**
    Creates react function which the AST can be manipulated and then
@@ -39,7 +39,7 @@ var reactEmitter = EventManager.create(); // the top emitter
  */
 function reactFactory() {
   if (arguments.length) throw new Error('react() takes no args, check API');
-  
+
   error.ensureStackTraceLimitSet(reactOptions.stackTraceLimitMin);
   var flowEmitter = EventManager.create();
   flowEmitter.parent = reactEmitter;
@@ -75,7 +75,7 @@ function reactFactory() {
       if (outTask.isReady()) return outTask.exec(); // all tasks done, exec cb, return
       tskutil.findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec);  //exec tasks that ready to run
     }
-    
+
     tasks.forEach(function (t) {
       t.id = idGenerator.createUniqueId();
       t.flowEmitter = flowEmitter;

package/lib/dsl.js

@@ -6,9 +6,11 @@ var core = require('./core.js');
 var parse = require('./parse.js');
 var tutil = require('./task.js');
 
+var MISSING_NAME = 'param[0] should be the flow name, instead found in/out def: %s';
 var INOUT_PARAMS_NO_MATCH = 'params in wrong format, wanted "foo, bar cb -> err, baz" - found: %s';
 var EXTRA_TASKARG = 'extra unmatched task arg: %s';
 
+var INOUT_RE = /\->/;  // used to detect missing name, in/out as first arg
 var CB_NAMES_RE = /^cb|callback$/i;  //cb, Cb, CB, callback, Callback
 var ERR_NAMES_RE = /^err$/i; // err, ERR, Err, ...
 
@@ -81,6 +83,7 @@ function parseVargs(vargs) {
 
 function dslDefine(name, arg1, arg2, argN) {
   var reactFn = core();
+  if (name && INOUT_RE.test(name)) throw new Error(sprintf(MISSING_NAME, name));
   var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
   var inOutDef = parseInOutParams(defObj.inOutParamStr);
   var ast = {

package/lib/error.js

@@ -9,19 +9,29 @@ function ensureStackTraceLimitSet(stackTraceLimit) {
 }
 
 function fName(fn) {
-  return (typeof(fn) === 'string') ? fn : fn.name;
+  if (!fn) return 'undefined';
+  return (fn && fn.name) ? fn.name : fn;
 }
 
 function formatErrorMeta(err) {
   if (!err.meta) return;
   var vcon = err.meta.vcon;
   var task = err.meta.task;
-  return '\n\n' +
-      'Error occurs in Task function: ' + fName(task.f) + '(' + task.a.join(',') + ')\n\n' + 
-      'Variable Context: \n' +
-      util.inspect(vcon) + '\n\n' +
-      'Task Source:\n\n' +
-      task.f.toString() + '\n\n'; //TODO need to pretty print function, gets collapsed
+  var errString = '\n\n';
+  if (task && task.f && task.a) {
+    errString += ('Error occurs in Task function: ' + fName(task.f) + '(' + task.a.join(',') + ')\n\n');
+  }
+  if (vcon) {
+    errString += 'Variable Context: \n';
+    errString += util.inspect(vcon);
+    errString +=  '\n\n';
+  }
+  if (task && task.f) {
+    errString += 'Task Source:\n\n';
+    errString += task.f.toString(); //TODO need to pretty print function, gets collapsed
+    errString += '\n\n';
+  }
+  return errString;    
 }
 
 function augmentError(err, meta) {

package/lib/event-manager.js

@@ -54,4 +54,5 @@ EventManager.prototype.emitObject = function (event, object) {
 };
 
 module.exports = EventManager;
-module.exports.TYPES = TYPES;
+module.exports.TYPES = TYPES;
+module.exports.globalEventManager = EventManager.create(); // create one top level emitter

package/lib/task.js

@@ -25,7 +25,7 @@ function outTaskTypeKeys() { return Object.keys(OUT_TASK_TYPES); }
 
 var LOCAL_FN_MISSING = 'function: %s not found in locals or input params - task[%s]';
 var TASKDEF_IS_OBJECT = 'task must be an object';
-var NO_TASKS_RUNNING_WONT_COMPLETE = 'no tasks running, flow will not complete';
+var NO_TASKS_RUNNING_WONT_COMPLETE = 'no tasks running, flow will not complete, remaining tasks: %s';
 var TASK_TYPE_SHOULD_MATCH = 'task.type should match one of ' +
   Object.keys(TASK_TYPES).join(', ');
 
@@ -201,7 +201,12 @@ function checkIfTasksRunning(vCon, tasks, handleError) {
   var tasksRunning = tasks.filter(function (t) {
     return (t.status === STATUS.RUNNING || t.status === STATUS.READY);
   });
-  if (!tasksRunning.length) handleError({}, new Error(NO_TASKS_RUNNING_WONT_COMPLETE));
+  if (!tasksRunning.length) {
+    var remainingTasks = tasks.filter(function (t) { return (!t.status); });
+    var remainingTNames = remainingTasks.map(function (t) { return t.name; });
+    var errMsg = sprintf(NO_TASKS_RUNNING_WONT_COMPLETE, remainingTNames.join(', '));
+    handleError({}, new Error(errMsg));
+  }
 }
 
 function findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec) {

package/lib/validate.js

@@ -11,14 +11,27 @@ var TASKS_ARR = 'ast.tasks must be an array of tasks';
 var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
 var LOCALS_NOTNULL = 'ast.locals should not be null';
 var DUP_OUTPUTS = 'multiple tasks output the same param, must be unique. param';
+var MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
+
+// match any of our literals true, false, int, float, quoted strings, or is property (has dot)
+var LITERAL_OR_PROP_RE = /^(true|false|\-?[0-9\.]+)$|'|"|\./i;  
 
 var validateInParams, validateTasks, validateOutTask, validateTaskNamesUnique;
-var validateLocals, validateOuputsUnique;
+var validateLocals, validateOuputsUnique, validateNoMissingNames;
 
 function format_error(errmsg, obj) {
   return sprintf('%s - %s', errmsg, util.inspect(obj));
 }
 
+/**
+   true if is a literal name
+  */
+function isLiteralOrProp(name) {  // need to match what is in vcon.js, TODO consolidate?
+  return LITERAL_OR_PROP_RE.test(name);
+}
+
+
+
 /**
    validate the AST return Errors
    @example
@@ -37,6 +50,7 @@ function validate(ast) {
   if (errors.length === 0) { // if no errors do additional validation
     if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
     errors = errors.concat(tutil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
+    errors = errors.concat(validateNoMissingNames(ast));
   }
   return errors;
 }
@@ -99,4 +113,47 @@ function validateOuputsUnique(taskDefs) {
   return errors;
 }
 
+
+/**
+   validate there are no missing or mispelled param names in any task inputs
+   or the final task output
+
+   @return array of errors, or empty array if none
+  */
+function validateNoMissingNames(ast) {
+  var errors = [];
+  var names = {};
+  if (ast.locals) {
+    names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
+      accum[k] = true;
+      return accum;
+    }, names);
+  }
+  ast.inParams.reduce(function (accum, p) {  // add input params
+    accum[p] = true;
+    return accum;
+  }, names);
+  ast.tasks.reduce(function (accum, t) { // add task outputs
+    return t.out.reduce(function (innerAccum, p) {
+      innerAccum[p] = true;
+      return innerAccum;
+    }, accum);
+  }, names);
+
+  // now we have all possible provided vars, check task inputs are accounted for
+  ast.tasks.reduce(function (accum, t) {  // for all tasks
+    return t.a.reduce(function (innerAccum, p) { // for all in params, except property
+      if (!isLiteralOrProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+      return innerAccum;
+    }, accum);
+  }, errors);
+
+  // now check the final task outputs
+  ast.outTask.a.reduce(function (accum, p) { // for final task out params
+    if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
+    return accum;
+  }, errors);
+  return errors;
+}
+
 module.exports = validate;

package/lib/vcon.js

@@ -9,9 +9,11 @@ VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULT
 VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
 
 VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
+  /*jshint regexp: false */
   var vConValues = this.values;
   if (typeof(name) !== 'string') return name; // literal boolean or number
   name = name.trim();
+  // literal checks need to match what is in validate.js
   if (name === 'true') return true;
   if (name === 'false') return false;
   if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react",
   "description": "React is a javascript module to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
   "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
   "bugs" : { "url": "http://github.com/jeffbski/react/issues" },

package/test/chain.test.js

@@ -63,10 +63,11 @@ test('in triple first param -> inParams["foo", "bar", "baz"]', function (t) {
 
 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, []);
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
   t.deepEqual(fn.ast.tasks, [
     { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
   ]);
@@ -77,11 +78,11 @@ test('single task, single out params', function (t) {
 test('single task, err and out params', function (t) {
   var fn = chainDefine()
     .out('err', 'c')
-    .async(falpha).in('a', 'b').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: ['a', 'b'], out: ['c'], name: 'falpha' }
+    { f: falpha, type: 'cb', a: [], out: ['c'], name: 'falpha' }
   ]);
   t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
   t.end();  
@@ -90,11 +91,11 @@ test('single task, err and out params', function (t) {
 test('single task, ERR and out params', function (t) {
   var fn = chainDefine()
     .out('ERR', 'c')
-    .async(falpha).in('a', 'b').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: ['a', 'b'], out: ['c'], name: 'falpha' }
+    { f: falpha, type: 'cb', a: [], out: ['c'], name: 'falpha' }
   ]);
   t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
   t.end();  

package/test/core.test.js

@@ -198,14 +198,15 @@ test('error when cant complete', function (t) {
     inParams: ['a', 'b', 'c'],
     tasks: [    
       { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
-      { f: fnRetsSum, a: ['c.bad', 'b'], out: ['c.sum'], type: 'ret' }
+      { f: fnRetsSum, a: ['c.bad', 'b'], out: ['c.sum'], type: 'ret' },
+      { f: add, a: ['c.sum', 'a'], out: ['d']}
     ],
-    outTask: { a: ['c.mult', 'c.sum', 'c'] }
+    outTask: { a: ['c.mult', 'c.sum', 'd'] }
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  fn(2, 3, { foo: 1 }, function (err, cmult, csum, c) {
-    t.equal(err.message, 'no tasks running, flow will not complete');
+  fn(2, 3, { foo: 1 }, function (err, cmult, csum, d) {
+    t.equal(err.message, 'no tasks running, flow will not complete, remaining tasks: fnRetsSum, add');
     t.end();
   });
 });

package/test/dsl.test.js

@@ -55,11 +55,11 @@ test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask
 
 test('single task, single out params', function (t) {
   var r = react('myName', 'cb -> err, c',
-    falpha, 'a, b, cb -> err, c'
+    falpha, 'cb -> err, c'
   );
   t.deepEqual(r.ast.inParams, []);
   t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+    { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
   t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
   t.end();  
@@ -67,11 +67,11 @@ test('single task, single out params', function (t) {
 
 test('single task, err and out params', function (t) {
   var r = react('myName', 'cb -> err, c',
-    falpha, 'a, b, cb -> err, c'
+    falpha, 'cb -> err, c'
   );
   t.deepEqual(r.ast.inParams, []);
   t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+    { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
   t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
   t.end();  
@@ -79,11 +79,11 @@ test('single task, err and out params', function (t) {
 
 test('single task, ERR and out params', function (t) {
   var r = react('myName', 'cb -> ERR, c', 
-    falpha, 'a, b, cb -> ERR, c'
+    falpha, 'cb -> ERR, c'
   );
   t.deepEqual(r.ast.inParams, []);
   t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+    { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
   t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
   t.end();  
@@ -191,6 +191,19 @@ test('object prop task params', function (t) {
   t.end();  
 });
 
+// Errors
+
+test('missing name, throws error', function (t) {
+  var fn = function () {
+    var r = react('cb -> err, c',
+                  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.end();
+});
+
+
 test('extra arg throws error', function (t) {
   var fn = function () {
     var r = react('myName', 'a, b, cb -> err, c, d', 
@@ -214,7 +227,35 @@ test('not enough args throws error', function (t) {
   t.end();  
 });
 
-
+test('long example', function (t) {
+  t.plan(4);
+  function loadUser(uid, cb){ setTimeout(cb, 100, null, "User"+uid); }
+  function loadFile(filename, cb){ setTimeout(cb, 100, null, 'Filedata'+filename); }
+  function markdown(filedata) { return 'html'+filedata; }
+  function prepareDirectory(outDirname, cb){ setTimeout(cb, 200, null, 'dircreated-'+outDirname); }
+  function writeOutput(html, user, cb){  setTimeout(cb, 300, null, html+'_bytesWritten'); }
+  function loadEmailTemplate(cb) { setTimeout(cb, 50, null, 'emailmd'); }
+  function customizeEmail(user, emailHtml) { return 'cust-'+user+emailHtml; }
+  function deliverEmail(custEmailHtml, cb) { setTimeout(cb, 100, null, 'delivered-'+custEmailHtml); }
+  var loadAndSave = react('loadAndSave', 'filename, uid, outDirname, cb -> err, html, user, bytesWritten',  // name, in/out params
+    loadUser,         'uid, cb          -> err, user',     // calling async fn loadUser with uid, callback is called with err and user
+    loadFile,         'filename, cb     -> err, filedata',
+    markdown,         'filedata         -> html',    // using a sync function
+    prepareDirectory, 'outDirname, cb   -> err, dircreated',
+    writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
+    loadEmailTemplate, 'cb              -> err, emailmd',
+    markdown,         'emailmd          -> emailHtml',   // using a sync function
+    customizeEmail,   'user, emailHtml  -> custEmailHtml',
+    deliverEmail,     'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
+  );
+  loadAndSave('file.md', 100, '/tmp/foo', function (err, html, user, bytesWritten) {  // executing the flow
+    t.equal(err, null);
+    t.equal(html, 'htmlFiledatafile.md');
+    t.equal(user, 'User100');
+    t.equal(bytesWritten, 'htmlFiledatafile.md_bytesWritten');
+    t.end();
+  });
+});
 
 // selectFirst 
 

package/test/fstr.test.js

@@ -48,10 +48,10 @@ test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask
 });
 
 test('single task, single out params', function (t) {
-  var r = fstrDefine('', [
+  var r = fstrDefine('a, b', [
     falpha, 'a, b -> err, c'
   ], 'c');
-  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
   t.deepEqual(r.ast.tasks, [
     { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
@@ -60,10 +60,10 @@ test('single task, single out params', function (t) {
 });
 
 test('single task, err and out params', function (t) {
-  var r = fstrDefine('', [
+  var r = fstrDefine('a, b', [
     falpha, 'a, b -> err, c'
   ], 'err, c');
-  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
   t.deepEqual(r.ast.tasks, [
     { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
@@ -72,10 +72,10 @@ test('single task, err and out params', function (t) {
 });
 
 test('single task, ERR and out params', function (t) {
-  var r = fstrDefine('', [
+  var r = fstrDefine('a, b', [
     falpha, 'a, b -> ERR, c'
   ], 'ERR, c');
-  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
   t.deepEqual(r.ast.tasks, [
     { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
   ]);

package/test/pcode.test.js

@@ -50,11 +50,11 @@ test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask
 
 test('single task, single out params', function (t) {
   var locals = { falpha: falpha };
-  var r = pcode('', [
+  var r = pcode('a, b', [
     'c := falpha(a, b)',
     'cb(err, c)'
   ], locals);
-  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
   t.deepEqual(r.ast.tasks, [
     { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
   ]);
@@ -64,11 +64,11 @@ test('single task, single out params', function (t) {
 
 test('single task, err and out params', function (t) {
   var locals = { falpha: falpha };
-  var r = pcode('', [
+  var r = pcode('a, b', [
     'c := falpha(a, b)',
     'cb(err, c)'
   ], locals);
-  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
   t.deepEqual(r.ast.tasks, [
     { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
   ]);

package/test/validate.test.js

@@ -210,9 +210,83 @@ test('multiple tasks output the same param, must be unique', function (t) {
       { f: foo, a: [], out: ['baz', 'c'] },
       { f: bar, a: [], out: ['c'] }
     ], 
-    outTask: { a: ['bar'] }
+    outTask: { a: ['baz'] }
   };
   var msg = 'multiple tasks output the same param, must be unique. param: c';
   t.deepEqual(validate(ast), [msg]);  
   t.end();
-});
+});
+
+test('missing or mispelled input variable', function (t) {
+  var ast = {
+    inParams: [], 
+    tasks: [
+      { f: foo, a: [], out: [] },
+      { f: bar, a: ['abc'], out: [] }
+    ], 
+    outTask: { a: [] }
+  };
+  var msg = 'missing or mispelled variable referenced in flow definition: abc';
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();  
+});
+
+test('missing or mispelled input variables', function (t) {
+  var ast = {
+    inParams: ['aaa', 'bbb'], 
+    tasks: [
+      { f: foo, a: ['aaa', 'cat'], out: ['ccc'] },
+      { f: bar, a: ['abc', 'bbb', 'ccc'], out: [] }
+    ], 
+    outTask: { a: [] }
+  };
+  var messages = [
+    'missing or mispelled variable referenced in flow definition: cat',
+    'missing or mispelled variable referenced in flow definition: abc'
+  ];
+  t.deepEqual(validate(ast), messages);  
+  t.end();  
+});
+
+test('missing or mispelled final output variables', function (t) {
+  var ast = {
+    inParams: ['aaa'], 
+    tasks: [
+      { f: foo, a: ['aaa'], out: ['bbb'] },
+      { f: bar, a: ['bbb'], out: ['ccc'] }
+    ], 
+    outTask: { a: ['ccc', 'ddd', 'eee'] }
+  };
+  var messages = [
+    'missing or mispelled variable referenced in flow definition: ddd',
+    'missing or mispelled variable referenced in flow definition: eee'
+  ];
+  t.deepEqual(validate(ast), messages);  
+  t.end();  
+});
+
+test('missing or mispelled validation ignores properties', function (t) {
+  var ast = {
+    inParams: ['obj'], 
+    tasks: [
+      { f: foo, a: ['obj.foo'], out: [] },
+      { f: bar, a: ['obj.bar'], out: [] }
+    ], 
+    outTask: { a: ['obj.cat'] }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();  
+});
+
+test('missing or mispelled validation ignores literals', function (t) {
+  var ast = {
+    inParams: [], 
+    tasks: [
+      { f: foo, a: ['true', 'false', '123', '123.1'], out: [] },
+      { f: bar, a: ['-123', '-123.4', '"wow"', "'hey'"], out: [] }
+    ], 
+    outTask: { a: [] }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();  
+});