'use strict';
|
|
var estraverse = require('estraverse');
|
var escodegen = require('escodegen');
|
var espurify = require('espurify');
|
var espurifyWithRaw = espurify.customize({extra: 'raw'});
|
var syntax = estraverse.Syntax;
|
var EspowerLocationDetector = require('espower-location-detector');
|
var EspowerError = require('./espower-error');
|
var toBeSkipped = require('./rules/to-be-skipped');
|
var toBeCaptured = require('./rules/to-be-captured');
|
var canonicalCodeOptions = {
|
format: {
|
indent: {
|
style: ''
|
},
|
newline: ''
|
},
|
verbatim: 'x-verbatim-espower'
|
};
|
var recorderClassAst = require('./power-assert-recorder.json');
|
|
function AssertionVisitor (matcher, options) {
|
this.matcher = matcher;
|
this.options = options;
|
this.valueRecorder = null;
|
this.locationDetector = new EspowerLocationDetector(this.options);
|
this.currentArgumentPath = null;
|
this.argumentModified = false;
|
}
|
|
AssertionVisitor.prototype.enter = function (controller) {
|
this.assertionPath = [].concat(controller.path());
|
var currentNode = controller.current();
|
this.canonicalCode = this.generateCanonicalCode(currentNode);
|
this.location = this.locationDetector.locationFor(currentNode);
|
var enclosingFunc = findEnclosingFunction(controller.parents());
|
this.withinGenerator = enclosingFunc && enclosingFunc.generator;
|
this.withinAsync = enclosingFunc && enclosingFunc.async;
|
};
|
|
AssertionVisitor.prototype.enterArgument = function (controller) {
|
var currentNode = controller.current();
|
var parentNode = getParentNode(controller);
|
var argMatchResult = this.matcher.matchArgument(currentNode, parentNode);
|
if (!argMatchResult) {
|
return undefined;
|
}
|
if (argMatchResult.name === 'message' && argMatchResult.kind === 'optional') {
|
// skip optional message argument
|
return undefined;
|
}
|
this.verifyNotInstrumented(currentNode);
|
// create recorder per argument
|
this.valueRecorder = this.createNewRecorder(controller);
|
// entering target argument
|
this.currentArgumentPath = [].concat(controller.path());
|
return undefined;
|
};
|
|
AssertionVisitor.prototype.leave = function (controller) {
|
// nothing to do now
|
};
|
|
AssertionVisitor.prototype.leaveArgument = function (resultTree) {
|
try {
|
return this.argumentModified ? this.captureArgument(resultTree) : resultTree;
|
} finally {
|
this.currentArgumentPath = null;
|
this.argumentModified = false;
|
this.valueRecorder = null;
|
}
|
};
|
|
AssertionVisitor.prototype.captureNode = function (controller) {
|
this.argumentModified = true;
|
var currentNode = controller.current();
|
var path = controller.path();
|
var n = newNodeWithLocationCopyOf(currentNode);
|
var relativeEsPath = path.slice(this.assertionPath.length);
|
return n({
|
type: syntax.CallExpression,
|
callee: n({
|
type: syntax.MemberExpression,
|
computed: false,
|
object: this.valueRecorder,
|
property: n({
|
type: syntax.Identifier,
|
name: '_capt'
|
})
|
}),
|
arguments: [
|
currentNode,
|
n({
|
type: syntax.Literal,
|
value: relativeEsPath.join('/')
|
})
|
]
|
});
|
};
|
|
AssertionVisitor.prototype.toBeSkipped = function (controller) {
|
var currentNode = controller.current();
|
var parentNode = getParentNode(controller);
|
var currentKey = getCurrentKey(controller);
|
return toBeSkipped(currentNode, parentNode, currentKey);
|
};
|
|
AssertionVisitor.prototype.toBeCaptured = function (controller) {
|
var currentNode = controller.current();
|
var parentNode = getParentNode(controller);
|
var currentKey = getCurrentKey(controller);
|
return toBeCaptured(currentNode, parentNode, currentKey);
|
};
|
|
AssertionVisitor.prototype.isCapturingArgument = function () {
|
return !!this.currentArgumentPath;
|
};
|
|
AssertionVisitor.prototype.isLeavingAssertion = function (controller) {
|
return isPathIdentical(this.assertionPath, controller.path());
|
};
|
|
AssertionVisitor.prototype.isLeavingArgument = function (controller) {
|
return isPathIdentical(this.currentArgumentPath, controller.path());
|
};
|
|
// internal
|
|
AssertionVisitor.prototype.generateCanonicalCode = function (node) {
|
var visitorKeys = this.options.visitorKeys;
|
var ast = espurifyWithRaw(node);
|
var visitor = {
|
leave: function (currentNode, parentNode) {
|
if (currentNode.type === syntax.Literal && typeof currentNode.raw !== 'undefined') {
|
currentNode['x-verbatim-espower'] = {
|
content : currentNode.raw,
|
precedence : escodegen.Precedence.Primary
|
};
|
return currentNode;
|
} else {
|
return undefined;
|
}
|
}
|
};
|
if (visitorKeys) {
|
visitor.keys = visitorKeys;
|
}
|
estraverse.replace(ast, visitor);
|
return escodegen.generate(ast, canonicalCodeOptions);
|
};
|
|
AssertionVisitor.prototype.captureArgument = function (node) {
|
var n = newNodeWithLocationCopyOf(node);
|
var props = [];
|
addLiteralTo(props, n, 'content', this.canonicalCode);
|
addLiteralTo(props, n, 'filepath', this.location.source);
|
addLiteralTo(props, n, 'line', this.location.line);
|
if (this.withinAsync) {
|
addLiteralTo(props, n, 'async', true);
|
}
|
if (this.withinGenerator) {
|
addLiteralTo(props, n, 'generator', true);
|
}
|
return n({
|
type: syntax.CallExpression,
|
callee: n({
|
type: syntax.MemberExpression,
|
computed: false,
|
object: this.valueRecorder,
|
property: n({
|
type: syntax.Identifier,
|
name: '_expr'
|
})
|
}),
|
arguments: [node].concat(n({
|
type: syntax.ObjectExpression,
|
properties: props
|
}))
|
});
|
};
|
|
AssertionVisitor.prototype.verifyNotInstrumented = function (currentNode) {
|
if (currentNode.type !== syntax.CallExpression) {
|
return;
|
}
|
if (currentNode.callee.type !== syntax.MemberExpression) {
|
return;
|
}
|
var prop = currentNode.callee.property;
|
if (prop.type === syntax.Identifier && prop.name === '_expr') {
|
var errorMessage = 'Attempted to transform AST twice.';
|
if (this.options.path) {
|
errorMessage += ' path: ' + this.options.path;
|
}
|
throw new EspowerError(errorMessage, this.verifyNotInstrumented);
|
}
|
};
|
|
AssertionVisitor.prototype.createNewRecorder = function (controller) {
|
var currentBlock = findBlockedScope(this.options.scopeStack).block;
|
var scopeBlockEspath = findEspathOfAncestorNode(currentBlock, 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 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) {
|
if (typeof value !== 'undefined') {
|
addToProps(props, createNode, name, createNode({
|
type: syntax.Literal,
|
value: value
|
}));
|
}
|
}
|
|
function addToProps (props, createNode, name, value) {
|
props.push(createNode({
|
type: syntax.Property,
|
key: createNode({
|
type: syntax.Identifier,
|
name: name
|
}),
|
value: value,
|
method: false,
|
shorthand: false,
|
computed: false,
|
kind: 'init'
|
}));
|
}
|
|
function updateLocRecursively (node, n, visitorKeys) {
|
var visitor = {
|
leave: function (currentNode, parentNode) {
|
return n(currentNode);
|
}
|
};
|
if (visitorKeys) {
|
visitor.keys = visitorKeys;
|
}
|
estraverse.replace(node, visitor);
|
return node;
|
}
|
|
function isPathIdentical (path1, path2) {
|
if (!path1 || !path2) {
|
return false;
|
}
|
return path1.join('/') === path2.join('/');
|
}
|
|
function newNodeWithLocationCopyOf (original) {
|
return function (newNode) {
|
if (typeof original.loc !== 'undefined') {
|
var newLoc = {
|
start: {
|
line: original.loc.start.line,
|
column: original.loc.start.column
|
},
|
end: {
|
line: original.loc.end.line,
|
column: original.loc.end.column
|
}
|
};
|
if (typeof original.loc.source !== 'undefined') {
|
newLoc.source = original.loc.source;
|
}
|
newNode.loc = newLoc;
|
}
|
if (Array.isArray(original.range)) {
|
newNode.range = [original.range[0], original.range[1]];
|
}
|
return newNode;
|
};
|
}
|
|
function findBlockedScope (scopeStack) {
|
var lastIndex = scopeStack.length - 1;
|
var scope = scopeStack[lastIndex];
|
if (!scope.block || isArrowFunctionWithConciseBody(scope.block)) {
|
return findBlockedScope(scopeStack.slice(0, lastIndex));
|
}
|
return scope;
|
}
|
|
function isArrowFunctionWithConciseBody (node) {
|
return node.type === 'ArrowFunctionExpression' && node.body.type !== 'BlockStatement';
|
}
|
|
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) {
|
switch(node.type) {
|
case syntax.FunctionDeclaration:
|
case syntax.FunctionExpression:
|
case syntax.ArrowFunctionExpression:
|
return true;
|
}
|
return false;
|
}
|
|
function findEnclosingFunction (parents) {
|
for (var i = parents.length - 1; i >= 0; i--) {
|
if (isFunction(parents[i])) {
|
return parents[i];
|
}
|
}
|
return null;
|
}
|
|
function getParentNode (controller) {
|
var parents = controller.parents();
|
return parents[parents.length - 1];
|
}
|
|
function getCurrentKey (controller) {
|
var path = controller.path();
|
return path ? path[path.length - 1] : null;
|
}
|
|
module.exports = AssertionVisitor;
|
