react 0.0.0-f77c7b9d7 → 0.1.2

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;

package/lib/core.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var EventEmitter = require('events').EventEmitter;
+
+var error = require('./error.js');
+var validate = require('./validate.js');
+var tskutil = require('./task.js');
+var STATUS = require('./status.js');
+var VContext = require('./vcon.js');
+var FinalCbTask = require('./finalcb-task.js');
+var EventManager = require('./event-manager.js');
+var inputParser = require('./input-parser.js');
+var idGenerator = require('./id.js');
+
+var reactOptions = {
+  stackTraceLimitMin: 30  
+};
+
+var reactEmitter = EventManager.create(); // the top emitter
+
+/**
+   Creates react function which the AST can be manipulated and then
+   is ready to be executed. Can be used directly or a DSL can wrap this
+   to provide the AST.
+
+   @example
+   var react = require('react');
+   var fn = react();
+   var valid2 = fn.setAndValidateAST({
+     name: 'optionalName',
+     inParams: ['a', 'b'],
+     tasks: [
+      { type: 'cb', f: multiply, a: ['a', 'b'], out: ['c'] }
+     ],
+    outTask: { a: ['c'] }
+   });
+   console.log(fn.ast); // view
+   fn(123, 456, cb);
+ */
+function reactFactory() {
+  if (arguments.length) throw new Error('react() takes no args, check API');
+  
+  error.ensureStackTraceLimitSet(reactOptions.stackTraceLimitMin);
+  var flowEmitter = EventManager.create();
+  flowEmitter.parent = reactEmitter;
+
+  var ast = {
+    inParams: [],
+    tasks: [],
+    outTask: {},
+    locals: {}
+  };
+
+  function setAndValidateAST(newAST) { //set AST then validate, ret error[]
+    Object.keys(newAST).forEach(function (k) { ast[k] = newAST[k]; }); // copy all properties
+    var errors = validate(ast);
+    if (!errors.length) tskutil.nameTasks(ast.tasks); //run this so names can be checked in ast
+    return errors;
+  }
+
+  function exec(arg1, arg2, argN, cb) { // called to execute the flow
+    var parsedInput = inputParser(Array.prototype.slice.call(arguments), ast);
+    var args = parsedInput.args;
+    var cbFinal = parsedInput.cb;
+    var extraArgs = parsedInput.extraArgs; // we'll have these if we need them
+    var vCon = VContext.create(args, ast.inParams, ast.locals); // create var ctx with in args & locals
+    var tasks = ast.tasks.map(tskutil.create);
+    var tasksByName = tskutil.nameTasks(tasks); // map names to working tasks
+    var outTask = tskutil.createOutTask(ast.outTask, cbFinal, tasks, vCon);
+    var handleError = tskutil.createErrorHandler(vCon, outTask);
+
+    function contExec() {
+      if (!outTask.f) { return; } //stop execution, we already hit an error, f was cleared
+      if (outTask.isReady()) return outTask.exec(); // all tasks done, exec cb, return
+      tskutil.findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec);  //exec tasks that ready to run
+    }
+    
+    tasks.forEach(function (t) {
+      t.id = idGenerator.createUniqueId();
+      t.flowEmitter = flowEmitter;
+      if (t.type === 'cb') t.cbFun = tskutil.createCallback(t, handleError, vCon, contExec, flowEmitter);
+    }); // create callbacks
+    contExec();   // start things off
+  }
+
+  var reactFn = exec;        // make the exec() the function returned
+  reactFn.ast  = ast;        // put AST hanging off the fn so it can be inspected
+  reactFn.setAndValidateAST = setAndValidateAST;   // call to set AST and then validate
+  reactFn.events = flowEmitter; // used to listen to execution events for this flow
+  return reactFn;
+}
+
+module.exports = reactFactory;           // module returns reactFactory to create a react fn
+module.exports.options = reactOptions;   // global react options
+module.exports.events = reactEmitter;    // global react emitter