react 0.6.1 → 0.7.1

package/test/core-when.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true Deferred:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(Deferred) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -51,7 +51,7 @@ if (typeof(Deferred) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['pm', 'pa'],
-      tasks: [    
+      tasks: [
         { a: ['pm'], out: ['m'], type: 'when' },
         { a: ['pa'], out: ['a'], type: 'when' }
       ],
@@ -61,21 +61,21 @@ if (typeof(Deferred) === 'undefined') {
 
     var pm = multiply(2, 3);
     var pa = add(4, 5);
-    
+
     fn(pm, pa, function (err, m, a) {
       t.equal(err, null);
       t.equal(m, 6);
       t.equal(a, 9);
       done();
     });
-  });  
+  });
 
 
   test('rejects with error', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['pm', 'pa'],
-      tasks: [    
+      tasks: [
         { a: ['pm'], out: ['m'], type: 'when' },
         { a: ['pa'], out: ['a'], type: 'when' }
       ],
@@ -86,11 +86,11 @@ if (typeof(Deferred) === 'undefined') {
     var pm = badF2(2, 3);
     var pa = add(4, 5);
 
-    
+
     fn(pm, pa, function (err, m, a) {
       t.equal(err.message, 'my-error');
       done();
     });
   });
 
-}());  
+}());

package/test/core.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true */
 
 if (typeof(chai) === 'undefined') {
@@ -10,6 +9,7 @@ if (typeof(react) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -68,7 +68,7 @@ if (typeof(react) === 'undefined') {
       { 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: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret', name: 'task_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' }
     ]);
     done();
@@ -96,7 +96,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: add, a: ['c', 'b'], out: ['d'] }
       ],
@@ -110,13 +110,13 @@ if (typeof(react) === 'undefined') {
       t.equal(d, 9);
       done();
     });
-  });  
+  });
 
   test('multi-step with after as nonarr fn', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'], after: add },
         { f: add, a: ['a', 'b'], out: ['d'] }
       ],
@@ -126,7 +126,7 @@ if (typeof(react) === 'undefined') {
 
     var collector = react.createEventCollector();
     collector.capture(fn, 'task.complete');
-    
+
     fn(2, 3, function (err, c, d) {
       t.equal(err, null);
       t.equal(c, 6);
@@ -137,13 +137,13 @@ if (typeof(react) === 'undefined') {
       t.equal(events[1].task.name, 'multiply', 'name matches');
       done();
     });
-  });  
+  });
 
   test('mixed multi-step with after as nonarr fn w/events', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'], after: fnRetsSum },
         { f: fnRetsSum, a: ['a', 'b'], out: ['d'], type: 'ret' }
       ],
@@ -153,7 +153,7 @@ if (typeof(react) === 'undefined') {
 
     var collector = react.createEventCollector();
     collector.capture(fn, 'task.complete');
-    
+
     fn(2, 3, function (err, c, d) {
       t.equal(err, null);
       t.equal(c, 6);
@@ -164,19 +164,19 @@ if (typeof(react) === 'undefined') {
       t.isNotNull(events[0].task.id, 'has unique id');
       t.isNotNull(events[0].task.startTime, 'has startTime');
       t.isNotNull(events[0].task.endTime, 'has endTime');
-      t.isNotNull(events[0].task.elapsedTime !== undefined, 'has elapsedTime');    
+      t.isNotNull(events[0].task.elapsedTime !== undefined, 'has elapsedTime');
       t.isNotNull(events[0].task.args, 'has args');
       t.isNotNull(events[0].task.results, 'has results');
       t.equal(events[1].task.name, 'multiply', 'name matches');
       t.isNotNull(events[1].task.id, 'has unique id');
       t.isNotNull(events[1].task.startTime, 'has startTime');
       t.isNotNull(events[1].task.endTime, 'has endTime');
-      t.isNotNull(events[1].task.elapsedTime !== undefined, 'has elapsedTime');    
+      t.isNotNull(events[1].task.elapsedTime !== undefined, 'has elapsedTime');
       t.isNotNull(events[1].task.args, 'has args');
       t.isNotNull(events[1].task.results, 'has results');
       done();
     });
-  });  
+  });
 
 
 
@@ -185,7 +185,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'c'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
         { f: fnRetsSum, a: ['c.mult', 'b'], out: ['c.sum'], type: 'ret' }
       ],
@@ -200,13 +200,13 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(c, { foo: 1, mult: 6, sum: 9});
       done();
     });
-  });  
+  });
 
   test('error when cant complete', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'c'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
         { f: fnRetsSum, a: ['c.bad', 'b'], out: ['c.sum'], type: 'ret' },
         { f: add, a: ['c.sum', 'a'], out: ['d']}
@@ -225,11 +225,11 @@ if (typeof(react) === 'undefined') {
   test('objects', function (done) {
     function retObj(a, b, cb) { cb(null, { bar: a + b }); }
     function concat(a, b, cb) { cb(null, { result: a + b }); }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: retObj, a: ['a.foo', 'b'], out: ['c'] },
         { f: concat, a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -243,18 +243,18 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from container', function (done) {
     var C = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: C.retObj, a: ['a.foo', 'b'], out: ['c'] },
         { f: C.concat, a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -268,43 +268,43 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from container input arg', function (done) {
     var CONT = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b', 'CONT'],
-      tasks: [    
+      tasks: [
         { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
       outTask: { a: ['c', 'd.result'] }
     });
     t.deepEqual(errors, [], 'no validation errors');
-    
+
     fn({ foo: 'FOO' }, 'B', CONT, function (err, c, dresult) {
       t.equal(err, null);
       t.deepEqual(c, { bar: 'FOOB' });
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('use locals for functions', function (done) {
     var locals = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: 'retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -319,18 +319,18 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
+  });
 
   test('objects from locals', function (done) {
     var CONT = {
       retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
       concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
     };
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
         { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
       ],
@@ -345,13 +345,13 @@ if (typeof(react) === 'undefined') {
       t.equal(dresult, 'FOOBB');
       done();
     });
-  });  
-  
+  });
+
   test('multi-step func throws, cb with error', function (done) {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: badFunc, a: ['c', 'b'], out: ['d'] }
       ],
@@ -363,14 +363,14 @@ if (typeof(react) === 'undefined') {
       t.equal(err.message, 'badFuncThrow');
       done();
     });
-  });  
-  
+  });
+
   test('multi-step func cb err, cb with error', function (done) {
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: badF2, a: ['c', 'b'], out: ['d'] },
         { f: add, a: ['d', 'b'], out: ['e'] }
@@ -383,19 +383,19 @@ if (typeof(react) === 'undefined') {
       t.equal(err.message, 'my-error');
       done();
     });
-  });  
+  });
 
   test('using "this" in a cb function', function (done) {
-    
+
     function getA(cb) {
       /*jshint validthis: true */
       cb(null, this.a);
     }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: [],
-      tasks: [    
+      tasks: [
         { f: getA, a: [], out: ['a'] }
       ],
       outTask: { a: ['a'] }
@@ -418,11 +418,11 @@ if (typeof(react) === 'undefined') {
       /*jshint validthis: true */
       return this.a;
     }
-    
+
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: [],
-      tasks: [    
+      tasks: [
         { f: getA, a: [], out: ['a'], type: 'ret' }
       ],
       outTask: { a: ['a'] }
@@ -443,7 +443,7 @@ if (typeof(react) === 'undefined') {
   test('undefined input arguments will be upgraded from undefined to null', function (done) {
     var fn = react();
     function concat(a, b) {
-      return '' + a + b;    
+      return '' + a + b;
     }
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
@@ -469,7 +469,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: multiply, a: ['a', 'b'], out: ['c'] },
         { f: add, a: ['a', 'b'], out: ['c'], after: ['multiply'] }
       ],
@@ -489,7 +489,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[0].task.results, [6], 'results match');
       done();
     });
-  });  
+  });
 
   test('selectFirst with third succeeding', function (done) {
     function noSuccess(a, b, cb) { cb(null); } // returns undefined result
@@ -497,7 +497,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'] },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess'] },
         { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] }
@@ -518,7 +518,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
 
   test('selectFirst forces order with third succeeding', function (done) {
@@ -529,7 +529,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'] },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess']},
         { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] },
@@ -553,7 +553,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
   test('selectFirst using direct returns', function (done) {
     function noSuccess(a, b) {  } // returns undefined result
@@ -562,7 +562,7 @@ if (typeof(react) === 'undefined') {
     var fn = react();
     var errors = fn.setAndValidateAST({
       inParams: ['a', 'b'],
-      tasks: [    
+      tasks: [
         { f: noSuccess, a: ['a', 'b'], out: ['c'], type: 'ret' },
         { f: noSuccessNull, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccess'] },
         { f: addRet, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccessNull'] }
@@ -583,7 +583,7 @@ if (typeof(react) === 'undefined') {
       t.deepEqual(events[2].task.results, [5], 'results match');
       done();
     });
-  });  
+  });
 
 
 }());

package/test/dsl.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true sprintf:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,6 +13,7 @@ if (typeof(sprintf) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -80,7 +80,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('single task, err and out params', function (done) {
@@ -92,7 +92,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('using - with literal string', function (done) {
@@ -104,11 +104,11 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: ['"another-string"'], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('single task, ERR and out params', function (done) {
-    var r = react('myName', 'cb -> ERR, c', 
+    var r = react('myName', 'cb -> ERR, c',
                   falpha, 'cb -> ERR, c'
                  );
     t.deepEqual(r.ast.inParams, []);
@@ -116,11 +116,11 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('cb used in defs is simply ignored', function (done) {
-    var r = react('myName', 'a, b, cb -> err, c', 
+    var r = react('myName', 'a, b, cb -> err, c',
                   falpha, 'a, b, cb -> err, c'
                  );
     t.deepEqual(r.ast.inParams, ['a', 'b']);
@@ -128,7 +128,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('callback used in defs is simply ignored', function (done) {
@@ -140,7 +140,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('two inputs, two tasks, two out params', function (done) {
@@ -154,7 +154,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: fbeta,  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   test('two inputs, two tasks, two out params, options', function (done) {
@@ -171,7 +171,7 @@ if (typeof(sprintf) === 'undefined') {
     t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
     t.equal(r.ast.name, 'myName', 'name should match');
     t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
-    done();  
+    done();
   });
 
   test('two inputs, two mixed tasks, two out params', function (done) {
@@ -185,12 +185,12 @@ if (typeof(sprintf) === 'undefined') {
       { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-    done();  
+    done();
   });
 
 
   test('two inputs, two mixed tasks, two out params, opts', function (done) {
-    var r = react('myName', 'a, b, cb -> err, c, d', 
+    var r = react('myName', 'a, b, cb -> err, c, d',
                   falpha, 'a, cb -> err, c', { after: fbeta },
                   fbeta,  'a, b -> d'
                  );
@@ -200,13 +200,13 @@ if (typeof(sprintf) === 'undefined') {
       { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
-    done();  
+    done();
   });
 
 
     // Object use
   test('object prop task params', function (done) {
-    var r = react('myName', 'a, b, cb -> err, c, e', 
+    var r = react('myName', 'a, b, cb -> err, c, e',
                   falpha, 'a, b.cat, cb -> err, c',
                   fbeta,  'c.dog, b -> d',
                   'd.egg', 'c, cb -> err, e'
@@ -218,7 +218,7 @@ if (typeof(sprintf) === 'undefined') {
       { f: 'd.egg', a: ['c'], out: ['e'], type: 'cb', name: 'd.egg'}
     ]);
     t.deepEqual(r.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
-    done();  
+    done();
   });
 
   // Errors
@@ -229,7 +229,7 @@ if (typeof(sprintf) === 'undefined') {
                     falpha, 'cb -> err, c'
                    );
     };
-    t.throws(fn, new Error('first flow parameter should be the flow name, but found in/out def: cb -> err, c'));
+    t.throws(fn, 'first flow parameter should be the flow name, but found in/out def: cb -> err, c');
     done();
   });
 
@@ -239,7 +239,7 @@ if (typeof(sprintf) === 'undefined') {
                     falpha, 'cb -> err, c'
                    );
     };
-    t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+    t.throws(fn, 'callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c');
     done();
   });
 
@@ -249,7 +249,7 @@ if (typeof(sprintf) === 'undefined') {
                     falpha, 'cb -> c'  // missing err
                    );
     };
-    t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+    t.throws(fn, 'callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c');
     done();
   });
 
@@ -259,7 +259,7 @@ if (typeof(sprintf) === 'undefined') {
                     falpha, 'cb -> err, c'
                    );
     };
-    t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
+    t.throws(fn, 'found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c');
     done();
   });
 
@@ -269,36 +269,36 @@ if (typeof(sprintf) === 'undefined') {
                     falpha, 'a -> err, c'  // missing cb
                    );
     };
-    t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
+    t.throws(fn, 'found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c');
     done();
   });
 
   test('extra arg throws error', function (done) {
     var fn = function () {
-      var r = react('myName', 'a, b, cb -> err, c, d', 
+      var r = react('myName', 'a, b, cb -> err, c, d',
                     falpha, 'a, cb -> err, c', { after: fbeta },
                     fbeta,  'a, b -> returns d',
                     'extraBadArg'
                    );
     };
-    t.throws(fn, new Error('extra unmatched task arg: extraBadArg'));
-    done();  
+    t.throws(fn, 'extra unmatched task arg: extraBadArg');
+    done();
   });
 
   test('not enough args throws error', function (done) {
     var fn = function () {
-      var r = react('myName', 'a, b, cb -> err, c, d', 
+      var r = react('myName', 'a, b, cb -> err, c, d',
                     falpha, 'a, cb -> err, c', { after: fbeta },
                     fbeta
                    );
     };
-    t.throws(fn, new Error(sprintf('extra unmatched task arg: %s', fbeta)));
-    done();  
+    t.throws(fn, sprintf('extra unmatched task arg: %s', fbeta));
+    done();
   });
 
   test('long example', function (done) {
     /*jshint white: false */
-    
+
     function loadUser(uid, cb){ setTimeout(cb, 100, null, "User"+uid); }
     function loadFile(filename, cb){ setTimeout(cb, 100, null, 'Filedata'+filename); }
     function markdown(filedata) { return 'html'+filedata; }
@@ -307,17 +307,19 @@ if (typeof(sprintf) === 'undefined') {
     function loadEmailTemplate(cb) { setTimeout(cb, 50, null, 'emailmd'); }
     function customizeEmail(user, emailHtml) { return 'cust-'+user+emailHtml; }
     function deliverEmail(custEmailHtml, cb) { setTimeout(cb, 100, null, 'delivered-'+custEmailHtml); }
-    var loadAndSave = react('loadAndSave', 'filename, uid, outDirname, cb -> err, html, user, bytesWritten',  // name, in/out params
-                            loadUser,         'uid, cb          -> err, user',     // calling async fn loadUser with uid, callback is called with err and user
-                            loadFile,         'filename, cb     -> err, filedata',
-                            markdown,         'filedata         -> html',    // using a sync function
-                            prepareDirectory, 'outDirname, cb   -> err, dircreated',
-                            writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
-                            loadEmailTemplate, 'cb              -> err, emailmd',
-                            markdown,         'emailmd          -> emailHtml',   // using a sync function
-                            customizeEmail,   'user, emailHtml  -> custEmailHtml',
-                            deliverEmail,     'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
-                           );
+    var loadAndSave = react(
+      'loadAndSave',     'filename, uid, outDirname, cb -> err, html, user, bytesWritten',  // name, in/out params
+      loadUser,          'uid, cb           -> err, user',     // calling async fn loadUser with uid, cb is called w/ err & user
+      loadFile,          'filename, cb      -> err, filedata',
+      markdown,          'filedata          -> html',    // using a sync function
+      prepareDirectory,  'outDirname, cb    -> err, dircreated',
+      writeOutput,       'html, user, cb    -> err, bytesWritten', { after: prepareDirectory },  // after prepareDirectory done
+      loadEmailTemplate, 'cb                -> err, emailmd',
+      markdown,          'emailmd           -> emailHtml',   // using a sync function
+      customizeEmail,    'user, emailHtml   -> custEmailHtml',
+      deliverEmail,      'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
+    );
+
     loadAndSave('file.md', 100, '/tmp/foo', function (err, html, user, bytesWritten) {  // executing the flow
       t.equal(err, null);
       t.equal(html, 'htmlFiledatafile.md');
@@ -327,11 +329,11 @@ if (typeof(sprintf) === 'undefined') {
     });
   });
 
-  // selectFirst 
+  // selectFirst
 
   test('selectFirst', function (done) {
     var r = react.selectFirst('myName', 'a, b, cb -> err, c',
-                              { otherOptFoo: 'foo'},  // main options                            
+                              { otherOptFoo: 'foo'},  // main options
                               falpha, 'a, b, cb -> err, c',
                               fbeta,  'a, b -> c'
                              );
@@ -344,7 +346,7 @@ if (typeof(sprintf) === 'undefined') {
     t.deepEqual(r.ast.outTask, { type: 'finalcbFirst', a: ['c'] });
     t.equal(r.ast.name, 'myName', 'name should match if supplied');
     t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
-    done();  
+    done();
   });
 
-}());  
+}());