react 0.6.2 → 0.8.0

package/lib/validate.js

@@ -1,159 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define(['util', './sprintf', 'ensure-array', './task'], function (util, sprintf, array, taskUtil) {
-  /*jshint latedef:false */
-  
-  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 MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
-
-  // match any of our literals true, false, int, float, quoted strings, or is property (has dot), match vcon.js
-  var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;  
-
-  function format_error(errmsg, obj) {
-    return sprintf('%s - %s', errmsg, util.inspect(obj));
-  }
-
-  /**
-     true if is a literal name
-  */
-  function isLiteralOrProp(name) {  // need to match what is in vcon.js, TODO consolidate?
-    return LITERAL_OR_PROP_RE.test(name);
-  }
-
-  /**
-     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(taskUtil.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(taskUtil.validateLocalFunctions(ast.inParams, ast.tasks, ast.locals));
-      errors = errors.concat(validateNoMissingNames(ast));
-    }
-    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(taskUtil.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;
-  }
-
-
-  /**
-     validate there are no missing or mispelled param names in any task inputs
-     or the final task output
-
-     @return array of errors, or empty array if none
-  */
-  function validateNoMissingNames(ast) {
-    var errors = [];
-    var names = {};
-    if (ast.locals) {
-      names = Object.keys(ast.locals).reduce(function (accum, k) { // start with locals
-        accum[k] = true;
-        return accum;
-      }, names);
-    }
-    ast.inParams.reduce(function (accum, p) {  // add input params
-      accum[p] = true;
-      return accum;
-    }, names);
-    ast.tasks.reduce(function (accum, t) { // add task outputs
-      return t.out.reduce(function (innerAccum, p) {
-        innerAccum[p] = true;
-        return innerAccum;
-      }, accum);
-    }, names);
-
-    // now we have all possible provided vars, check task inputs are accounted for
-    ast.tasks.reduce(function (accum, t) {  // for all tasks
-      return t.a.reduce(function (innerAccum, p) { // for all in params, except property
-        if (!isLiteralOrProp(p) && !names[p]) innerAccum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
-        return innerAccum;
-      }, accum);
-    }, errors);
-
-    // now check the final task outputs
-    ast.outTask.a.reduce(function (accum, p) { // for final task out params
-      if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
-      return accum;
-    }, errors);
-    return errors;  
-  }
-
-  return validate;
-
-});  

package/lib/vcon.js

@@ -1,90 +0,0 @@
-'use strict';
-/*global define:true */
-
-if (typeof define !== 'function') {
-  var define = require('amdefine')(module);
-}
-
-define([], function () {
-  
-  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
-    /*jshint regexp: false */
-    var vConValues = this.values;
-    if (typeof(name) !== 'string') return name; // literal boolean or number
-    name = name.trim();
-    // literal checks need to match what is in validate.js
-    if (name === 'true') return true;
-    if (name === 'false') return false;
-    if (name === 'null') return null;
-    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
-       @param self used to pass 'this' context in
-  */
-  VContext.create = function (args, inParams, locals, self) {
-    var initValues = {};
-    if (self) initValues['this'] = self;
-    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 !== undefined) ? x : null; // upgrade undefined to null
-      return vcon;
-    }, initValues);
-    return vContext;
-  };
-
-
-  return VContext;
-
-});  

package/lib/when-task.js

@@ -1,85 +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) {
-  
-  /**
-     When task which checks if is a promise (has a then method)
-     and waits for it to resolve.
-
-     If argument does not have a then method, it resolves immediately
-  */
-
-  function format_error(errmsg, obj) {
-    return sprintf('%s - %s', errmsg, util.inspect(obj));
-  }
-
-  var REQ = 'whenTask requires a, out';
-  var A_REQ = 'whenTask requires a to be an array[1] of string param names';
-  var OUT_REQ = 'whenTask requires out to be an array[1] of string param names';
-
-  function WhenTask(taskDef) {
-    var self = this;
-    Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  }
-
-  WhenTask.prototype = new BaseTask();
-  WhenTask.prototype.constructor = WhenTask;
-
-  WhenTask.prototype.f = function when() { // just here to keep validations happy 
-  }
-
-  WhenTask.validate = function (taskDef) {
-    var errors = [];
-    if (!taskDef.a || !taskDef.out) {
-      errors.push(format_error(REQ, taskDef));
-    } else {
-      if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 && 
-             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;
-  };
-
-  WhenTask.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);
-    };
-  };
-
-  WhenTask.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('WhenTask.exec.args=', args);
-      //console.error('WhenTask.exec.vCon=', vCon);
-      this.start(args); //note the start time, args
-      var arg = args[0]; // one value allowed
-      if (arg && typeof(arg.then) === 'function') { // is a promise
-        arg.then(this.nextFn, this.failFn);
-      } else { // not a promise continue immediately
-        this.nextFn(arg);
-      }
-    } catch (err) { //catch and handle the task error, calling final cb
-      handleError(this, err);
-    } 
-  };
-
-  return WhenTask;
-
-});  

package/src/dist.build.requirejs

@@ -1,20 +0,0 @@
-({
-  baseUrl: "..",
-  optimize: "none",
-  packages: [
-    {
-      name: "react",
-      location: "lib",
-      main: "react"
-    }
-  ],
-  paths: {
-    jQuery: "empty:",
-    eventemitter2: "node_modules/eventemitter2/lib/eventemitter2",
-    util: "vendor/node/util",
-    sprint: "node_modules/sprint/lib/sprint",
-    "ensure-array": "node_modules/ensure-array/ensure-array"
-  },
-  name: "react",
-  out: "dist/react.js"
-})

package/test/ast.mocha.js

@@ -1,136 +0,0 @@
-'use strict';
-/*global react:true */
-
-if (typeof(chai) === 'undefined') {
-  var chai = require('chai');
-}
-
-if (typeof(react) === 'undefined') {
-  var react = require('../'); //require('react');
-}
-
-(function () {
-
-  var t = chai.assert;
-
-/**
-   Testing ast
-  */
-
-
-  suite('ast');
-
-  function load(res, cb) { cb(null, res + '-loaded'); }
-  function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
-  function postfix(str, poststr, cb) { cb(null, str + poststr); }
-  function upper(str) { return str.toUpperCase(); }
-  function makeError(str, cb) { cb(new Error('makeErr-' + str)); }
-
-  test('mixed', function (done) {
-    var fn = react();
-    var errors = fn.setAndValidateAST({
-      inParams: ['res', 'prefstr', 'poststr'],
-      tasks: [
-        { f: load,    a: ['res'],              out: ['lres'] },
-        { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
-        { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
-        { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
-      ],
-      outTask: { a: ['plresp'] }
-    });
-
-    t.deepEqual(errors, []);
-
-    fn('foo', 'pre-', '-post', function cb(err, lres) {
-      t.equal(err, null);
-      t.equal(lres, 'pre-FOO-LOADED-post');
-    });
-
-    fn('bar', 'PRE-', '-POST', function cb(err, lres) {
-      t.equal(err, null);
-      t.equal(lres, 'PRE-BAR-LOADED-POST');
-      done();
-    });
-  });
-
-  test('ast.defined event called when ast is defined', function (done) {
-    var fn = react();
-    var collector = react.createEventCollector();
-    collector.capture(fn, 'ast.*');
-    
-    var errors = fn.setAndValidateAST({
-      inParams: ['res', 'prefstr', 'poststr'],
-      tasks: [
-        { f: load,    a: ['res'],              out: ['lres'] },
-        { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
-        { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
-        { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
-      ],
-      outTask: { a: ['plresp'] }
-    });
-
-    var events = collector.list();
-    t.equal(events.length, 1);
-    t.isObject(events[0].ast);
-    t.isNotNull(events[0].ast.inParams);
-    t.isNotNull(events[0].ast.tasks);
-    t.isNotNull(events[0].ast.outTask);
-    done();
-  });
-
-  test('ast.defined event is passed to process', function (done) {
-    // browser might not have this, so only if process is an eventemitter
-    if (process && process.once) {
-      var fn = react();
-      process.once('ast.defined', function (ast) {
-        t.isObject(ast);
-        t.isNotNull(ast.inParams);
-        t.isNotNull(ast.tasks);
-        t.isNotNull(ast.outTask);
-        t.deepEqual(ast.inParams, ['res', 'prefstr', 'poststr']);
-        done();
-      });
-      var errors = fn.setAndValidateAST({
-        inParams: ['res', 'prefstr', 'poststr'],
-        tasks: [
-          { f: load,    a: ['res'],              out: ['lres'] },
-          { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
-          { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
-          { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
-        ],
-        outTask: { a: ['plresp'] }
-      });      
-    } else {
-      done(); //skipping in browser
-    }
-  });
-
-  test('cb with err', function (done) {
-    var fn = react();
-    var errors = fn.setAndValidateAST({
-      inParams: ['res', 'prefstr', 'poststr'],
-      tasks: [
-        { f: load,      a: ['res'],               out: ['lres'] },
-        { f: upper,     a: ['lres'],              out: ['ulres'], type: 'ret' },
-        { f: makeError, a: ['ulres'],             out: ['na']  },
-        { f: prefix,    a: ['prefstr', 'na'],     out: ['plres'] },
-        { f: postfix,   a: ['plres', 'poststr'],  out: ['plresp'] }
-      ],
-      outTask: { a: ['plresp'] }
-    });
-
-    t.deepEqual(errors, []);
-
-    fn('foo', 'pre-', '-post', function cb(err, lres) {
-      t.equal(err.message, 'makeErr-FOO-LOADED');
-      t.equal(lres, undefined);
-    });
-
-    fn('bar', 'PRE-', '-POST', function cb(err, lres) {
-      t.equal(err.message, 'makeErr-BAR-LOADED');
-      t.equal(lres, undefined);
-      done();
-    });
-  });
-
-}());