eslint 4.5.0 → 4.7.1

package/lib/testers/rule-tester.js

@@ -159,7 +159,8 @@ class RuleTester {
 
             // we have to clone because merge uses the first argument for recipient
             lodash.cloneDeep(defaultConfig),
-            testerConfig
+            testerConfig,
+            { rules: { "rule-tester/validate-ast": "error" } }
         );
 
         /**
@@ -306,7 +307,17 @@ class RuleTester {
                 config.rules[ruleName] = 1;
             }
 
-            linter.defineRule(ruleName, rule);
+            linter.defineRule(ruleName, Object.assign({}, rule, {
+
+                // Create a wrapper rule that freezes the `context` properties.
+                create(context) {
+                    freezeDeeply(context.options);
+                    freezeDeeply(context.settings);
+                    freezeDeeply(context.parserOptions);
+
+                    return (typeof rule === "function" ? rule : rule.create)(context);
+                }
+            }));
 
             const schema = validator.getRuleOptionsSchema(ruleName, linter.rules);
 
@@ -331,55 +342,20 @@ class RuleTester {
              * The goal is to check whether or not AST was modified when
              * running the rule under test.
              */
-            linter.reset();
-
-            linter.on("Program", node => {
-                beforeAST = cloneDeeplyExcludesParent(node);
-            });
-
-            linter.on("Program:exit", node => {
-                afterAST = node;
-            });
-
-            // Freezes rule-context properties.
-            const originalGet = linter.rules.get;
-
-            try {
-                linter.rules.get = function(ruleId) {
-                    const originalRule = originalGet.call(linter.rules, ruleId);
-
-                    if (typeof originalRule === "function") {
-                        return function(context) {
-                            Object.freeze(context);
-                            freezeDeeply(context.options);
-                            freezeDeeply(context.settings);
-                            freezeDeeply(context.parserOptions);
-
-                            return originalRule(context);
-                        };
-                    }
-                    return {
-                        meta: originalRule.meta,
-                        create(context) {
-                            Object.freeze(context);
-                            freezeDeeply(context.options);
-                            freezeDeeply(context.settings);
-                            freezeDeeply(context.parserOptions);
-
-                            return originalRule.create(context);
-                        }
-                    };
-
-                };
+            linter.defineRule("rule-tester/validate-ast", () => ({
+                Program(node) {
+                    beforeAST = cloneDeeplyExcludesParent(node);
+                },
+                "Program:exit"(node) {
+                    afterAST = node;
+                }
+            }));
 
-                return {
-                    messages: linter.verify(code, config, filename, true),
-                    beforeAST,
-                    afterAST: cloneDeeplyExcludesParent(afterAST)
-                };
-            } finally {
-                linter.rules.get = originalGet;
-            }
+            return {
+                messages: linter.verify(code, config, filename, true),
+                beforeAST,
+                afterAST: cloneDeeplyExcludesParent(afterAST)
+            };
         }
 
         /**
@@ -519,7 +495,7 @@ class RuleTester {
                         "Expected no autofixes to be suggested"
                     );
                 } else {
-                    const fixResult = SourceCodeFixer.applyFixes(linter.getSourceCode(), messages);
+                    const fixResult = SourceCodeFixer.applyFixes(item.code, messages);
 
                     assert.equal(fixResult.output, item.output, "Output is incorrect.");
                 }

package/lib/timing.js

@@ -84,11 +84,11 @@ function display(data) {
         }
     });
 
-    const table = rows.map(row =>
+    const table = rows.map(row => (
         row
             .map((cell, index) => ALIGN[index](cell, widths[index]))
             .join(" | ")
-    );
+    ));
 
     table.splice(1, 0, widths.map((w, index) => {
         if (index !== 0 && index !== widths.length - 1) {

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

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview A module that filters reported problems based on `eslint-disable` and `eslint-enable` comments
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+const lodash = require("lodash");
+
+/**
+ * Compares the locations of two objects in a source file
+ * @param {{line: number, column: number}} itemA The first object
+ * @param {{line: number, column: number}} itemB The second object
+ * @returns {number} A value less than 1 if itemA appears before itemB in the source file, greater than 1 if
+ * itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location.
+ */
+function compareLocations(itemA, itemB) {
+    return itemA.line - itemB.line || itemA.column - itemB.column;
+}
+
+/**
+ * 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)
+ */
+function applyDirectives(options) {
+    const problems = [];
+    let nextDirectiveIndex = 0;
+    let globalDisableActive = false;
+
+    // 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.
+    const enabledRules = new Set();
+
+    for (const problem of options.problems) {
+        while (
+            nextDirectiveIndex < options.directives.length &&
+            compareLocations(options.directives[nextDirectiveIndex], problem) <= 0
+        ) {
+            const directive = options.directives[nextDirectiveIndex++];
+
+            switch (directive.type) {
+                case "disable":
+                    if (directive.ruleId === null) {
+                        globalDisableActive = true;
+                        enabledRules.clear();
+                    } else if (globalDisableActive) {
+                        enabledRules.delete(directive.ruleId);
+                    } else {
+                        disabledRules.add(directive.ruleId);
+                    }
+                    break;
+
+                case "enable":
+                    if (directive.ruleId === null) {
+                        globalDisableActive = false;
+                        disabledRules.clear();
+                    } else if (globalDisableActive) {
+                        enabledRules.add(directive.ruleId);
+                    } else {
+                        disabledRules.delete(directive.ruleId);
+                    }
+                    break;
+
+                // no default
+            }
+        }
+
+        if (
+            globalDisableActive && enabledRules.has(problem.ruleId) ||
+            !globalDisableActive && !disabledRules.has(problem.ruleId)
+        ) {
+            problems.push(problem);
+        }
+    }
+
+    return problems;
+}
+
+/**
+ * Given a list of directive comments (i.e. metadata about eslint-disable and eslint-enable comments) and a list
+ * of reported problems, determines which problems should be reported.
+ * @param {Object} options Information about directives and problems
+ * @param {{
+ *      type: ("disable"|"enable"|"disable-line"|"disable-next-line"),
+ *      ruleId: (string|null),
+ *      line: number,
+ *      column: number
+ * }} options.directives Directive comments found in the file, with one-based columns.
+ * Two directive comments can only have the same location if they also have the same type (e.g. a single eslint-disable
+ * 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.
+ * @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")
+        .sort(compareLocations);
+
+    const lineDirectives = lodash.flatMap(options.directives, directive => {
+        switch (directive.type) {
+            case "disable":
+            case "enable":
+                return [];
+
+            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 }
+                ];
+
+            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 }
+                ];
+
+            default:
+                throw new TypeError(`Unrecognized directive type '${directive.type}'`);
+        }
+    }).sort(compareLocations);
+
+    const problemsAfterBlockDirectives = applyDirectives({ problems: options.problems, directives: blockDirectives });
+    const problemsAfterLineDirectives = applyDirectives({ problems: problemsAfterBlockDirectives, directives: lineDirectives });
+
+    return problemsAfterLineDirectives.sort(compareLocations);
+};

package/lib/util/fix-tracker.js

@@ -57,8 +57,7 @@ class FixTracker {
     retainEnclosingFunction(node) {
         const functionNode = astUtils.getUpperFunction(node);
 
-        return this.retainRange(
-            functionNode ? functionNode.range : this.sourceCode.ast.range);
+        return this.retainRange(functionNode ? functionNode.range : this.sourceCode.ast.range);
     }
 
     /**

package/lib/util/npm-util.js

@@ -53,22 +53,39 @@ function installSyncSaveDev(packages) {
     if (!Array.isArray(packages)) {
         packages = [packages];
     }
-    spawn.sync("npm", ["i", "--save-dev"].concat(packages), { stdio: "inherit" });
+    const npmProcess = spawn.sync("npm", ["i", "--save-dev"].concat(packages),
+        { stdio: "inherit" });
+    const error = npmProcess.error;
+
+    if (error && error.code === "ENOENT") {
+        const pluralS = packages.length > 1 ? "s" : "";
+
+        log.error(`Could not execute npm. Please install the following package${pluralS} with your package manager of choice: ${packages.join(", ")}`);
+    }
 }
 
 /**
  * Fetch `peerDependencies` of the given package by `npm show` command.
  * @param {string} packageName The package name to fetch peerDependencies.
- * @returns {Object} Gotten peerDependencies.
+ * @returns {Object} Gotten peerDependencies. Returns null if npm was not found.
  */
 function fetchPeerDependencies(packageName) {
-    const fetchedText = spawn.sync(
+    const npmProcess = spawn.sync(
         "npm",
         ["show", "--json", packageName, "peerDependencies"],
         { encoding: "utf8" }
-    ).stdout.trim();
+    );
+
+    const error = npmProcess.error;
+
+    if (error && error.code === "ENOENT") {
+        return null;
+    }
+    const fetchedText = npmProcess.stdout.trim();
 
     return JSON.parse(fetchedText || "{}");
+
+
 }
 
 /**

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

@@ -53,37 +53,28 @@ function SourceCodeFixer() {
 /**
  * Applies the fixes specified by the messages to the given text. Tries to be
  * smart about the fixes and won't apply fixes over the same area in the text.
- * @param {SourceCode} sourceCode The source code to apply the changes to.
+ * @param {string} sourceText The text to apply the changes to.
  * @param {Message[]} messages The array of messages reported by ESLint.
  * @param {boolean|Function} [shouldFix=true] Determines whether each message should be fixed
  * @returns {Object} An object containing the fixed text and any unfixed messages.
  */
-SourceCodeFixer.applyFixes = function(sourceCode, messages, shouldFix) {
+SourceCodeFixer.applyFixes = function(sourceText, messages, shouldFix) {
     debug("Applying fixes");
 
-    if (!sourceCode) {
-        debug("No source code to fix");
-        return {
-            fixed: false,
-            messages,
-            output: ""
-        };
-    }
-
     if (shouldFix === false) {
         debug("shouldFix parameter was false, not attempting fixes");
         return {
             fixed: false,
             messages,
-            output: sourceCode.text
+            output: sourceText
         };
     }
 
     // clone the array
     const remainingMessages = [],
         fixes = [],
-        bom = (sourceCode.hasBOM ? BOM : ""),
-        text = sourceCode.text;
+        bom = sourceText.startsWith(BOM) ? BOM : "",
+        text = bom ? sourceText.slice(1) : sourceText;
     let lastPos = Number.NEGATIVE_INFINITY,
         output = bom;
 

package/lib/util/source-code.js

@@ -349,15 +349,13 @@ class SourceCode extends TokenStore {
      * @returns {ASTNode} The node if found or null if not found.
      */
     getNodeByRangeIndex(index) {
-        let result = null,
-            resultParent = null;
+        let result = null;
         const traverser = new Traverser();
 
         traverser.traverse(this.ast, {
-            enter(node, parent) {
+            enter(node) {
                 if (node.range[0] <= index && index < node.range[1]) {
                     result = node;
-                    resultParent = parent;
                 } else {
                     this.skip();
                 }
@@ -369,7 +367,7 @@ class SourceCode extends TokenStore {
             }
         });
 
-        return result ? Object.assign({ parent: resultParent }, result) : null;
+        return result;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "4.5.0",
+  "version": "4.7.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -40,10 +40,10 @@
     "chalk": "^2.1.0",
     "concat-stream": "^1.6.0",
     "cross-spawn": "^5.1.0",
-    "debug": "^2.6.8",
+    "debug": "^3.0.1",
     "doctrine": "^2.0.0",
     "eslint-scope": "^3.7.1",
-    "espree": "^3.5.0",
+    "espree": "^3.5.1",
     "esquery": "^1.0.0",
     "estraverse": "^4.2.0",
     "esutils": "^2.0.2",
@@ -64,7 +64,7 @@
     "natural-compare": "^1.4.0",
     "optionator": "^0.8.2",
     "path-is-inside": "^1.0.2",
-    "pluralize": "^4.0.0",
+    "pluralize": "^7.0.0",
     "progress": "^2.0.0",
     "require-uncached": "^1.0.3",
     "semver": "^5.3.0",
@@ -85,11 +85,11 @@
     "coveralls": "^2.13.1",
     "dateformat": "^2.0.0",
     "ejs": "^2.5.6",
-    "eslint-plugin-eslint-plugin": "^0.8.0",
+    "eslint-plugin-eslint-plugin": "^1.2.0",
     "eslint-plugin-node": "^5.1.0",
     "eslint-release": "^0.10.1",
     "eslump": "1.6.0",
-    "esprima": "^3.1.3",
+    "esprima": "^4.0.0",
     "esprima-fb": "^15001.1001.0-dev-harmony-fb",
     "istanbul": "^0.4.5",
     "jsdoc": "^3.4.3",
@@ -100,7 +100,7 @@
     "karma-phantomjs-launcher": "^1.0.4",
     "leche": "^2.1.2",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.5.0",
+    "markdownlint": "^0.6.1",
     "mocha": "^3.4.2",
     "mock-fs": "^4.3.0",
     "npm-license": "^0.3.3",
@@ -108,7 +108,7 @@
     "proxyquire": "^1.8.0",
     "shelljs": "^0.7.7",
     "shelljs-nodecli": "~0.1.1",
-    "sinon": "^2.3.2",
+    "sinon": "^3.2.1",
     "temp": "^0.8.3",
     "through": "^2.3.8"
   },

package/lib/rule-context.js

@@ -1,241 +0,0 @@
-/**
- * @fileoverview RuleContext utility for rules
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const assert = require("assert");
-const ruleFixer = require("./util/rule-fixer");
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-const PASSTHROUGHS = [
-    "getAncestors",
-    "getDeclaredVariables",
-    "getFilename",
-    "getScope",
-    "getSourceCode",
-    "markVariableAsUsed",
-
-    // DEPRECATED
-    "getAllComments",
-    "getComments",
-    "getFirstToken",
-    "getFirstTokens",
-    "getJSDocComment",
-    "getLastToken",
-    "getLastTokens",
-    "getNodeByRangeIndex",
-    "getSource",
-    "getSourceLines",
-    "getTokenAfter",
-    "getTokenBefore",
-    "getTokenByRangeStart",
-    "getTokens",
-    "getTokensAfter",
-    "getTokensBefore",
-    "getTokensBetween"
-];
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * An error message description
- * @typedef {Object} MessageDescriptor
- * @property {string} nodeType The type of node.
- * @property {Location} loc The location of the problem.
- * @property {string} message The problem message.
- * @property {Object} [data] Optional data to use to fill in placeholders in the
- *      message.
- * @property {Function} fix The function to call that creates a fix command.
- */
-
-//------------------------------------------------------------------------------
-// Module Definition
-//------------------------------------------------------------------------------
-
-/**
- * Compares items in a fixes array by range.
- * @param {Fix} a The first message.
- * @param {Fix} b The second message.
- * @returns {int} -1 if a comes before b, 1 if a comes after b, 0 if equal.
- * @private
- */
-function compareFixesByRange(a, b) {
-    return a.range[0] - b.range[0] || a.range[1] - b.range[1];
-}
-
-/**
- * Merges the given fixes array into one.
- * @param {Fix[]} fixes The fixes to merge.
- * @param {SourceCode} sourceCode The source code object to get the text between fixes.
- * @returns {void}
- */
-function mergeFixes(fixes, sourceCode) {
-    if (fixes.length === 0) {
-        return null;
-    }
-    if (fixes.length === 1) {
-        return fixes[0];
-    }
-
-    fixes.sort(compareFixesByRange);
-
-    const originalText = sourceCode.text;
-    const start = fixes[0].range[0];
-    const end = fixes[fixes.length - 1].range[1];
-    let text = "";
-    let lastPos = Number.MIN_SAFE_INTEGER;
-
-    for (const fix of fixes) {
-        assert(fix.range[0] >= lastPos, "Fix objects must not be overlapped in a report.");
-
-        if (fix.range[0] >= 0) {
-            text += originalText.slice(Math.max(0, start, lastPos), fix.range[0]);
-        }
-        text += fix.text;
-        lastPos = fix.range[1];
-    }
-    text += originalText.slice(Math.max(0, start, lastPos), end);
-
-    return { range: [start, end], text };
-}
-
-/**
- * Gets one fix object from the given descriptor.
- * If the descriptor retrieves multiple fixes, this merges those to one.
- * @param {Object} descriptor The report descriptor.
- * @param {SourceCode} sourceCode The source code object to get text between fixes.
- * @returns {Fix} The got fix object.
- */
-function getFix(descriptor, sourceCode) {
-    if (typeof descriptor.fix !== "function") {
-        return null;
-    }
-
-    // @type {null | Fix | Fix[] | IterableIterator<Fix>}
-    const fix = descriptor.fix(ruleFixer);
-
-    // Merge to one.
-    if (fix && Symbol.iterator in fix) {
-        return mergeFixes(Array.from(fix), sourceCode);
-    }
-    return fix;
-}
-
-/**
- * Rule context class
- * Acts as an abstraction layer between rules and the main linter object.
- */
-class RuleContext {
-
-    /**
-     * @param {string} ruleId The ID of the rule using this object.
-     * @param {Linter} linter The linter object.
-     * @param {number} severity The configured severity level of the rule.
-     * @param {Array} options The configuration information to be added to the rule.
-     * @param {Object} settings The configuration settings passed from the config file.
-     * @param {Object} parserOptions The parserOptions settings passed from the config file.
-     * @param {Object} parserPath The parser setting passed from the config file.
-     * @param {Object} meta The metadata of the rule
-     * @param {Object} parserServices The parser services for the rule.
-     */
-    constructor(ruleId, linter, severity, options, settings, parserOptions, parserPath, meta, parserServices) {
-
-        // public.
-        this.id = ruleId;
-        this.options = options;
-        this.settings = settings;
-        this.parserOptions = parserOptions;
-        this.parserPath = parserPath;
-        this.meta = meta;
-
-        // create a separate copy and freeze it (it's not nice to freeze other people's objects)
-        this.parserServices = Object.freeze(Object.assign({}, parserServices));
-
-        // private.
-        this._linter = linter;
-        this._severity = severity;
-
-        Object.freeze(this);
-    }
-
-    /**
-     * Passthrough to Linter#report() that automatically assigns the rule ID and severity.
-     * @param {ASTNode|MessageDescriptor} nodeOrDescriptor The AST node related to the message or a message
-     *      descriptor.
-     * @param {Object=} location The location of the error.
-     * @param {string} message The message to display to the user.
-     * @param {Object} opts Optional template data which produces a formatted message
-     *     with symbols being replaced by this object's values.
-     * @returns {void}
-     */
-    report(nodeOrDescriptor, location, message, opts) {
-
-        // check to see if it's a new style call
-        if (arguments.length === 1) {
-            const descriptor = nodeOrDescriptor;
-            const fix = getFix(descriptor, this.getSourceCode());
-
-            if (descriptor.loc) {
-                this._linter.report(
-                    this.id,
-                    this._severity,
-                    descriptor.node,
-                    descriptor.loc,
-                    descriptor.message,
-                    descriptor.data,
-                    fix,
-                    this.meta
-                );
-            } else {
-                this._linter.report(
-                    this.id,
-                    this._severity,
-                    descriptor.node,
-
-                    /* loc not provided */
-                    descriptor.message,
-                    descriptor.data,
-                    fix,
-                    this.meta
-                );
-            }
-
-        } else {
-
-            // old style call
-            this._linter.report(
-                this.id,
-                this._severity,
-                nodeOrDescriptor,
-                location,
-                message,
-                opts,
-                this.meta
-            );
-        }
-    }
-}
-
-// Copy over passthrough methods.
-PASSTHROUGHS.forEach(name => {
-    Object.defineProperty(RuleContext.prototype, name, {
-        value() {
-            return this._linter[name].apply(this._linter, arguments);
-        },
-        configurable: true,
-        writable: true,
-        enumerable: false
-    });
-});
-
-module.exports = RuleContext;