react 0.3.5 → 0.6.0

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/promise-resolve.js

@@ -1,35 +0,0 @@
-'use strict';
-
-/**
-   Auto resolve promises passed in as arguments to the flow
-
-    - Detects promises by checking for .then()
-    - Create promise name for param (param__promise)
-    - moves existing vCon promise into the param__promise
-    - creates WhenTask which resolves param__promise into param
-  */
-
-
-var react = require('./');  // require('react');
-
-var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
-
-react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (env) {
-  var vConValues = env.vCon.values;
-  var promiseParams = env.ast.inParams.filter(function (p) {
-    var value = vConValues[p];
-    return (value && typeof(value.then) === 'function');
-  });
-  promiseParams.forEach(function (p) {
-    var promiseName = p + PROMISE_SUFFIX;
-    vConValues[promiseName] = vConValues[p];
-    vConValues[p] = undefined;
-    env.taskDefs.push({
-      type: 'when',
-      a: [promiseName],
-      out: [p]
-    });
-  });
-});
-
-module.exports = react;  // return react

package/react.js

@@ -1,8 +0,0 @@
-'use strict';
-
-var core = require('./lib/core.js');
-
-module.exports = require('./lib/dsl.js');  // core + default dsl
-module.exports.options = core.options; // global react options
-module.exports.events = core.events;   // global react event emitter
-

package/test/ast.test.js

@@ -1,69 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-
-var react = require('../react');
-
-function load(res, cb) { cb(null, res + '-loaded'); }
-function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
-function postfix(str, poststr, cb) { cb(null, str + poststr); }
-function upper(str) { return str.toUpperCase(); }
-function makeError(str, cb) { cb(new Error('makeErr-' + str)); }
-
-test('mixed', function (t) {
-  t.plan(5);
-  
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: ['res', 'prefstr', 'poststr'],
-    tasks: [
-      { f: load,    a: ['res'],              out: ['lres'] },
-      { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
-      { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
-      { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
-    ],
-    outTask: { a: ['plresp'] }
-  });
-
-  t.deepEqual(errors, []);
-
-  fn('foo', 'pre-', '-post', function cb(err, lres) {
-    t.equal(err, null);
-    t.equal(lres, 'pre-FOO-LOADED-post');
-  });
-
-  fn('bar', 'PRE-', '-POST', function cb(err, lres) {
-    t.equal(err, null);
-    t.equal(lres, 'PRE-BAR-LOADED-POST');
-  });
-});
-
-test('cb with err', function (t) {
-  t.plan(5);
-  
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: ['res', 'prefstr', 'poststr'],
-    tasks: [
-      { f: load,      a: ['res'],               out: ['lres'] },
-      { f: upper,     a: ['lres'],              out: ['ulres'], type: 'ret' },
-      { f: makeError, a: ['ulres'],             out: ['na']  },
-      { f: prefix,    a: ['prefstr', 'na'],     out: ['plres'] },
-      { f: postfix,   a: ['plres', 'poststr'],  out: ['plresp'] }
-    ],
-    outTask: { a: ['plresp'] }
-  });
-
-  t.deepEqual(errors, []);
-
-  fn('foo', 'pre-', '-post', function cb(err, lres) {
-    t.equal(err.message, 'makeErr-FOO-LOADED');
-    t.equal(lres, undefined);
-  });
-
-  fn('bar', 'PRE-', '-POST', function cb(err, lres) {
-    t.equal(err.message, 'makeErr-BAR-LOADED');
-    t.equal(lres, undefined);
-  });
-});
-

package/test/cb-task.test.js

@@ -1,197 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-
-var CbTask = require('../lib/cb-task.js');
-var VContext = require('../lib/vcon.js');
-
-function foo() { }
-function bar() { }
-function cat() { }
-
-test('new task is not complete', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: []});
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('ready task is not complete', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'ready'});
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('running task is not complete', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'running'});
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('complete task is complete', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
-  t.equal(task.isComplete(), true);
-  t.end();
-});
-
-test('task with any status is not ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
-  var vCon = VContext.create([], []);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false);
-  task.status = 'ready';
-  t.equal(task.isReady(vCon, tasksByName), false);
-  task.status = 'running';
-  t.equal(task.isReady(vCon, tasksByName), false);
-  task.status = null;
-  t.equal(task.isReady(vCon, tasksByName), true);
-  t.end();  
-});
-
-test('no args defined, no after -> not ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b'], out: [] });
-  var vCon = VContext.create([], []);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false);
-  t.end();
-});
-
-test('objprop undefined -> NOT ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
-  var vCon = VContext.create([1, {}], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false);
-  t.end();  
-});
-
-test('all args defined, no after, out no obj parent -> NOT ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d.e'] });
-  var vCon = VContext.create([1, null], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
-  t.end();  
-});
-
-test('all args defined, no after, out no obj.par.par -> NOT ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
-  var vCon = VContext.create([1, { }], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
-  t.end();  
-});
-
-test('all args defined, no after, out null obj parent -> NOT ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e'] });
-  var vCon = VContext.create([1, null], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
-  t.end();  
-});
-
-test('all args defined, no after, out null obj.par.par -> NOT ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
-  var vCon = VContext.create([1, { e: null }], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
-  t.end();  
-});
-
-test('all args defined, no after -> ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d'] });
-  var vCon = VContext.create([1, null], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), true);
-  t.end();  
-});
-
-test('all args defined, objprop null, no after -> ready', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
-  var vCon = VContext.create([1, { prop: null }], ['b', 'c']);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), true);
-  t.end();  
-});
-
-test('all args defined, after not complete -> NOT ready', function (t) {
-  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
-  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'running' });
-  var task = new CbTask(
-    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
-  var vCon = VContext.create([1, 2], ['b', 'c']);
-  var tasksByName = { foo: task, bar: tbar, cat: tcat };
-  t.equal(task.isReady(vCon, tasksByName), false);  
-  t.end();  
-});
-
-test('all args defined, after all complete -> ready', function (t) {
-  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
-  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'complete' });
-  var task = new CbTask(
-    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
-  var vCon = VContext.create([1, 2], ['b', 'c']);
-  var tasksByName = { foo: task, bar: tbar, cat: tcat };
-  t.equal(task.isReady(vCon, tasksByName), true);  
-  t.end();  
-});
-
-test('string without . is not method call', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
-  t.equal(task.isMethodCall(), false);
-  task.f = null;
-  t.equal(task.isMethodCall(), false);
-  t.end();
-});
-
-test('string with . is method call', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo.bar', a: [], out: [] });
-  t.equal(task.isMethodCall(), true);
-  task.f = 'foo.bar.baz';
-  t.equal(task.isMethodCall(), true);
-  t.end();
-});
-
-test('undefined or null fn - functionExists', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
-  var vCon = VContext.create([], []);
-  task.f = null;
-  t.notOk(task.functionExists(vCon));
-  task.f = undefined;
-  t.notOk(task.functionExists(vCon));
-  task.f = 'foo';
-  t.notOk(task.functionExists(vCon));
-  vCon.values.foo = { };
-  task.f = 'foo.bar';
-  t.notOk(task.functionExists(vCon));
-  t.end();
-});
-
-test('functionExists', function (t) {
-  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [] });
-  var vCon = VContext.create([], []);
-  t.ok(task.functionExists(vCon));
-  t.end();
-});
-
-test('method functionExists', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
-  var vCon = VContext.create([{b: bar}], ['foo']);
-  t.ok(task.functionExists(vCon));
-  task.f = 'foo.bar.cat';
-  vCon.values.foo = { bar: { cat: cat}};
-  t.ok(task.functionExists(vCon));
-  t.end();
-});
-
-test('getMethodObj non-existent return undefined', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo.b.c', a: [], out: [] });
-  var vCon = VContext.create([{}], ['foo']);
-  t.equal(task.getMethodObj(vCon), undefined);
-  t.end();
-});
-
-test('getMethodObj returns object', function (t) {
-  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
-  var vCon = VContext.create([{b: bar}], ['foo']);
-  t.deepEqual(task.getMethodObj(vCon), { b: bar});
-  t.end();
-});
-

package/test/core-deferred.test.js

@@ -1,134 +0,0 @@
-'use strict';
-
-/**
-   Test core PromiseTasks using Deferred - jquery style promises
-  */
-
-
-var test = require('tap').test;
-var Deferred = require('Deferred');
-//var when = Deferred.when;
-
-
-var react = require('../');  //require('react');
-
-function multiply(x, y) {
-  var deferred = new Deferred();
-  setTimeout(function () {
-    deferred.resolve(x * y);
-  }, 10);
-  return deferred.promise();
-}
-function add(x, y) {
-  var deferred = new Deferred();
-  setTimeout(function () {
-    deferred.resolve(x + y);
-  }, 10);
-  return deferred.promise();
-}
-
-function badFunc(a, b) {
-  throw new Error('badFuncThrow');
-}
-
-function badF2(a, b) {
-  var deferred = new Deferred();
-  setTimeout(function () {
-    deferred.reject(new Error('my-error'));
-  }, 10);
-  return deferred.promise();
-}
-
-
-test('multi-step', function (t) {
-  t.plan(4);
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: ['a', 'b'],
-    tasks: [    
-      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
-      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
-    ],
-    outTask: { a: ['c', 'd'] }
-  });
-  t.deepEqual(errors, [], 'no validation errors');
-
-  fn(2, 3, function (err, c, d) {
-    t.equal(err, null);
-    t.equal(c, 6);
-    t.equal(d, 9);
-    t.end();
-  });
-});  
-
-test('using "this" in a cb function', function (t) {
-  t.plan(3);
-  function getA(cb) {
-    /*jshint validthis: true */
-    var deferred = new Deferred();
-    var self = this;
-    setTimeout(function () {
-      deferred.resolve(self.a);
-    }, 10);
-    return deferred.promise();
-  }
-  
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: [],
-    tasks: [    
-      { f: getA, a: [], out: ['a'], type: 'promise' }
-    ],
-    outTask: { a: ['a'] }
-  });
-  t.deepEqual(errors, [], 'no validation errors');
-
-  var obj = {
-      a: 100
-  };
-
-  fn.apply(obj, [function (err, a) {
-    t.equal(err, null);
-    t.equal(a, 100);
-    t.end();
-  }]);
-});
-
-
-test('throws error', function (t) {
-  t.plan(2);
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: ['a', 'b'],
-    tasks: [    
-      { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
-      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
-    ],
-    outTask: { a: ['c', 'd'] }
-  });
-  t.deepEqual(errors, [], 'no validation errors');
-
-  fn(2, 3, function (err, c, d) {
-    t.equal(err.message, 'badFuncThrow');
-    t.end();
-  });
-});
-
-test('rejects with error', function (t) {
-  t.plan(2);
-  var fn = react();
-  var errors = fn.setAndValidateAST({
-    inParams: ['a', 'b'],
-    tasks: [    
-      { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
-      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
-    ],
-    outTask: { a: ['c', 'd'] }
-  });
-  t.deepEqual(errors, [], 'no validation errors');
-
-  fn(2, 3, function (err, c, d) {
-    t.equal(err.message, 'my-error');
-    t.end();
-  });
-});