127 lines
3.1 KiB
JavaScript
127 lines
3.1 KiB
JavaScript
"use strict";
|
|
|
|
module.exports = TraversalIteration;
|
|
|
|
/* jshint maxparams:7 */
|
|
|
|
var traverse = require("./index");
|
|
var contains = require("lodash/collection/contains");
|
|
var Scope = require("./scope");
|
|
var t = require("../types");
|
|
|
|
function TraversalIteration(context, parent, obj, key) {
|
|
this.key = key;
|
|
this.obj = obj;
|
|
this.context = context;
|
|
this.parent = parent;
|
|
this.scope = TraversalIteration.getScope(this.getNode(), parent, context.scope);
|
|
this.state = context.state;
|
|
}
|
|
|
|
TraversalIteration.getScope = function (node, parent, scope) {
|
|
var ourScope = scope;
|
|
|
|
// we're entering a new scope so let's construct it!
|
|
if (t.isScope(node)) {
|
|
ourScope = new Scope(node, parent, scope);
|
|
}
|
|
|
|
return ourScope;
|
|
};
|
|
|
|
TraversalIteration.prototype.maybeRemove = function () {
|
|
if (this.context.shouldRemove) {
|
|
this.setNode(null);
|
|
this.context.flatten();
|
|
}
|
|
};
|
|
|
|
TraversalIteration.prototype.setNode = function (val) {
|
|
return this.obj[this.key] = val;
|
|
};
|
|
|
|
TraversalIteration.prototype.getNode = function () {
|
|
return this.obj[this.key];
|
|
};
|
|
|
|
TraversalIteration.prototype.replaceNode = function (replacement, scope) {
|
|
var isArray = Array.isArray(replacement);
|
|
|
|
// inherit comments from original node to the first replacement node
|
|
var inheritTo = replacement;
|
|
if (isArray) inheritTo = replacement[0];
|
|
if (inheritTo) t.inheritsComments(inheritTo, this.getNode());
|
|
|
|
// replace the node
|
|
this.setNode(replacement);
|
|
|
|
var file = this.scope && this.scope.file;
|
|
if (file) {
|
|
if (isArray) {
|
|
for (var i = 0; i < replacement.length; i++) {
|
|
file.checkNode(replacement[i], scope);
|
|
}
|
|
} else {
|
|
file.checkNode(replacement, scope);
|
|
}
|
|
}
|
|
|
|
// we're replacing a statement or block node with an array of statements so we better
|
|
// ensure that it's a block
|
|
if (isArray) {
|
|
if (contains(t.STATEMENT_OR_BLOCK_KEYS, this.key) && !t.isBlockStatement(this.obj)) {
|
|
t.ensureBlock(this.obj, this.key);
|
|
}
|
|
|
|
this.context.flatten();
|
|
}
|
|
};
|
|
|
|
TraversalIteration.prototype.call = function (fn) {
|
|
var node = this.getNode();
|
|
var replacement = fn.call(this, node, this.parent, this.scope, this.context, this.state);
|
|
|
|
if (replacement) {
|
|
this.replaceNode(replacement);
|
|
node = replacement;
|
|
}
|
|
|
|
this.maybeRemove();
|
|
|
|
return node;
|
|
};
|
|
|
|
TraversalIteration.prototype.visit = function () {
|
|
this.context.reset();
|
|
|
|
var state = this.context.state;
|
|
var opts = this.context.opts;
|
|
var node = this.getNode();
|
|
|
|
// type is blacklisted
|
|
if (opts.blacklist && opts.blacklist.indexOf(node.type) > -1) {
|
|
return;
|
|
}
|
|
|
|
this.call(opts.enter);
|
|
|
|
if (this.context.shouldSkip) {
|
|
return this.context.shouldStop;
|
|
}
|
|
|
|
node = this.getNode();
|
|
|
|
if (Array.isArray(node)) {
|
|
// traverse over these replacement nodes we purposely don't call exitNode
|
|
// as the original node has been destroyed
|
|
for (var i = 0; i < node.length; i++) {
|
|
traverse.node(node[i], opts, this.scope, state);
|
|
}
|
|
} else {
|
|
traverse.node(node, opts, this.scope, state);
|
|
this.call(opts.exit);
|
|
}
|
|
|
|
return this.context.shouldStop;
|
|
};
|