feat(babel-plugin-espower): embed assertion's AST and tokens to make …

…runtime side parser unnecessary

lib/babel-assertion-visitor.js

@@ -2,10 +2,13 @@
 
 var EspowerLocationDetector = require('espower-location-detector');
 var estraverse = require('estraverse');
+var cloneWithWhitelist = require('espurify').cloneWithWhitelist;
 var babelgen = require('babel-generator');
 var define = require('define-properties');
 var toBeCaptured = require('./to-be-captured');
 var toBeSkipped = require('./to-be-skipped');
+var clone = require('clone');
+var path = require('path');
 var fs = require('fs');
 var helperCode = '(' +
   fs.readFileSync(require.resolve('./power-assert-recorder.js'), 'utf8')
@@ -24,16 +27,22 @@ function BabelAssertionVisitor (babel, matcher, options) {
     this.locationDetector = new EspowerLocationDetector(this.options);
     var babelTemplate = babel.template;
     this.helperTemplate = babelTemplate(helperCode);
+    var whiteListWithLoc = Object.keys(options.astWhiteList).reduce(function (acc, key) {
+        acc[key] = options.astWhiteList[key].concat(['loc']);
+        return acc;
+    }, {});
+    this.purifyAst = cloneWithWhitelist(whiteListWithLoc);
 }
 
 BabelAssertionVisitor.prototype.enter = function (nodePath) {
     this.assertionNodePath = nodePath;
     var currentNode = nodePath.node;
-    this.canonicalCode = this.generateCanonicalCode(currentNode);
     this.location = this.locationDetector.locationFor(currentNode);
     var enclosingFunc = this.findEnclosingFunction(nodePath);
     this.withinGenerator = enclosingFunc && enclosingFunc.generator;
     this.withinAsync = enclosingFunc && enclosingFunc.async;
+    var file = nodePath.hub.file;
+    this.generateCanonicalCode(file, currentNode); // should be next to enclosingFunc detection
     // store original espath for each node
     var visitorKeys = this.options.visitorKeys;
     estraverse.traverse(currentNode, {
@@ -132,11 +141,98 @@ BabelAssertionVisitor.prototype.isGeneratedNode = function (nodePath) {
 
 // internal
 
-BabelAssertionVisitor.prototype.generateCanonicalCode = function (node) {
+BabelAssertionVisitor.prototype.generateCanonicalCode = function (file, node) {
+    var src = path.basename(file.opts.filename);
     var gen = new babelgen.CodeGenerator(node, { concise: true, comments: false });
-    return gen.generate().code;
+    var output = gen.generate();
+    this.canonicalCode = output.code;
+    var astAndTokens = this.parseCanonicalCode(file, this.canonicalCode);
+    this.ast = JSON.stringify(this.purifyAst(astAndTokens.expression));
+    this.tokens = JSON.stringify(astAndTokens.tokens);
+};
+
+BabelAssertionVisitor.prototype.parseCanonicalCode = function (file, code) {
+    var ast, tokens;
+
+    function doParse(wrapper) {
+        var content = wrapper ? wrapper(code) : code;
+        var output = file.parse(content);
+        if (wrapper) {
+            ast = output.program.body[0].body;
+            tokens = output.tokens.slice(6, -2);
+        } else {
+            ast = output.program;
+            tokens = output.tokens.slice(0, -1);
+        }
+    }
+
+    if (this.withinAsync) {
+        doParse(wrappedInAsync);
+    } else if (this.withinGenerator) {
+        doParse(wrappedInGenerator);
+    } else {
+        doParse();
+    }
+
+    var exp = ast.body[0].expression;
+    var columnOffset = exp.loc.start.column;
+    var offsetTree = estraverse.replace(exp, {
+        keys: this.options.visitorKeys,
+        enter: function (eachNode) {
+            eachNode.loc.start = {
+                line: 1,
+                column: eachNode.loc.start.column - columnOffset
+            };
+            eachNode.loc.end = {
+                line: 1,
+                column: eachNode.loc.end.column - columnOffset
+            };
+            return eachNode;
+        }
+    });
+
+    return {
+        tokens: offsetTokens(tokens).map(slimDown),
+        expression: offsetTree
+    };
 };
 
+function wrappedInGenerator (jsCode) {
+    return 'function *wrapper() { ' + jsCode + ' }';
+}
+
+function wrappedInAsync (jsCode) {
+    return 'async function wrapper() { ' + jsCode + ' }';
+}
+
+function offsetTokens (tokens) {
+    var i, token, result = [];
+    var lineOffset, columnOffset;
+    for(i = 0; i < tokens.length; i += 1) {
+        token = clone(tokens[i]);
+        if (i === 0) {
+            columnOffset = token.loc.start.column;
+            lineOffset = token.loc.start.line - 1;
+        }
+        token.loc.start.line -= lineOffset;
+        token.loc.start.column -= columnOffset;
+        token.loc.end.line -= lineOffset;
+        token.loc.end.column -= columnOffset;
+        result.push(token);
+    }
+    return result;
+}
+
+function slimDown (token) {
+    return {
+        type: {
+            label: token.type.label
+        },
+        value: token.value,
+        loc: clone(token.loc)
+    };
+}
+
 BabelAssertionVisitor.prototype.captureArgument = function (node) {
     var t = this.babel.types;
     var props = {
@@ -150,6 +246,12 @@ BabelAssertionVisitor.prototype.captureArgument = function (node) {
     if (this.withinGenerator) {
         props.generator = true;
     }
+    if (this.ast) {
+        props.ast = this.ast;
+    }
+    if (this.tokens) {
+        props.tokens = this.tokens;
+    }
     var newNode = t.callExpression(
         t.memberExpression(this.valueRecorder, t.identifier('_expr')),
         [

package.json

@@ -19,8 +19,10 @@
     "babel-generator": "^6.1.0",
     "babylon": "^6.1.0",
     "call-matcher": "^0.1.0",
+    "clone": "^1.0.2",
     "define-properties": "^1.1.2",
     "espower-location-detector": "^0.1.1",
+    "espurify": "^1.5.0",
     "estraverse": "^4.1.1",
     "xtend": "^4.0.0"
   },