Embed value capturing helper into transpiled code

CHANGELOG.md

@@ -1,3 +1,27 @@
+### [1.3.2](https://github.com/power-assert-js/espower/releases/tag/v1.3.2) (2016-06-22)
+
+
+#### Bug Fixes
+
+  * fix breaking changes introduced in 1.3.0 and 1.3.1
+
+
+### [1.3.1](https://github.com/power-assert-js/espower/releases/tag/v1.3.1) (2016-06-21)
+
+
+#### Bug Fixes
+
+  * stop capturing SequenceExpression itself since SequenceExpressions are not enclosed in parentheses in some cases ([e8acbc61](https://github.com/power-assert-js/espower/commit/e8acbc61810454da05098baf6624b57d68deb3f9))
+
+
+## [1.3.0](https://github.com/power-assert-js/espower/releases/tag/v1.3.0) (2016-06-21)
+
+
+#### Features
+
+  * [Support SequenceExpression (i.e., comma operator)](https://github.com/power-assert-js/espower/pull/27)
+
+
 ### [1.2.1](https://github.com/power-assert-js/espower/releases/tag/v1.2.1) (2015-11-06)
 
 

gulpfile.js

@@ -7,12 +7,16 @@ var mochaPhantomJS = require('gulp-mocha-phantomjs');
 var webserver = require('gulp-webserver');
 var del = require('del');
 var path = require('path');
+var fs = require('fs');
 var source = require('vinyl-source-stream');
 var through = require('through2');
 var browserify = require('browserify');
 var licensify = require('licensify');
+var packageJsonVersionify = require('package-json-versionify');
 var dereserve = require('gulp-dereserve');
 var derequire = require('gulp-derequire');
+var acorn = require('acorn');
+var espurify = require('espurify');
 var config = {
     jshint: {
         src: './lib/**/*.js'
@@ -146,6 +150,7 @@ gulp.task('clean_bundle', function () {
 gulp.task('bundle', ['clean_bundle'], function() {
     var b = browserify({entries: config.bundle.srcFile, standalone: config.bundle.standalone});
     b.plugin(licensify);
+    b.transform(packageJsonVersionify, {global: true});
     var bundleStream = b.bundle();
     return bundleStream
         .pipe(source(config.bundle.destName))
@@ -160,6 +165,7 @@ LOCAL_BUILDS.forEach(function (name) {
     });
     gulp.task(name + '_bundle', ['clean_' + name + '_bundle'], function() {
         var b = browserify({standalone: config[name + '_bundle'].standalone});
+        b.transform(packageJsonVersionify, {global: true});
         if (config[name + '_bundle'].srcFile) {
             b.add(config[name + '_bundle'].srcFile);
         }
@@ -175,7 +181,15 @@ LOCAL_BUILDS.forEach(function (name) {
 gulp.task('clean_deps', LOCAL_BUILDS.map(function (name) { return 'clean_' + name + '_bundle'; }));
 gulp.task('build_deps', LOCAL_BUILDS.map(function (name) { return name + '_bundle'; }));
 
-gulp.task('unit', function () {
+gulp.task('generate_recorder_json', function (done) {
+    var filepath = path.join(__dirname, 'power-assert-recorder.js');
+    var ast = acorn.parse(fs.readFileSync(filepath), { ecmaVersion: 6, locations: true });
+    var callexp = espurify(ast).body[0].expression;
+    fs.writeFileSync(path.join(__dirname, 'lib', 'power-assert-recorder.json'), JSON.stringify(callexp, null, 2));
+    done();
+});
+
+gulp.task('unit', ['generate_recorder_json'], function () {
     return runMochaSimply();
 });
 

lib/assertion-visitor.js

@@ -5,7 +5,6 @@ var escodegen = require('escodegen');
 var espurify = require('espurify');
 var espurifyWithRaw = espurify.customize({extra: 'raw'});
 var isArray = require('isarray');
-var deepEqual = require('deep-equal');
 var syntax = estraverse.Syntax;
 var EspowerLocationDetector = require('espower-location-detector');
 var EspowerError = require('./espower-error');
@@ -20,10 +19,12 @@ var canonicalCodeOptions = {
     },
     verbatim: 'x-verbatim-espower'
 };
+var recorderClassAst = require('./power-assert-recorder.json');
 
 function AssertionVisitor (matcher, options) {
     this.matcher = matcher;
-    this.options = options || {};
+    this.options = options;
+    this.valueRecorder = null;
     this.locationDetector = new EspowerLocationDetector(this.options);
     this.currentArgumentPath = null;
     this.argumentModified = false;
@@ -33,7 +34,6 @@ AssertionVisitor.prototype.enter = function (controller) {
     this.assertionPath = [].concat(controller.path());
     var currentNode = controller.current();
     this.canonicalCode = this.generateCanonicalCode(currentNode);
-    this.powerAssertCalleeObject = this.guessPowerAssertCalleeObjectFor(currentNode.callee);
     this.location = this.locationDetector.locationFor(currentNode);
     var enclosingFunc = findEnclosingFunction(controller.parents());
     this.withinGenerator = enclosingFunc && enclosingFunc.generator;
@@ -52,6 +52,8 @@ AssertionVisitor.prototype.enterArgument = function (controller) {
         return undefined;
     }
     this.verifyNotInstrumented(currentNode);
+    // create recorder per argument
+    this.valueRecorder = this.createNewRecorder(controller);
     // entering target argument
     this.currentArgumentPath = [].concat(controller.path());
     return undefined;
@@ -67,6 +69,7 @@ AssertionVisitor.prototype.leaveArgument = function (resultTree) {
     } finally {
         this.currentArgumentPath = null;
         this.argumentModified = false;
+        this.valueRecorder = null;
     }
 };
 
@@ -76,13 +79,12 @@ AssertionVisitor.prototype.captureNode = function (controller) {
     var path = controller.path();
     var n = newNodeWithLocationCopyOf(currentNode);
     var relativeEsPath = path.slice(this.assertionPath.length);
-    var newCalleeObject = updateLocRecursively(espurify(this.powerAssertCalleeObject), n, this.options.visitorKeys);
     return n({
         type: syntax.CallExpression,
         callee: n({
             type: syntax.MemberExpression,
             computed: false,
-            object: newCalleeObject,
+            object: this.valueRecorder,
             property: n({
                 type: syntax.Identifier,
                 name: '_capt'
@@ -152,7 +154,6 @@ AssertionVisitor.prototype.generateCanonicalCode = function (node) {
 AssertionVisitor.prototype.captureArgument = function (node) {
     var n = newNodeWithLocationCopyOf(node);
     var props = [];
-    var newCalleeObject = updateLocRecursively(espurify(this.powerAssertCalleeObject), n, this.options.visitorKeys);
     addLiteralTo(props, n, 'content', this.canonicalCode);
     addLiteralTo(props, n, 'filepath', this.location.source);
     addLiteralTo(props, n, 'line', this.location.line);
@@ -167,7 +168,7 @@ AssertionVisitor.prototype.captureArgument = function (node) {
         callee: n({
             type: syntax.MemberExpression,
             computed: false,
-            object: newCalleeObject,
+            object: this.valueRecorder,
             property: n({
                 type: syntax.Identifier,
                 name: '_expr'
@@ -189,24 +190,90 @@ AssertionVisitor.prototype.verifyNotInstrumented = function (currentNode) {
     }
     var prop = currentNode.callee.property;
     if (prop.type === syntax.Identifier && prop.name === '_expr') {
-        if (astEqual(currentNode.callee.object, this.powerAssertCalleeObject)) {
-            var errorMessage = 'Attempted to transform AST twice.';
-            if (this.options.path) {
-                errorMessage += ' path: ' + this.options.path;
-            }
-            throw new EspowerError(errorMessage, this.verifyNotInstrumented);
+        var errorMessage = 'Attempted to transform AST twice.';
+        if (this.options.path) {
+            errorMessage += ' path: ' + this.options.path;
         }
+        throw new EspowerError(errorMessage, this.verifyNotInstrumented);
     }
 };
 
-AssertionVisitor.prototype.guessPowerAssertCalleeObjectFor = function (node) {
-    switch(node.type) {
-    case syntax.Identifier:
-        return node;
-    case syntax.MemberExpression:
-        return node.object; // Returns browser.assert when browser.assert.element(selector)
+AssertionVisitor.prototype.createNewRecorder = function (controller) {
+    var currentScope = this.options.currentScope;
+    var scopeBlockEspath = findEspathOfAncestorNode(currentScope.block, controller);
+    var recorderConstructorName = this.getRecorderConstructorName(controller);
+    var recorderVariableName = this.options.transformation.generateUniqueName('rec');
+
+    var currentNode = controller.current();
+    var createNode = newNodeWithLocationCopyOf(currentNode);
+    var ident = createNode({
+        type: syntax.Identifier,
+        name: recorderVariableName
+    });
+    var init = this.createNewExpression(createNode, recorderConstructorName);
+    var decl = this.createVariableDeclaration(createNode, ident, init);
+    this.options.transformation.register(scopeBlockEspath, function (matchNode) {
+        var body;
+        if (/Function/.test(matchNode.type)) {
+            var blockStatement = matchNode.body;
+            body = blockStatement.body;
+        } else {
+            body = matchNode.body;
+        }
+        insertAfterUseStrictDirective(decl, body);
+    });
+    return ident;
+};
+
+AssertionVisitor.prototype.getRecorderConstructorName = function (controller) {
+    var ctorName = this.options.storage.powerAssertRecorderConstructorName;
+    if (!ctorName) {
+        ctorName = this.createRecorderClass(controller);
     }
-    return null;
+    return ctorName;
+};
+
+AssertionVisitor.prototype.createRecorderClass = function (controller) {
+    var globalScope = this.options.globalScope;
+    var globalScopeBlockEspath = findEspathOfAncestorNode(globalScope.block, controller);
+    var createNode = newNodeWithLocationCopyOf(globalScope.block);
+    var ctorName = this.options.transformation.generateUniqueName('PowerAssertRecorder');
+    var ident = createNode({
+        type: syntax.Identifier,
+        name: ctorName
+    });
+    var classDef = updateLocRecursively(espurify(recorderClassAst), createNode, this.options.visitorKeys);
+    var decl = this.createVariableDeclaration(createNode, ident, classDef);
+    this.options.transformation.register(globalScopeBlockEspath, function (matchNode) {
+        insertAfterUseStrictDirective(decl, matchNode.body);
+    });
+    this.options.storage.powerAssertRecorderConstructorName = ctorName;
+    return ctorName;
+};
+
+AssertionVisitor.prototype.createVariableDeclaration = function (createNode, ident, init) {
+    return createNode({
+        type: syntax.VariableDeclaration,
+        declarations: [
+            createNode({
+                type: syntax.VariableDeclarator,
+                id: ident,
+                init: init
+            })
+        ],
+        kind: 'var'
+    });
+};
+
+AssertionVisitor.prototype.createNewExpression = function (createNode, constructorName) {
+    return createNode({
+        type: syntax.NewExpression,
+        callee: createNode({
+            type: syntax.Identifier,
+            name: constructorName
+        }),
+        arguments: []
+    });
 };
 
 function addLiteralTo (props, createNode, name, value) {
@@ -278,8 +345,40 @@ function newNodeWithLocationCopyOf (original) {
     };
 }
 
-function astEqual (ast1, ast2) {
-    return deepEqual(espurify(ast1), espurify(ast2));
+function findEspathOfAncestorNode (targetNode, controller) {
+    // iterate child to root
+    var child, parent;
+    var path = controller.path();
+    var parents = controller.parents();
+    var popUntilParent = function (key) {
+        if (parent[key] !== undefined) {
+            return;
+        }
+        popUntilParent(path.pop());
+    };
+    for (var i = parents.length - 1; i >= 0; i--) {
+        parent = parents[i];
+        if (child) {
+            popUntilParent(path.pop());
+        }
+        if (parent === targetNode) {
+            return path.join('/');
+        }
+        child = parent;
+    }
+    return null;
+}
+
+function insertAfterUseStrictDirective (decl, body) {
+    var firstBody = body[0];
+    if (firstBody.type === syntax.ExpressionStatement) {
+        var expression = firstBody.expression;
+        if (expression.type === syntax.Literal && expression.value === 'use strict') {
+            body.splice(1,0, decl);
+            return;
+        }
+    }
+    body.unshift(decl);
 }
 
 function isFunction (node) {