react 0.6.3 → 0.9.0-rc1

package/lib/react.js

@@ -1,59 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['./core', './dsl', './track-tasks', './log-events', './promise-resolve', './event-collector'],
-       function (core, dsl, trackTasksFn, logEventsMod, resolvePromisesFn, eventCollectorFactory) {
-
-  var react = dsl; // core + default dsl
-
-  /**
-     Enable detection of promises and resolution
-    */
-  function resolvePromises() {
-    resolvePromisesFn(react);
-  }
-
-  /**
-     Enable tracking of tasks and flow execution, emitting events and
-     tracking start, end, elapsed time
-    */
-  function trackTasks() {
-    trackTasksFn(react);
-  }
-
-  /**
-     If called, load the built-in plugin for log events and invoke
-
-     @param flowFn [function] if not provided uses global react
-     @param eventWildcard [string] pattern to log events for
-  */
-  function logEvents(flowFn, eventWildcard) {
-    if (typeof(flowFn) !== 'function') { // only wildcard provided
-      eventWildcard = flowFn;
-      flowFn = undefined;
-    }
-    if (!flowFn) flowFn = react; // use global
-    trackTasks();
-    return logEventsMod.logEvents(flowFn, eventWildcard);
-  }
-
-  /**
-     Instantiate an event collector
-    */
-  function createEventCollector() {
-    return eventCollectorFactory(react);
-  }
-
-  react.options = core.options; // global react options
-  react.events = core.events;   // global react event emitter
-  react.logEvents = logEvents;  // enable event logging
-  react.resolvePromises = resolvePromises; // enable promise resolution
-  react.trackTasks = trackTasks; // enable tracking of tasks
-  react.createEventCollector = createEventCollector; // create instance of EventCollector
-  return react;
-
-});

package/lib/ret-task.js

@@ -1,71 +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) {
-  
-  function format_error(errmsg, obj) {
-    return sprintf('%s - %s', errmsg, util.inspect(obj));
-  }
-
-  var REQ = 'retTask requires f, a, out';
-  var FN_REQ = 'retTask requires f to be a function or string';
-  var A_REQ = 'retTask requires a to be an array of string param names';
-  var RET_REQ = 'retTask requires out to be an array with single string param name or []';
-
-  function RetTask(taskDef) {
-    var self = this;
-    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  }
-
-  RetTask.prototype = new BaseTask();
-  RetTask.prototype.constructor = RetTask;
-
-  RetTask.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 === 0 ||
-              (taskDef.out.length === 1 && typeof(taskDef.out[0] === 'string'))))) {
-        errors.push(format_error(RET_REQ, taskDef));
-      }
-    }
-    return errors;
-  };
-
-  RetTask.prototype.exec = function exec(vCon, handleError, contExec) {
-    try {
-      var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from 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 results = [func.apply(bindObj, args)];
-      vCon.saveResults(this.out, results); // save retval, takes arrays
-      this.complete(results);
-      contExec();       // continue since no callback to run this
-    } catch (err) { handleError(this, err); }    // catch and handle the task error, calling final cb
-  };
-
-  return RetTask;
-
-});  

package/lib/sprintf.js

@@ -1,18 +0,0 @@
-'use strict';
-/*global define:true sprint:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util'], function (util) {
-
-  /**
-     Abstract the details of getting a sprintf function.
-     Currently using the simple format capabilities of node's util.format
-    */
-  
-  var sprintf = util.format;
-  return sprintf;
-  
-});  

package/lib/status.js

@@ -1,14 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-  
-  var STATUS = { READY: 'ready',  RUNNING: 'running', ERRORED: 'errored', COMPLETE: 'complete' };
-
-  return STATUS;
-
-});  

package/lib/task.js

@@ -1,251 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util', './sprintf', 'ensure-array', './cb-task', './promise-task',
-       './ret-task', './when-task', './finalcb-task', './finalcb-first-task',
-       './status', './error', './vcon', './event-manager'],
-function (util, sprintf, array, CbTask, PromiseTask,
-         RetTask, WhenTask, FinalCbTask, FinalCbFirstSuccTask,
-         STATUS, error, VContext, EventManager) {
-  
-  var TASK_TYPES = {
-    cb: CbTask,
-    ret: RetTask,
-    promise: PromiseTask,
-    when: WhenTask
-  };
-
-  var DEFAULT_TASK_NAME = 'task_%s';  // for unnamed tasks use task_idx, like task_0
-
-  function taskTypeKeys() { return Object.keys(TASK_TYPES); }
-
-  var OUT_TASK_TYPES = {
-    finalcb: FinalCbTask,   //first task is the default if no type specified in taskDef
-    finalcbFirst: FinalCbFirstSuccTask
-  };
-  function outTaskTypeKeys() { return Object.keys(OUT_TASK_TYPES); }
-
-  var LOCAL_FN_MISSING = 'function: %s not found in locals or input params - task[%s]';
-  var TASKDEF_IS_OBJECT = 'task must be an object';
-  var NO_TASKS_RUNNING_WONT_COMPLETE = 'no tasks running, flow will not complete, remaining tasks: %s';
-  var TASK_TYPE_SHOULD_MATCH = 'task.type should match one of ' +
-    Object.keys(TASK_TYPES).join(', ');
-
-  function format_error(errmsg, obj) {
-    return sprintf('%s - %s', errmsg, util.inspect(obj));
-  }
-
-  /**
-     guess the missing types from params.
-     Augments in place but also returns taskDef.
-     If not specified then is 'cb'
-  */
-  function setMissingType(taskDef) {
-    if (taskDef.type) return taskDef; //already set, return
-    taskDef.type = 'cb'; 
-    return taskDef;
-  }
-
-  function setMissingOutTaskType(taskDef) {
-    if (!taskDef.type) taskDef.type = Object.keys(OUT_TASK_TYPES)[0]; //use first outTask type as default
-  } 
-
-  function ensureAfterArrStrings(taskDef) { // convert any fn to str, and make sure is array
-    if (!taskDef.after) return;
-    var afterArr = array(taskDef.after);  // ensure is array, null becomes []
-    afterArr = afterArr.map(function (a) { return (typeof(a) === 'function') ? a.name : a; });
-    taskDef.after = afterArr;
-  }
-
-  /**
-     @returns array of errors for taskDef, could be empty
-  */
-  function validate(taskDef) {
-    if (!taskDef || typeof(taskDef) !== 'object') {    
-      return [format_error(TASKDEF_IS_OBJECT, taskDef)];
-    }
-    setMissingType(taskDef);
-    ensureAfterArrStrings(taskDef);
-    var errors = [];
-    errors = errors.concat(validateTaskType(taskDef));
-    errors = errors.concat(validateTask(taskDef));  
-    return errors;
-  }
-
-  function validateTaskType(taskDef) {
-    var errors = [];
-    if (!Object.keys(TASK_TYPES).some(
-      function (type) { return (taskDef.type === type); })) {
-      errors.push(format_error(TASK_TYPE_SHOULD_MATCH, taskDef));
-    }
-    return errors;
-  }
-
-  function validateTask(taskDef) {
-    var errors = [];
-    var taskCons = TASK_TYPES[taskDef.type];
-    if (taskCons) {
-      errors = errors.concat(taskCons.validate(taskDef));
-    }
-    return errors;
-  }
-
-  function validateOutTask(taskDef) {
-    var errors = [];
-    setMissingOutTaskType(taskDef);
-    var taskCons = OUT_TASK_TYPES[taskDef.type];
-    errors = errors.concat(taskCons.validate(taskDef));
-    return errors;  
-  }
-
-
-  function validateLocalFunctions(inParams, taskDefs, locals) {
-    var errors = [];
-    function foo() { } //used to mock args as fns for validation check 
-    var mock_args = inParams.map(function (p) { return foo; }); //mock args with fns
-    var vCon = VContext.create(mock_args, inParams, locals);
-    var tasks = taskDefs.map(create);
-    var tasksWFunctions = tasks.filter(function (t) { return (t.type !== 'when'); }); // non-when tasks need f
-    tasksWFunctions.forEach(function (t, idx) {
-      if (!t.functionExists(vCon)) {   // error if function doesnt exist AND
-        if (!t.isMethodCall()) errors.push(sprintf(LOCAL_FN_MISSING, t.f, idx)); // not method OR
-        else {
-          var obj = t.getMethodObj(vCon);
-          if (obj && obj !== foo) {  // (has parent but not our mock)
-            errors.push(sprintf(LOCAL_FN_MISSING, t.f, idx));
-          }
-        }
-      }
-    });
-    return errors;
-  }
-
-  function fName(fn) {
-    if (typeof(fn) === 'function') {
-      return fn.name;
-    }
-    return (fn) ? fn : '';
-  }
-
-  /**
-     Name tasks that are not already named. Prenamed task uniquness validation
-     will be done in validate.
-
-     This modifies the tasks with the new names.
-
-     @returns map of names to tasks
-  */
-  function nameTasks(tasks) { //name tasks that are not already named, validation done elsewhere, ret map
-    var namesMap = tasks.reduce(function (map, t) {
-      if (t.name) { map[t.name] = t; }
-      return map;
-    }, {});
-    tasks.forEach(function (t, idx) {
-      if (!t.name) { //not already named
-        var name = fName(t.f);
-        if (!name) name = sprintf(DEFAULT_TASK_NAME, idx);
-        if (!name || namesMap[name]) {
-          name = sprintf('%s_%s', name, idx); //if empty or already used, postfix with _idx
-        }
-        t.name = name;
-        namesMap[name] = t;
-      }
-    });
-    return namesMap;
-  }
-
-  function create(taskDef) {
-    var TaskConstructor = TASK_TYPES[taskDef.type];
-    return new TaskConstructor(taskDef);
-  }
-
-  function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions, env) {
-    setMissingOutTaskType(taskDef);
-    var outTaskOptions = {
-      taskDef: taskDef,
-      cbFunc: cbFunc,
-      tasks: tasks,
-      vCon: vCon,
-      execOptions: execOptions,
-      env: env,
-      TaskConstructor: OUT_TASK_TYPES[taskDef.type]
-    };
-    EventManager.global.emit(EventManager.TYPES.EXEC_OUTTASK_CREATE, outTaskOptions); // hook
-    var TaskConstructor = outTaskOptions.TaskConstructor;  // hook could have changed
-    return new TaskConstructor(outTaskOptions);
-  }
-  
-  function createErrorHandler(vCon, outTask) {
-    return function handleError(task, err) {
-      task.status = STATUS.ERRORED;
-      task.error = err;
-      outTask.env.currentTask = task;
-      outTask.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_ERRORED, task);
-      var errWithMeta = error.augmentError(err, {task: task, vcon: vCon});
-      outTask.exec(errWithMeta); //call the final callback with the first error hit
-    };
-  }
-
-  function findTasksReady(vCon, tasks, tasksByName) {
-    return tasks.filter(function (t) { return t.isReady(vCon, tasksByName); });
-  }
-
-  function execTasks(tasksReady, vCon, handleError, contExec) {
-    tasksReady.forEach(function (t) { t.status = STATUS.READY; }); //set ready first, no double exec
-    tasksReady.forEach(function (t) { t.exec(vCon, handleError, contExec); }); 
-  }
-
-  /**
-     this will be called if there are no tasks found to run,
-     and it will check if there are still tasks running or ready
-     (which means they will be running shortly), in which
-      case everything is fine. If no tasks are running then
-      call handleError since this will never complete.
-  */
-  function checkIfTasksRunning(vCon, tasks, handleError, env) {
-    var tasksRunning = tasks.filter(function (t) {
-      return (t.status === STATUS.RUNNING || t.status === STATUS.READY);
-    });
-    if (!tasksRunning.length) {
-      var remainingTasks = tasks.filter(function (t) { return (!t.status); });
-      var remainingTNames = remainingTasks.map(function (t) { return t.name; });
-      var errMsg = sprintf(NO_TASKS_RUNNING_WONT_COMPLETE, remainingTNames.join(', '));
-      var emptyTask = { env: env };
-      handleError(emptyTask, new Error(errMsg));
-    }
-  }
-
-  function findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec, env) {
-    var tasksReady = findTasksReady(vCon, tasks, tasksByName);
-    if (!tasksReady.length) checkIfTasksRunning(vCon, tasks, handleError, env); // no tasks to run, check if ok
-    execTasks(tasksReady, vCon, handleError, contExec);
-  }
-
-  function serializeTasks(tasks) { // conveniently set after for each task idx > 0
-    nameTasks(tasks);
-    tasks.forEach(function (t, idx, arr) { if (idx !== 0) t.after = [arr[idx - 1].name]; }); 
-    return tasks;
-  }
-
-  return {
-    serializeTasks: serializeTasks,
-    TASK_TYPES: TASK_TYPES,
-    taskTypeKeys: taskTypeKeys,
-    OUT_TASK_TYPES: OUT_TASK_TYPES,
-    outTaskTypeKeys: outTaskTypeKeys,
-    setMissingType: setMissingType,
-    validate: validate,
-    validateOutTask: validateOutTask,
-    validateLocalFunctions: validateLocalFunctions,
-    nameTasks: nameTasks,
-    create: create,
-    createOutTask: createOutTask,
-    createErrorHandler: createErrorHandler,
-    findReadyAndExec: findReadyAndExec
-  };
-
-});  

package/lib/track-tasks.js

@@ -1,74 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-  
-  /**
-     Track the tasks, start, complete, args, results, elapsed time
-     Emits events that can be monitored
-
-     - track start and complete
-     - record args each task was called with
-     - record results at completion
-     - record start, end, and calc elapsed time
-     - emits flow.begin with flowEnv
-     - emits task.begin with task
-     - emits task.complete with task
-     - emits flow complete with flowEnv
-     - emits flow errored with flowEnv
-
-     @example
-     var react = require('react');
-     react.trackTasks(); // enable task and flow tracking
-    */
-
-
-  var trackingTasks = false;
-
-  function trackTasks(react) {
-    if (trackingTasks) return;  // already tracking
-    trackingTasks = true;
-
-    react.events.on(react.events.TYPES.EXEC_FLOW_START, function (env) {
-      env.startTime = Date.now();
-      env.flowEmitter.emit(react.events.TYPES.FLOW_BEGIN, env); //fire public ev
-    });
-
-    react.events.on(react.events.TYPES.EXEC_TASK_START, function (task) {
-      task.startTime = Date.now();
-      task.env.flowEmitter.emit(react.events.TYPES.TASK_BEGIN, task); //fire public ev
-    });
-
-    react.events.on(react.events.TYPES.EXEC_TASK_COMPLETE, function (task) {
-      task.endTime = Date.now();
-      task.elapsedTime = task.endTime - task.startTime;
-      task.env.flowEmitter.emit(react.events.TYPES.TASK_COMPLETE, task); // fire public ev
-    });
-
-    react.events.on(react.events.TYPES.EXEC_TASK_ERRORED, function (task) {
-      task.endTime = Date.now();
-      task.elapsedTime = task.endTime - task.startTime;
-      task.env.flowEmitter.emit(react.events.TYPES.TASK_ERRORED, task); // fire public ev
-    });
-
-    react.events.on(react.events.TYPES.EXEC_FLOW_COMPLETE, function (env) {
-      env.endTime = Date.now();
-      env.elapsedTime = env.endTime - env.startTime;
-      env.flowEmitter.emit(react.events.TYPES.FLOW_COMPLETE, env); //fire public ev
-    });
-
-    react.events.on(react.events.TYPES.EXEC_FLOW_ERRORED, function (env) {
-      env.endTime = Date.now();
-      env.elapsedTime = env.endTime - env.startTime;
-      env.flowEmitter.emit(react.events.TYPES.FLOW_ERRORED, env); //fire public ev
-    });
-
-  }
-
-  return trackTasks; 
-
-});