react 0.2.3 → 0.3.0

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();
-});
+});
+

package/test/module-use.test.js

@@ -3,7 +3,7 @@
 var test = require('tap').test;
 var BaseTask = require('../lib/base-task.js');
 
-var react = require('../react');
+var react = require('../'); // require('react');
 
 /**
   @example
@@ -35,9 +35,7 @@ var react = require('../react');
 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.type(react.events, 'object', 'has global react event manager');
   t.end();
 });
 
@@ -125,193 +123,7 @@ test('use react.selectFirst() default DSL with events', function (t) {
 });
 
 
-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/promise-auto-resolve.test.js

@@ -0,0 +1,51 @@
+'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('../promise-resolve');  // require('react/promise-resolve');
+
+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

@@ -263,4 +263,33 @@ test('missing or mispelled final output variables', function (t) {
   ];
   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', '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: [] }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();  
+});
+

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/oldExamples/analyze.js

@@ -1,29 +0,0 @@
-'use strict';
-
-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 analyze(fn) {
-  console.log(fn.toString());
-}
-
-var fn = analyze(function loadAndSend(filename, uid, outDirname, cb,
-                         R, filedata, outDirName, dircreated, emailmd, emailHtml,
-                                   custEmailHtml, deliveredEmail, err, user, html, bytesWritten) {
-  R.async(loadUser, uid).cb(err, user)
-    .async(loadFile, filename).cb(err, filedata)
-    .sync(markdown, filedata).returns(filedata)
-    .async(prepareDirectory, outDirName).cb(dircreated)
-    .async(writeOutput, html, user).cb(err, bytesWritten).after(prepareDirectory)
-    .async(loadEmailTemplate).cb(err, emailmd)
-    .sync(markdown, emailmd).returns(emailHtml)
-    .sync(customizeEmail, user, emailHtml).returns(custEmailHtml)
-    .sync(deliverEmail, custEmailHtml).returns(deliveredEmail).after(writeOutput)
-    .finalCb(err, html, user, bytesWritten);
-});