mirror of
https://github.com/JamesIves/github-pages-deploy-action.git
synced 2023-12-15 20:03:39 +08:00
1040 lines
36 KiB
JavaScript
1040 lines
36 KiB
JavaScript
/**
|
|
* @fileoverview The factory of `ConfigArray` objects.
|
|
*
|
|
* This class provides methods to create `ConfigArray` instance.
|
|
*
|
|
* - `create(configData, options)`
|
|
* Create a `ConfigArray` instance from a config data. This is to handle CLI
|
|
* options except `--config`.
|
|
* - `loadFile(filePath, options)`
|
|
* Create a `ConfigArray` instance from a config file. This is to handle
|
|
* `--config` option. If the file was not found, throws the following error:
|
|
* - If the filename was `*.js`, a `MODULE_NOT_FOUND` error.
|
|
* - If the filename was `package.json`, an IO error or an
|
|
* `ESLINT_CONFIG_FIELD_NOT_FOUND` error.
|
|
* - Otherwise, an IO error such as `ENOENT`.
|
|
* - `loadInDirectory(directoryPath, options)`
|
|
* Create a `ConfigArray` instance from a config file which is on a given
|
|
* directory. This tries to load `.eslintrc.*` or `package.json`. If not
|
|
* found, returns an empty `ConfigArray`.
|
|
* - `loadESLintIgnore(filePath)`
|
|
* Create a `ConfigArray` instance from a config file that is `.eslintignore`
|
|
* format. This is to handle `--ignore-path` option.
|
|
* - `loadDefaultESLintIgnore()`
|
|
* Create a `ConfigArray` instance from `.eslintignore` or `package.json` in
|
|
* the current working directory.
|
|
*
|
|
* `ConfigArrayFactory` class has the responsibility that loads configuration
|
|
* files, including loading `extends`, `parser`, and `plugins`. The created
|
|
* `ConfigArray` instance has the loaded `extends`, `parser`, and `plugins`.
|
|
*
|
|
* But this class doesn't handle cascading. `CascadingConfigArrayFactory` class
|
|
* handles cascading and hierarchy.
|
|
*
|
|
* @author Toru Nagashima <https://github.com/mysticatea>
|
|
*/
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const importFresh = require("import-fresh");
|
|
const stripComments = require("strip-json-comments");
|
|
const { validateConfigSchema } = require("../shared/config-validator");
|
|
const naming = require("../shared/naming");
|
|
const ModuleResolver = require("../shared/relative-module-resolver");
|
|
const {
|
|
ConfigArray,
|
|
ConfigDependency,
|
|
IgnorePattern,
|
|
OverrideTester
|
|
} = require("./config-array");
|
|
const debug = require("debug")("eslint:config-array-factory");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helpers
|
|
//------------------------------------------------------------------------------
|
|
|
|
const eslintRecommendedPath = path.resolve(__dirname, "../../conf/eslint-recommended.js");
|
|
const eslintAllPath = path.resolve(__dirname, "../../conf/eslint-all.js");
|
|
const configFilenames = [
|
|
".eslintrc.js",
|
|
".eslintrc.cjs",
|
|
".eslintrc.yaml",
|
|
".eslintrc.yml",
|
|
".eslintrc.json",
|
|
".eslintrc",
|
|
"package.json"
|
|
];
|
|
|
|
// Define types for VSCode IntelliSense.
|
|
/** @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 */
|
|
|
|
/**
|
|
* @typedef {Object} ConfigArrayFactoryOptions
|
|
* @property {Map<string,Plugin>} [additionalPluginPool] The map for additional plugins.
|
|
* @property {string} [cwd] The path to the current working directory.
|
|
* @property {string} [resolvePluginsRelativeTo] A path to the directory that plugins should be resolved from. Defaults to `cwd`.
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} ConfigArrayFactoryInternalSlots
|
|
* @property {Map<string,Plugin>} additionalPluginPool The map for additional plugins.
|
|
* @property {string} cwd The path to the current working directory.
|
|
* @property {string} resolvePluginsRelativeTo An absolute path the the directory that plugins should be resolved from.
|
|
*/
|
|
|
|
/** @type {WeakMap<ConfigArrayFactory, ConfigArrayFactoryInternalSlots>} */
|
|
const internalSlotsMap = new WeakMap();
|
|
|
|
/**
|
|
* Check if a given string is a file path.
|
|
* @param {string} nameOrPath A module name or file path.
|
|
* @returns {boolean} `true` if the `nameOrPath` is a file path.
|
|
*/
|
|
function isFilePath(nameOrPath) {
|
|
return (
|
|
/^\.{1,2}[/\\]/u.test(nameOrPath) ||
|
|
path.isAbsolute(nameOrPath)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Convenience wrapper for synchronously reading file contents.
|
|
* @param {string} filePath The filename to read.
|
|
* @returns {string} The file contents, with the BOM removed.
|
|
* @private
|
|
*/
|
|
function readFile(filePath) {
|
|
return fs.readFileSync(filePath, "utf8").replace(/^\ufeff/u, "");
|
|
}
|
|
|
|
/**
|
|
* Loads a YAML configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadYAMLConfigFile(filePath) {
|
|
debug(`Loading YAML config file: ${filePath}`);
|
|
|
|
// lazy load YAML to improve performance when not used
|
|
const yaml = require("js-yaml");
|
|
|
|
try {
|
|
|
|
// empty YAML file can be null, so always use
|
|
return yaml.safeLoad(readFile(filePath)) || {};
|
|
} catch (e) {
|
|
debug(`Error reading YAML file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a JSON configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadJSONConfigFile(filePath) {
|
|
debug(`Loading JSON config file: ${filePath}`);
|
|
|
|
try {
|
|
return JSON.parse(stripComments(readFile(filePath)));
|
|
} catch (e) {
|
|
debug(`Error reading JSON file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
e.messageTemplate = "failed-to-read-json";
|
|
e.messageData = {
|
|
path: filePath,
|
|
message: e.message
|
|
};
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a legacy (.eslintrc) configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadLegacyConfigFile(filePath) {
|
|
debug(`Loading legacy config file: ${filePath}`);
|
|
|
|
// lazy load YAML to improve performance when not used
|
|
const yaml = require("js-yaml");
|
|
|
|
try {
|
|
return yaml.safeLoad(stripComments(readFile(filePath))) || /* istanbul ignore next */ {};
|
|
} catch (e) {
|
|
debug("Error reading YAML file: %s\n%o", filePath, e);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a JavaScript configuration from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadJSConfigFile(filePath) {
|
|
debug(`Loading JS config file: ${filePath}`);
|
|
try {
|
|
return importFresh(filePath);
|
|
} catch (e) {
|
|
debug(`Error reading JavaScript file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a configuration from a package.json file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {ConfigData} The configuration object from the file.
|
|
* @throws {Error} If the file cannot be read.
|
|
* @private
|
|
*/
|
|
function loadPackageJSONConfigFile(filePath) {
|
|
debug(`Loading package.json config file: ${filePath}`);
|
|
try {
|
|
const packageData = loadJSONConfigFile(filePath);
|
|
|
|
if (!Object.hasOwnProperty.call(packageData, "eslintConfig")) {
|
|
throw Object.assign(
|
|
new Error("package.json file doesn't have 'eslintConfig' field."),
|
|
{ code: "ESLINT_CONFIG_FIELD_NOT_FOUND" }
|
|
);
|
|
}
|
|
|
|
return packageData.eslintConfig;
|
|
} catch (e) {
|
|
debug(`Error reading package.json file: ${filePath}`);
|
|
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads a `.eslintignore` from a file.
|
|
* @param {string} filePath The filename to load.
|
|
* @returns {string[]} The ignore patterns from the file.
|
|
* @private
|
|
*/
|
|
function loadESLintIgnoreFile(filePath) {
|
|
debug(`Loading .eslintignore file: ${filePath}`);
|
|
|
|
try {
|
|
return readFile(filePath)
|
|
.split(/\r?\n/gu)
|
|
.filter(line => line.trim() !== "" && !line.startsWith("#"));
|
|
} catch (e) {
|
|
debug(`Error reading .eslintignore file: ${filePath}`);
|
|
e.message = `Cannot read .eslintignore file: ${filePath}\nError: ${e.message}`;
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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, importerName) {
|
|
return Object.assign(
|
|
new Error(`Failed to load config "${configName}" to extend from.`),
|
|
{
|
|
messageTemplate: "extend-config-missing",
|
|
messageData: { configName, importerName }
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Loads a configuration file regardless of the source. Inspects the file path
|
|
* to determine the correctly way to load the config file.
|
|
* @param {string} filePath The path to the configuration.
|
|
* @returns {ConfigData|null} The configuration information.
|
|
* @private
|
|
*/
|
|
function loadConfigFile(filePath) {
|
|
switch (path.extname(filePath)) {
|
|
case ".js":
|
|
case ".cjs":
|
|
return loadJSConfigFile(filePath);
|
|
|
|
case ".json":
|
|
if (path.basename(filePath) === "package.json") {
|
|
return loadPackageJSONConfigFile(filePath);
|
|
}
|
|
return loadJSONConfigFile(filePath);
|
|
|
|
case ".yaml":
|
|
case ".yml":
|
|
return loadYAMLConfigFile(filePath);
|
|
|
|
default:
|
|
return loadLegacyConfigFile(filePath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write debug log.
|
|
* @param {string} request The requested module name.
|
|
* @param {string} relativeTo The file path to resolve the request relative to.
|
|
* @param {string} filePath The resolved file path.
|
|
* @returns {void}
|
|
*/
|
|
function writeDebugLogForLoading(request, relativeTo, filePath) {
|
|
/* istanbul ignore next */
|
|
if (debug.enabled) {
|
|
let nameAndVersion = null;
|
|
|
|
try {
|
|
const packageJsonPath = ModuleResolver.resolve(
|
|
`${request}/package.json`,
|
|
relativeTo
|
|
);
|
|
const { version = "unknown" } = require(packageJsonPath);
|
|
|
|
nameAndVersion = `${request}@${version}`;
|
|
} catch (error) {
|
|
debug("package.json was not found:", error.message);
|
|
nameAndVersion = request;
|
|
}
|
|
|
|
debug("Loaded: %s (%s)", nameAndVersion, filePath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Concatenate two config data.
|
|
* @param {IterableIterator<ConfigArrayElement>|null} elements The config elements.
|
|
* @param {ConfigArray|null} parentConfigArray The parent config array.
|
|
* @returns {ConfigArray} The concatenated config array.
|
|
*/
|
|
function createConfigArray(elements, parentConfigArray) {
|
|
if (!elements) {
|
|
return parentConfigArray || new ConfigArray();
|
|
}
|
|
const configArray = new ConfigArray(...elements);
|
|
|
|
if (parentConfigArray && !configArray.isRoot()) {
|
|
configArray.unshift(...parentConfigArray);
|
|
}
|
|
return configArray;
|
|
}
|
|
|
|
/**
|
|
* Normalize a given plugin.
|
|
* - Ensure the object to have four properties: configs, environments, processors, and rules.
|
|
* - Ensure the object to not have other properties.
|
|
* @param {Plugin} plugin The plugin to normalize.
|
|
* @returns {Plugin} The normalized plugin.
|
|
*/
|
|
function normalizePlugin(plugin) {
|
|
return {
|
|
configs: plugin.configs || {},
|
|
environments: plugin.environments || {},
|
|
processors: plugin.processors || {},
|
|
rules: plugin.rules || {}
|
|
};
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Public Interface
|
|
//------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* The factory of `ConfigArray` objects.
|
|
*/
|
|
class ConfigArrayFactory {
|
|
|
|
/**
|
|
* Initialize this instance.
|
|
* @param {ConfigArrayFactoryOptions} [options] The map for additional plugins.
|
|
*/
|
|
constructor({
|
|
additionalPluginPool = new Map(),
|
|
cwd = process.cwd(),
|
|
resolvePluginsRelativeTo = cwd
|
|
} = {}) {
|
|
internalSlotsMap.set(this, { additionalPluginPool, cwd, resolvePluginsRelativeTo: path.resolve(cwd, resolvePluginsRelativeTo) });
|
|
}
|
|
|
|
/**
|
|
* Create `ConfigArray` instance from a config data.
|
|
* @param {ConfigData|null} configData The config data to create.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.filePath] The path to this config data.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config.
|
|
*/
|
|
create(configData, { filePath, name, parent } = {}) {
|
|
return createConfigArray(
|
|
configData
|
|
? this._normalizeConfigData(configData, filePath, name)
|
|
: null,
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load a config file.
|
|
* @param {string} filePath The path to a config file.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config.
|
|
*/
|
|
loadFile(filePath, { name, parent } = {}) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, filePath);
|
|
|
|
return createConfigArray(
|
|
this._loadConfigData(absolutePath, name),
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load the config file on a given directory if exists.
|
|
* @param {string} directoryPath The path to a directory.
|
|
* @param {Object} [options] The options.
|
|
* @param {string} [options.name] The config name.
|
|
* @param {ConfigArray} [options.parent] The parent config array.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadInDirectory(directoryPath, { name, parent } = {}) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, directoryPath);
|
|
|
|
return createConfigArray(
|
|
this._loadConfigDataInDirectory(absolutePath, name),
|
|
parent
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load `.eslintignore` file.
|
|
* @param {string} filePath The path to a `.eslintignore` file to load.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadESLintIgnore(filePath) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const absolutePath = path.resolve(cwd, filePath);
|
|
const name = path.relative(cwd, absolutePath);
|
|
const ignorePatterns = loadESLintIgnoreFile(absolutePath);
|
|
|
|
return createConfigArray(
|
|
this._normalizeESLintIgnoreData(ignorePatterns, absolutePath, name)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load `.eslintignore` file in the current working directory.
|
|
* @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
|
|
*/
|
|
loadDefaultESLintIgnore() {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const eslintIgnorePath = path.resolve(cwd, ".eslintignore");
|
|
const packageJsonPath = path.resolve(cwd, "package.json");
|
|
|
|
if (fs.existsSync(eslintIgnorePath)) {
|
|
return this.loadESLintIgnore(eslintIgnorePath);
|
|
}
|
|
if (fs.existsSync(packageJsonPath)) {
|
|
const data = loadJSONConfigFile(packageJsonPath);
|
|
|
|
if (Object.hasOwnProperty.call(data, "eslintIgnore")) {
|
|
if (!Array.isArray(data.eslintIgnore)) {
|
|
throw new Error("Package.json eslintIgnore property requires an array of paths");
|
|
}
|
|
return createConfigArray(
|
|
this._normalizeESLintIgnoreData(
|
|
data.eslintIgnore,
|
|
packageJsonPath,
|
|
"eslintIgnore in package.json"
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
return new ConfigArray();
|
|
}
|
|
|
|
/**
|
|
* Load a given config file.
|
|
* @param {string} filePath The path to a config file.
|
|
* @param {string} name The config name.
|
|
* @returns {IterableIterator<ConfigArrayElement>} Loaded config.
|
|
* @private
|
|
*/
|
|
_loadConfigData(filePath, name) {
|
|
return this._normalizeConfigData(
|
|
loadConfigFile(filePath),
|
|
filePath,
|
|
name
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Load the config file in a given directory if exists.
|
|
* @param {string} directoryPath The path to a directory.
|
|
* @param {string} name The config name.
|
|
* @returns {IterableIterator<ConfigArrayElement> | null} Loaded config. `null` if any config doesn't exist.
|
|
* @private
|
|
*/
|
|
_loadConfigDataInDirectory(directoryPath, name) {
|
|
for (const filename of configFilenames) {
|
|
const filePath = path.join(directoryPath, filename);
|
|
|
|
if (fs.existsSync(filePath)) {
|
|
let configData;
|
|
|
|
try {
|
|
configData = loadConfigFile(filePath);
|
|
} catch (error) {
|
|
if (!error || error.code !== "ESLINT_CONFIG_FIELD_NOT_FOUND") {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
if (configData) {
|
|
debug(`Config file found: ${filePath}`);
|
|
return this._normalizeConfigData(configData, filePath, name);
|
|
}
|
|
}
|
|
}
|
|
|
|
debug(`Config file not found on ${directoryPath}`);
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Normalize a given `.eslintignore` data to config array elements.
|
|
* @param {string[]} ignorePatterns The patterns to ignore files.
|
|
* @param {string|undefined} filePath The file path of this config.
|
|
* @param {string|undefined} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {
|
|
const elements = this._normalizeObjectConfigData(
|
|
{ ignorePatterns },
|
|
filePath,
|
|
name
|
|
);
|
|
|
|
// Set `ignorePattern.loose` flag for backward compatibility.
|
|
for (const element of elements) {
|
|
if (element.ignorePattern) {
|
|
element.ignorePattern.loose = true;
|
|
}
|
|
yield element;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData} configData The config data to normalize.
|
|
* @param {string|undefined} providedFilePath The file path of this config.
|
|
* @param {string|undefined} providedName The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_normalizeConfigData(configData, providedFilePath, providedName) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const filePath = providedFilePath
|
|
? path.resolve(cwd, providedFilePath)
|
|
: "";
|
|
const name = providedName || (filePath && path.relative(cwd, filePath));
|
|
|
|
validateConfigSchema(configData, name || filePath);
|
|
|
|
return this._normalizeObjectConfigData(configData, filePath, name);
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData|OverrideConfigData} configData The config data to normalize.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeObjectConfigData(configData, filePath, name) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const { files, excludedFiles, ...configBody } = configData;
|
|
const basePath = filePath ? path.dirname(filePath) : cwd;
|
|
const criteria = OverrideTester.create(files, excludedFiles, basePath);
|
|
const elements =
|
|
this._normalizeObjectConfigDataBody(configBody, filePath, name);
|
|
|
|
// Apply the criteria to every element.
|
|
for (const element of elements) {
|
|
|
|
// Adopt the base path of the entry file (the outermost base path).
|
|
if (element.criteria) {
|
|
element.criteria.basePath = basePath;
|
|
}
|
|
if (element.ignorePattern) {
|
|
element.ignorePattern.basePath = basePath;
|
|
}
|
|
|
|
/*
|
|
* Merge the criteria; this is for only file extension processors in
|
|
* `overrides` section for now.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalize a given config to an array.
|
|
* @param {ConfigData} configData The config data to normalize.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
*_normalizeObjectConfigDataBody(
|
|
{
|
|
env,
|
|
extends: extend,
|
|
globals,
|
|
ignorePatterns,
|
|
noInlineConfig,
|
|
parser: parserName,
|
|
parserOptions,
|
|
plugins: pluginList,
|
|
processor,
|
|
reportUnusedDisableDirectives,
|
|
root,
|
|
rules,
|
|
settings,
|
|
overrides: overrideList = []
|
|
},
|
|
filePath,
|
|
name
|
|
) {
|
|
const extendList = Array.isArray(extend) ? extend : [extend];
|
|
const ignorePattern = ignorePatterns && new IgnorePattern(
|
|
Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],
|
|
filePath ? path.dirname(filePath) : internalSlotsMap.get(this).cwd
|
|
);
|
|
|
|
// Flatten `extends`.
|
|
for (const extendName of extendList.filter(Boolean)) {
|
|
yield* this._loadExtends(extendName, filePath, name);
|
|
}
|
|
|
|
// Load parser & plugins.
|
|
const parser =
|
|
parserName && this._loadParser(parserName, filePath, name);
|
|
const plugins =
|
|
pluginList && this._loadPlugins(pluginList, filePath, name);
|
|
|
|
// Yield pseudo config data for file extension processors.
|
|
if (plugins) {
|
|
yield* this._takeFileExtensionProcessors(plugins, filePath, name);
|
|
}
|
|
|
|
// Yield the config data except `extends` and `overrides`.
|
|
yield {
|
|
|
|
// Debug information.
|
|
name,
|
|
filePath,
|
|
|
|
// Config data.
|
|
criteria: null,
|
|
env,
|
|
globals,
|
|
ignorePattern,
|
|
noInlineConfig,
|
|
parser,
|
|
parserOptions,
|
|
plugins,
|
|
processor,
|
|
reportUnusedDisableDirectives,
|
|
root,
|
|
rules,
|
|
settings
|
|
};
|
|
|
|
// Flatten `overries`.
|
|
for (let i = 0; i < overrideList.length; ++i) {
|
|
yield* this._normalizeObjectConfigData(
|
|
overrideList[i],
|
|
filePath,
|
|
`${name}#overrides[${i}]`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtends(extendName, importerPath, importerName) {
|
|
debug("Loading {extends:%j} relative to %s", extendName, importerPath);
|
|
try {
|
|
if (extendName.startsWith("eslint:")) {
|
|
return this._loadExtendedBuiltInConfig(
|
|
extendName,
|
|
importerName
|
|
);
|
|
}
|
|
if (extendName.startsWith("plugin:")) {
|
|
return this._loadExtendedPluginConfig(
|
|
extendName,
|
|
importerPath,
|
|
importerName
|
|
);
|
|
}
|
|
return this._loadExtendedShareableConfig(
|
|
extendName,
|
|
importerPath,
|
|
importerName
|
|
);
|
|
} catch (error) {
|
|
error.message += `\nReferenced from: ${importerPath || importerName}`;
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedBuiltInConfig(extendName, importerName) {
|
|
const name = `${importerName} » ${extendName}`;
|
|
|
|
if (extendName === "eslint:recommended") {
|
|
return this._loadConfigData(eslintRecommendedPath, name);
|
|
}
|
|
if (extendName === "eslint:all") {
|
|
return this._loadConfigData(eslintAllPath, name);
|
|
}
|
|
|
|
throw configMissingError(extendName, importerName);
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedPluginConfig(extendName, importerPath, importerName) {
|
|
const slashIndex = extendName.lastIndexOf("/");
|
|
const pluginName = extendName.slice("plugin:".length, slashIndex);
|
|
const configName = extendName.slice(slashIndex + 1);
|
|
|
|
if (isFilePath(pluginName)) {
|
|
throw new Error("'extends' cannot use a file path for plugins.");
|
|
}
|
|
|
|
const plugin = this._loadPlugin(pluginName, importerPath, importerName);
|
|
const configData =
|
|
plugin.definition &&
|
|
plugin.definition.configs[configName];
|
|
|
|
if (configData) {
|
|
return this._normalizeConfigData(
|
|
configData,
|
|
plugin.filePath,
|
|
`${importerName} » plugin:${plugin.id}/${configName}`
|
|
);
|
|
}
|
|
|
|
throw plugin.error || configMissingError(extendName, importerPath);
|
|
}
|
|
|
|
/**
|
|
* Load configs of an element in `extends`.
|
|
* @param {string} extendName The name of a base config.
|
|
* @param {string} importerPath The file path which has the `extends` property.
|
|
* @param {string} importerName The name of the config which has the `extends` property.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The normalized config.
|
|
* @private
|
|
*/
|
|
_loadExtendedShareableConfig(extendName, importerPath, importerName) {
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const relativeTo = importerPath || path.join(cwd, "__placeholder__.js");
|
|
let request;
|
|
|
|
if (isFilePath(extendName)) {
|
|
request = extendName;
|
|
} else if (extendName.startsWith(".")) {
|
|
request = `./${extendName}`; // For backward compatibility. A ton of tests depended on this behavior.
|
|
} else {
|
|
request = naming.normalizePackageName(
|
|
extendName,
|
|
"eslint-config"
|
|
);
|
|
}
|
|
|
|
let filePath;
|
|
|
|
try {
|
|
filePath = ModuleResolver.resolve(request, relativeTo);
|
|
} catch (error) {
|
|
/* istanbul ignore else */
|
|
if (error && error.code === "MODULE_NOT_FOUND") {
|
|
throw configMissingError(extendName, importerPath);
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
writeDebugLogForLoading(request, relativeTo, filePath);
|
|
return this._loadConfigData(filePath, `${importerName} » ${request}`);
|
|
}
|
|
|
|
/**
|
|
* Load given plugins.
|
|
* @param {string[]} names The plugin names to load.
|
|
* @param {string} importerPath The path to a config file that imports it. This is just a debug info.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {Record<string,DependentPlugin>} The loaded parser.
|
|
* @private
|
|
*/
|
|
_loadPlugins(names, importerPath, importerName) {
|
|
return names.reduce((map, name) => {
|
|
if (isFilePath(name)) {
|
|
throw new Error("Plugins array cannot includes file paths.");
|
|
}
|
|
const plugin = this._loadPlugin(name, importerPath, importerName);
|
|
|
|
map[plugin.id] = plugin;
|
|
|
|
return map;
|
|
}, {});
|
|
}
|
|
|
|
/**
|
|
* Load a given parser.
|
|
* @param {string} nameOrPath The package name or the path to a parser file.
|
|
* @param {string} importerPath The path to a config file that imports it.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {DependentParser} The loaded parser.
|
|
*/
|
|
_loadParser(nameOrPath, importerPath, importerName) {
|
|
debug("Loading parser %j from %s", nameOrPath, importerPath);
|
|
|
|
const { cwd } = internalSlotsMap.get(this);
|
|
const relativeTo = importerPath || path.join(cwd, "__placeholder__.js");
|
|
|
|
try {
|
|
const filePath = ModuleResolver.resolve(nameOrPath, relativeTo);
|
|
|
|
writeDebugLogForLoading(nameOrPath, relativeTo, filePath);
|
|
|
|
return new ConfigDependency({
|
|
definition: require(filePath),
|
|
filePath,
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
} catch (error) {
|
|
|
|
// If the parser name is "espree", load the espree of ESLint.
|
|
if (nameOrPath === "espree") {
|
|
debug("Fallback espree.");
|
|
return new ConfigDependency({
|
|
definition: require("espree"),
|
|
filePath: require.resolve("espree"),
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
debug("Failed to load parser '%s' declared in '%s'.", nameOrPath, importerName);
|
|
error.message = `Failed to load parser '${nameOrPath}' declared in '${importerName}': ${error.message}`;
|
|
|
|
return new ConfigDependency({
|
|
error,
|
|
id: nameOrPath,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load a given plugin.
|
|
* @param {string} name The plugin name to load.
|
|
* @param {string} importerPath The path to a config file that imports it. This is just a debug info.
|
|
* @param {string} importerName The name of a config file that imports it. This is just a debug info.
|
|
* @returns {DependentPlugin} The loaded plugin.
|
|
* @private
|
|
*/
|
|
_loadPlugin(name, importerPath, importerName) {
|
|
debug("Loading plugin %j from %s", name, importerPath);
|
|
|
|
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(
|
|
new Error(`Whitespace found in plugin name '${name}'`),
|
|
{
|
|
messageTemplate: "whitespace-found",
|
|
messageData: { pluginName: request }
|
|
}
|
|
);
|
|
|
|
return new ConfigDependency({
|
|
error,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
// Check for additional pool.
|
|
const plugin =
|
|
additionalPluginPool.get(request) ||
|
|
additionalPluginPool.get(id);
|
|
|
|
if (plugin) {
|
|
return new ConfigDependency({
|
|
definition: normalizePlugin(plugin),
|
|
filePath: importerPath,
|
|
id,
|
|
importerName,
|
|
importerPath
|
|
});
|
|
}
|
|
|
|
let filePath;
|
|
let error;
|
|
|
|
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,
|
|
resolvePluginsRelativeTo,
|
|
importerName
|
|
};
|
|
}
|
|
}
|
|
|
|
if (filePath) {
|
|
try {
|
|
writeDebugLogForLoading(request, relativeTo, filePath);
|
|
|
|
const startTime = Date.now();
|
|
const pluginDefinition = require(filePath);
|
|
|
|
debug(`Plugin ${filePath} loaded in: ${Date.now() - startTime}ms`);
|
|
|
|
return new ConfigDependency({
|
|
definition: normalizePlugin(pluginDefinition),
|
|
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
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Take file expression processors as config array elements.
|
|
* @param {Record<string,DependentPlugin>} plugins The plugin definitions.
|
|
* @param {string} filePath The file path of this config.
|
|
* @param {string} name The name of this config.
|
|
* @returns {IterableIterator<ConfigArrayElement>} The config array elements of file expression processors.
|
|
* @private
|
|
*/
|
|
*_takeFileExtensionProcessors(plugins, filePath, name) {
|
|
for (const pluginId of Object.keys(plugins)) {
|
|
const processors =
|
|
plugins[pluginId] &&
|
|
plugins[pluginId].definition &&
|
|
plugins[pluginId].definition.processors;
|
|
|
|
if (!processors) {
|
|
continue;
|
|
}
|
|
|
|
for (const processorId of Object.keys(processors)) {
|
|
if (processorId.startsWith(".")) {
|
|
yield* this._normalizeObjectConfigData(
|
|
{
|
|
files: [`*${processorId}`],
|
|
processor: `${pluginId}/${processorId}`
|
|
},
|
|
filePath,
|
|
`${name}#processors["${pluginId}/${processorId}"]`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = { ConfigArrayFactory };
|