eslint 3.14.0 → 3.16.1

package/lib/token-store/skip-cursor.js

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Define the cursor which ignores the first few tokens.
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const DecorativeCursor = require("./decorative-cursor");
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * The decorative cursor which ignores the first few tokens.
+ */
+module.exports = class SkipCursor extends DecorativeCursor {
+
+    /**
+     * Initializes this cursor.
+     * @param {Cursor} cursor - The cursor to be decorated.
+     * @param {number} count - The count of tokens this cursor skips.
+     */
+    constructor(cursor, count) {
+        super(cursor);
+        this.count = count;
+    }
+
+    /** @inheritdoc */
+    moveNext() {
+        while (this.count > 0) {
+            this.count -= 1;
+            if (!super.moveNext()) {
+                return false;
+            }
+        }
+        return super.moveNext();
+    }
+};

package/lib/token-store/utils.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Define utilify functions for token store.
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const lodash = require("lodash");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets `token.range[0]` from the given token.
+ *
+ * @param {Node|Token|Comment} token - The token to get.
+ * @returns {number} The start location.
+ * @private
+ */
+function getStartLocation(token) {
+    return token.range[0];
+}
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * Binary-searches the index of the first token which is after the given location.
+ * If it was not found, this returns `tokens.length`.
+ *
+ * @param {(Token|Comment)[]} tokens - It searches the token in this list.
+ * @param {number} location - The location to search.
+ * @returns {number} The found index or `tokens.length`.
+ */
+exports.search = function search(tokens, location) {
+    return lodash.sortedIndexBy(
+        tokens,
+        { range: [location] },
+        getStartLocation
+    );
+};
+
+/**
+ * Gets the index of the `startLoc` in `tokens`.
+ * `startLoc` can be the value of `node.range[1]`, so this checks about `startLoc - 1` as well.
+ *
+ * @param {(Token|Comment)[]} tokens - The tokens to find an index.
+ * @param {Object} indexMap - The map from locations to indices.
+ * @param {number} startLoc - The location to get an index.
+ * @returns {number} The index.
+ */
+exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
+    if (startLoc in indexMap) {
+        return indexMap[startLoc];
+    }
+    if ((startLoc - 1) in indexMap) {
+        const index = indexMap[startLoc - 1];
+        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
+
+        // For the map of "comment's location -> token's index", it points the next token of a comment.
+        // In that case, +1 is unnecessary.
+        if (token && token.range[0] >= startLoc) {
+            return index;
+        }
+        return index + 1;
+    }
+    return 0;
+};
+
+/**
+ * Gets the index of the `endLoc` in `tokens`.
+ * The information of end locations are recorded at `endLoc - 1` in `indexMap`, so this checks about `endLoc - 1` as well.
+ *
+ * @param {(Token|Comment)[]} tokens - The tokens to find an index.
+ * @param {Object} indexMap - The map from locations to indices.
+ * @param {number} endLoc - The location to get an index.
+ * @returns {number} The index.
+ */
+exports.getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {
+    if (endLoc in indexMap) {
+        return indexMap[endLoc] - 1;
+    }
+    if ((endLoc - 1) in indexMap) {
+        const index = indexMap[endLoc - 1];
+        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
+
+        // For the map of "comment's location -> token's index", it points the next token of a comment.
+        // In that case, -1 is necessary.
+        if (token && token.range[1] > endLoc) {
+            return index - 1;
+        }
+        return index;
+    }
+    return tokens.length - 1;
+};

package/lib/util/glob.js

@@ -15,7 +15,7 @@ const Sync = require("glob").GlobSync,
 // Private
 //------------------------------------------------------------------------------
 
-const IGNORE = typeof Symbol === "function" ? Symbol("ignore") : "_shouldIgnore";
+const IGNORE = Symbol("ignore");
 
 /**
  * Subclass of `glob.GlobSync`

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

@@ -16,6 +16,17 @@ const debug = require("debug")("eslint:text-fixer");
 
 const BOM = "\uFEFF";
 
+/**
+ * Compares items in a messages array by range.
+ * @param {Message} a The first message.
+ * @param {Message} b The second message.
+ * @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.
+ * @private
+ */
+function compareMessagesByFixRange(a, b) {
+    return a.fix.range[0] - b.fix.range[0] || a.fix.range[1] - b.fix.range[1];
+}
+
 /**
  * Compares items in a messages array by line and column.
  * @param {Message} a The first message.
@@ -24,13 +35,7 @@ const BOM = "\uFEFF";
  * @private
  */
 function compareMessagesByLocation(a, b) {
-    const lineDiff = a.line - b.line;
-
-    if (lineDiff === 0) {
-        return a.column - b.column;
-    } else {
-        return lineDiff;
-    }
+    return a.line - b.line || a.column - b.column;
 }
 
 //------------------------------------------------------------------------------
@@ -68,9 +73,10 @@ SourceCodeFixer.applyFixes = function(sourceCode, messages) {
     // clone the array
     const remainingMessages = [],
         fixes = [],
+        bom = (sourceCode.hasBOM ? BOM : ""),
         text = sourceCode.text;
-    let lastFixPos = text.length + 1,
-        prefix = (sourceCode.hasBOM ? BOM : "");
+    let lastPos = Number.NEGATIVE_INFINITY,
+        output = bom;
 
     messages.forEach(problem => {
         if (problem.hasOwnProperty("fix")) {
@@ -83,53 +89,49 @@ SourceCodeFixer.applyFixes = function(sourceCode, messages) {
     if (fixes.length) {
         debug("Found fixes to apply");
 
-        // sort in reverse order of occurrence
-        fixes.sort((a, b) => b.fix.range[1] - a.fix.range[1] || b.fix.range[0] - a.fix.range[0]);
-
-        // split into array of characters for easier manipulation
-        const chars = text.split("");
-
-        fixes.forEach(problem => {
+        for (const problem of fixes.sort(compareMessagesByFixRange)) {
             const fix = problem.fix;
-            let start = fix.range[0];
+            const start = fix.range[0];
             const end = fix.range[1];
-            let insertionText = fix.text;
-
-            if (end < lastFixPos) {
-                if (start < 0) {
 
-                    // Remove BOM.
-                    prefix = "";
-                    start = 0;
-                }
+            // Remain it as a problem if it's overlapped.
+            if (lastPos >= start) {
+                remainingMessages.push(problem);
+                continue;
+            }
 
-                if (start === 0 && insertionText[0] === BOM) {
+            // Remove BOM.
+            if ((start < 0 && end >= 0) || (start === 0 && fix.text.startsWith(BOM))) {
+                output = "";
+            }
 
-                    // Set BOM.
-                    prefix = BOM;
-                    insertionText = insertionText.slice(1);
-                }
+            // Make output to this fix.
+            output += text.slice(Math.max(0, lastPos), Math.max(0, start));
+            output += fix.text;
 
-                chars.splice(start, end - start, insertionText);
-                lastFixPos = start;
-            } else {
-                remainingMessages.push(problem);
-            }
-        });
+            /*
+             * 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);
+        }
+        output += text.slice(Math.max(0, lastPos));
 
         return {
             fixed: true,
             messages: remainingMessages.sort(compareMessagesByLocation),
-            output: prefix + chars.join("")
-        };
-    } else {
-        debug("No fixes to apply");
-        return {
-            fixed: false,
-            messages,
-            output: prefix + text
+            output
         };
     }
+
+    debug("No fixes to apply");
+    return {
+        fixed: false,
+        messages,
+        output: bom + text
+    };
+
 };
 
 module.exports = SourceCodeFixer;

package/lib/util/source-code.js

@@ -8,8 +8,9 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const createTokenStore = require("../token-store.js"),
-    Traverser = require("./traverser");
+const TokenStore = require("../token-store"),
+    Traverser = require("./traverser"),
+    astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Private
@@ -56,9 +57,9 @@ function findJSDocComment(comments, line) {
 
                 if (line - comments[i].loc.end.line <= 1) {
                     return comments[i];
-                } else {
-                    break;
                 }
+                break;
+
             }
         }
     }
@@ -77,6 +78,28 @@ function looksLikeExport(astNode) {
         astNode.type === "ExportAllDeclaration" || astNode.type === "ExportSpecifier";
 }
 
+/**
+ * Merges two sorted lists into a larger sorted list in O(n) time
+ * @param {Token[]} tokens The list of tokens
+ * @param {Token[]} comments The list of comments
+ * @returns {Token[]} A sorted list of tokens and comments
+ */
+function sortedMerge(tokens, comments) {
+    const result = [];
+    let tokenIndex = 0;
+    let commentIndex = 0;
+
+    while (tokenIndex < tokens.length || commentIndex < comments.length) {
+        if (commentIndex >= comments.length || tokenIndex < tokens.length && tokens[tokenIndex].range[0] < comments[commentIndex].range[0]) {
+            result.push(tokens[tokenIndex++]);
+        } else {
+            result.push(comments[commentIndex++]);
+        }
+    }
+
+    return result;
+}
+
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -117,21 +140,14 @@ function SourceCode(text, ast) {
      */
     this.lines = SourceCode.splitLines(this.text);
 
-    this.tokensAndComments = ast.tokens
-        .concat(ast.comments)
-        .sort((left, right) => left.range[0] - right.range[0]);
+    this.tokensAndComments = sortedMerge(ast.tokens, ast.comments);
 
     // create token store methods
-    const tokenStore = createTokenStore(ast.tokens);
-
-    Object.keys(tokenStore).forEach(methodName => {
-        this[methodName] = tokenStore[methodName];
-    });
-
-    const tokensAndCommentsStore = createTokenStore(this.tokensAndComments);
+    const tokenStore = new TokenStore(ast.tokens, ast.comments);
 
-    this.getTokenOrCommentBefore = tokensAndCommentsStore.getTokenBefore;
-    this.getTokenOrCommentAfter = tokensAndCommentsStore.getTokenAfter;
+    for (const methodName of TokenStore.PUBLIC_METHODS) {
+        this[methodName] = tokenStore[methodName].bind(tokenStore);
+    }
 
     // don't allow modification of this object
     Object.freeze(this);
@@ -145,7 +161,7 @@ function SourceCode(text, ast) {
  * @public
  */
 SourceCode.splitLines = function(text) {
-    return text.split(/\r\n|\r|\n|\u2028|\u2029/g);
+    return text.split(astUtils.createGlobalLinebreakMatcher());
 };
 
 SourceCode.prototype = {
@@ -162,9 +178,9 @@ SourceCode.prototype = {
         if (node) {
             return this.text.slice(Math.max(node.range[0] - (beforeCount || 0), 0),
                 node.range[1] + (afterCount || 0));
-        } else {
-            return this.text;
         }
+        return this.text;
+
 
     },
 

package/messages/extend-config-missing.txt

@@ -0,0 +1,3 @@
+ESLint couldn't find the config "<%- configName %>" to extend from. Please check that the name of the config is correct.
+
+If you still have problems, please stop by https://gitter.im/eslint/eslint to chat with the team.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "3.14.0",
+  "version": "3.16.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -40,7 +40,7 @@
     "debug": "^2.1.1",
     "doctrine": "^1.2.2",
     "escope": "^3.6.0",
-    "espree": "^3.3.1",
+    "espree": "^3.4.0",
     "estraverse": "^4.2.0",
     "esutils": "^2.0.2",
     "file-entry-cache": "^2.0.0",
@@ -98,7 +98,7 @@
     "load-perf": "^0.2.0",
     "markdownlint": "^0.3.1",
     "mocha": "^2.4.5",
-    "mock-fs": "^3.12.1",
+    "mock-fs": "^4.0.0",
     "npm-license": "^0.3.2",
     "phantomjs-prebuilt": "^2.1.7",
     "proxyquire": "^1.7.10",

package/lib/token-store.js

@@ -1,203 +0,0 @@
-/**
- * @fileoverview Object to handle access and retrieval of tokens.
- * @author Brandon Mills
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Implementation
-//------------------------------------------------------------------------------
-
-module.exports = function(tokens) {
-    const api = {},
-        starts = Object.create(null),
-        ends = Object.create(null),
-        length = tokens.length;
-
-    /**
-     * Gets tokens in a given interval.
-     * @param {int} start Inclusive index of the first token. 0 if negative.
-     * @param {int} end Exclusive index of the last token.
-     * @returns {Token[]} Tokens in the interval.
-     */
-    function get(start, end) {
-        const result = [];
-
-        for (let i = Math.max(0, start); i < end && i < length; i++) {
-            result.push(tokens[i]);
-        }
-
-        return result;
-    }
-
-    /**
-     * Gets the index in the tokens array of the last token belonging to a node.
-     * Usually a node ends exactly at a token, but due to ASI, sometimes a
-     * node's range extends beyond its last token.
-     * @param {ASTNode} node The node for which to find the last token's index.
-     * @returns {int} Index in the tokens array of the node's last token.
-     */
-    function lastTokenIndex(node) {
-        const end = node.range[1];
-        let cursor = ends[end];
-
-        // If the node extends beyond its last token, get the token before the
-        // next token
-        if (typeof cursor === "undefined") {
-            cursor = starts[end] - 1;
-        }
-
-        // If there isn't a next token, the desired token is the last one in the
-        // array
-        if (isNaN(cursor)) {
-            cursor = length - 1;
-        }
-
-        return cursor;
-    }
-
-    // Map tokens' start and end range to the index in the tokens array
-    for (let i = 0; i < length; i++) {
-        const range = tokens[i].range;
-
-        starts[range[0]] = i;
-        ends[range[1]] = i;
-    }
-
-    /**
-     * Gets a number of tokens that precede a given node or token in the token
-     * stream.
-     * @param {(ASTNode|Token)} node The AST node or token.
-     * @param {int} [beforeCount=0] The number of tokens before the node or
-     *     token to retrieve.
-     * @returns {Token[]} Array of objects representing tokens.
-     */
-    api.getTokensBefore = function(node, beforeCount) {
-        const first = starts[node.range[0]];
-
-        return get(first - (beforeCount || 0), first);
-    };
-
-    /**
-     * Gets the token that precedes a given node or token in the token stream.
-     * @param {(ASTNode|Token)} node The AST node or token.
-     * @param {int} [skip=0] A number of tokens to skip before the given node or
-     *     token.
-     * @returns {Token} An object representing the token.
-     */
-    api.getTokenBefore = function(node, skip) {
-        return tokens[starts[node.range[0]] - (skip || 0) - 1];
-    };
-
-    /**
-     * Gets a number of tokens that follow a given node or token in the token
-     * stream.
-     * @param {(ASTNode|Token)} node The AST node or token.
-     * @param {int} [afterCount=0] The number of tokens after the node or token
-     *     to retrieve.
-     * @returns {Token[]} Array of objects representing tokens.
-     */
-    api.getTokensAfter = function(node, afterCount) {
-        const start = lastTokenIndex(node) + 1;
-
-        return get(start, start + (afterCount || 0));
-    };
-
-    /**
-     * Gets the token that follows a given node or token in the token stream.
-     * @param {(ASTNode|Token)} node The AST node or token.
-     * @param {int} [skip=0] A number of tokens to skip after the given node or
-     *     token.
-     * @returns {Token} An object representing the token.
-     */
-    api.getTokenAfter = function(node, skip) {
-        return tokens[lastTokenIndex(node) + (skip || 0) + 1];
-    };
-
-    /**
-     * Gets all tokens that are related to the given node.
-     * @param {ASTNode} node The AST node.
-     * @param {int} [beforeCount=0] The number of tokens before the node to retrieve.
-     * @param {int} [afterCount=0] The number of tokens after the node to retrieve.
-     * @returns {Token[]} Array of objects representing tokens.
-     */
-    api.getTokens = function(node, beforeCount, afterCount) {
-        return get(
-            starts[node.range[0]] - (beforeCount || 0),
-            lastTokenIndex(node) + (afterCount || 0) + 1
-        );
-    };
-
-    /**
-     * Gets the first `count` tokens of the given node's token stream.
-     * @param {ASTNode} node The AST node.
-     * @param {int} [count=0] The number of tokens of the node to retrieve.
-     * @returns {Token[]} Array of objects representing tokens.
-     */
-    api.getFirstTokens = function(node, count) {
-        const first = starts[node.range[0]];
-
-        return get(
-            first,
-            Math.min(lastTokenIndex(node) + 1, first + (count || 0))
-        );
-    };
-
-    /**
-     * Gets the first token of the given node's token stream.
-     * @param {ASTNode} node The AST node.
-     * @param {int} [skip=0] A number of tokens to skip.
-     * @returns {Token} An object representing the token.
-     */
-    api.getFirstToken = function(node, skip) {
-        return tokens[starts[node.range[0]] + (skip || 0)];
-    };
-
-    /**
-     * Gets the last `count` tokens of the given node.
-     * @param {ASTNode} node The AST node.
-     * @param {int} [count=0] The number of tokens of the node to retrieve.
-     * @returns {Token[]} Array of objects representing tokens.
-     */
-    api.getLastTokens = function(node, count) {
-        const last = lastTokenIndex(node) + 1;
-
-        return get(Math.max(starts[node.range[0]], last - (count || 0)), last);
-    };
-
-    /**
-     * Gets the last token of the given node's token stream.
-     * @param {ASTNode} node The AST node.
-     * @param {int} [skip=0] A number of tokens to skip.
-     * @returns {Token} An object representing the token.
-     */
-    api.getLastToken = function(node, skip) {
-        return tokens[lastTokenIndex(node) - (skip || 0)];
-    };
-
-    /**
-     * Gets all of the tokens between two non-overlapping nodes.
-     * @param {ASTNode} left Node before the desired token range.
-     * @param {ASTNode} right Node after the desired token range.
-     * @param {int} [padding=0] Number of extra tokens on either side of center.
-     * @returns {Token[]} Tokens between left and right plus padding.
-     */
-    api.getTokensBetween = function(left, right, padding) {
-        padding = padding || 0;
-        return get(
-            lastTokenIndex(left) + 1 - padding,
-            starts[right.range[0]] + padding
-        );
-    };
-
-    /**
-     * Gets the token starting at the specified index.
-     * @param {int} startIndex Index of the start of the token's range.
-     * @returns {Token} The token starting at index, or null if no such token.
-     */
-    api.getTokenByRangeStart = function(startIndex) {
-        return (tokens[starts[startIndex]] || null);
-    };
-
-    return api;
-};