eslint 3.16.0 → 3.18.0

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;
             }

package/lib/util/source-code.js

@@ -10,7 +10,8 @@
 
 const TokenStore = require("../token-store"),
     Traverser = require("./traverser"),
-    astUtils = require("../ast-utils");
+    astUtils = require("../ast-utils"),
+    lodash = require("lodash");
 
 //------------------------------------------------------------------------------
 // Private
@@ -138,7 +139,26 @@ function SourceCode(text, ast) {
      * This is done to avoid each rule needing to do so separately.
      * @type string[]
      */
-    this.lines = SourceCode.splitLines(this.text);
+    this.lines = [];
+    this.lineStartIndices = [0];
+
+    const lineEndingPattern = astUtils.createGlobalLinebreakMatcher();
+    let match;
+
+    /*
+     * Previously, this was implemented using a regex that
+     * matched a sequence of non-linebreak characters followed by a
+     * linebreak, then adding the lengths of the matches. However,
+     * this caused a catastrophic backtracking issue when the end
+     * of a file contained a large number of non-newline characters.
+     * To avoid this, the current implementation just matches newlines
+     * and uses match.index to get the correct line start indices.
+     */
+    while ((match = lineEndingPattern.exec(this.text))) {
+        this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1], match.index));
+        this.lineStartIndices.push(match.index + match[0].length);
+    }
+    this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1]));
 
     this.tokensAndComments = sortedMerge(ast.tokens, ast.comments);
 
@@ -312,6 +332,83 @@ SourceCode.prototype = {
         const text = this.text.slice(first.range[1], second.range[0]);
 
         return /\s/.test(text.replace(/\/\*.*?\*\//g, ""));
+    },
+
+    /**
+    * Converts a source text index into a (line, column) pair.
+    * @param {number} index The index of a character in a file
+    * @returns {Object} A {line, column} location object with a 0-indexed column
+    */
+    getLocFromIndex(index) {
+        if (typeof index !== "number") {
+            throw new TypeError("Expected `index` to be a number.");
+        }
+
+        if (index < 0 || index > this.text.length) {
+            throw new RangeError(`Index out of range (requested index ${index}, but source text has length ${this.text.length}).`);
+        }
+
+        /*
+         * For an argument of this.text.length, return the location one "spot" past the last character
+         * of the file. If the last character is a linebreak, the location will be column 0 of the next
+         * line; otherwise, the location will be in the next column on the same line.
+         *
+         * See getIndexFromLoc for the motivation for this special case.
+         */
+        if (index === this.text.length) {
+            return { line: this.lines.length, column: this.lines[this.lines.length - 1].length };
+        }
+
+        /*
+         * To figure out which line rangeIndex is on, determine the last index at which rangeIndex could
+         * be inserted into lineIndices to keep the list sorted.
+         */
+        const lineNumber = lodash.sortedLastIndex(this.lineStartIndices, index);
+
+        return { line: lineNumber, column: index - this.lineStartIndices[lineNumber - 1] };
+
+    },
+
+    /**
+    * Converts a (line, column) pair into a range index.
+    * @param {Object} loc A line/column location
+    * @param {number} loc.line The line number of the location (1-indexed)
+    * @param {number} loc.column The column number of the location (0-indexed)
+    * @returns {number} The range index of the location in the file.
+    */
+    getIndexFromLoc(loc) {
+        if (typeof loc !== "object" || typeof loc.line !== "number" || typeof loc.column !== "number") {
+            throw new TypeError("Expected `loc` to be an object with numeric `line` and `column` properties.");
+        }
+
+        if (loc.line <= 0) {
+            throw new RangeError(`Line number out of range (line ${loc.line} requested). Line numbers should be 1-based.`);
+        }
+
+        if (loc.line > this.lineStartIndices.length) {
+            throw new RangeError(`Line number out of range (line ${loc.line} requested, but only ${this.lineStartIndices.length} lines present).`);
+        }
+
+        const lineStartIndex = this.lineStartIndices[loc.line - 1];
+        const lineEndIndex = loc.line === this.lineStartIndices.length ? this.text.length : this.lineStartIndices[loc.line];
+        const positionIndex = lineStartIndex + loc.column;
+
+        /*
+         * By design, getIndexFromLoc({ line: lineNum, column: 0 }) should return the start index of
+         * the given line, provided that the line number is valid element of this.lines. Since the
+         * last element of this.lines is an empty string for files with trailing newlines, add a
+         * special case where getting the index for the first location after the end of the file
+         * will return the length of the file, rather than throwing an error. This allows rules to
+         * use getIndexFromLoc consistently without worrying about edge cases at the end of a file.
+         */
+        if (
+            loc.line === this.lineStartIndices.length && positionIndex > lineEndIndex ||
+            loc.line < this.lineStartIndices.length && positionIndex >= lineEndIndex
+        ) {
+            throw new RangeError(`Column number out of range (column ${loc.column} requested, but the length of line ${loc.line} is ${lineEndIndex - lineStartIndex}).`);
+        }
+
+        return positionIndex;
     }
 };
 

package/lib/util/traverser.js

@@ -14,41 +14,32 @@ const estraverse = require("estraverse");
 // Helpers
 //------------------------------------------------------------------------------
 
-const KEY_BLACKLIST = [
+const KEY_BLACKLIST = new Set([
     "parent",
     "leadingComments",
     "trailingComments"
-];
+]);
 
 /**
  * Wrapper around an estraverse controller that ensures the correct keys
  * are visited.
  * @constructor
  */
-function Traverser() {
-
-    const controller = Object.create(new estraverse.Controller()),
-        originalTraverse = controller.traverse;
-
-    // intercept call to traverse() and add the fallback key to the visitor
-    controller.traverse = function(node, visitor) {
+class Traverser extends estraverse.Controller {
+    traverse(node, visitor) {
         visitor.fallback = Traverser.getKeys;
-        return originalTraverse.call(this, node, visitor);
-    };
-
-    return controller;
+        return super.traverse(node, visitor);
+    }
+
+    /**
+     * Calculates the keys to use for traversal.
+     * @param {ASTNode} node The node to read keys from.
+     * @returns {string[]} An array of keys to visit on the node.
+     * @private
+     */
+    static getKeys(node) {
+        return Object.keys(node).filter(key => !KEY_BLACKLIST.has(key));
+    }
 }
 
-/**
- * Calculates the keys to use for traversal.
- * @param {ASTNode} node The node to read keys from.
- * @returns {string[]} An array of keys to visit on the node.
- * @private
- */
-Traverser.getKeys = function(node) {
-    return Object.keys(node).filter(key => KEY_BLACKLIST.indexOf(key) === -1);
-};
-
 module.exports = Traverser;
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -36,11 +36,12 @@
   "dependencies": {
     "babel-code-frame": "^6.16.0",
     "chalk": "^1.1.3",
-    "concat-stream": "^1.4.6",
+    "concat-stream": "^1.5.2",
     "debug": "^2.1.1",
-    "doctrine": "^1.2.2",
+    "doctrine": "^2.0.0",
     "escope": "^3.6.0",
     "espree": "^3.4.0",
+    "esquery": "^1.0.0",
     "estraverse": "^4.2.0",
     "esutils": "^2.0.2",
     "file-entry-cache": "^2.0.0",
@@ -78,14 +79,14 @@
     "browserify": "^12.0.1",
     "chai": "^3.5.0",
     "cheerio": "^0.19.0",
-    "coveralls": "2.11.4",
+    "coveralls": "^2.11.16",
     "dateformat": "^1.0.8",
     "ejs": "^2.3.3",
-    "eslint-plugin-node": "^2.0.0",
+    "eslint-plugin-eslint-plugin": "^0.7.1",
+    "eslint-plugin-node": "^4.1.0",
     "eslint-release": "^0.10.0",
     "esprima": "^2.4.1",
     "esprima-fb": "^15001.1001.0-dev-harmony-fb",
-    "gh-got": "^2.2.0",
     "istanbul": "^0.4.0",
     "jsdoc": "^3.3.0-beta1",
     "karma": "^0.13.22",
@@ -94,11 +95,10 @@
     "karma-mocha-reporter": "^2.0.3",
     "karma-phantomjs-launcher": "^1.0.0",
     "leche": "^2.1.1",
-    "linefix": "^0.1.1",
     "load-perf": "^0.2.0",
     "markdownlint": "^0.3.1",
     "mocha": "^2.4.5",
-    "mock-fs": "^4.0.0",
+    "mock-fs": "^4.2.0",
     "npm-license": "^0.3.2",
     "phantomjs-prebuilt": "^2.1.7",
     "proxyquire": "^1.7.10",