eslint 4.7.2 → 4.11.0

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

@@ -45,9 +45,11 @@ module.exports = class ForwardTokenCursor extends Cursor {
         return false;
     }
 
-    //
-    // Shorthand for performance.
-    //
+    /*
+     *
+     * Shorthand for performance.
+     *
+     */
 
     /** @inheritdoc */
     getOneToken() {

package/lib/token-store/utils.js

@@ -62,8 +62,10 @@ exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
         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.
+        /*
+         * 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;
         }
@@ -89,8 +91,10 @@ exports.getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {
         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.
+        /*
+         * 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;
         }

package/lib/util/apply-disable-directives.js

@@ -19,20 +19,24 @@ function compareLocations(itemA, itemB) {
 }
 
 /**
- * This is the same as the exported function, except that it doesn't handle disable-line and disable-next-line directives.
- * @param {Object} options options (see the exported function)
- * @returns {Problem[]} Filtered problems (see the exported function)
+ * This is the same as the exported function, except that it
+ * doesn't handle disable-line and disable-next-line directives, and it always reports unused
+ * disable directives.
+ * @param {Object} options options for applying directives. This is the same as the options
+ * for the exported function, except that `reportUnusedDisableDirectives` is not supported
+ * (this function always reports unused disable directives).
+ * @returns {{problems: Problem[], unusedDisableDirectives: Problem[]}} An object with a list
+ * of filtered problems and unused eslint-disable directives
  */
 function applyDirectives(options) {
     const problems = [];
     let nextDirectiveIndex = 0;
-    let globalDisableActive = false;
+    let currentGlobalDisableDirective = null;
+    const disabledRuleMap = new Map();
 
-    // disabledRules is only used when there is no active global /* eslint-disable */ comment.
-    const disabledRules = new Set();
-
-    // enabledRules is only used when there is an active global /* eslint-disable */ comment.
+    // enabledRules is only used when there is a current global disable directive.
     const enabledRules = new Set();
+    const usedDisableDirectives = new Set();
 
     for (const problem of options.problems) {
         while (
@@ -44,23 +48,26 @@ function applyDirectives(options) {
             switch (directive.type) {
                 case "disable":
                     if (directive.ruleId === null) {
-                        globalDisableActive = true;
+                        currentGlobalDisableDirective = directive;
+                        disabledRuleMap.clear();
                         enabledRules.clear();
-                    } else if (globalDisableActive) {
+                    } else if (currentGlobalDisableDirective) {
                         enabledRules.delete(directive.ruleId);
+                        disabledRuleMap.set(directive.ruleId, directive);
                     } else {
-                        disabledRules.add(directive.ruleId);
+                        disabledRuleMap.set(directive.ruleId, directive);
                     }
                     break;
 
                 case "enable":
                     if (directive.ruleId === null) {
-                        globalDisableActive = false;
-                        disabledRules.clear();
-                    } else if (globalDisableActive) {
+                        currentGlobalDisableDirective = null;
+                        disabledRuleMap.clear();
+                    } else if (currentGlobalDisableDirective) {
                         enabledRules.add(directive.ruleId);
+                        disabledRuleMap.delete(directive.ruleId);
                     } else {
-                        disabledRules.delete(directive.ruleId);
+                        disabledRuleMap.delete(directive.ruleId);
                     }
                     break;
 
@@ -68,15 +75,30 @@ function applyDirectives(options) {
             }
         }
 
-        if (
-            globalDisableActive && enabledRules.has(problem.ruleId) ||
-            !globalDisableActive && !disabledRules.has(problem.ruleId)
-        ) {
+        if (disabledRuleMap.has(problem.ruleId)) {
+            usedDisableDirectives.add(disabledRuleMap.get(problem.ruleId));
+        } else if (currentGlobalDisableDirective && !enabledRules.has(problem.ruleId)) {
+            usedDisableDirectives.add(currentGlobalDisableDirective);
+        } else {
             problems.push(problem);
         }
     }
 
-    return problems;
+    const unusedDisableDirectives = options.directives
+        .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive))
+        .map(directive => ({
+            ruleId: null,
+            message: directive.ruleId
+                ? `Unused eslint-disable directive (no problems were reported from '${directive.ruleId}').`
+                : "Unused eslint-disable directive (no problems were reported).",
+            line: directive.unprocessedDirective.line,
+            column: directive.unprocessedDirective.column,
+            severity: 2,
+            source: null,
+            nodeType: null
+        }));
+
+    return { problems, unusedDisableDirectives };
 }
 
 /**
@@ -93,12 +115,14 @@ function applyDirectives(options) {
  * comment for two different rules is represented as two directives).
  * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems
  * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns.
+ * @param {boolean} options.reportUnusedDisableDirectives If `true`, adds additional problems for unused directives
  * @returns {{ruleId: (string|null), line: number, column: number}[]}
  * A list of reported problems that were not disabled by the directive comments.
  */
 module.exports = options => {
     const blockDirectives = options.directives
         .filter(directive => directive.type === "disable" || directive.type === "enable")
+        .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))
         .sort(compareLocations);
 
     const lineDirectives = lodash.flatMap(options.directives, directive => {
@@ -109,14 +133,14 @@ module.exports = options => {
 
             case "disable-line":
                 return [
-                    { type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId },
-                    { type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId }
+                    { type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
+                    { type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
                 ];
 
             case "disable-next-line":
                 return [
-                    { type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId },
-                    { type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId }
+                    { type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
+                    { type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
                 ];
 
             default:
@@ -124,8 +148,13 @@ module.exports = options => {
         }
     }).sort(compareLocations);
 
-    const problemsAfterBlockDirectives = applyDirectives({ problems: options.problems, directives: blockDirectives });
-    const problemsAfterLineDirectives = applyDirectives({ problems: problemsAfterBlockDirectives, directives: lineDirectives });
+    const blockDirectivesResult = applyDirectives({ problems: options.problems, directives: blockDirectives });
+    const lineDirectivesResult = applyDirectives({ problems: blockDirectivesResult.problems, directives: lineDirectives });
 
-    return problemsAfterLineDirectives.sort(compareLocations);
+    return options.reportUnusedDisableDirectives
+        ? lineDirectivesResult.problems
+            .concat(blockDirectivesResult.unusedDisableDirectives)
+            .concat(lineDirectivesResult.unusedDisableDirectives)
+            .sort(compareLocations)
+        : lineDirectivesResult.problems;
 };

package/lib/util/glob.js

@@ -47,7 +47,7 @@ GlobSync.prototype._readdir = function(abs, inGlobStar) {
      * `options.nodir` makes `options.mark` as `true`.
      * Mark `abs` first
      * to make sure `"node_modules"` will be ignored immediately with ignore pattern `"node_modules/"`.
-
+     *
      * There is a built-in cache about marked `File.Stat` in `glob`, so that we could not worry about the extra invocation of `this._mark()`
      */
     const marked = this._mark(abs);

package/lib/util/naming.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Common helpers for naming of plugins, formatters and configs
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const pathUtil = require("../util/path-util");
+
+//------------------------------------------------------------------------------
+// Private
+//------------------------------------------------------------------------------
+
+const NAMESPACE_REGEX = /^@.*\//i;
+
+/**
+ * Brings package name to correct format based on prefix
+ * @param {string} name The name of the package.
+ * @param {string} prefix Can be either "eslint-plugin", "eslint-config" or "eslint-formatter"
+ * @returns {string} Normalized name of the package
+ * @private
+ */
+function normalizePackageName(name, prefix) {
+
+    /**
+     * On Windows, name can come in with Windows slashes instead of Unix slashes.
+     * Normalize to Unix first to avoid errors later on.
+     * https://github.com/eslint/eslint/issues/5644
+     */
+    if (name.indexOf("\\") > -1) {
+        name = pathUtil.convertPathToPosix(name);
+    }
+
+    if (name.charAt(0) === "@") {
+
+        /**
+         * it's a scoped package
+         * package name is the prefix, or just a username
+         */
+        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`),
+            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`);
+
+        if (scopedPackageShortcutRegex.test(name)) {
+            name = name.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
+        } else if (!scopedPackageNameRegex.test(name.split("/")[1])) {
+
+            /**
+             * for scoped packages, insert the prefix after the first / unless
+             * the path is already @scope/eslint or @scope/eslint-xxx-yyy
+             */
+            name = name.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}-$2`);
+        }
+    } else if (name.indexOf(`${prefix}-`) !== 0) {
+        name = `${prefix}-${name}`;
+    }
+
+    return name;
+}
+
+/**
+ * Removes the prefix from a term.
+ * @param {string} prefix The prefix to remove.
+ * @param {string} term The term which may have the prefix.
+ * @returns {string} The term without prefix.
+ */
+function removePrefixFromTerm(prefix, term) {
+    return term.startsWith(prefix) ? term.slice(prefix.length) : term;
+}
+
+/**
+ * Adds a prefix to a term.
+ * @param {string} prefix The prefix to add.
+ * @param {string} term The term which may not have the prefix.
+ * @returns {string} The term with prefix.
+ */
+function addPrefixToTerm(prefix, term) {
+    return term.startsWith(prefix) ? term : `${prefix}${term}`;
+}
+
+/**
+ * Gets the scope (namespace) of a term.
+ * @param {string} term The term which may have the namespace.
+ * @returns {string} The namepace of the term if it has one.
+ */
+function getNamespaceFromTerm(term) {
+    const match = term.match(NAMESPACE_REGEX);
+
+    return match ? match[0] : "";
+}
+
+/**
+ * Removes the namespace from a term.
+ * @param {string} term The term which may have the namespace.
+ * @returns {string} The name of the plugin without the namespace.
+ */
+function removeNamespaceFromTerm(term) {
+    return term.replace(NAMESPACE_REGEX, "");
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    normalizePackageName,
+    removePrefixFromTerm,
+    addPrefixToTerm,
+    getNamespaceFromTerm,
+    removeNamespaceFromTerm
+};

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

@@ -33,10 +33,10 @@ const lodash = require("lodash");
 //------------------------------------------------------------------------------
 
 /**
-* 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
-*/
+ * 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":
@@ -160,7 +160,7 @@ function tryParseSelector(rawSelector) {
         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 new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
         }
         throw err;
     }
@@ -194,7 +194,7 @@ const parseSelector = lodash.memoize(rawSelector => {
  *
  * ```ts
  * interface EventGenerator {
- *     emitter: EventEmitter;
+ *     emitter: SafeEmitter;
  *     enterNode(node: ASTNode): void;
  *     leaveNode(node: ASTNode): void;
  * }
@@ -203,10 +203,12 @@ const parseSelector = lodash.memoize(rawSelector => {
 class NodeEventGenerator {
 
     /**
-    * @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
-    */
+     * @param {SafeEmitter} emitter
+     * An SafeEmitter which is the destination of events. This emitter must already
+     * have registered listeners for all of the events that it needs to listen for.
+     * (See lib/util/safe-emitter.js for more details on `SafeEmitter`.)
+     * @returns {NodeEventGenerator} new instance
+     */
     constructor(emitter) {
         this.emitter = emitter;
         this.currentAncestry = [];
@@ -215,23 +217,7 @@ class NodeEventGenerator {
         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 => {
+        emitter.eventNames().forEach(rawSelector => {
             const selector = parseSelector(rawSelector);
 
             if (selector.listenerTypes) {

package/lib/util/safe-emitter.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview A variant of EventEmitter which does not give listeners information about each other
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * An event emitter
+ * @typedef {Object} SafeEmitter
+ * @property {function(eventName: string, listenerFunc: Function): void} on Adds a listener for a given event name
+ * @property {function(eventName: string, arg1?: any, arg2?: any, arg3?: any)} emit Emits an event with a given name.
+ * This calls all the listeners that were listening for that name, with `arg1`, `arg2`, and `arg3` as arguments.
+ * @property {function(): string[]} eventNames Gets the list of event names that have registered listeners.
+ */
+
+/**
+ * Creates an object which can listen for and emit events.
+ * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.
+ * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without
+ * letting the modules know about each other at all.
+ * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when
+ * another module throws an error or registers a listener.
+ * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a
+ * `this` value of the emitter instance, which would give listeners access to other listeners.)
+ * 3. Events can be emitted with at most 3 arguments. (For example: when using `emitter.emit('foo', a, b, c)`,
+ * the arguments `a`, `b`, and `c` will be passed to the listener functions.)
+ * @returns {SafeEmitter} An emitter
+ */
+module.exports = () => {
+    const listeners = Object.create(null);
+
+    return Object.freeze({
+        on(eventName, listener) {
+            if (eventName in listeners) {
+                listeners[eventName].push(listener);
+            } else {
+                listeners[eventName] = [listener];
+            }
+        },
+        emit(eventName, a, b, c) {
+            if (eventName in listeners) {
+                listeners[eventName].forEach(listener => listener(a, b, c));
+            }
+        },
+        eventNames() {
+            return Object.keys(listeners);
+        }
+    });
+};

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

@@ -122,8 +122,10 @@ SourceCodeFixer.applyFixes = function(sourceText, messages, shouldFix) {
             if (typeof shouldFix !== "function" || shouldFix(problem)) {
                 attemptFix(problem);
 
-                // The only time attemptFix will fail is if a previous fix was
-                // applied which conflicts with it.  So we can mark this as true.
+                /*
+                 * The only time attemptFix will fail is if a previous fix was
+                 * applied which conflicts with it.  So we can mark this as true.
+                 */
                 fixesWereApplied = true;
             } else {
                 remainingMessages.push(problem);