react 0.2.6 → 0.5.0

package/test/promise-auto-resolve.test.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+  Test that arguments which are promises are automatically resolved
+  before calling react functions
+  */
+
+var test = require('tap').test;
+var Deferred = require('promised-io/promise').Deferred;
+
+var react = require('../');  // require('react');
+react.resolvePromises(); // enable promise resolving
+
+function multiply(x, y, cb) { cb(null, x * y); }
+function add(x, y, cb) { cb(null, x + y); }
+// function badF2(a, b, cb) { cb('my-error'); }
+
+test('auto resolve promises passed as args', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'] },
+      { f: add, a: ['c', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  function retAP() {
+    var deferred = new Deferred();
+    setTimeout(function () { deferred.resolve(2); }, 10);
+    return deferred.promise;
+  }
+
+  function retBP() {
+    var deferred = new Deferred();
+    setTimeout(function () { deferred.resolve(3); }, 10);
+    return deferred.promise;      
+  }
+
+  var ap = retAP();
+  var bp = retBP();
+
+  fn(ap, bp, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 9);
+    t.end();
+  });
+});

package/test/validate.test.js

@@ -282,8 +282,10 @@ 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: [] }
+      { f: foo, a: ['true', 'false', '123', '123.1', 'null'], out: [] },
+      { f: bar, a: ['-123', '-123.4', '"wow"', "'hey'"], out: [] },
+      { f: foo, a: ['"two-words"', "'also-two'", '"two.words"', "'also.two'"], out: [] },
+      { f: foo, a: ['this'], out: [] }
     ], 
     outTask: { a: [] }
   };

package/test/vcon.test.js

@@ -67,12 +67,25 @@ test('simple getVar returns existing value', function (t) {
 test('getVar on literals returns the literal', function (t) {
   t.equal(VContext.create([], []).getVar(true), true);
   t.equal(VContext.create([], []).getVar(false), false);
+  t.equal(VContext.create([], []).getVar(null), null);  
+  t.equal(VContext.create([], []).getVar('true'), true);
+  t.equal(VContext.create([], []).getVar('false'), false);
+  t.equal(VContext.create([], []).getVar('null'), null);  
   t.equal(VContext.create([], []).getVar(-100), -100);
   t.equal(VContext.create([], []).getVar(100), 100);
   t.equal(VContext.create([], []).getVar(123.4), 123.4);
   t.equal(VContext.create([], []).getVar(-987.6), -987.6);
+  t.equal(VContext.create([], []).getVar('-100'), -100);
+  t.equal(VContext.create([], []).getVar('100'), 100);
+  t.equal(VContext.create([], []).getVar('123.4'), 123.4);
+  t.equal(VContext.create([], []).getVar('-987.6'), -987.6);
   t.equal(VContext.create([], []).getVar('"foo"'), 'foo');
   t.equal(VContext.create([], []).getVar("'foo'"), 'foo');
+  t.equal(VContext.create([], []).getVar("'foo.bar'"), 'foo.bar');
+  t.equal(VContext.create([], []).getVar("'foo-bar'"), 'foo-bar');
+  t.equal(VContext.create([], []).getVar("'foo-bar.json'"), 'foo-bar.json');
+  t.equal(VContext.create([], []).getVar('"foo-bar.json"'), 'foo-bar.json');
+  t.deepEqual(VContext.create([], [], null, { a: 1}).getVar('this'), { a: 1});
   t.end();
 });
 

package/Jakefile.js

@@ -1,8 +0,0 @@
-
-
-require('./jake-tasks/jake-test.js');
-
-desc('Default - run watch');
-task('default', ['test:watch']);
-
-

package/examples/chain-events1.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var react = require('../'); // require('react');
-
-//output events as tasks start and complete
-react.events.on('*', function (obj) {
-  var time = new Date();
-  time.setTime(obj.time);
-  var eventTimeStr = time.toISOString();
-  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
-  if (obj.event === 'task.complete') {
-    console.error('%s: %s \tmsecs:(%s) \n\targs:(%s) \n\tresults:(%s)\n',
-                  obj.event, obj.name, obj.elapsedTime, argsNoCb, obj.results);
-  } else {
-    console.error('%s: %s \n\targs:(%s)\n', obj.event, obj.name, argsNoCb);
-  }
-});
-
-
-function multiply(a, b, cb) { cb(null, a * b); }
-function add(a, b) { return a + b; }
-
-var fn = react.chainDefine()
-  .in('a', 'b', 'cb')                                   // input params
-  .out('err', 'm', 's')                                 // final callback output params
-  .async(multiply).in('a', 'b', 'cb').out('err', 'm')   // task def - async fn, in params, callback out params
-  .sync(add).in('m', 'a').out('s')                      // task def - sync fn, in params, return value
-  .end();
-
-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/examples/chain1.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var react = require('../'); // require('react');
-
-function multiply(a, b, cb) { cb(null, a * b); }
-function add(a, b) { return a + b; }
-
-var fn = react.chainDefine()
-  .in('a', 'b', 'cb')                                   // input params
-  .out('err', 'm', 's')                                 // final callback output params
-  .async(multiply).in('a', 'b', 'cb').out('err', 'm')   // task def - async fn, in params, callback out params
-  .sync(add).in('m', 'a').out('s')                      // task def - sync fn, in params, return value
-  .end();
-
-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/examples/fstr-events1.js

@@ -1,51 +0,0 @@
-'use strict';
-
-var react = require('../'); // require('react');
-
-//output events as tasks start and complete
-react.events.on('*', function (obj) {
-  var time = new Date();
-  time.setTime(obj.time);
-  var eventTimeStr = time.toISOString();
-  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
-  if (obj.event === 'task.complete') {
-    console.error('%s: %s \tmsecs:(%s) \n\targs:(%s) \n\tresults:(%s)\n',
-                  obj.event, obj.name, obj.elapsedTime, argsNoCb, obj.results);
-  } else {
-    console.error('%s: %s \n\targs:(%s)\n', obj.event, obj.name, argsNoCb);
-  }
-});
-                
-
-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, cb) { 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);
-    return;
-  }
-  console.log('final result: %s, user: %s, written:%s', html, user, bytesWritten);
-}
-
-var loadAndSave = react.fstrDefine('filename, uid, outDirname, cb', [  // input params
-  loadUser,         'uid              -> err, user',     // calling async fn loadUser with uid, callback is called with err and user
-  loadFile,         'filename         -> err, filedata',
-  markdown,         'filedata         -> returns html',    // using a sync function
-  prepareDirectory, 'outDirname       -> err, dircreated',
-  writeOutput,      'html, user       -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
-  loadEmailTemplate, '                 -> err, emailmd',
-  markdown,         'emailmd          -> returns emailHtml',   // using a sync function
-  customizeEmail,   'user, emailHtml  -> returns custEmailHtml',
-  deliverEmail,     'custEmailHtml    -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
-], 'err, html, user, bytesWritten');   // callback output params
-
-loadAndSave('file.md', 100, '/tmp/foo', useHtml);  // executing the flow
-
-

package/examples/pcode1.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var react = require('../'); // require('react');
-
-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 = react.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/lib/chain.js

@@ -1,148 +0,0 @@
-'use strict';
-
-var sprintf = require('sprintf').sprintf;
-var core = require('./core.js');
-var tutil = require('./task.js');
-
-// err for task type cb is implied and thus optional, but allow for clarity. 
-var ERROR_NAMES_RE = /^err$/i;  // first out param matching this is skipped as being the err object
-
-// callback is implied for task type cb is implied and thus optional, but allow for clarity. 
-var CALLBACK_NAMES_RE = /^cb$|^callback$/i;  // last in param matching this is skipped as being the cb
-
-var FlowBuilder;
-
-/**
-   jQuery-like chain interface for defining flow
-
-   @example
-    // normal flow
-    var react = require('react');
-    var fn = react.chainDefine()
-      .in('filename', 'uid', 'outDirname', 'cb')
-      .out('err', 'html', 'user', 'bytesWritten')  
-      .async(loadUser)          .in('uid')               .out('err', 'user')
-      .async(loadFile)          .in('filename')          .out('err', 'filedata')
-      .sync(markdown)           .in('filedata')          .out('html')
-      .async(prepareDirectory)  .in('outDirname')        .out('err', 'dircreated') 
-      .async(writeOutput)       .in('html', 'user')      .out('err', 'bytesWritten')   .after('prepareDirectory')
-      .async(loadEmailTemplate) .in()                    .out('err', 'emailmd')
-      .sync(markdown)           .in('emailmd')           .out('emailHtml')
-      .sync(customizeEmail)     .in('user', 'emailHtml') .out('custEmailHtml')
-      .async(deliverEmail)      .in('custEmailHtml')     .out('err', 'deliveredEmail') .after('writeOutput')
-      .end();
-
-   @example
-    // selectFirst flow
-    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();    
-*/
-function chainDefine() {
-  return FlowBuilder.create();
-}
-
-function FlowBuilder() {
-  this.main = {
-    name: null,
-    options: {}
-  };
-  this.tasks = [];
-  this.focus = this.main;
-}
-
-FlowBuilder.create = function () { return new FlowBuilder(); };
-
-FlowBuilder.prototype.selectFirst = function () {
-  this.main.outTaskType = 'finalcbFirst';
-  return this;
-};
-
-FlowBuilder.prototype.name = function (name) {
-  this.focus.name = name;
-  return this;
-};
-
-FlowBuilder.prototype.in = function (param1, param2, paramN) { 
-  var args = Array.prototype.slice.call(arguments);
-  if (args.length && this.focus.type !== 'ret') {  // has args and cb or main
-    if (args[args.length - 1].match(CALLBACK_NAMES_RE)) args.pop(); // pop off the cb name if specified
-  }
-  if (this.focus === this.main) this.focus.in = args;
-  else this.focus.a = args;   // for tasks
-  return this;
-};
-
-FlowBuilder.prototype.out = function (param1, param2, paramN) {
-  var args = Array.prototype.slice.call(arguments);
-  if (args.length && this.focus.type !== 'ret') {  // has args and cb or main
-    if (args[0].match(ERROR_NAMES_RE)) args.shift(); // shift off err if specified
-  }
-  this.focus.out = args;
-  return this;
-};
-
-FlowBuilder.prototype.options = function (options) {
-  var self = this;
-  if (this.focus === this.main) {
-    Object.keys(options).forEach(function (k) { self.focus.options[k] = options[k]; });
-  } else { // task so set options right on task
-    Object.keys(options).forEach(function (k) { self.focus[k] = options[k]; });
-  }
-  return this;
-};
-
-FlowBuilder.prototype.async = function (funcOrStrMethod) {
-  var task = { f: funcOrStrMethod, type: 'cb' };
-  this.tasks.push(task);
-  this.focus = task;
-  return this;
-};
-
-FlowBuilder.prototype.sync = function (funcOrStrMethod) {
-  var task = { f: funcOrStrMethod, type: 'ret' };
-  this.tasks.push(task);
-  this.focus = task;
-  return this;
-};
-
-FlowBuilder.prototype.after = function (name1, name2, nameN) {
-  this.focus.after = Array.prototype.slice.call(arguments);
-  return this;
-};
-
-/**
-   Complete the building of a flow and perform validation
-   which throws error if flow is not valid.
-  */
-FlowBuilder.prototype.end = function end() {
-  var reactFn = core();
-
-  if (this.main.outTaskType === 'finalcbFirst') {
-    this.tasks = tutil.serializeTasks(this.tasks);
-  }
-
-  var ast = {
-    inParams: this.main.in || [],
-    tasks: this.tasks,
-    outTask: {
-      a: this.main.out || [],
-      type: this.main.outTaskType || 'finalcb'
-    }
-  };
-  if (this.main.name) ast.name = this.main.name;
-  var self = this;
-  Object.keys(this.main.options).forEach(function (k) { ast[k] = self.main.options[k]; });
-  var errors = reactFn.setAndValidateAST(ast);
-  if (errors.length) {
-    var errorStr = errors.join('\n');
-    throw new Error(errorStr);
-  }
-  return reactFn;
-};
-
-module.exports = chainDefine;