react 0.0.3 → 0.1.2

package/oldExamples/example14.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var react = require('react');
+
+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 fn = react(function (r, filename, uid, outDirname, cb) {
+  var err, user, html, bytesWritten;
+  r.sync(loadUser).in(uid).out(err, user)
+    .cb(err, html, user, bytesWritten);
+});
+
+
+/*
+var r = react();
+    r.ast.inputNames = ['filename', 'uid', 'outDirname', 'cb'];
+    r.ast.taskDefs = [
+      { f:loadUser,          a:['uid'],               cb:['user'] },
+      { f:loadFile,          a:['filename'],          cb:['filedata'] },
+      { f:markdown,          a:['filedata'],          ret:['html'] },
+      { f:prepareDirectory,  a:['outDirname'],        cb:['dircreated'] },
+      { f:writeOutput,       a:['html', 'user'],      cb:['bytesWritten'],   after:['prepareDirectory'] },
+      { f:loadEmailTemplate, a:[],                    cb:['emailmd'] },
+      { f:markdown,          a:['emailmd'],           ret:['emailHtml'] },
+      { f:customizeEmail,    a:['user', 'emailHtml'], ret:['custEmailHtml'] },
+      { f:deliverEmail,      a:['custEmailHtml'],     cb:['deliveredEmail'], after:['writeOutput'] }
+    ];
+    r.ast.finalOutputNames = ['html', 'user', 'bytesWritten'];
+*/
+
+var fn = react(function (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);
+});
+  
+              

package/oldExamples/example15.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var react = require('react');
+
+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 fn = react(function (r, filename, uid, outDirname, cb) {
+  var err, user, html, bytesWritten;
+  r.sync(loadUser).in(uid).out(err, user)
+    .cb(err, html, user, bytesWritten);
+});
+
+
+/*
+var r = react();
+    r.ast.inputNames = ['filename', 'uid', 'outDirname', 'cb'];
+    r.ast.taskDefs = [
+      { f:loadUser,          a:['uid'],               cb:['user'] },
+      { f:loadFile,          a:['filename'],          cb:['filedata'] },
+      { f:markdown,          a:['filedata'],          ret:['html'] },
+      { f:prepareDirectory,  a:['outDirname'],        cb:['dircreated'] },
+      { f:writeOutput,       a:['html', 'user'],      cb:['bytesWritten'],   after:['prepareDirectory'] },
+      { f:loadEmailTemplate, a:[],                    cb:['emailmd'] },
+      { f:markdown,          a:['emailmd'],           ret:['emailHtml'] },
+      { f:customizeEmail,    a:['user', 'emailHtml'], ret:['custEmailHtml'] },
+      { f:deliverEmail,      a:['custEmailHtml'],     cb:['deliveredEmail'], after:['writeOutput'] }
+    ];
+    r.ast.finalOutputNames = ['html', 'user', 'bytesWritten'];
+*/
+
+var fn = react(function (R, filename, uid, outDirname, cb) {
+
+  //local vars used
+  var filedata = R.var();
+  var outDirName = R.var();
+  var dircreated = R.var();
+  var emailmd = R.var();
+  var emailHtml = R.var();
+  var custEmailHtml = R.var();
+  var deliveredEmail = R.var();
+  var err = R.var();
+  var user = R.var();
+  var html = R.var();
+  var bytesWritten = R.var();
+  
+  R.out(err, html, user, bytesWritten)
+    .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);
+});
+  
+              

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.1.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 = core;
+module.exports.options = core.options;
+module.exports.events = core.events;   // top level emitter
+
+// 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);
+  });
+});
+