react 0.0.1 → 0.2.0

package/lib/validate.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+var array = require('ensure-array');
+var tutil = require('./task.js');
+
+var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
+var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
+var TASKS_ARR = 'ast.tasks must be an array of tasks';
+var NAMES_UNIQUE = 'ast.tasks that specify name need to be unique, duplicate:';
+var LOCALS_NOTNULL = 'ast.locals should not be null';
+var DUP_OUTPUTS = 'multiple tasks output the same param, must be unique. param';
+
+var validateInParams, validateTasks, validateOutTask, validateTaskNamesUnique;
+var validateLocals, validateOuputsUnique;
+
+function format_error(errmsg, obj) {
+  return sprintf('%s - %s', errmsg, util.inspect(obj));
+}
+
+/**
+   validate the AST return Errors
+   @example
+   var validate = require('./validate');
+   var errors = validate(ast);
+   @returns array of errors, could be empty
+  */
+function validate(ast) {
+  if (!ast || !ast.inParams || !ast.tasks || !ast.outTask) return [AST_IS_OBJECT];
+  var errors = [];
+  errors = errors.concat(validateInParams(ast.inParams));
+  errors = errors.concat(validateTasks(ast.tasks));
+  errors = errors.concat(validateTaskNamesUnique(ast.tasks));
+  errors = errors.concat(tutil.validateOutTask(ast.outTask));
+  errors = errors.concat(validateLocals(ast.locals));
+  if (errors.length === 0) { // if no errors do additional validation
+    if (ast.outTask.type !== 'finalcbFirst') errors = errors.concat(validateOuputsUnique(ast.tasks));
+    errors = errors.concat(tutil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
+  }
+  return errors;
+}
+
+/**
+   @returns array of errors, could be empty
+ */
+function validateInParams(inParams) {
+  if (!Array.isArray(inParams) ||
+      !inParams.every(function (x) { return (typeof(x) === 'string'); })) {
+    return [INPARAMS_ARR_STR];
+  }
+  return [];
+}
+
+/**
+   @returns array of errors, could be empty
+ */
+function validateTasks(tasks) {
+  if (!Array.isArray(tasks)) return [TASKS_ARR];
+  var errors = [];
+  tasks.forEach(function (t) {
+    errors = errors.concat(tutil.validate(t));
+  });
+  return errors;
+}
+
+function validateTaskNamesUnique(tasks) {
+  if (!Array.isArray(tasks)) return [];
+  var errors = [];
+  var namedTasks = tasks.filter(function (t) { return (t.name); });
+  var names = namedTasks.map(function (t) { return t.name; });
+  names.reduce(function (accum, name) {
+    if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
+    else accum[name] = true;
+    return accum;
+  }, {});                             
+  return errors;
+}
+
+function validateLocals(locals) {
+  var errors = [];
+  if (locals === null) errors.push(LOCALS_NOTNULL);
+  return errors;
+}
+
+function getOutputParams(taskDef) {
+  return array(taskDef.out); //ensure array
+}
+
+function validateOuputsUnique(taskDefs) {
+  var errors = [];
+  taskDefs.reduce(function (accum, t) {
+    getOutputParams(t).forEach(function (param) {
+      if (accum[param] !== undefined) errors.push(sprintf('%s: %s', DUP_OUTPUTS, param));
+      else accum[param] = true;
+    });
+    return accum;
+  }, {});
+  return errors;
+}
+
+module.exports = validate;

package/lib/vcon.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var LAST_RESULTS_KEY = ':LAST_RESULTS';
+
+function VContext() {
+}
+
+VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
+VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
+
+VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
+  var vConValues = this.values;
+  if (typeof(name) !== 'string') return name; // literal boolean or number
+  name = name.trim();
+  if (name === 'true') return true;
+  if (name === 'false') return false;
+  if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
+  if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
+  var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
+  if (m) return m[2]; // if is quoted str, return inside of the quotes
+  var nameAndProps = name.split('.');
+  return nameAndProps.reduce(function (accObj, prop) {
+    if (accObj === undefined || accObj === null) return undefined; // prevent exception
+    return accObj[prop];
+  }, vConValues);   // vCon['foo']['bar']
+};
+
+/**
+   Saves all the results from a task as a unit, also sets special
+   variable :LAST_RESULTS which keeps an array of the last values
+   which can be used for chaining and testing last results, etc.
+  */
+VContext.prototype.saveResults = function(paramArr, valuesArr) { // set values for params
+  var self = this;
+  paramArr.forEach(function (k, idx) { //save values to v context
+    self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
+  });
+  this.setLastResults(valuesArr);
+}
+
+VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
+  if (!name) return;  // if name is undefined or null, then discard
+  var vConValues = this.values;
+  var nameAndProps = name.split('.');
+  var lastProp = nameAndProps.pop();
+  var obj = nameAndProps.reduce(function (accObj, prop) {
+    var o = accObj[prop];
+    if (o === undefined || o === null) {  // if doesn't exist create it
+      o = accObj[prop] = { };
+    }
+    return o;
+  }, vConValues);   // vCon['foo']['bar']
+  obj[lastProp] = value;
+};
+  
+
+/**
+   Create Variable Context using arguments passed in.
+   Ignore extra arguments passed in. Locals can be
+   passed into seed the VContext otherwise empty {}
+   will be used
+ */
+VContext.create = function (args, inParams, locals) {
+  var initValues = {};
+  if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
+  var vContext = new VContext();
+  vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
+    var param = inParams[idx];
+    if (param) vcon[param] = x;
+    return vcon;
+  }, initValues);
+  return vContext;
+};
+
+
+module.exports = VContext;

package/oldExamples/analyze.js

@@ -0,0 +1,29 @@
+'use strict';
+
+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 analyze(fn) {
+  console.log(fn.toString());
+}
+
+var fn = analyze(function loadAndSend(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/analyze2.js

@@ -0,0 +1,29 @@
+'use strict';
+
+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 react(fn) {
+  console.log(fn.toString());
+}
+
+var fn = react(function (R, filename, uid, outDirname, cb) {
+  var filedata, outDirName, dircreated, emailmd, emailHtml,
+    custEmailHtml, deliveredEmail, err, user, html, bytesWritten;
+  R.async(loadUser).in(uid).out(err, user)
+    .async(loadFile).in(filename).out(err, filedata)
+    .sync(markdown, filedata).out(filedata)
+    .async(prepareDirectory, outDirName).out(dircreated)
+    .async(writeOutput, html, user).out(err, bytesWritten).after(prepareDirectory)
+    .async(loadEmailTemplate).out(err, emailmd)
+    .sync(markdown, emailmd).out(emailHtml)
+    .sync(customizeEmail, user, emailHtml).out(custEmailHtml)
+    .sync(deliverEmail, custEmailHtml).out(deliveredEmail).after(writeOutput)
+    .cb(err, html, user, bytesWritten);
+});

package/oldExamples/example10-dsl.js

@@ -0,0 +1,63 @@
+
+
+var reactMod = require(__dirname+'/../lib/react.js'); 
+var react = reactMod.react;
+
+var r = react('allStart, titlesFile, numQueries, numFactors, cb').define(
+    openTitlesStream, 'titlesFile         -> err, fileStream', { tasks: [
+      split,          'fileStream         -> err, lineStream',
+      filterLines,    'lineStream, numQueries -> err, filteredLineStream',
+      trimLines,      'filteredLineStream -> err, trimmedLineStream',
+      recordTime,     '                   -> returns qStart', { after: trimLines },
+      runQuery,       'trimmedLineStream, numFactors -> err, qResults', { after: recordTime },
+      calcTime,       'qStart             -> returns qTime', { after: runQuery },
+      sumTotal,       'qTime              -> returns qTotal', { reduce: true }
+    ], cb:'-> err, qTotal' },
+    calcTime,         'allStart           -> returns allElapsed', { after: openTitlesStream }
+  ).callbackDef('allElapsed, qTotal, numQueries, numFactors');
+
+
+
+//new simpler syntax
+
+var react = require('react');
+
+var loadAndSave = react('allStart, titlesFile, numQueries, numFactors, cb',
+                        foo, 'bar -> err, baz',
+                        cat, 'baz -> err, zoo',
+                        '-> err, allElapse, qTotal');
+
+var loadAndSave = react('allStart, titlesFile, numQueries, numFactors, cb', [
+                        foo, 'bar -> err, baz',
+                        cat, 'baz -> returns zoo'
+                        ], 'err, allElapse, qTotal');
+
+var loadAndSave = react('allStart, titlesFile, numQueries, numFactors, cb', [
+                        foo, 'bar => err, baz',
+                        cat, 'baz -> returns zoo'
+                        ], 'err, allElapse, qTotal');
+
+var loadAndSave = react('allStart, titlesFile, numQueries, numFactors, cb', [
+                        foo, 'bar -> err, baz',
+                        'zoo <- ', cat, 'baz',
+                        ], 'err, allElapse, qTotal');
+
+
+
+var loadAndSave = react('allStart, titlesFile, numQueries, numFactors, cb -> err, allElapse, qTotal',
+                        foo, 'bar -> err, baz',
+                        cat, 'baz -> err, zoo');
+loadAndSave(1, 2, 3, cb);
+
+OR using AST
+
+var loadAndSave = react();
+loadAndSave.ast.inputs(['one', 'two'])
+   .tasks({ })
+   .outTask({ });
+
+loadAndSave(1,2,cb);
+
+
+
+

package/oldExamples/example11.js

@@ -0,0 +1,62 @@
+'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) {
+  var filedata, outDirName, dircreated, emailmd, emailHtml, custEmailHtml, deliveredEmail;
+  var err, user, html, bytesWritten;
+  
+  r.async(loadUser).in(uid).out(err, user)
+    .async(loadFile).in(filename).out(filedata)
+    .sync(markdown).in(filedata).out(html)
+    .async(prepareDirectory).in(outDirName).out(dircreated)
+    .async(writeOutput).in(html, user).out(bytesWritten).after(prepareDirectory)
+    .async(loadEmailTemplate).out(emailmd)
+    .sync(markdown).in(emailmd).out(emailHtml)
+    .sync(customizeEmail).in(user, emailHtml).out(custEmailHtml)
+    .async(deliveredEmail).in(custEmailHtml).out(deliveredEmail).after(writeOutput)
+    .cb(err, html, user, bytesWritten);
+});

package/oldExamples/example12.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 (r, filename, uid, outDirname, cb,
+                         filedata, outDirName, dircreated, emailmd, emailHtml,
+                         custEmailHtml, deliveredEmail,
+                         err, user, html, bytesWritten) {
+
+  r.async(loadUser, [uid], [err, user])
+    .async(loadFile, [filename], [filedata])
+    .sync(markdown, [filedata], filedata)
+    .async(prepareDirectory, [outDirName], [dircreated])
+    .async(writeOutput, [html, user], [err, bytesWritten], { after: prepareDirectory })
+    .async(loadEmailTemplate, [], [emailmd])
+    .sync(markdown, [emailmd], emailHtml)
+    .sync(customizeEmail, [user, emailHtml], custEmailHtml)
+    .sync(deliverEmail, [custEmailHtml], [deliveredEmail], { after: writeOutput })
+    .cb(err, html, user, bytesWritten);
+});

package/oldExamples/example13.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 (r, filename, uid, outDirname, cb,
+                         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);
+});