eslint 3.16.1 → 3.19.0

package/lib/testers/rule-tester.js

@@ -343,12 +343,13 @@ RuleTester.prototype = {
              * running the rule under test.
              */
             eslint.reset();
+
             eslint.on("Program", node => {
                 beforeAST = cloneDeeplyExcludesParent(node);
+            });
 
-                eslint.on("Program:exit", node => {
-                    afterAST = cloneDeeplyExcludesParent(node);
-                });
+            eslint.on("Program:exit", node => {
+                afterAST = node;
             });
 
             // Freezes rule-context properties.
@@ -385,7 +386,7 @@ RuleTester.prototype = {
                 return {
                     messages: eslint.verify(code, config, filename, true),
                     beforeAST,
-                    afterAST
+                    afterAST: cloneDeeplyExcludesParent(afterAST)
                 };
             } finally {
                 rules.get = originalGet;
@@ -425,6 +426,28 @@ RuleTester.prototype = {
             assertASTDidntChange(result.beforeAST, result.afterAST);
         }
 
+        /**
+         * Asserts that the message matches its expected value. If the expected
+         * value is a regular expression, it is checked against the actual
+         * value.
+         * @param {string} actual Actual value
+         * @param {string|RegExp} expected Expected value
+         * @returns {void}
+         * @private
+         */
+        function assertMessageMatches(actual, expected) {
+            if (expected instanceof RegExp) {
+
+                // assert.js doesn't have a built-in RegExp match function
+                assert.ok(
+                    expected.test(actual),
+                    `Expected '${actual}' to match ${expected}`
+                );
+            } else {
+                assert.equal(actual, expected);
+            }
+        }
+
         /**
          * Check if the template is invalid or not
          * all invalid cases go through this.
@@ -454,10 +477,10 @@ RuleTester.prototype = {
                     assert.ok(!("fatal" in messages[i]), `A fatal parsing error occurred: ${messages[i].message}`);
                     assert.equal(messages[i].ruleId, ruleName, "Error rule name should be the same as the name of the rule being tested");
 
-                    if (typeof item.errors[i] === "string") {
+                    if (typeof item.errors[i] === "string" || item.errors[i] instanceof RegExp) {
 
                         // Just an error message.
-                        assert.equal(messages[i].message, item.errors[i]);
+                        assertMessageMatches(messages[i].message, item.errors[i]);
                     } else if (typeof item.errors[i] === "object") {
 
                         /*
@@ -466,7 +489,7 @@ RuleTester.prototype = {
                          * column.
                          */
                         if (item.errors[i].message) {
-                            assert.equal(messages[i].message, item.errors[i].message);
+                            assertMessageMatches(messages[i].message, item.errors[i].message);
                         }
 
                         if (item.errors[i].type) {
@@ -490,16 +513,24 @@ RuleTester.prototype = {
                         }
                     } else {
 
-                        // Only string or object errors are valid.
-                        assert.fail(messages[i], null, "Error should be a string or object.");
+                        // Message was an unexpected type
+                        assert.fail(messages[i], null, "Error should be a string, object, or RegExp.");
                     }
                 }
             }
 
             if (item.hasOwnProperty("output")) {
-                const fixResult = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
-
-                assert.equal(fixResult.output, item.output, "Output is incorrect.");
+                if (item.output === null) {
+                    assert.strictEqual(
+                        messages.filter(message => message.fix).length,
+                        0,
+                        "Expected no autofixes to be suggested"
+                    );
+                } else {
+                    const fixResult = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
+
+                    assert.equal(fixResult.output, item.output, "Output is incorrect.");
+                }
             }
 
             assertASTDidntChange(result.beforeAST, result.afterAST);
@@ -512,7 +543,7 @@ RuleTester.prototype = {
         RuleTester.describe(ruleName, () => {
             RuleTester.describe("valid", () => {
                 test.valid.forEach(valid => {
-                    RuleTester.it(valid.code || valid, () => {
+                    RuleTester.it(typeof valid === "object" ? valid.code : valid, () => {
                         eslint.defineRules(this.rules);
                         testValidTemplate(ruleName, valid);
                     });

package/lib/util/fix-tracker.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Helper class to aid in constructing fix commands.
+ * @author Alan Pierce
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * A helper class to combine fix options into a fix command. Currently, it
+ * exposes some "retain" methods that extend the range of the text being
+ * replaced so that other fixes won't touch that region in the same pass.
+ */
+class FixTracker {
+
+    /**
+     * Create a new FixTracker.
+     *
+     * @param {ruleFixer} fixer A ruleFixer instance.
+     * @param {SourceCode} sourceCode A SourceCode object for the current code.
+     */
+    constructor(fixer, sourceCode) {
+        this.fixer = fixer;
+        this.sourceCode = sourceCode;
+        this.retainedRange = null;
+    }
+
+    /**
+     * Mark the given range as "retained", meaning that other fixes may not
+     * may not modify this region in the same pass.
+     *
+     * @param {int[]} range The range to retain.
+     * @returns {FixTracker} The same RuleFixer, for chained calls.
+     */
+    retainRange(range) {
+        this.retainedRange = range;
+        return this;
+    }
+
+    /**
+     * Given a node, find the function containing it (or the entire program) and
+     * mark it as retained, meaning that other fixes may not modify it in this
+     * pass. This is useful for avoiding conflicts in fixes that modify control
+     * flow.
+     *
+     * @param {ASTNode} node The node to use as a starting point.
+     * @returns {FixTracker} The same RuleFixer, for chained calls.
+     */
+    retainEnclosingFunction(node) {
+        const functionNode = astUtils.getUpperFunction(node);
+
+        return this.retainRange(
+            functionNode ? functionNode.range : this.sourceCode.ast.range);
+    }
+
+    /**
+     * Given a node or token, find the token before and afterward, and mark that
+     * range as retained, meaning that other fixes may not modify it in this
+     * pass. This is useful for avoiding conflicts in fixes that make a small
+     * change to the code where the AST should not be changed.
+     *
+     * @param {ASTNode|Token} nodeOrToken The node or token to use as a starting
+     *      point. The token to the left and right are use in the range.
+     * @returns {FixTracker} The same RuleFixer, for chained calls.
+     */
+    retainSurroundingTokens(nodeOrToken) {
+        const tokenBefore = this.sourceCode.getTokenBefore(nodeOrToken) || nodeOrToken;
+        const tokenAfter = this.sourceCode.getTokenAfter(nodeOrToken) || nodeOrToken;
+
+        return this.retainRange([tokenBefore.range[0], tokenAfter.range[1]]);
+    }
+
+    /**
+     * Create a fix command that replaces the given range with the given text,
+     * accounting for any retained ranges.
+     *
+     * @param {int[]} range The range to remove in the fix.
+     * @param {string} text The text to insert in place of the range.
+     * @returns {Object} The fix command.
+     */
+    replaceTextRange(range, text) {
+        let actualRange;
+
+        if (this.retainedRange) {
+            actualRange = [
+                Math.min(this.retainedRange[0], range[0]),
+                Math.max(this.retainedRange[1], range[1])
+            ];
+        } else {
+            actualRange = range;
+        }
+
+        return this.fixer.replaceTextRange(
+            actualRange,
+            this.sourceCode.text.slice(actualRange[0], range[0]) +
+                text +
+                this.sourceCode.text.slice(range[1], actualRange[1])
+        );
+    }
+
+    /**
+     * Create a fix command that removes the given node or token, accounting for
+     * any retained ranges.
+     *
+     * @param {ASTNode|Token} nodeOrToken The node or token to remove.
+     * @returns {Object} The fix command.
+     */
+    remove(nodeOrToken) {
+        return this.replaceTextRange(nodeOrToken.range, "");
+    }
+}
+
+module.exports = FixTracker;

package/lib/util/glob-util.js

@@ -86,7 +86,7 @@ function resolveFileGlobPatterns(patterns, options) {
 
     const processPathExtensions = processPath(options);
 
-    return patterns.map(processPathExtensions);
+    return patterns.filter(p => p.length).map(processPathExtensions);
 }
 
 /**

package/lib/util/node-event-generator.js

@@ -5,6 +5,185 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const esquery = require("esquery");
+const lodash = require("lodash");
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * An object describing an AST selector
+ * @typedef {Object} ASTSelector
+ * @property {string} rawSelector The string that was parsed into this selector
+ * @property {boolean} isExit `true` if this should be emitted when exiting the node rather than when entering
+ * @property {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector
+ * @property {string[]|null} listenerTypes A list of node types that could possibly cause the selector to match,
+ * or `null` if all node types could cause a match
+ * @property {number} attributeCount The total number of classes, pseudo-classes, and attribute queries in this selector
+ * @property {number} identifierCount The total number of identifier queries in this selector
+ */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+* Gets the possible types of a selector
+* @param {Object} parsedSelector An object (from esquery) describing the matching behavior of the selector
+* @returns {string[]|null} The node types that could possibly trigger this selector, or `null` if all node types could trigger it
+*/
+function getPossibleTypes(parsedSelector) {
+    switch (parsedSelector.type) {
+        case "identifier":
+            return [parsedSelector.value];
+
+        case "matches": {
+            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
+
+            if (typesForComponents.every(typesForComponent => typesForComponent)) {
+                return lodash.union.apply(null, typesForComponents);
+            }
+            return null;
+        }
+
+        case "compound": {
+            const typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(typesForComponent => typesForComponent);
+
+            // If all of the components could match any type, then the compound could also match any type.
+            if (!typesForComponents.length) {
+                return null;
+            }
+
+            /*
+             * If at least one of the components could only match a particular type, the compound could only match
+             * the intersection of those types.
+             */
+            return lodash.intersection.apply(null, typesForComponents);
+        }
+
+        case "child":
+        case "descendant":
+        case "sibling":
+        case "adjacent":
+            return getPossibleTypes(parsedSelector.right);
+
+        default:
+            return null;
+
+    }
+}
+
+/**
+ * Counts the number of class, pseudo-class, and attribute queries in this selector
+ * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns {number} The number of class, pseudo-class, and attribute queries in this selector
+ */
+function countClassAttributes(parsedSelector) {
+    switch (parsedSelector.type) {
+        case "child":
+        case "descendant":
+        case "sibling":
+        case "adjacent":
+            return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);
+
+        case "compound":
+        case "not":
+        case "matches":
+            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countClassAttributes(childSelector), 0);
+
+        case "attribute":
+        case "field":
+        case "nth-child":
+        case "nth-last-child":
+            return 1;
+
+        default:
+            return 0;
+    }
+}
+
+/**
+ * Counts the number of identifier queries in this selector
+ * @param {Object} parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns {number} The number of identifier queries
+ */
+function countIdentifiers(parsedSelector) {
+    switch (parsedSelector.type) {
+        case "child":
+        case "descendant":
+        case "sibling":
+        case "adjacent":
+            return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);
+
+        case "compound":
+        case "not":
+        case "matches":
+            return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);
+
+        case "identifier":
+            return 1;
+
+        default:
+            return 0;
+    }
+}
+
+/**
+ * Compares the specificity of two selector objects, with CSS-like rules.
+ * @param {ASTSelector} selectorA An AST selector descriptor
+ * @param {ASTSelector} selectorB Another AST selector descriptor
+ * @returns {number}
+ * a value less than 0 if selectorA is less specific than selectorB
+ * a value greater than 0 if selectorA is more specific than selectorB
+ * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically
+ * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically
+ */
+function compareSpecificity(selectorA, selectorB) {
+    return selectorA.attributeCount - selectorB.attributeCount ||
+        selectorA.identifierCount - selectorB.identifierCount ||
+        (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);
+}
+
+/**
+ * Parses a raw selector string, and throws a useful error if parsing fails.
+ * @param {string} rawSelector A raw AST selector
+ * @returns {Object} An object (from esquery) describing the matching behavior of this selector
+ * @throws {Error} An error if the selector is invalid
+ */
+function tryParseSelector(rawSelector) {
+    try {
+        return esquery.parse(rawSelector.replace(/:exit$/, ""));
+    } catch (err) {
+        if (typeof err.offset === "number") {
+            throw new Error(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
+        }
+        throw err;
+    }
+}
+
+/**
+ * Parses a raw selector string, and returns the parsed selector along with specificity and type information.
+ * @param {string} rawSelector A raw AST selector
+ * @returns {ASTSelector} A selector descriptor
+ */
+const parseSelector = lodash.memoize(rawSelector => {
+    const parsedSelector = tryParseSelector(rawSelector);
+
+    return {
+        rawSelector,
+        isExit: rawSelector.endsWith(":exit"),
+        parsedSelector,
+        listenerTypes: getPossibleTypes(parsedSelector),
+        attributeCount: countClassAttributes(parsedSelector),
+        identifierCount: countIdentifiers(parsedSelector)
+    };
+});
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -24,10 +203,97 @@
 class NodeEventGenerator {
 
     /**
-     * @param {EventEmitter} emitter - An event emitter which is the destination of events.
-     */
+    * @param {EventEmitter} emitter - An event emitter which is the destination of events. This emitter must already
+    * have registered listeners for all of the events that it needs to listen for.
+    * @returns {NodeEventGenerator} new instance
+    */
     constructor(emitter) {
         this.emitter = emitter;
+        this.currentAncestry = [];
+        this.enterSelectorsByNodeType = new Map();
+        this.exitSelectorsByNodeType = new Map();
+        this.anyTypeEnterSelectors = [];
+        this.anyTypeExitSelectors = [];
+
+        const eventNames = typeof emitter.eventNames === "function"
+
+            // Use the built-in eventNames() function if available (Node 6+)
+            ? emitter.eventNames()
+
+            /*
+             * Otherwise, use the private _events property.
+             * Using a private property isn't ideal here, but this seems to
+             * be the best way to get a list of event names without overriding
+             * addEventListener, which would hurt performance. This property
+             * is widely used and unlikely to be removed in a future version
+             * (see https://github.com/nodejs/node/issues/1817). Also, future
+             * node versions will have eventNames() anyway.
+             */
+            : Object.keys(emitter._events); // eslint-disable-line no-underscore-dangle
+
+        eventNames.forEach(rawSelector => {
+            const selector = parseSelector(rawSelector);
+
+            if (selector.listenerTypes) {
+                selector.listenerTypes.forEach(nodeType => {
+                    const typeMap = selector.isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType;
+
+                    if (!typeMap.has(nodeType)) {
+                        typeMap.set(nodeType, []);
+                    }
+                    typeMap.get(nodeType).push(selector);
+                });
+            } else {
+                (selector.isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors).push(selector);
+            }
+        });
+
+        this.anyTypeEnterSelectors.sort(compareSpecificity);
+        this.anyTypeExitSelectors.sort(compareSpecificity);
+        this.enterSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
+        this.exitSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
+    }
+
+    /**
+     * Checks a selector against a node, and emits it if it matches
+     * @param {ASTNode} node The node to check
+     * @param {ASTSelector} selector An AST selector descriptor
+     * @returns {void}
+     */
+    applySelector(node, selector) {
+        if (esquery.matches(node, selector.parsedSelector, this.currentAncestry)) {
+            this.emitter.emit(selector.rawSelector, node);
+        }
+    }
+
+    /**
+     * Applies all appropriate selectors to a node, in specificity order
+     * @param {ASTNode} node The node to check
+     * @param {boolean} isExit `false` if the node is currently being entered, `true` if it's currently being exited
+     * @returns {void}
+     */
+    applySelectors(node, isExit) {
+        const selectorsByNodeType = (isExit ? this.exitSelectorsByNodeType : this.enterSelectorsByNodeType).get(node.type) || [];
+        const anyTypeSelectors = isExit ? this.anyTypeExitSelectors : this.anyTypeEnterSelectors;
+
+        /*
+         * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
+         * Iterate through each of them, applying selectors in the right order.
+         */
+        let selectorsByTypeIndex = 0;
+        let anyTypeSelectorsIndex = 0;
+
+        while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {
+            if (
+                selectorsByTypeIndex >= selectorsByNodeType.length ||
+                anyTypeSelectorsIndex < anyTypeSelectors.length &&
+                compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0
+            ) {
+                this.applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);
+            } else {
+                this.applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);
+            }
+        }
     }
 
     /**
@@ -36,7 +302,10 @@ class NodeEventGenerator {
      * @returns {void}
      */
     enterNode(node) {
-        this.emitter.emit(node.type, node);
+        if (node.parent) {
+            this.currentAncestry.unshift(node.parent);
+        }
+        this.applySelectors(node, false);
     }
 
     /**
@@ -45,7 +314,8 @@ class NodeEventGenerator {
      * @returns {void}
      */
     leaveNode(node) {
-        this.emitter.emit(`${node.type}:exit`, node);
+        this.applySelectors(node, true);
+        this.currentAncestry.shift();
     }
 }
 

package/lib/util/source-code-fixer.js

@@ -94,8 +94,8 @@ SourceCodeFixer.applyFixes = function(sourceCode, messages) {
             const start = fix.range[0];
             const end = fix.range[1];
 
-            // Remain it as a problem if it's overlapped.
-            if (lastPos >= start) {
+            // Remain it as a problem if it's overlapped or it's a negative range
+            if (lastPos >= start || start > end) {
                 remainingMessages.push(problem);
                 continue;
             }
@@ -108,13 +108,7 @@ SourceCodeFixer.applyFixes = function(sourceCode, messages) {
             // Make output to this fix.
             output += text.slice(Math.max(0, lastPos), Math.max(0, start));
             output += fix.text;
-
-            /*
-             * If the start of the range is larger than the end for some reason, make sure
-             * the text between the end and the start doesn't get duplicated.
-             * https://github.com/eslint/eslint/issues/8116
-             */
-            lastPos = Math.max(start, end);
+            lastPos = end;
         }
         output += text.slice(Math.max(0, lastPos));