eslint 6.0.0-alpha.1 → 6.0.1

package/lib/cli-engine/config-array/config-dependency.js

@@ -108,7 +108,7 @@ class ConfigDependency {
     }
 }
 
-/** @typedef {ConfigDependency<import("../../util/types").Parser>} DependentParser */
-/** @typedef {ConfigDependency<import("../../util/types").Plugin>} DependentPlugin */
+/** @typedef {ConfigDependency<import("../../shared/types").Parser>} DependentParser */
+/** @typedef {ConfigDependency<import("../../shared/types").Plugin>} DependentPlugin */
 
 module.exports = { ConfigDependency };

package/lib/cli-engine/config-array/extracted-config.js

@@ -17,9 +17,9 @@
 "use strict";
 
 // For VSCode intellisense
-/** @typedef {import("../../util/types").ConfigData} ConfigData */
-/** @typedef {import("../../util/types").GlobalConf} GlobalConf */
-/** @typedef {import("../../util/types").SeverityConf} SeverityConf */
+/** @typedef {import("../../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../../shared/types").SeverityConf} SeverityConf */
 /** @typedef {import("./config-dependency").DependentParser} DependentParser */
 /** @typedef {import("./config-dependency").DependentPlugin} DependentPlugin */
 

package/lib/cli-engine/config-array/override-tester.js

@@ -55,7 +55,17 @@ function toMatcher(patterns) {
     if (patterns.length === 0) {
         return null;
     }
-    return patterns.map(pattern => new Minimatch(pattern, minimatchOpts));
+    return patterns.map(pattern => {
+        if (/^\.[/\\]/u.test(pattern)) {
+            return new Minimatch(
+                pattern.slice(2),
+
+                // `./*.js` should not match with `subdir/foo.js`
+                { ...minimatchOpts, matchBase: false }
+            );
+        }
+        return new Minimatch(pattern, minimatchOpts);
+    });
 }
 
 /**

package/lib/cli-engine/config-array-factory.js

@@ -37,10 +37,10 @@ const fs = require("fs");
 const path = require("path");
 const importFresh = require("import-fresh");
 const stripComments = require("strip-json-comments");
-const { validateConfigSchema } = require("../config/config-validator");
+const { validateConfigSchema } = require("../shared/config-validator");
+const ModuleResolver = require("../shared/relative-module-resolver");
 const { ConfigArray, ConfigDependency, OverrideTester } = require("./config-array");
-const ModuleResolver = require("../util/relative-module-resolver");
-const naming = require("../util/naming");
+const naming = require("./naming");
 const debug = require("debug")("eslint:config-array-factory");
 
 //------------------------------------------------------------------------------
@@ -59,10 +59,10 @@ const configFilenames = [
 ];
 
 // Define types for VSCode IntelliSense.
-/** @typedef {import("../util/types").ConfigData} ConfigData */
-/** @typedef {import("../util/types").OverrideConfigData} OverrideConfigData */
-/** @typedef {import("../util/types").Parser} Parser */
-/** @typedef {import("../util/types").Plugin} Plugin */
+/** @typedef {import("../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../shared/types").OverrideConfigData} OverrideConfigData */
+/** @typedef {import("../shared/types").Parser} Parser */
+/** @typedef {import("../shared/types").Plugin} Plugin */
 /** @typedef {import("./config-array/config-dependency").DependentParser} DependentParser */
 /** @typedef {import("./config-array/config-dependency").DependentPlugin} DependentPlugin */
 /** @typedef {ConfigArray[0]} ConfigArrayElement */
@@ -224,15 +224,16 @@ function loadPackageJSONConfigFile(filePath) {
 /**
  * Creates an error to notify about a missing config to extend from.
  * @param {string} configName The name of the missing config.
+ * @param {string} importerName The name of the config that imported the missing config
  * @returns {Error} The error object to throw
  * @private
  */
-function configMissingError(configName) {
+function configMissingError(configName, importerName) {
     return Object.assign(
         new Error(`Failed to load config "${configName}" to extend from.`),
         {
             messageTemplate: "extend-config-missing",
-            messageData: { configName }
+            messageData: { configName, importerName }
         }
     );
 }
@@ -427,28 +428,22 @@ class ConfigArrayFactory {
     _loadConfigDataInDirectory(directoryPath, name) {
         for (const filename of configFilenames) {
             const filePath = path.join(directoryPath, filename);
-            const originalDebugEnabled = debug.enabled;
-            let configData;
 
-            // Make silent temporary because of too verbose.
-            debug.enabled = false;
-            try {
-                configData = loadConfigFile(filePath);
-            } catch (error) {
-                if (
-                    error.code !== "ENOENT" &&
-                    error.code !== "MODULE_NOT_FOUND" &&
-                    error.code !== "ESLINT_CONFIG_FIELD_NOT_FOUND"
-                ) {
-                    throw error;
+            if (fs.existsSync(filePath)) {
+                let configData;
+
+                try {
+                    configData = loadConfigFile(filePath);
+                } catch (error) {
+                    if (!error || error.code !== "ESLINT_CONFIG_FIELD_NOT_FOUND") {
+                        throw error;
+                    }
                 }
-            } finally {
-                debug.enabled = originalDebugEnabled;
-            }
 
-            if (configData) {
-                debug(`Config file found: ${filePath}`);
-                return this._normalizeConfigData(configData, filePath, name);
+                if (configData) {
+                    debug(`Config file found: ${filePath}`);
+                    return this._normalizeConfigData(configData, filePath, name);
+                }
             }
         }
 
@@ -506,6 +501,14 @@ class ConfigArrayFactory {
              */
             element.criteria = OverrideTester.and(criteria, element.criteria);
 
+            /*
+             * Remove `root` property to ignore `root` settings which came from
+             * `extends` in `overrides`.
+             */
+            if (element.criteria) {
+                element.root = void 0;
+            }
+
             yield element;
         }
     }
@@ -526,7 +529,7 @@ class ConfigArrayFactory {
             parser: parserName,
             parserOptions,
             plugins: pluginList,
-            processor, // processor is only for file extension processors.
+            processor,
             root,
             rules,
             settings,
@@ -635,7 +638,7 @@ class ConfigArrayFactory {
             return this._loadConfigData(eslintAllPath, name);
         }
 
-        throw configMissingError(extendName);
+        throw configMissingError(extendName, importerName);
     }
 
     /**
@@ -668,7 +671,7 @@ class ConfigArrayFactory {
             );
         }
 
-        throw plugin.error || configMissingError(extendName);
+        throw plugin.error || configMissingError(extendName, importerPath);
     }
 
     /**
@@ -695,20 +698,20 @@ class ConfigArrayFactory {
             );
         }
 
-        try {
-            const filePath = ModuleResolver.resolve(request, relativeTo);
-
-            writeDebugLogForLoading(request, relativeTo, filePath);
+        let filePath;
 
-            return this._loadConfigData(filePath, `${importerName} » ${request}`);
+        try {
+            filePath = ModuleResolver.resolve(request, relativeTo);
         } catch (error) {
-            /* istanbul ignore next */
-            if (!error || error.code !== "MODULE_NOT_FOUND") {
-                throw error;
+            /* istanbul ignore else */
+            if (error && error.code === "MODULE_NOT_FOUND") {
+                throw configMissingError(extendName, importerPath);
             }
+            throw error;
         }
 
-        throw configMissingError(extendName);
+        writeDebugLogForLoading(request, relativeTo, filePath);
+        return this._loadConfigData(filePath, `${importerName} » ${request}`);
     }
 
     /**
@@ -797,6 +800,7 @@ class ConfigArrayFactory {
         const { additionalPluginPool, resolvePluginsRelativeTo } = internalSlotsMap.get(this);
         const request = naming.normalizePackageName(name, "eslint-plugin");
         const id = naming.getShorthandName(request, "eslint-plugin");
+        const relativeTo = path.join(resolvePluginsRelativeTo, "__placeholder__.js");
 
         if (name.match(/\s+/u)) {
             const error = Object.assign(
@@ -830,25 +834,15 @@ class ConfigArrayFactory {
             });
         }
 
-        try {
-
-            // Resolve the plugin file
-            const relativeTo = path.join(resolvePluginsRelativeTo, "__placeholder__.js");
-            const filePath = ModuleResolver.resolve(request, relativeTo);
-
-            writeDebugLogForLoading(request, relativeTo, filePath);
-
-            return new ConfigDependency({
-                definition: normalizePlugin(require(filePath)),
-                filePath,
-                id,
-                importerName,
-                importerPath
-            });
-        } catch (error) {
-            debug("Failed to load plugin '%s' declared in '%s'.", name, importerName);
+        let filePath;
+        let error;
 
-            if (error && error.code === "MODULE_NOT_FOUND" && error.message.includes(request)) {
+        try {
+            filePath = ModuleResolver.resolve(request, relativeTo);
+        } catch (resolveError) {
+            error = resolveError;
+            /* istanbul ignore else */
+            if (error && error.code === "MODULE_NOT_FOUND") {
                 error.messageTemplate = "plugin-missing";
                 error.messageData = {
                     pluginName: request,
@@ -856,15 +850,31 @@ class ConfigArrayFactory {
                     importerName
                 };
             }
-            error.message = `Failed to load plugin '${name}' declared in '${importerName}': ${error.message}`;
+        }
 
-            return new ConfigDependency({
-                error,
-                id,
-                importerName,
-                importerPath
-            });
+        if (filePath) {
+            try {
+                writeDebugLogForLoading(request, relativeTo, filePath);
+                return new ConfigDependency({
+                    definition: normalizePlugin(require(filePath)),
+                    filePath,
+                    id,
+                    importerName,
+                    importerPath
+                });
+            } catch (loadError) {
+                error = loadError;
+            }
         }
+
+        debug("Failed to load plugin '%s' declared in '%s'.", name, importerName);
+        error.message = `Failed to load plugin '${name}' declared in '${importerName}': ${error.message}`;
+        return new ConfigDependency({
+            error,
+            id,
+            importerName,
+            importerPath
+        });
     }
 
     /**

package/lib/cli-engine/file-enumerator.js

@@ -41,7 +41,7 @@ const isGlob = require("is-glob");
 const { escapeRegExp } = require("lodash");
 const { Minimatch } = require("minimatch");
 const { CascadingConfigArrayFactory } = require("./cascading-config-array-factory");
-const { IgnoredPaths } = require("../util/ignored-paths");
+const { IgnoredPaths } = require("./ignored-paths");
 const debug = require("debug")("eslint:file-enumerator");
 
 //------------------------------------------------------------------------------
@@ -89,7 +89,7 @@ const IGNORED = 2;
  * @typedef {Object} FileEnumeratorInternalSlots
  * @property {CascadingConfigArrayFactory} configArrayFactory The factory for config arrays.
  * @property {string} cwd The base directory to start lookup.
- * @property {RegExp} extRegExp The RegExp to test if a string ends with specific file extensions.
+ * @property {RegExp} extensionRegExp The RegExp to test if a string ends with specific file extensions.
  * @property {boolean} globInputPaths Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} ignoreFlag The flag to check ignored files.
  * @property {IgnoredPaths} ignoredPathsWithDotfiles The ignored paths but don't include dot files.
@@ -196,7 +196,7 @@ class FileEnumerator {
         internalSlotsMap.set(this, {
             configArrayFactory,
             cwd,
-            extRegExp: new RegExp(
+            extensionRegExp: new RegExp(
                 `.\\.(?:${extensions
                     .map(ext => escapeRegExp(
                         ext.startsWith(".")
@@ -217,6 +217,14 @@ class FileEnumerator {
         });
     }
 
+    /**
+     * The `RegExp` object that tests if a file path has the allowed file extensions.
+     * @type {RegExp}
+     */
+    get extensionRegExp() {
+        return internalSlotsMap.get(this).extensionRegExp;
+    }
+
     /**
      * Iterate files which are matched by given glob patterns.
      * @param {string|string[]} patternOrPatterns The glob patterns to iterate files.
@@ -380,11 +388,11 @@ class FileEnumerator {
      * @private
      */
     *_iterateFilesRecursive(directoryPath, options) {
-        if (this._isIgnoredFile(directoryPath, options)) {
+        if (this._isIgnoredFile(directoryPath + path.sep, options)) {
             return;
         }
         debug(`Enter the directory: ${directoryPath}`);
-        const { configArrayFactory, extRegExp } = internalSlotsMap.get(this);
+        const { configArrayFactory, extensionRegExp } = internalSlotsMap.get(this);
 
         /** @type {ConfigArray|null} */
         let config = null;
@@ -407,7 +415,7 @@ class FileEnumerator {
                     ? options.selector.match(filePath)
 
                     // Started with a directory path; choose by file extensions.
-                    : extRegExp.test(filePath);
+                    : extensionRegExp.test(filePath);
 
                 if (matched) {
                     debug(`Yield: ${filename}${ignored ? " but ignored" : ""}`);

package/lib/{formatters → cli-engine/formatters}/checkstyle.js

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-const xmlEscape = require("../util/xml-escape");
+const xmlEscape = require("../xml-escape");
 
 //------------------------------------------------------------------------------
 // Helper Functions

package/lib/{formatters → cli-engine/formatters}/jslint-xml.js

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-const xmlEscape = require("../util/xml-escape");
+const xmlEscape = require("../xml-escape");
 
 //------------------------------------------------------------------------------
 // Public Interface

package/lib/{formatters → cli-engine/formatters}/junit.js

@@ -4,7 +4,8 @@
  */
 "use strict";
 
-const xmlEscape = require("../util/xml-escape");
+const xmlEscape = require("../xml-escape");
+const path = require("path");
 
 //------------------------------------------------------------------------------
 // Helper Functions
@@ -24,6 +25,16 @@ function getMessageType(message) {
 
 }
 
+/**
+ * Returns a full file path without extension
+ * @param {string} filePath input file path
+ * @returns {string} file path without extension
+ * @private
+ */
+function pathWithoutExt(filePath) {
+    return path.posix.join(path.posix.dirname(filePath), path.basename(filePath, path.extname(filePath)));
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -38,13 +49,14 @@ module.exports = function(results) {
     results.forEach(result => {
 
         const messages = result.messages;
+        const classname = pathWithoutExt(result.filePath);
 
         if (messages.length > 0) {
             output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
             messages.forEach(message => {
                 const type = message.fatal ? "error" : "failure";
 
-                output += `<testcase time="0" name="org.eslint.${message.ruleId || "unknown"}">`;
+                output += `<testcase time="0" name="org.eslint.${message.ruleId || "unknown"}" classname="${classname}">`;
                 output += `<${type} message="${xmlEscape(message.message || "")}">`;
                 output += "<![CDATA[";
                 output += `line ${message.line || 0}, col `;
@@ -58,7 +70,7 @@ module.exports = function(results) {
             output += "</testsuite>\n";
         } else {
             output += `<testsuite package="org.eslint" time="0" tests="1" errors="0" name="${result.filePath}">\n`;
-            output += `<testcase time="0" name="${result.filePath}" />\n`;
+            output += `<testcase time="0" name="${result.filePath}" classname="${classname}" />\n`;
             output += "</testsuite>\n";
         }
 

package/lib/{util → cli-engine}/ignored-paths.js

@@ -328,12 +328,17 @@ class IgnoredPaths {
      * @returns {boolean} true if the file path matches one or more patterns, false otherwise
      */
     contains(filepath, category) {
+        const isDir = filepath.endsWith(path.sep) ||
+            (path.sep === "\\" && filepath.endsWith("/"));
         let result = false;
         const basePath = this.getBaseDir();
         const absolutePath = path.resolve(this.options.cwd, filepath);
-        const relativePath = path.relative(basePath, absolutePath);
+        let relativePath = path.relative(basePath, absolutePath);
 
         if (relativePath) {
+            if (isDir) {
+                relativePath += path.sep;
+            }
             if (typeof category === "undefined") {
                 result =
                     (this.ig.default.filter([relativePath]).length === 0) ||

package/lib/cli-engine/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+const { CLIEngine } = require("./cli-engine");
+
+module.exports = {
+    CLIEngine
+};

package/lib/cli.js

@@ -17,10 +17,10 @@
 
 const fs = require("fs"),
     path = require("path"),
-    options = require("./options"),
-    CLIEngine = require("./cli-engine").CLIEngine,
     mkdirp = require("mkdirp"),
-    log = require("./util/logging");
+    { CLIEngine } = require("./cli-engine"),
+    options = require("./options"),
+    log = require("./shared/logging");
 
 const debug = require("debug")("eslint:cli");
 

package/lib/{config → init}/autoconfig.js

@@ -10,10 +10,10 @@
 //------------------------------------------------------------------------------
 
 const lodash = require("lodash"),
+    recConfig = require("../../conf/eslint-recommended"),
+    ConfigOps = require("../shared/config-ops"),
     { Linter } = require("../linter"),
-    configRule = require("./config-rule"),
-    ConfigOps = require("./config-ops"),
-    recConfig = require("../../conf/eslint-recommended");
+    configRule = require("./config-rule");
 
 const debug = require("debug")("eslint:autoconfig");
 const linter = new Linter();

package/lib/{config → init}/config-initializer.js

@@ -15,14 +15,14 @@ const util = require("util"),
     inquirer = require("inquirer"),
     ProgressBar = require("progress"),
     semver = require("semver"),
+    recConfig = require("../../conf/eslint-recommended"),
+    ConfigOps = require("../shared/config-ops"),
+    log = require("../shared/logging"),
+    ModuleResolver = require("../shared/relative-module-resolver"),
     autoconfig = require("./autoconfig.js"),
     ConfigFile = require("./config-file"),
-    ConfigOps = require("./config-ops"),
-    { getSourceCodeOfFiles } = require("../util/source-code-utils"),
-    ModuleResolver = require("../util/relative-module-resolver"),
-    npmUtils = require("../util/npm-utils"),
-    recConfig = require("../../conf/eslint-recommended"),
-    log = require("../util/logging");
+    npmUtils = require("./npm-utils"),
+    { getSourceCodeOfFiles } = require("./source-code-utils");
 
 const debug = require("debug")("eslint:config-initializer");
 

package/lib/{config → init}/config-rule.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const builtInRules = require("../built-in-rules-index");
+const builtInRules = require("../rules");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -293,11 +293,17 @@ function generateConfigsFromSchema(schema) {
 
 /**
  * Generate possible rule configurations for all of the core rules
+ * @param {boolean} noDeprecated Indicates whether ignores deprecated rules or not.
  * @returns {rulesConfig} Hash of rule names and arrays of possible configurations
  */
-function createCoreRuleConfigs() {
+function createCoreRuleConfigs(noDeprecated = false) {
     return Array.from(builtInRules).reduce((accumulator, [id, rule]) => {
         const schema = (typeof rule === "function") ? rule.schema : rule.meta.schema;
+        const isDeprecated = (typeof rule === "function") ? rule.deprecated : rule.meta.deprecated;
+
+        if (noDeprecated && isDeprecated) {
+            return accumulator;
+        }
 
         accumulator[id] = generateConfigsFromSchema(schema);
         return accumulator;

package/lib/{util → init}/npm-utils.js

@@ -12,7 +12,7 @@
 const fs = require("fs"),
     spawn = require("cross-spawn"),
     path = require("path"),
-    log = require("./logging");
+    log = require("../shared/logging");
 
 //------------------------------------------------------------------------------
 // Helpers

package/lib/{util → init}/source-code-utils.js

@@ -9,7 +9,22 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CLIEngine, getCLIEngineInternalSlots } = require("../cli-engine");
+const { CLIEngine } = require("../cli-engine");
+
+/*
+ * This is used for:
+ *
+ * 1. Enumerate target file because we have not expose such a API on `CLIEngine`
+ *    (https://github.com/eslint/eslint/issues/11222).
+ * 2. Create `SourceCode` instances. Because we don't have any function which
+ *    instantiate `SourceCode` so it needs to take the created `SourceCode`
+ *    instance out after linting.
+ *
+ * TODO1: Expose the API that enumerates target files.
+ * TODO2: Extract the creation logic of `SourceCode` from `Linter` class.
+ */
+const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line no-restricted-modules
+
 const debug = require("debug")("eslint:source-code-utils");
 
 //------------------------------------------------------------------------------