react 0.5.0 → 0.5.1

package/README.md

@@ -35,7 +35,7 @@ It takes inspiration from several projects including:
  - object instance method calls
  - class method calls
  - selectFirst flow where the first task that returns defined, non-null value is used
- - promise style functions - also automatic resolution of promise inputs (optional require('react/promise-resolve');)
+ - promise style functions - also automatic resolution of promise inputs (optionally loaded with `react.resolvePromises();`)
  - use of resulting flow function as callback style or promise style (if no callback provided) (provided via plugin corresponding to the promise library used) See https://github.com/jeffbski/react-deferred
  - (planned) iteration on arrays, streams, sockets
  - (planned) event emitter integration
@@ -182,7 +182,7 @@ See the [Advanced React](https://github.com/jeffbski/react/blob/master/doc/advan
 
 ## Status
 
- - 2012-01-18 - Remove old DSL interfaces, improve plugin loading (v0.5.0)
+ - 2012-01-18 - Remove old DSL interfaces, improve plugin loading, log flow name with task name, ast.defined event, test with node 0.7.0 (v0.5.1)
  - 2012-01-17 - Additional documentation (v0.3.5)
  - 2012-01-16 - Refine events and create logging plugin (v0.3.3)
  - 2012-01-13 - Add promise tasks, promise resolution, refactor alternate DSL interfaces as optional requires (v0.3.0)
@@ -194,12 +194,12 @@ See the [Advanced React](https://github.com/jeffbski/react/blob/master/doc/advan
 ## Test Results
 
 ```bash
-ok ast.test.js .................... 10/10
+ok ast.test.js .................... 15/15
 ok cb-task.test.js ................ 31/31
 ok core-deferred.test.js .......... 11/11
 ok core-promised.test.js .......... 11/11
 ok core-when.test.js ................ 6/6
-ok core.test.js ................. 104/104
+ok core.test.js ................. 108/108
 ok dsl.test.js .................... 70/70
 ok event-manager.test.js .......... 13/13
 ok exec-options.test.js ............. 3/3
@@ -213,7 +213,7 @@ ok validate-cb-task.test.js ......... 6/6
 ok validate-ret-task.test.js ........ 7/7
 ok validate.test.js ............... 31/31
 ok vcon.test.js ................... 55/55
-total ........................... 457/457
+total ........................... 466/466
 
 ok
 ```

package/doc/advanced.md

@@ -133,6 +133,7 @@ react.trackTasks();  // turn on flow and task tracking events
 
 Available Events that can be consumed
 
+ - ast.defined - ast was defined (receives the ast)
  - flow.begin - flow execution has started (receives a flow env)
  - flow.complete - flow execution has successfully completed (receives a flow env)
  - flow.errored - flow execution has errored (receives a flow env)
@@ -159,3 +160,7 @@ collector.capture(flowFn, 'flow.*'); // add capture flow events on a flow
 var events = collector.list();  // retrieve the list of events
 collector.clear();  // clear the list of events;
 ```
+
+### External Plugins
+
+ - https://github.com/jeffbski/react-deferred - integrates jQuery style Deferred/Promises with react, providing automatic promise resolution and optional usage for react functions where by calling without a callback returns a promise.

package/examples/{ast1.js → using-ast-directly.js}

@@ -1,5 +1,9 @@
 'use strict';
 
+/**
+   Advanced example using the AST directly which most users will not do.
+   For general use, see other examples like simple.js
+  */
 var react = require('../'); // require('react');
 
 function load(res, cb) { setTimeout(cb, 100, null, res + '-loaded'); }

package/lib/core.js

@@ -10,6 +10,7 @@ var VContext = require('./vcon.js');
 var EventManager = require('./event-manager.js');
 var inputParser = require('./input-parser.js');
 var idGenerator = require('./id.js');
+var sprintf = require('sprintf').sprintf;
 
 var reactOptions = {
   stackTraceLimitMin: 30
@@ -27,6 +28,13 @@ function mergeOptions(parsedOptions) {
   }, parsedOptions);    
 }
 
+/**
+   generate a flow name when one is not provided
+  */
+function generateFlowName() {
+  return sprintf('flow_%s', idGenerator.createUniqueId());
+}
+
 /**
    Creates react function which the AST can be manipulated and then
    is ready to be executed. Can be used directly or a DSL can wrap this
@@ -64,13 +72,17 @@ function reactFactory() {
   function setAndValidateAST(newAST) { //set AST then validate, ret error[]
     Object.keys(newAST).forEach(function (k) { ast[k] = newAST[k]; }); // copy all properties
     var errors = validate(ast);
-    if (!errors.length) tskutil.nameTasks(ast.tasks); //run this so names can be checked in ast
+    if (!errors.length) {
+      if (!ast.name) ast.name = generateFlowName();
+      tskutil.nameTasks(ast.tasks); //run this so names can be checked in ast
+    }
     if (Object.freeze) { //lets freeze the AST so plugin writers don't accidentally manip the ast
       Object.keys(newAST).forEach(function (k) {
         if (typeof(newAST[k]) === 'object') Object.freeze(newAST[k]);
       });
       Object.freeze(newAST);
     }
+    flowEmitter.emit(EventManager.TYPES.AST_DEFINED, ast); 
     return errors;
   }
 

package/lib/event-collector.js

@@ -3,6 +3,7 @@
 var react = require('../');  // require('react');
 react.trackTasks(); // enable task tracking
 
+var AST_EVENTS_RE = /^ast\./;
 var TASK_EVENTS_RE = /^task\./;
 var FLOW_EVENTS_RE = /^flow\./;
 
@@ -48,6 +49,8 @@ EventCollector.prototype.capture = function (flowFn, eventId) {
       eventObject.env = obj;
     } else if (TASK_EVENTS_RE.test(this.event)) {
       eventObject.task = obj;
+    } else if (AST_EVENTS_RE.test(this.event)) {
+      eventObject.ast = obj;      
     }
     self.events.push(eventObject);      
   }

package/lib/event-manager.js

@@ -10,6 +10,7 @@ var EVENT_EMITTER2_CONFIG = {
 
 var TYPES = {
   // Flow monitoring events and their params
+  AST_DEFINED: 'ast.defined',                      // ast
   FLOW_BEGIN: 'flow.begin',                        // env
   TASK_BEGIN: 'task.begin',                        // task
   TASK_COMPLETE: 'task.complete',                  // task

package/lib/id.js

@@ -4,6 +4,7 @@ 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;
 }
 

package/lib/log-events.js

@@ -45,12 +45,12 @@ function taskLog(obj) {
   var eventTimeStr = time.toISOString();
   if (this.event === 'task.complete') {
     var task = obj;
-    console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
-                  this.event, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
+    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 \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
+    console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.name, util.inspect(argsNoCb));
   }
   
 }

package/lib/task.js

@@ -20,6 +20,9 @@ var TASK_TYPES = {
   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 = {
@@ -127,9 +130,10 @@ function validateLocalFunctions(inParams, taskDefs, locals) {
 }
 
 function fName(fn) {
-  return (fn) ?
-    ((fn.name) ? fn.name : fn) :  // if defined, try name, otherwise toString()
-    'undefined';  // not defined, use undefined
+  if (typeof(fn) === 'function') {
+    return fn.name;
+  }
+  return (fn) ? fn : '';
 }
 
 /**
@@ -148,6 +152,7 @@ function nameTasks(tasks) { //name tasks that are not already named, validation
   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
       }

package/lib/vcon.js

@@ -71,7 +71,7 @@ VContext.create = function (args, inParams, locals, self) {
   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;
+    if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
     return vcon;
   }, initValues);
   return vContext;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react",
   "description": "React is a javascript module implementing a lightweight rules engine to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
   "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
   "bugs" : { "url": "http://github.com/jeffbski/react/issues" },

package/test/ast.test.js

@@ -2,7 +2,8 @@
 
 var test = require('tap').test;
 
-var react = require('../react');
+var react = require('../'); // require('react');
+var EventCollector = require('../lib/event-collector');
 
 function load(res, cb) { cb(null, res + '-loaded'); }
 function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
@@ -38,6 +39,31 @@ test('mixed', function (t) {
   });
 });
 
+test('ast.defined event called when ast is defined', function (t) {
+  var fn = react();
+  var collector = new EventCollector();
+  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.type(events[0].ast, 'object');
+  t.ok(events[0].ast.inParams);
+  t.ok(events[0].ast.tasks);
+  t.ok(events[0].ast.outTask);
+  t.end();
+});
+
 test('cb with err', function (t) {
   t.plan(5);
   

package/test/core.test.js

@@ -10,6 +10,7 @@ function add(x, y, cb) { cb(null, x + y); }
 function badFunc(a, b, cb) { throw new Error('badFuncThrow'); }
 function badF2(a, b, cb) { cb('my-error'); }
 function fnRetsSum(a, b) { return a + b; }
+var anonFn = function (a, b) { return a + b; };
 
 test('set and validate AST', function (t) {
   var fn = react();
@@ -42,16 +43,19 @@ test('unnamed tasks will be assigned unique names', function (t) {
       { f: multiply, a: ['a', 'b'], out: ['c'] },
       { f: multiply, a: ['a', 'b'], out: ['d'], name: 'multiply' },
       { f: multiply, a: ['a', 'b'], out: ['e'], name: 'times' },
+      { f: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret' },
       { f: multiply, a: ['a', 'b'], out: ['f'] }
     ],
     outTask: { a: ['c'] }
   });
   t.deepEqual(errors, [], 'should set and validate as true');
+  t.equal(fn.ast.name.slice(0, 'flow_'.length), 'flow_', 'generated flow name should start with flow_');
   t.deepEqual(fn.ast.tasks, [
       { f: multiply, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'multiply_0' },
       { f: multiply, a: ['a', 'b'], out: ['d'], name: 'multiply', type: 'cb' },
       { f: multiply, a: ['a', 'b'], out: ['e'], name: 'times', type: 'cb' },
-      { f: multiply, a: ['a', 'b'], out: ['f'], type: 'cb', name: 'multiply_3' }
+      { f: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret', name: 'task_3' },    
+      { f: multiply, a: ['a', 'b'], out: ['f'], type: 'cb', name: 'multiply_4' }
     ]);
   t.end();
 });
@@ -431,6 +435,27 @@ test('using "this" in a sync function', function (t) {
   }]);
 });
 
+test('undefined input arguments will be upgraded from undefined to null', function (t) {
+  var fn = react();
+  function concat(a, b) {
+    return '' + a + b;    
+  }
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [
+      { f: concat, a: ['a', 'b'], out: ['c'], type: 'ret' }
+    ],
+    outTask: { a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+  fn('first', undefined, function (err, c) {  // undefined second param, upgrade to null
+    t.equal(err, null);
+    t.equal(c, 'firstnull');
+    t.end();
+  });
+});
+
+
 
 // Select first tests
 

package/test/dsl.test.js

@@ -16,7 +16,7 @@ test('module exports is a fn with properties', function (t) {
 
 test('no arguments -> empty name, inParams, tasks, outTask', function (t) {
   var r = react();
-  t.equal(r.ast.name, undefined);
+  t.equal(r.ast.name.slice(0, 'flow_'.length), 'flow_', 'generated flow name should start with flow_');
   t.deepEqual(r.ast.inParams, []);
   t.deepEqual(r.ast.tasks, []);
   t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
@@ -26,7 +26,7 @@ test('no arguments -> empty name, inParams, tasks, outTask', function (t) {
 
 test('empty first string -> empty name, inParams, tasks, outTask', function (t) {
   var r = react('');
-  t.equal(r.ast.name, '');
+  t.equal(r.ast.name.slice(0, 'flow_'.length), 'flow_', 'generated flow name should start with flow_');
   t.deepEqual(r.ast.inParams, []);
   t.deepEqual(r.ast.tasks, []);
   t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });