feat(power-assert-formatter): add support for yield statements

From what I can tell, there is no way to get esprima to parse a
yield statement that is not wrapped in a generator function.
To work around this: try to parse normally first, then try
parsing by wrapping with a generator statement. If it works
the second time, then we assume it is due to a yield statement.

Author: jamestalmage

lib/traverse.js

@@ -24,14 +24,14 @@ ContextTraversal.prototype.traverse = function () {
 };
 
 function onEachEsNode(arg, jsCode, callback) {
-    var jsAST = esprima.parse(jsCode, {sourceType: 'module', tolerant: true, loc: true, tokens: true, raw: true});
-    var tokens = jsAST.tokens;
+    var parseResult = parse(jsCode);
+    var tokens = parseResult.tokens;
     var espathToValue = reduce(arg.events, function (accum, ev) {
         accum[ev.espath] = ev.value;
         return accum;
     }, {});
     var nodeStack = [];
-    estraverse.traverse(extractExpressionFrom(jsAST), {
+    estraverse.traverse(parseResult.expression, {
         enter: function (currentNode, parentNode) {
             var esNode = new EsNode(this.path(), currentNode, parentNode, espathToValue, jsCode, tokens);
             if (1 < nodeStack.length) {
@@ -46,6 +46,33 @@ function onEachEsNode(arg, jsCode, callback) {
     });
 }
 
+function parserOptions() {
+    return {sourceType: 'module', tolerant: true, loc: true, tokens: true, raw: true};
+}
+
+function wrappedInGenerator(jsCode) {
+    return 'function *wrapper() {\n' + jsCode + '\n}';
+}
+
+function parse(jsCode) {
+    var ast;
+    var top;
+    try {
+        // Try parsing the raw line of code, without wrapping.
+        top = ast = esprima.parse(jsCode, parserOptions());
+    } catch (e) {
+        // Esprima will throw an error if YieldExpressions are not inside a generator function.
+        // Since we only have a single line of code to work with; wrap it with a dummy generator function;
+        // then unwrap the original code from the resulting AST.
+        ast = esprima.parse(wrappedInGenerator(jsCode), parserOptions());
+        top = ast.body[0].body;
+    }
+    return {
+        tokens: ast.tokens,
+        expression: extractExpressionFrom(top)
+    };
+}
+
 function extractExpressionFrom (tree) {
     var expressionStatement = tree.body[0];
     var expression = expressionStatement.expression;

package.json

@@ -27,11 +27,12 @@
     "babel-core": "^5.8.22",
     "babel-plugin-espower": "^1.0.0",
     "blanket": "^1.1.7",
+    "bluebird": "^3.0.5",
     "browserify": "^11.0.1",
     "del": "^1.2.1",
     "empower": "^1.0.0",
     "escodegen": "^1.6.1",
-    "espower": "^1.0.6",
+    "espower": "^1.1.0",
     "gulp": "^3.9.0",
     "gulp-derequire": "^2.1.0",
     "gulp-dereserve": "^0.2.1",
@@ -44,6 +45,7 @@
     "licensify": "^2.0.1",
     "mocha": "^2.2.5",
     "mocha-lcov-reporter": "^0.0.2",
+    "regenerator": "^0.8.41",
     "through2": "^2.0.0",
     "vinyl-source-stream": "^1.1.0"
   },

test/es6_test.js

@@ -16,12 +16,28 @@ function weave (line) {
     }).code;
 }
 
-function assertPowerAssertContextFormatting (body, expectedLines) {
-    try {
-        body();
-        baseAssert.fail('AssertionError should be thrown');
-    } catch (e) {
-        baseAssert.equal(e.message, expectedLines.join('\n'));
+function assertPowerAssertContextFormatting (body, expectedLines, done) {
+    if (done) {
+        baseAssert.equal(body.length, 1, 'body should accept a "done" callback');
+        body(function (e) {
+            try {
+                if (!e) {
+                    baseAssert.fail('AssertionError should be thrown');
+                }
+                baseAssert.equal(e.message, expectedLines.join('\n'));
+            } catch (err) {
+                return done(err);
+            }
+            done();
+        });
+    } else {
+        baseAssert.equal(body.length, 0, 'assertPowerAssertContextFormatting must be passed a "done" callback if "body" needs to run async');
+        try {
+            body();
+            baseAssert.fail('AssertionError should be thrown');
+        } catch (e) {
+            baseAssert.equal(e.message, expectedLines.join('\n'));
+        }
     }
 }
 
@@ -91,4 +107,38 @@ suite('ES6 features', function () {
         ]);
     });
 
+    test('Yield Statements', function (done) {
+        assertPowerAssertContextFormatting(function (done) {
+            var Promise = require('bluebird');
+            var regeneratorRuntime = require('regenerator/runtime-module');
+            var big = 'big';
+            eval(weave([
+                'function bigOrSmall(size) {',
+                '  return Promise.resolve(size > 100 ? "big" : "small");',
+                '}',
+                '',
+                'function *myGenerator (input) {',
+                '  assert((yield bigOrSmall(input)) === big);',
+                '}',
+                '',
+                'var gen = myGenerator(3);',
+                'gen.next().value.then((val) => gen.next(val)).catch(done);'
+            ].join('\n')));
+        }, [
+            '  # test/some_test.js:6',
+            '  ',
+            '  assert((yield bigOrSmall(input)) === big)',
+            '          |                |       |   |   ',
+            '          |                |       |   "big"',
+            '          "small"          3       false   ',
+            '  ',
+            '  --- [string] big',
+            '  +++ [string] yield bigOrSmall(input)',
+            '  @@ -1,3 +1,5 @@',
+            '  -big',
+            '  +small',
+            '  ',
+            '  '
+        ], done);
+    });
 });