react 0.0.2 → 0.2.1

package/examples/default-events1.js

@@ -0,0 +1,52 @@
+'use strict';
+/*jshint white: false */
+
+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('loadAndSave', 'filename, uid, outDirname, cb -> err, html, user, bytesWritten',  // name, in/out params
+  loadUser,         'uid, cb          -> err, user',     // calling async fn loadUser with uid, callback is called with err and user
+  loadFile,         'filename, cb     -> err, filedata',
+  markdown,         'filedata         -> html',    // using a sync function
+  prepareDirectory, 'outDirname, cb   -> err, dircreated',
+  writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
+  loadEmailTemplate, 'cb              -> err, emailmd',
+  markdown,         'emailmd          -> emailHtml',   // using a sync function
+  customizeEmail,   'user, emailHtml, cb -> err, custEmailHtml',
+  deliverEmail,     'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
+); 
+
+loadAndSave('file.md', 100, '/tmp/foo', useHtml);  // executing the flow
+
+

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, cb          -> err, user',     // calling async loadUser with uid, cb called with err and user
+  loadFile,         'filename, cb     -> err, filedata',
+  markdown,         'filedata         -> html',    // using a sync function
+  prepareDirectory, 'outDirname, cb   -> err, dircreated',
+  writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
+  loadEmailTemplate, 'cb              -> err, emailmd',
+  markdown,         'emailmd          -> emailHtml',   // using a sync function
+  customizeEmail,   'user, emailHtml, cb  -> custEmailHtml',
+  deliverEmail,     'custEmailHtml, cb    -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
+);
+
+//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;