react 0.0.2 → 0.2.1

package/lib/finalcb-first-task.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var sprintf = require('sprintf').sprintf;
+var util = require('util');
+
+var STATUS = require('./status.js');
+var VContext = require('./vcon.js');
+
+var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
+
+function FinalCbFirstSuccTask(taskDef, cbFunc, tasks, vCon) {
+  var self = this;
+  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  this.f = cbFunc;
+  this.tasks = tasks;
+  this.vCon = vCon;
+}
+
+function format_error(errmsg, obj) {
+  return sprintf('%s - %s', errmsg, util.inspect(obj));
+}
+
+FinalCbFirstSuccTask.validate = function (taskDef) {
+  var errors = [];
+  if (! (Array.isArray(taskDef.a) &&
+         taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+    errors.push(format_error(OUTTASK_A_REQ, taskDef));
+  }
+  return errors;
+}
+
+FinalCbFirstSuccTask.create = function (taskDef, cbFunc, tasks, vCon) {
+  if (!(cbFunc && cbFunc instanceof Function)) throw new Error('callback is not a function'); 
+  return new FinalCbFirstSuccTask(taskDef, cbFunc, tasks, vCon);
+};
+
+/**
+   is ready to exit when any task comes back with non-null defined value
+  */
+FinalCbFirstSuccTask.prototype.isReady = function () {
+  var lastres = this.vCon.getLastResults();
+  if (!lastres) return false; // no results yet
+  return (lastres.some(function (v) { return (v !== undefined && v !== null); }));
+};
+
+FinalCbFirstSuccTask.prototype.exec = function (err) {
+  if (!this.f) return;   //must have already been called
+  if (err) {
+    this.f.call(null, err); //call the final callback with the first error hit
+  } else { // no error, call with args
+    var vCon = this.vCon;
+    var finalArgs = this.a.map(function (k) { return vCon.getVar(k); });
+    finalArgs.unshift(null);   //unshift err=null to front
+    this.f.apply(null, finalArgs);
+  }
+  this.f = null;   // prevent multiple calls
+};
+
+module.exports = FinalCbFirstSuccTask;

package/lib/finalcb-task.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var sprintf = require('sprintf').sprintf;
+var util = require('util');
+
+var STATUS = require('./status.js');
+
+var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
+
+function FinalCbTask(taskDef, cbFunc, tasks, vCon) {
+  var self = this;
+  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
+  this.f = cbFunc;
+  this.tasks = tasks;
+  this.vCon = vCon;
+}
+
+function format_error(errmsg, obj) {
+  return sprintf('%s - %s', errmsg, util.inspect(obj));
+}
+
+
+FinalCbTask.validate = function (taskDef) {
+  var errors = [];
+  if (! (Array.isArray(taskDef.a) &&
+         taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
+    errors.push(format_error(OUTTASK_A_REQ, taskDef));
+  }
+  return errors;
+};
+
+FinalCbTask.create = function (taskDef, cbFunc, tasks, vCon) {
+  if (!(cbFunc && cbFunc instanceof Function)) throw new Error('callback is not a function'); 
+  return new FinalCbTask(taskDef, cbFunc, tasks, vCon);
+};
+
+FinalCbTask.prototype.isReady = function () {
+  return (this.tasks.every(function (t) { return (t.status === STATUS.COMPLETE); }));
+};
+
+FinalCbTask.prototype.exec = function (err) {
+  if (!this.f) return;   //must have already been called
+  if (err) {
+    this.f.call(null, err); //call the final callback with the first error hit
+  } else { // no error, call with args
+    var vCon = this.vCon;
+    var finalArgs = this.a.map(function (k) { return vCon.getVar(k); });
+    finalArgs.unshift(null);   //unshift err=null to front
+    this.f.apply(null, finalArgs);
+  }
+  this.f = null;   // prevent multiple calls
+};
+
+module.exports = FinalCbTask;

package/lib/fstr.js

@@ -0,0 +1,110 @@
+'use strict';
+
+var sprintf = require('sprintf').sprintf;
+var core = require('./core.js');
+var parse = require('./parse.js');
+var tutil = require('./task.js');
+
+var INPARAMS_NO_MATCH = 'input params in wrong format, wanted "foo, bar" -  found: %s';
+var OUTPARAMS_NO_MATCH = 'output params in wrong format, wanted "foo, bar" - found: %s';
+var INOUT_PARAMS_NO_MATCH = 'task params in wrong format, wanted "foo, bar -> err, baz" - found: %s';
+var EXTRA_TASKARG = 'extra unmatched task arg: %s';
+
+var inOutDefParse = {
+  regex: /^([^-]*)(->)?\s*(er{0,2}\s*,|returns?\s+)?(.*)$/i,
+  fn: function (m) {
+    var reMatchReturns = /returns?/i;
+    return {
+      type: (m[3] && m[3].match(reMatchReturns)) ? 'ret' : 'cb',
+      inDef: parse.splitTrimFilterArgs(m[1]),
+      outDef: parse.splitTrimFilterArgs(m[4])
+    };
+  }
+};
+
+function filterOutTrailingCbParam(args) { // if has trailing cb | callback param, filter it out
+  var cbNamesRe = /^cb|callback$/i;  //cb, Cb, CB, callback, Callback
+  if (args.length && args[args.length - 1].match(cbNamesRe)) args.pop();
+  return args;
+}
+
+function parseInParams(str) {
+  var objDef = parse.parseStr(str, [inOutDefParse], INPARAMS_NO_MATCH);
+  objDef.inDef = filterOutTrailingCbParam(objDef.inDef);
+  return objDef;
+}
+
+function parseInOutParams(str) {
+  var objDef = parse.parseStr(str, [inOutDefParse], INOUT_PARAMS_NO_MATCH);
+  objDef.inDef = filterOutTrailingCbParam(objDef.inDef);
+  return objDef;
+}
+
+function parseOutParams(str) {
+  if (str.indexOf('->') === -1) str = '-> ' + str; // prefix so does out err process
+  return parse.parseStr(str, [inOutDefParse], OUTPARAMS_NO_MATCH);
+} 
+
+function parseTasks(arr) {
+  var tasks = [];
+  var fn, obj, result;
+  while (arr.length >= 2) {
+    obj = {};
+    fn = arr.shift();
+    result = parseInOutParams(arr.shift());
+    if (typeof(arr[0]) === 'object') obj = arr.shift(); // has options, use as obj
+    obj.f = fn;
+    obj.a = result.inDef;
+    var type = result.type;
+    obj.out = result.outDef;
+    obj.type = type;
+    tasks.push(obj);
+  }
+  if (arr.length) throw new Error(sprintf(EXTRA_TASKARG, arr[0]));
+  return tasks;
+}
+
+
+function fstrDefine(inParamStr, taskDefArr, outParamStr, options) {
+  if (!inParamStr) inParamStr = '';
+  if (!taskDefArr) taskDefArr = [];
+  if (!outParamStr) outParamStr = '';
+
+  var reactFn = core();
+  var ast = {
+    inParams: parseInParams(inParamStr).inDef,
+    tasks: parseTasks(taskDefArr),
+    outTask: { a: parseOutParams(outParamStr).outDef }
+  };
+  if (options) Object.keys(options).forEach(function (k) { ast[k] = options[k]; });
+  var errors = reactFn.setAndValidateAST(ast);
+  if (errors.length) {
+    var errorStr = errors.join('\n');
+    throw new Error(errorStr);
+  }
+  return reactFn;
+}
+
+function selectFirst(inParamStr, taskDefArr, outParamStr, options) {
+  if (!inParamStr) inParamStr = '';
+  if (!taskDefArr) taskDefArr = [];
+  if (!outParamStr) outParamStr = '';
+  var tasks = tutil.serializeTasks(parseTasks(taskDefArr));
+
+  var reactFn = core();
+  var ast = {
+    inParams: parseInParams(inParamStr).inDef,
+    tasks: tasks,
+    outTask: { type: 'finalcbFirst', a: parseOutParams(outParamStr).outDef },
+  };
+  if (options) Object.keys(options).forEach(function (k) { ast[k] = options[k]; });  
+  var errors = reactFn.setAndValidateAST(ast);
+  if (errors.length) {
+    var errorStr = errors.join('\n');
+    throw new Error(errorStr);
+  }
+  return reactFn;
+}
+
+module.exports = fstrDefine;
+module.exports.selectFirst = selectFirst;

package/lib/id.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var startingId = 0;
+
+function createUniqueId() {
+  startingId += 1;
+  return startingId;
+}
+
+exports.createUniqueId = createUniqueId;

package/lib/input-parser.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var defaultExecOptions = {
+  reactExecOptions: true,
+  outputStyle: 'callback',
+};
+
+var OUTPUT_STYLES = {
+  CALLBACK: 'callback',
+  NONE: 'none'
+};
+
+function isExecOptions(x) { return (x && x.reactExecOptions); }
+function execOptionsFilter(x) { return isExecOptions(x); }
+function nonExecOptionsFilter(x) { return !isExecOptions(x); }
+function mergeExecOptions(accum, options) {
+  Object.keys(options).forEach(function (k) { accum[k] = options[k]; });
+  return accum;
+}
+
+function splitArgs(args, inParams, style) {
+  var result = { };
+  result.args = inParams.map(function (p) { return args.shift(); }); // take args for input params first
+  if (style === OUTPUT_STYLES.CALLBACK && args.length) result.cb = args.shift(); // next take the cb
+  result.extra = args; // these remaining were after the callback
+  return result;
+}
+  
+function inputParser(inputArgs, ast) {
+  var parsedInput = { };
+  var execOptionsArr = inputArgs.filter(execOptionsFilter);
+  execOptionsArr.unshift(defaultExecOptions);
+  parsedInput.options = execOptionsArr.reduce(mergeExecOptions, {});
+
+  var args = inputArgs.filter(nonExecOptionsFilter);
+  var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle); 
+  parsedInput.args = splitResult.args;
+  parsedInput.cb = splitResult.cb;
+  if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;  
+  return parsedInput;
+}
+
+module.exports = inputParser;
+module.exports.defaultExecOptions = defaultExecOptions;

package/lib/parse.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var sprintf = require('sprintf').sprintf;
+
+function splitTrimFilterArgs(commaSepArgs) { //parse 'one, two' into ['one', 'two']
+  if (!commaSepArgs) return [];
+  return commaSepArgs.split(',')            //split on commas
+    .map(function (s) { return s.trim(); }) //trim
+    .filter(function (s) { return (s); });  //filter out empty strings
+}
+
+function parseReduce(accum, regexFn) {
+  if (typeof(accum) !== 'string') return accum; // already matched
+  var m = regexFn.regex.exec(accum);
+  if (m) return regexFn.fn(m); // return result obj
+  return accum; // no match, return str, will try next matcher
+}
+
+function parseStr(str, parseMatchers, errStr) {
+  var result = parseMatchers.reduce(parseReduce, str);
+  if (typeof(result) !== 'string') { // matched
+    return result;
+  } else { // no match
+    throw new Error(sprintf(errStr, str));
+  }  
+}
+
+exports.splitTrimFilterArgs = splitTrimFilterArgs;
+exports.parseStr = parseStr;

package/lib/pcode.js

@@ -0,0 +1,164 @@
+'use strict';
+
+var sprintf = require('sprintf').sprintf;
+var core = require('./core.js');
+var parse = require('./parse.js');
+var tutil = require('./task.js');
+
+var INPARAMS_NO_MATCH = 'input params in wrong format, wanted "foo, bar, cb" -  found: %s';
+var OUTPARAMS_NO_MATCH = 'output params in wrong format, wanted "cb(err, foo)" - found: %s';
+var INOUT_PARAMS_NO_MATCH = 'task params in wrong format, wanted "foo, bar := func(baz, cat, cb) " - found: %s';
+var EXTRA_TASKARG = 'extra unmatched task arg: %s';
+
+/**
+  Examples:
+  var react = require('react');
+  
+  var locals = { falpha: falpha, fbeta: fbeta, fcharlie: fcharlie };
+  var fn = react.pcodeDefine('a, b', [
+    'd := fbeta(a, b)',
+    'e = fcharlie(a, b)',
+    'c := falpha(a, b) when fbeta:done and fcharlie:done',
+    'cb(err, c, d, e);'
+  ], locals);
+
+  function cb(err, d, e) { }
+  fn(10, 20, cb);
+ */
+
+function splitAndFilterArgs(commaSepArgs) { // split, trim, filter out empty and (cb or callback)
+  var args = parse.splitTrimFilterArgs(commaSepArgs);
+  var cbNamesRe = /^cb|callback$/i;  //cb, Cb, CB, callback, Callback
+  if (args.length && args[args.length - 1].match(cbNamesRe)) args.pop();
+  return args;
+}
+
+function extractNamesFromWhenClause(str) { //given 'foo:done and bar.baz:done' return ['foo', 'bar.baz']
+  var reSplit = /\s+and\s+/i;
+  var reDone = /^([^:]+):done$/i;
+  var names = str.split(reSplit).map(function (x) {
+    x = x.trim();
+    var m = x.match(reDone); // if foo:done, we'll use foo
+    return (m) ? m[1] : x; 
+  });
+  return names;
+}
+
+var inParse = {
+  regex: /^(.*)$/, 
+  fn: function (m) {
+    return {
+      inDef: splitAndFilterArgs(m[1]),
+    };
+  }
+};
+
+var cbParse = {
+  regex: /^\s*(var\s+)?([^:]*)\s*:=\s*([a-zA-Z0-9_\.-]+)\s*\(\s*([^)]*)\)\s*(when\s+([^;]+))?;?\s*$/,
+  fn: function (m) {
+    var taskDef = {
+      type: 'cb',
+      f: m[3],
+      inDef: (m[4]) ? splitAndFilterArgs(m[4]) : [],
+      outDef: (m[2]) ? parse.splitTrimFilterArgs(m[2]) : []
+    };
+    if (m[6]) taskDef.after = extractNamesFromWhenClause(m[6]);
+    return taskDef;
+  }
+};
+
+var retParse = {
+  regex: /^\s*(var\s+)?([^:]*)\s*=\s*([a-zA-Z0-9_\.-]+)\s*\(\s*([^)]*)\)\s*(when\s+([^;]+))?;?\s*$/,
+  fn: function (m) {
+    var taskDef = {
+      type: 'ret',
+      f: m[3],
+      inDef: (m[4]) ? splitAndFilterArgs(m[4]) : [],
+      outDef: (m[2]) ? parse.splitTrimFilterArgs(m[2]) : []
+    };
+    if (m[6]) taskDef.after = extractNamesFromWhenClause(m[6]);
+    return taskDef;
+  }
+};
+
+var finalCbParse = {
+  regex: /^\s*(cb|callback)\s*\((er{0,2}\s*,\s*)?([^)]*)\)\s*;?$/i,
+  fn: function (m) {
+    return {
+      outDef: (m[3]) ? parse.splitTrimFilterArgs(m[3]) : []
+    };
+  }
+};
+
+function parseInParams(str) {
+  return parse.parseStr(str, [inParse], INPARAMS_NO_MATCH);
+}
+
+function parseTask(str) {
+  var result = parse.parseStr(str, [cbParse, retParse], INOUT_PARAMS_NO_MATCH);
+  var type = result.type;
+  var task = {
+    f: result.f,
+    a: result.inDef
+  };
+  task.out = result.outDef;
+  task.type = type;
+  if (result.after) task.after = result.after;
+  return task;
+}
+
+function parseOutParams(str) {
+  if (!str.trim().length) return { outDef: [] };
+  return parse.parseStr(str, [finalCbParse], OUTPARAMS_NO_MATCH);
+} 
+
+function parseTasks(arr) { return arr.map(parseTask); }
+
+
+function pcodeDefine(inParamStr, taskStrArr, locals, options) {
+  if (!inParamStr) inParamStr = '';
+  if (!taskStrArr) taskStrArr = [];
+  var outTaskStr = (taskStrArr.length) ? taskStrArr.pop() : '';
+  if (!locals) locals = { };
+
+  var reactFn = core();
+  var ast = {
+    inParams: parseInParams(inParamStr).inDef,
+    tasks: parseTasks(taskStrArr),
+    outTask: { a: parseOutParams(outTaskStr).outDef },
+    locals: locals
+  };
+  if (options) Object.keys(options).forEach(function (k) { ast[k] = options[k]; });  
+  var errors = reactFn.setAndValidateAST(ast);
+  if (errors.length) {
+    var errorStr = errors.join('\n');
+    throw new Error(errorStr);
+  }
+  return reactFn;
+}
+
+function selectFirst(inParamStr, taskStrArr, locals, options) {
+  if (!inParamStr) inParamStr = '';
+  if (!taskStrArr) taskStrArr = [];
+  var outTaskStr = (taskStrArr.length) ? taskStrArr.pop() : '';
+  if (!locals) locals = { };
+  var tasks = tutil.serializeTasks(parseTasks(taskStrArr));
+  
+  var reactFn = core();
+  var ast = {
+    inParams: parseInParams(inParamStr).inDef,
+    tasks: tasks,
+    outTask: { type: 'finalcbFirst', a: parseOutParams(outTaskStr).outDef },
+    locals: locals
+  };
+  if (options) Object.keys(options).forEach(function (k) { ast[k] = options[k]; });  
+  var errors = reactFn.setAndValidateAST(ast);
+  if (errors.length) {
+    var errorStr = errors.join('\n');
+    throw new Error(errorStr);
+  }
+  return reactFn;
+}
+
+module.exports = pcodeDefine;
+module.exports.selectFirst = selectFirst;