react 0.6.3 → 0.9.0-rc1

package/lib/eventemitter.js

@@ -1,20 +0,0 @@
-'use strict';
-/*global define:true EventEmitter2:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['eventemitter2'], function (EventEmitterMod) {
-
-  /**
-     Abstract the details of getting an EventEmitter
-    */
-
-  // EventEmitter doesn't return itself in browser so need to get the global
-  // EventEmitter api changed, so accomodate which ever version is available
-  var EventEmitter = (EventEmitterMod) ?
-    ((EventEmitterMod.EventEmitter2) ? EventEmitterMod.EventEmitter2 : EventEmitterMod) : EventEmitter2;
-  return EventEmitter;
-  
-});  

package/lib/finalcb-first-task.js

@@ -1,68 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./sprintf', 'util', './status', './vcon', './event-manager'],
-       function (sprintf, util, STATUS, VContext, EventManager) {
-
-  var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
-
-  function FinalCbFirstSuccTask(outTaskOptions) {
-      var taskDef = outTaskOptions.taskDef;
-    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
-    var self = this;
-    for (var k in taskDef) {
-      if (true) self[k] = taskDef[k];  // if to make jshint happy
-    }
-    this.f = outTaskOptions.cbFunc;
-    this.tasks = outTaskOptions.tasks;
-    this.vCon = outTaskOptions.vCon;
-    this.retValue = outTaskOptions.retValue;
-    this.env = outTaskOptions.env;
-  }
-
-  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;
-  };
-
-  /**
-     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.env.error = err;
-      this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_ERRORED, this.env);
-      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.env.results = finalArgs;
-      this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_COMPLETE, this.env);
-      this.f.apply(null, finalArgs);
-    }
-    this.f = null;   // prevent multiple calls
-  };
-
-  return FinalCbFirstSuccTask;
-
-});  

package/lib/finalcb-task.js

@@ -1,65 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./sprintf', 'util', './status', './event-manager'],
-       function (sprintf, util, STATUS, EventManager) {
-
-  var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
-
-  function FinalCbTask(outTaskOptions) {
-      var taskDef = outTaskOptions.taskDef;
-    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
-    var self = this;
-    for (var k in taskDef) {
-      if (true) self[k] = taskDef[k];  // if to make jshint happy
-    }
-    this.f = outTaskOptions.cbFunc;
-    this.tasks = outTaskOptions.tasks;
-    this.vCon = outTaskOptions.vCon;
-    this.retValue = outTaskOptions.retValue;
-    this.execOptions = outTaskOptions.execOptions;
-    this.env = outTaskOptions.env;
-  }
-
-  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.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.env.error = err;
-      this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_ERRORED, this.env);
-      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.env.results = finalArgs;
-      this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_COMPLETE, this.env);
-      this.f.apply(null, finalArgs);
-    }
-    this.f = null;   // prevent multiple calls
-  };
-
-  return FinalCbTask;
-
-});  

package/lib/id.js

@@ -1,22 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-  
-  var startingId = 0;
-
-  function createUniqueId() {
-    startingId += 1;
-    if (startingId === Number.MAX_VALUE) startingId = 0; // if hits this start over //TODO need something better?
-    return startingId;
-  }
-
-  return {
-    createUniqueId: createUniqueId
-  };
-
-});  

package/lib/input-parser.js

@@ -1,56 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./event-manager'], function (EventManager) {
-
-  var defaultExecOptions = {
-    reactExecOptions: true,
-    outputStyle: 'cb',
-  };
-
-    var OUTPUT_STYLES = {
-      CALLBACK: 'cb',
-      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.outputStyle) parsedInput.options.outputStyle = splitResult.outputStyle;
-    if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;
-    EventManager.global.emit(EventManager.TYPES.EXEC_INPUT_PREPROCESS, parsedInput);  // hook
-    return parsedInput;
-  }
-
-
-  inputParser.defaultExecOptions = defaultExecOptions;
-  return inputParser;
-
-});  

package/lib/log-events.js

@@ -1,101 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util'], function (util) { // TODO replace util.inspect with something portable to browser
-
-  var logEventsMod = { };
-
-  /**
-     Log events to console.error
-
-     @example
-     var react = require('react');
-     react.logEvents(); // log all task and flow events on all react functions
-     react.logEvents('task.*'); // log all task events on all react functions
-     react.logEvents(flowFn); // log all task and flow events on flowFn only
-     react.logEvents(flowFn, 'flow.*'); // log all flow events on flowFn only
-    */
-
-  var ALL_FLOW_EVENTS = 'flow.*';
-  var ALL_TASK_EVENTS = 'task.*';
-  var FLOW_RE = /^flow\./;
-
-  function flowLog(obj) {
-    /*jshint validthis: true */
-    var time = new Date();
-    time.setTime(obj.startTime);
-    var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
-    var eventTimeStr = time.toISOString();
-    if (this.event === 'flow.complete') {
-      var env = obj;
-      console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
-                    this.event, env.name, env.elapsedTime, util.inspect(argsNoCb), util.inspect(env.results));
-    } else {
-      var name = obj.name;
-      var args = obj.args;
-      console.error('%s: %s \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
-    }
-  }
-
-  function taskLog(obj) {
-    /*jshint validthis: true */
-    var time = new Date();
-    time.setTime(obj.startTime);
-    var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
-    var eventTimeStr = time.toISOString();
-    if (this.event === 'task.complete') {
-      var task = obj;
-      console.error('%s: %s:%s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
-                    this.event, task.env.name, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
-    } else {
-      var name = obj.name;
-      var args = obj.args;
-      console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.name, util.inspect(argsNoCb));
-    }
-
-  }
-
-  /**
-     Log flow and task events for a flowFn or all of react.
-     If called multiple times, remove previous listener (if any) before
-     adding.
-
-     @example
-     var react = require('react');
-     react.logEvents(flowFn, eventWildcard); //log events on flowfn matching wildcard
-
-     @param flowFn Flow function or global react object
-     @param eventWildcard wildcarded event type, if not provided use flow.* and task.*
-  */
-  function logEvents(flowFn, eventWildcard) {
-    if (!flowFn) throw new Error('flowFn is required');
-    if (!flowFn.events._loggingEvents) flowFn.events._loggingEvents = [];
-    if (eventWildcard === false) { // turn off logging
-      flowFn.events._loggingEvents.forEach(function (evt) {
-        flowFn.events.removeAllListeners(evt);
-      });
-      flowFn.events._loggingEvents.length = 0; // clear
-    } else if (eventWildcard && eventWildcard !== '*') {
-      var logFn = (FLOW_RE.test(eventWildcard)) ? flowLog : taskLog;
-      flowFn.events.removeListener(eventWildcard, logFn);
-      flowFn.events.on(eventWildcard, logFn);
-      flowFn.events._loggingEvents.push(eventWildcard);
-    } else { // none provided, use flow.* and task.*
-      //output events as tasks start and complete
-      flowFn.events.removeListener(ALL_FLOW_EVENTS, flowLog);
-      flowFn.events.on(ALL_FLOW_EVENTS, flowLog);
-      flowFn.events._loggingEvents.push(ALL_FLOW_EVENTS);
-      flowFn.events.removeListener(ALL_TASK_EVENTS, taskLog);
-      flowFn.events.on(ALL_TASK_EVENTS, taskLog);
-      flowFn.events._loggingEvents.push(ALL_TASK_EVENTS);
-    }
-  }
-
-  logEventsMod.logEvents = logEvents;
-  return logEventsMod;
-
-});

package/lib/parse.js

@@ -1,41 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./sprintf'], function (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
-  }
-
-  /**
-     @param patternFn regex + fn or splitStr + fn
-  */
-  function parseReduce(accum, patternFn) {
-    if (typeof(accum) !== 'string') return accum; // already matched
-    var m = (patternFn.regex) ? patternFn.regex.exec(accum) : accum.split(patternFn.splitStr);
-    if (m) return patternFn.fn(m, accum); // pass in matches and origStr, 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));
-    }  
-  }
-
-  return {
-    splitTrimFilterArgs: splitTrimFilterArgs,
-    parseStr: parseStr
-  };
-
-});  

package/lib/promise-resolve.js

@@ -1,50 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-
-  /**
-     Auto resolve promises passed in as arguments to the flow
-
-     - Detects promises by checking for .then()
-     - Create promise name for param (param__promise)
-     - moves existing vCon promise into the param__promise
-     - creates WhenTask which resolves param__promise into param
-  */
-
-
-    var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
-
-    var resolvingPromises = false;
-
-  function resolvePromises(react) {
-    if (resolvingPromises) return; // already resolving
-    resolvingPromises = true;
-
-    react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (env) {
-      var vConValues = env.vCon.values;
-      var promiseParams = env.ast.inParams.filter(function (p) {
-        var value = vConValues[p];
-        return (value && typeof(value.then) === 'function');
-      });
-      promiseParams.forEach(function (p) {
-        var promiseName = p + PROMISE_SUFFIX;
-        vConValues[promiseName] = vConValues[p];
-        vConValues[p] = undefined;
-        env.taskDefs.push({
-          type: 'when',
-          a: [promiseName],
-          out: [p]
-        });
-      });
-    });
-
-  }
-
-  return resolvePromises;
-
-});  

package/lib/promise-task.js

@@ -1,93 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
-
-  /**
-     PromiseTask is a task which executes a fn that returns a promise
-     and when it completes it sets the values in vCon
-  */
-
-  function format_error(errmsg, obj) {
-    return sprintf('%s - %s', errmsg, util.inspect(obj));
-  }
-
-  var REQ = 'promiseTask requires f, a, out';
-  var FN_REQ = 'promiseTask requires f to be a function or string';
-  var A_REQ = 'promiseTask requires a to be an array of string param names';
-  var OUT_REQ = 'promiseTask requires out to be an array[1] of string param names';
-
-  function PromiseTask(taskDef) {
-    var self = this;
-    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  }
-
-  PromiseTask.prototype = new BaseTask();
-  PromiseTask.prototype.constructor = PromiseTask;
-
-  PromiseTask.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.length <= 1 && 
-             taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
-        errors.push(format_error(OUT_REQ, taskDef));
-      }
-    }
-    return errors;
-  };
-
-  PromiseTask.prototype.prepare = function prepare(handleTaskError, vCon, contExec) {
-    var self = this;
-    this.nextFn = function (arg) {
-      var args = Array.prototype.slice.call(arguments);
-      vCon.saveResults(self.out, args);
-      self.complete(args);
-      contExec();
-    };
-    this.failFn = function (err) {
-      handleTaskError(self, err);
-    };
-  };
-
-  PromiseTask.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('PromiseTask.exec.args=', args);
-      //console.error('PromiseTask.exec.vCon=', vCon);
-      this.start(args); //note the start time, args
-      var func = this.f;
-      var bindObj = vCon.getVar('this'); //global space or the original this
-      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
-      }
-      var retValue = func.apply(bindObj, args);
-      if (retValue && typeof(retValue.then) === 'function') { // is a promise
-        retValue.then(this.nextFn, this.failFn);
-      } else { // just a value, proceed now
-        this.nextFn(retValue);
-      }
-    } catch (err) { //catch and handle the task error, calling final cb
-      handleError(this, err);
-    }    
-  };
-
-  return PromiseTask;
-
-});