react 0.6.3 → 0.7.0

package/test/validate-ret-task.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true util:true sprintf:true validate:true */
 
 if (typeof(chai) === 'undefined') {
@@ -22,6 +21,7 @@ if (typeof(validate) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -36,19 +36,19 @@ if (typeof(validate) === 'undefined') {
 
   test('retTask requires f, a, out', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'ret' }],
       outTask: { a: ['bar'] }
     };
     var msg = sprintf('retTask requires f, a, out - %s',
                       util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
-  
+
   test('retTask verifies f type', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
       outTask: { a: ['bar'] }
     };
@@ -61,50 +61,50 @@ if (typeof(validate) === 'undefined') {
 
   test('retTask verifies a type', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
       outTask: { a: ['bar'] }
     };
     ast.tasks[0].a = 'foo'; //err should be arr of strings
     var msg = sprintf('retTask requires a to be an array of string param names - %s',
                       util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
 
     ast = Object.create(ast);
     ast.tasks[0].a = ['foo', 1]; //err should be arr of strings
     msg = sprintf('retTask requires a to be an array of string param names - %s',
                   util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
 
   test('retTask verifies out type', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
       outTask: { a: ['bar'] }
     };
     ast.tasks[0].out = 'foo'; //err should be array with single string or []
     var msg = sprintf('retTask requires out to be an array with single string param name or [] - %s',
                       util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
 
     ast = Object.create(ast);
     ast.tasks[0].out = 123; //err should be array with single string or []
     msg = sprintf('retTask requires out to be an array with single string param name or [] - %s',
                   util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
 
   test('valid retTask', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
       outTask: { a: ['bar'] }
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
-}());  
+}());

package/test/validate.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true util:true sprintf:true validate:true taskUtil:true */
 
 if (typeof(chai) === 'undefined') {
@@ -26,6 +25,7 @@ if (typeof(taskUtil) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
@@ -57,7 +57,7 @@ if (typeof(taskUtil) === 'undefined') {
     t.deepEqual(validate(ast), ['ast.inParams must be an array of strings']);
 
     ast.inParams = [1]; //err not an array of strings
-    t.deepEqual(validate(ast), ['ast.inParams must be an array of strings']);  
+    t.deepEqual(validate(ast), ['ast.inParams must be an array of strings']);
     done();
   });
 
@@ -73,19 +73,19 @@ if (typeof(taskUtil) === 'undefined') {
 
   test('each task must be an object', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [1],  //err not array of objects
       outTask: { a: ['bar'] }
     };
-    t.deepEqual(validate(ast), ['task must be an object - 1']);  
+    t.deepEqual(validate(ast), ['task must be an object - 1']);
     done();
-    
+
   });
 
-  
+
   test('each task in ast.tasks must match a valid task type', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ type: 'zoo', f: foo, a: [], out: ['bar'] }], //err wrong type
       outTask: { a: ['bar'] }
     };
@@ -97,48 +97,48 @@ if (typeof(taskUtil) === 'undefined') {
 
   test('ast.outTask.a should be an array of string param names', function (done) {
     var ast = {
-      inParams: ['a'], 
-      tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }], 
+      inParams: ['a'],
+      tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] }
     };
     ast.outTask = {}; //err a should be an arr
     var msg = sprintf('ast.outTask.a should be an array of string param names - %s',
                       util.inspect({ type: 'finalcb' }));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
 
     ast.outTask = { type: 'finalcb', a: 'bar' }; //err a should be an arr
     msg = sprintf('ast.outTask.a should be an array of string param names - %s',
                   util.inspect(ast.outTask));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
 
     ast.outTask = { type: 'finalcb', a: ['bar', 1] }; //err a should be an arr of strings
     msg = sprintf('ast.outTask.a should be an array of string param names - %s',
                   util.inspect(ast.outTask));
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
 
     ast.outTask = { a: [] }; //valid
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('ast.tasks that specify name need to be unique', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [
         { f: foo, a: [], out: ['bar'], name: 'dog' },
         { f: foo, a: [], out: ['bar'], name: 'dog' }
-      ], 
+      ],
       outTask: { a: ['bar'] }
     };
     var msg = sprintf('ast.tasks that specify name need to be unique, duplicate: %s',
                       'dog');
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
-  
+
   test('ast.locals should be non-null if passed in', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: null  //err should be non-null if passed in
@@ -152,173 +152,173 @@ if (typeof(taskUtil) === 'undefined') {
 
   test('non-method string functions need to map to fn in locals or in params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'foo', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { }
     };
-    var msg = sprintf('function: %s not found in locals or input params - task[%s]', 
+    var msg = sprintf('function: %s not found in locals or input params - task[%s]',
                       'foo', 0);
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
 
   test('string functions maps to fn in locals', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'cat.bar', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { cat: { bar: foo }}
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('string functions maps to fn in inputs', function (done) {
     var ast = {
-      inParams: ['a1', 'dog'], 
+      inParams: ['a1', 'dog'],
       tasks: [{ f: 'dog.food', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { }
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('string functions need to map to fn in locals or in params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'foo.bar', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { foo: {}}
     };
-    var msg = sprintf('function: %s not found in locals or input params - task[%s]', 
+    var msg = sprintf('function: %s not found in locals or input params - task[%s]',
                       'foo.bar', 0);
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
 
   test('param func str fn need to map to fn in locals or in params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'a', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { }
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('param obj exist func str needs map to fn in locals or in params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'a.b', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { }
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('param obj !exist func str needs map to fn in locals or in params', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [{ f: 'd.e', a: [], out: ['bar'], type: 'ret' }],
       outTask: { a: ['bar'] },
       locals: { }
     };
-    t.deepEqual(validate(ast), []);  
+    t.deepEqual(validate(ast), []);
     done();
   });
 
   test('multiple tasks output the same param, must be unique', function (done) {
     var ast = {
-      inParams: ['a'], 
+      inParams: ['a'],
       tasks: [
         { f: foo, a: [], out: ['baz', 'c'] },
         { f: bar, a: [], out: ['c'] }
-      ], 
+      ],
       outTask: { a: ['baz'] }
     };
     var msg = 'multiple tasks output the same param, must be unique. param: c';
-    t.deepEqual(validate(ast), [msg]);  
+    t.deepEqual(validate(ast), [msg]);
     done();
   });
 
   test('missing or mispelled input variable', function (done) {
     var ast = {
-      inParams: [], 
+      inParams: [],
       tasks: [
         { f: foo, a: [], out: [] },
         { f: bar, a: ['abc'], out: [] }
-      ], 
+      ],
       outTask: { a: [] }
     };
     var msg = 'missing or mispelled variable referenced in flow definition: abc';
-    t.deepEqual(validate(ast), [msg]);  
-    done();  
+    t.deepEqual(validate(ast), [msg]);
+    done();
   });
 
   test('missing or mispelled input variables', function (done) {
     var ast = {
-      inParams: ['aaa', 'bbb'], 
+      inParams: ['aaa', 'bbb'],
       tasks: [
         { f: foo, a: ['aaa', 'cat'], out: ['ccc'] },
         { f: bar, a: ['abc', 'bbb', 'ccc'], out: [] }
-      ], 
+      ],
       outTask: { a: [] }
     };
     var messages = [
       'missing or mispelled variable referenced in flow definition: cat',
       'missing or mispelled variable referenced in flow definition: abc'
     ];
-    t.deepEqual(validate(ast), messages);  
-    done();  
+    t.deepEqual(validate(ast), messages);
+    done();
   });
 
   test('missing or mispelled final output variables', function (done) {
     var ast = {
-      inParams: ['aaa'], 
+      inParams: ['aaa'],
       tasks: [
         { f: foo, a: ['aaa'], out: ['bbb'] },
         { f: bar, a: ['bbb'], out: ['ccc'] }
-      ], 
+      ],
       outTask: { a: ['ccc', 'ddd', 'eee'] }
     };
     var messages = [
       'missing or mispelled variable referenced in flow definition: ddd',
       'missing or mispelled variable referenced in flow definition: eee'
     ];
-    t.deepEqual(validate(ast), messages);  
-    done();  
+    t.deepEqual(validate(ast), messages);
+    done();
   });
 
   test('missing or mispelled validation ignores properties', function (done) {
     var ast = {
-      inParams: ['obj'], 
+      inParams: ['obj'],
       tasks: [
         { f: foo, a: ['obj.foo'], out: [] },
         { f: bar, a: ['obj.bar'], out: [] }
-      ], 
+      ],
       outTask: { a: ['obj.cat'] }
     };
-    t.deepEqual(validate(ast), []);  
-    done();  
+    t.deepEqual(validate(ast), []);
+    done();
   });
 
   test('missing or mispelled validation ignores literals', function (done) {
     var ast = {
-      inParams: [], 
+      inParams: [],
       tasks: [
         { f: foo, a: ['true', 'false', '123', '123.1', 'null'], out: [] },
         { f: bar, a: ['-123', '-123.4', '"wow"', "'hey'"], out: [] },
         { f: foo, a: ['"two-words"', "'also-two'", '"two.words"', "'also.two'"], out: [] },
         { f: foo, a: ['this'], out: [] }
-      ], 
+      ],
       outTask: { a: [] }
     };
-    t.deepEqual(validate(ast), []);  
-    done();  
+    t.deepEqual(validate(ast), []);
+    done();
   });
 
 }());

package/test/vcon.mocha.js

@@ -1,4 +1,3 @@
-'use strict';
 /*global react:true VContext:true */
 
 if (typeof(chai) === 'undefined') {
@@ -14,11 +13,12 @@ if (typeof(VContext) === 'undefined') {
 }
 
 (function () {
+  'use strict';
 
   var t = chai.assert;
 
   /**
-     Testing Variable Context 
+     Testing Variable Context
   */
 
   suite('vcon');
@@ -86,10 +86,10 @@ if (typeof(VContext) === 'undefined') {
   test('getVar on literals returns the literal', function (done) {
     t.equal(VContext.create([], []).getVar(true), true);
     t.equal(VContext.create([], []).getVar(false), false);
-    t.equal(VContext.create([], []).getVar(null), null);  
+    t.equal(VContext.create([], []).getVar(null), null);
     t.equal(VContext.create([], []).getVar('true'), true);
     t.equal(VContext.create([], []).getVar('false'), false);
-    t.equal(VContext.create([], []).getVar('null'), null);  
+    t.equal(VContext.create([], []).getVar('null'), null);
     t.equal(VContext.create([], []).getVar(-100), -100);
     t.equal(VContext.create([], []).getVar(100), 100);
     t.equal(VContext.create([], []).getVar(123.4), 123.4);
@@ -113,7 +113,7 @@ if (typeof(VContext) === 'undefined') {
     t.equal(VContext.create([o], ['a']).getVar('a.b'), 100);
     o = { b: { c: 200 }};
     t.equal(VContext.create([o], ['a']).getVar('a.b.c'), 200);
-    done();  
+    done();
   });
 
   test('setVar will create objects if needed', function (done) {
@@ -141,14 +141,14 @@ if (typeof(VContext) === 'undefined') {
     var v = VContext.create([{ bar: 1}], ['foo']);
     v.setVar(null, 2);
     t.deepEqual(v.values, { foo: { bar: 1 }});
-    done();  
+    done();
   });
 
   test('setVar with undefined key, will not set anything', function (done) {
     var v = VContext.create([{ bar: 1}], ['foo']);
     v.setVar(undefined, 2);
     t.deepEqual(v.values, { foo: { bar: 1 }});
-    done();  
+    done();
   });
 
   test('saveResults will set values for params and :LAST_RESULTS', function (done) {
@@ -156,7 +156,7 @@ if (typeof(VContext) === 'undefined') {
     v.saveResults(['foo', 'bar', 'cat'], [1, 'hello', null]);
     t.deepEqual(v.values, { foo: 1, bar: 'hello', cat: null,
                             ':LAST_RESULTS': [1, 'hello', null] });
-    done();  
+    done();
   });
 
   test('saveResults set :LAST_RESULT w/all even params is short', function (done) {
@@ -164,7 +164,7 @@ if (typeof(VContext) === 'undefined') {
     v.saveResults(['foo'], [1, 'hello', null]);
     t.deepEqual(v.values, { foo: 1,
                             ':LAST_RESULTS': [1, 'hello', null] });
-    done();  
+    done();
   });
 
   test('saveResults will set values for params and :LAST_RESULTS', function (done) {
@@ -172,22 +172,22 @@ if (typeof(VContext) === 'undefined') {
     v.saveResults(['foo', 'bar', 'cat'], [1, 'hello', null]);
     t.deepEqual(v.values, { foo: 1, bar: 'hello', cat: null,
                             ':LAST_RESULTS': [1, 'hello', null] });
-    done();  
+    done();
   });
 
   test('saveResults upgrades undefined to null, but :LAST_RESULT is exact', function (done) {
     var v = VContext.create([], []);
     v.saveResults(['foo', 'bar', 'baz'], [1, undefined]);
-    t.deepEqual(v.values, { foo: 1, bar: null, baz: null, 
+    t.deepEqual(v.values, { foo: 1, bar: null, baz: null,
                             ':LAST_RESULTS': [1, undefined] });
-    done();  
+    done();
   });
 
   test('saveResults null params skips saving, :LAST_RESULT is exact', function (done) {
     var v = VContext.create([], []);
     v.saveResults(['foo', null], [1, 20]); //skip second param
     t.deepEqual(v.values, { foo: 1, ':LAST_RESULTS': [1, 20] });
-    done();  
+    done();
   });
 
 }());