react 0.0.3 → 0.2.2

package/oldExamples/function-str-ex1.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var react = require('react');
+var CB = react.cb;
+var CBV = react.cbv;
+
+function loadMdFile(file, cb) {
+  var data = file + '-data';
+  setTimeout(function () { cb(null, data); }, 100); //similate file load
+}
+
+function mergeIntoHtml(data, cb) {
+  var html = data + '-html';
+  setTimeout(function () { cb(null, html); }, 100); //simulate templ load
+}
+
+function sendHtml(html, cb) {
+  var bytes = html.length;
+  setTimeout(function () { cb(null, bytes); }, 100); //simulate write
+}
+
+var loadAndSave = react(function defineFromSource(file, cb) {
+  loadMdFile(file, CB);
+  var data = CBV();
+
+  mergeIntoHtml(data, CB);
+  var html = CBV();
+
+  sendHtml(html, CB);
+  var bytes = CBV();
+
+  cb(null, file, bytes);
+});

package/oldExamples/function-str-ex2.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var react = require('react');
+var CB = react.cb;
+var CBV = react.cbv;
+var WAIT = react.wait;
+
+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 r = react('filename, uid, outDirname, cb').define(
+    loadUser,         'uid              -> err, user',
+    loadFile,         'filename         -> err, filedata',
+    markdown,         'filedata         -> returns html',
+    prepareDirectory, 'outDirname       -> err, dircreated', 
+    writeOutput,      'html, user       -> err, bytesWritten', { after:prepareDirectory },
+    loadEmailTemplate,'                 -> err, emailmd',
+    markdown,         'emailmd          -> returns emailHtml',
+    customizeEmail,   'user, emailHtml  -> returns custEmailHtml',
+    deliverEmail,     'custEmailHtml    -> err, deliveredEmail', { after: writeOutput }
+).callbackDef('err, html, user, bytesWritten');
+
+var loadAndDeliver = react(
+  function defineFromSource(filename, uid, outDirname, cb) {
+    loadUser(uid, CB);
+    var user = CBV();
+
+    loadFile(filename, CB);
+    var filedata = CBV();
+
+    var html = markdown(filedata);
+
+    prepareDirectory(outDirname, CB);
+    var dircreated = CBV();
+
+    WAIT(prepareDirectory);
+    writeOutput(html, user, CB);
+    var bytesWritten = CBV();
+
+    loadEmailTemplate(CB);
+    var emailmd = CBV();
+
+    var emailHtml = markdown(emailmd);
+
+    var custEmailHtml = customizeEmail(user, emailHtml);
+    
+    deliverEmail(custEmailHtml, CB);
+    var deliveredEmail = CBV();
+
+    cb(null, html, user, bytesWritten);
+  }
+);

package/oldExamples/trait1.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var trait = require('light-traits').Trait;
+
+var tTaskMethods = trait({
+  ready: trait.required,
+  isReady: function(){ return this.ready; },
+  exec: function(){ console.log('exec'); },
+  toString: function(){ return 'taskMethods'; },
+  matches: function (taskDef) { return (/foo/.test(taskDef.name)) }
+});
+
+var tDebugOutput = trait({
+  isReady: trait.required,
+  //toStringTaskMethods: trait.required,
+  toString: function(){ return "trait: ready: "+this.isReady() /* +
+                        ' taskMethods: '+this.toStringTaskMethods();*/
+                      }
+});
+
+var tTask = trait.compose(
+//    tTaskMethods.resolve({ toString: 'toStringTaskMethods' }),
+    tTaskMethods.resolve({ toString: null }),
+    tDebugOutput
+);
+
+function taskFactory(ready){
+  return tTask.create({ ready: ready });
+}
+
+var t = taskFactory(true);
+console.log(t.toString());
+
+if (t.isReady()) {
+  t.exec();
+}
+
+console.log('foo', tTaskMethods.matches.value({ name: 'foo'}));
+console.log('bar', tTaskMethods.matches.value({ name: 'bar'}));
+
+console.log(tTask);

package/oldExamples/trait2.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var trait = require('traits').Trait;
+
+
+
+
+var tTaskMethods = trait({
+  ready: trait.required,
+  isReady: function(){ return this.ready; },
+  exec: function(){ console.log('exec'); },
+  toString: function(){ return 'taskMethods'; }
+});
+
+var tDebugOutput = trait({
+  isReady: trait.required,
+  toString: function(){ return "trait: ready: "+this.isReady(); }
+});
+
+function Foo() {
+}
+
+Foo.prototype = { };
+Foo.prototype.constructor = Foo;
+Foo.prototype.greet = function(){ console.log('hello'); };
+
+function taskFactory(ready){
+  return Object.create(Foo.prototype, trait.compose(
+    tTaskMethods,
+    tDebugOutput,
+    trait({ ready: ready })
+  ));
+}
+
+
+
+var t = taskFactory(true);
+console.log(t.toString());
+
+if (t.isReady()) {
+  t.exec();
+}
+
+t.greet();

package/package.json

@@ -1,13 +1,23 @@
 {
   "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.0.3",
+  "version": "0.2.2",
   "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" }, 
+  "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
+  "bugs" : { "url": "http://github.com/jeffbski/react/issues" },
   "licenses": [{ "type": "MIT", "url" : "http://github.com/jeffbski/react/raw/master/LICENSE" }],
   "main": "react",
-  "engines": { "node": "~v0.4.12" },
-  "dependencies": {},
-  "devDependencies": {}
+  "engines": { "node": "*" },
+  "dependencies": {
+    "eventemitter2": "~0.4.1",
+    "sprintf": "~0.1.1",
+    "ensure-array": "~0.0.2"
+  },
+  "devDependencies": {
+    "tap" : "~0.1.0",
+    "tapr" : "~0.1.0"
+  },
+  "scripts": {
+    "test": "node_modules/.bin/tapr test"
+  }
 }

package/react.js

@@ -1,2 +1,12 @@
+'use strict';
 
-module.exports = require('./lib/react');
+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
+
+// additional interfaces
+module.exports.fstrDefine = require('./lib/fstr.js');
+module.exports.pcodeDefine = require('./lib/pcode.js');
+module.exports.chainDefine = require('./lib/chain.js');

package/test/ast.test.js

@@ -0,0 +1,69 @@
+'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

@@ -0,0 +1,197 @@
+'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();
+});
+