react 0.0.1 → 0.2.0

package/examples/default1.js

@@ -0,0 +1,40 @@
+'use strict';
+/*jshint white: false */
+
+var react = require('../'); // 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);
+}
+
+// define fn, glue together with react, it will parallelize
+// starts with name and in/out params, then the tasks
+var loadAndSave = react('loadAndSave', 'fName, uid, outDir, cb -> err, html, user, bytes',  
+  loadUser,         'uid              -> err, user',     // calling async loadUser with uid, cb 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
+);   // callback output params
+
+//in another module you can use this as any other exported fn
+loadAndSave('file.md', 100, '/tmp/foo', useHtml);  // executing the flow
+
+

package/examples/fstr-events1.js

@@ -0,0 +1,51 @@
+'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/fstr1.js

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

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

@@ -0,0 +1,64 @@
+
+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/base-task.js

@@ -0,0 +1,115 @@
+'use strict';
+
+var array = require('ensure-array');
+var STATUS = require('./status.js');
+var EventManager = require('./event-manager.js');
+
+function BaseTask() {
+}
+
+/**
+   Getter Fn to retrieveAn array of the output param names for this task.
+  */
+BaseTask.prototype.getOutParams = function () {
+  return array(this.out); // ensure array
+};
+
+BaseTask.prototype.isComplete = function () {
+  return (this.status === STATUS.COMPLETE);
+};
+
+BaseTask.prototype.start = function (args) { // mark task as started with args and note time
+  this.args = args;
+  this.startTime = Date.now();
+  if (this.flowEmitter) this.flowEmitter.emitObject(EventManager.TYPES.TASK_BEGIN, this);
+};
+
+BaseTask.prototype.complete = function (args) { //args that were used are available
+  this.results = args;  // save the results
+  this.endTime = Date.now();
+  this.elapsedTime = this.endTime - this.startTime;
+  if (this.flowEmitter) this.flowEmitter.emitObject(EventManager.TYPES.TASK_COMPLETE, this);
+  this.status = STATUS.COMPLETE;
+};
+
+BaseTask.prototype.functionExists = function (vCon) {
+  var fn = this.f;
+  if (!fn) return false;
+  if (fn instanceof Function) return true;
+  if (typeof(fn) === 'string') {
+    var f = vCon.getVar(fn);  // fn/method by string
+    if (f && f instanceof Function) return true;
+  }
+  return false;
+};
+
+BaseTask.prototype.areAllDepArgsDefined = function (vCon) {
+  return this.a.every(function (k) { return (vCon.getVar(k) !== undefined); });
+};
+
+BaseTask.prototype.depTasksAreDone = function (tasksByName) {
+  return (!this.after || !this.after.length || // no dep tasks OR
+          this.after.every(function (n) { return tasksByName[n].isComplete(); }));  //all done
+};
+
+function isObjProperty(str) { return (str.indexOf('.') !== -1); }
+
+/**
+   check that obj parent is def and not null so writing to obj.prop
+   will not fail. ex: 'b.c' checks that b is def and not null.
+   Also returns true if not obj.prop but simple var ex: 'b'.
+   Tasks will implement outParentsExist() passing each out str
+   to this if they want to do this check.
+  */
+BaseTask.prototype.parentExists = function (objPropStr, vCon) {
+  if (!isObjProperty(objPropStr)) return true; // NOT obj prop, just simple arg, ret true
+  var nameAndProps = objPropStr.split('.');
+  nameAndProps.pop(); // pop off final prop
+  var parent = nameAndProps.reduce(function (accObj, prop) {
+    if (accObj === undefined || accObj === null) return undefined; // prevent exception
+    return accObj[prop];
+  }, vCon.values);   // vCon['foo']['bar']
+  return (parent !== undefined && parent !== null);
+};
+
+/**
+   If params are obj property writes make sure the dst objects
+   are defined and not null. cb: ['b.c'] -> b is def and not null.
+   If null is specified then param is valid and will be ignored.
+   @returns true if all obj prop parents are def and non null
+  */
+BaseTask.prototype.outParentsExist = function (vCon) {
+  var self = this;
+  return this.getOutParams().every(function (x) {
+    if (x === null) return true;
+    return self.parentExists(x, vCon);
+  });
+};
+
+BaseTask.prototype.isReady = function (vCon, tasksByName) {
+  return !this.status &&                  // not started AND
+  this.functionExists(vCon) &&            // function/method exists AND
+  this.areAllDepArgsDefined(vCon) &&      // all dep vars defined AND
+  this.depTasksAreDone(tasksByName) &&    // all dep tasks are done AND
+  (!this.outParentsExist ||               // (task does not implement outParentsExist method OR
+   this.outParentsExist(vCon));          //  output parents exists (for obj property writes)
+};
+
+BaseTask.prototype.isMethodCall = function () {
+  return (typeof(this.f) === 'string' && /^.*\..*$/.test(this.f));  //str contains .
+};
+
+BaseTask.prototype.getMethodObj =  function (vCon) { //obj.prop.prop2, returns obj.prop or undefined
+  var name = this.f;
+  if (!name) return undefined;
+  var nameAndProps = name.split('.');
+  nameAndProps.pop(); // pop off last one
+  if (!nameAndProps.length) return undefined;
+  var result = nameAndProps.reduce(function (accObj, prop) {
+    if (accObj === undefined || accObj === null) return undefined; // prevent exception
+    return accObj[prop];
+  }, vCon.values); // vCon['foo']['bar']
+  return result;
+};
+
+module.exports = BaseTask;

package/lib/cb-task.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+
+var BaseTask = require('./base-task.js');
+
+function format_error(errmsg, obj) {
+  return sprintf('%s - %s', errmsg, util.inspect(obj));
+}
+
+var REQ = 'cbTask requires f, a, out';
+var FN_REQ = 'cbTask requires f to be a function or string';
+var A_REQ = 'cbTask requires a to be an array of string param names';
+var CB_REQ = 'cbTask requires out to be an array of string param names';
+
+function CbTask(taskDef) {
+  var self = this;
+  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+}
+
+CbTask.prototype = new BaseTask();
+CbTask.prototype.constructor = CbTask;
+
+CbTask.validate = function (taskDef) {
+  var errors = [];
+  if (!taskDef.f || !taskDef.a || !taskDef.out) {
+    errors.push(format_error(REQ, taskDef));
+  } else {
+    var ftype = typeof(taskDef.f);
+    if (! ((taskDef.f instanceof Function) || (ftype === 'string'))) {
+      errors.push(format_error(FN_REQ, taskDef));
+    }
+    if (! (Array.isArray(taskDef.a) &&
+           taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+      errors.push(format_error(A_REQ, taskDef));
+    }
+    if (! (Array.isArray(taskDef.out) &&
+           taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
+      errors.push(format_error(CB_REQ, taskDef));
+    }
+  }
+  return errors;
+};
+
+CbTask.prototype.exec = function exec(vCon, handleError, contExec) {
+  try {
+    var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
+    //console.error('CbTask.exec.args=', args);
+    //console.error('CbTask.exec.vCon=', vCon);
+    this.start(args); //note the start time, args
+    args.push(this.cbFun);   // push callback fn on end
+    var func = this.f;
+    var bindObj = null; //global space
+    if (this.isMethodCall()) { //if method call then reset func and bindObj
+      func = vCon.getVar(this.f);
+      bindObj = this.getMethodObj(vCon);
+    } else if (typeof(func) === 'string') {
+      func = vCon.getVar(func); // we want the actual fn from this string
+    }
+    func.apply(bindObj, args); 
+  } catch (err) { //catch and handle the task error, calling final cb
+    handleError(this, err);
+  }    
+};
+
+module.exports = CbTask;

package/lib/chain.js

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