You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1067 lines
37 KiB
1067 lines
37 KiB
/** |
|
* @fileoverview Main CLI object. |
|
* @author Nicholas C. Zakas |
|
*/ |
|
|
|
"use strict"; |
|
|
|
/* |
|
* The CLI object should *not* call process.exit() directly. It should only return |
|
* exit codes. This allows other programs to use the CLI object and still control |
|
* when the program exits. |
|
*/ |
|
|
|
//------------------------------------------------------------------------------ |
|
// Requirements |
|
//------------------------------------------------------------------------------ |
|
|
|
const fs = require("fs"); |
|
const path = require("path"); |
|
const defaultOptions = require("../../conf/default-cli-options"); |
|
const pkg = require("../../package.json"); |
|
|
|
|
|
const { |
|
Legacy: { |
|
ConfigOps, |
|
naming, |
|
CascadingConfigArrayFactory, |
|
IgnorePattern, |
|
getUsedExtractedConfigs, |
|
ModuleResolver |
|
} |
|
} = require("@eslint/eslintrc"); |
|
|
|
const { FileEnumerator } = require("./file-enumerator"); |
|
|
|
const { Linter } = require("../linter"); |
|
const builtInRules = require("../rules"); |
|
const loadRules = require("./load-rules"); |
|
const hash = require("./hash"); |
|
const LintResultCache = require("./lint-result-cache"); |
|
|
|
const debug = require("debug")("eslint:cli-engine"); |
|
const validFixTypes = new Set(["directive", "problem", "suggestion", "layout"]); |
|
|
|
//------------------------------------------------------------------------------ |
|
// Typedefs |
|
//------------------------------------------------------------------------------ |
|
|
|
// For VSCode IntelliSense |
|
/** @typedef {import("../shared/types").ConfigData} ConfigData */ |
|
/** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */ |
|
/** @typedef {import("../shared/types").LintMessage} LintMessage */ |
|
/** @typedef {import("../shared/types").SuppressedLintMessage} SuppressedLintMessage */ |
|
/** @typedef {import("../shared/types").ParserOptions} ParserOptions */ |
|
/** @typedef {import("../shared/types").Plugin} Plugin */ |
|
/** @typedef {import("../shared/types").RuleConf} RuleConf */ |
|
/** @typedef {import("../shared/types").Rule} Rule */ |
|
/** @typedef {import("../shared/types").FormatterFunction} FormatterFunction */ |
|
/** @typedef {ReturnType<CascadingConfigArrayFactory.getConfigArrayForFile>} ConfigArray */ |
|
/** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */ |
|
|
|
/** |
|
* The options to configure a CLI engine with. |
|
* @typedef {Object} CLIEngineOptions |
|
* @property {boolean} [allowInlineConfig] Enable or disable inline configuration comments. |
|
* @property {ConfigData} [baseConfig] Base config object, extended by all configs used with this CLIEngine instance |
|
* @property {boolean} [cache] Enable result caching. |
|
* @property {string} [cacheLocation] The cache file to use instead of .eslintcache. |
|
* @property {string} [configFile] The configuration file to use. |
|
* @property {string} [cwd] The value to use for the current working directory. |
|
* @property {string[]} [envs] An array of environments to load. |
|
* @property {string[]|null} [extensions] An array of file extensions to check. |
|
* @property {boolean|Function} [fix] Execute in autofix mode. If a function, should return a boolean. |
|
* @property {string[]} [fixTypes] Array of rule types to apply fixes for. |
|
* @property {string[]} [globals] An array of global variables to declare. |
|
* @property {boolean} [ignore] False disables use of .eslintignore. |
|
* @property {string} [ignorePath] The ignore file to use instead of .eslintignore. |
|
* @property {string|string[]} [ignorePattern] One or more glob patterns to ignore. |
|
* @property {boolean} [useEslintrc] False disables looking for .eslintrc |
|
* @property {string} [parser] The name of the parser to use. |
|
* @property {ParserOptions} [parserOptions] An object of parserOption settings to use. |
|
* @property {string[]} [plugins] An array of plugins to load. |
|
* @property {Record<string,RuleConf>} [rules] An object of rules to use. |
|
* @property {string[]} [rulePaths] An array of directories to load custom rules from. |
|
* @property {boolean} [reportUnusedDisableDirectives] `true` adds reports for unused eslint-disable directives |
|
* @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 {string} [resolvePluginsRelativeTo] The folder where plugins should be resolved from, defaulting to the CWD |
|
*/ |
|
|
|
/** |
|
* A linting result. |
|
* @typedef {Object} LintResult |
|
* @property {string} filePath The path to the file that was linted. |
|
* @property {LintMessage[]} messages All of the messages for the result. |
|
* @property {SuppressedLintMessage[]} suppressedMessages All of the suppressed messages for the result. |
|
* @property {number} errorCount Number of errors for the result. |
|
* @property {number} fatalErrorCount Number of fatal errors for the result. |
|
* @property {number} warningCount Number of warnings for the result. |
|
* @property {number} fixableErrorCount Number of fixable errors for the result. |
|
* @property {number} fixableWarningCount Number of fixable warnings for the result. |
|
* @property {string} [source] The source code of the file that was linted. |
|
* @property {string} [output] The source code of the file that was linted, with as many fixes applied as possible. |
|
*/ |
|
|
|
/** |
|
* Linting results. |
|
* @typedef {Object} LintReport |
|
* @property {LintResult[]} results All of the result. |
|
* @property {number} errorCount Number of errors for the result. |
|
* @property {number} fatalErrorCount Number of fatal errors for the result. |
|
* @property {number} warningCount Number of warnings for the result. |
|
* @property {number} fixableErrorCount Number of fixable errors for the result. |
|
* @property {number} fixableWarningCount Number of fixable warnings for the result. |
|
* @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules. |
|
*/ |
|
|
|
/** |
|
* Private data for CLIEngine. |
|
* @typedef {Object} CLIEngineInternalSlots |
|
* @property {Map<string, Plugin>} additionalPluginPool The map for additional plugins. |
|
* @property {string} cacheFilePath The path to the cache of lint results. |
|
* @property {CascadingConfigArrayFactory} configArrayFactory The factory of configs. |
|
* @property {(filePath: string) => boolean} defaultIgnores The default predicate function to check if a file ignored or not. |
|
* @property {FileEnumerator} fileEnumerator The file enumerator. |
|
* @property {ConfigArray[]} lastConfigArrays The list of config arrays that the last `executeOnFiles` or `executeOnText` used. |
|
* @property {LintResultCache|null} lintResultCache The cache of lint results. |
|
* @property {Linter} linter The linter instance which has loaded rules. |
|
* @property {CLIEngineOptions} options The normalized options of this instance. |
|
*/ |
|
|
|
//------------------------------------------------------------------------------ |
|
// Helpers |
|
//------------------------------------------------------------------------------ |
|
|
|
/** @type {WeakMap<CLIEngine, CLIEngineInternalSlots>} */ |
|
const internalSlotsMap = new WeakMap(); |
|
|
|
/** |
|
* Determines if each fix type in an array is supported by ESLint and throws |
|
* an error if not. |
|
* @param {string[]} fixTypes An array of fix types to check. |
|
* @returns {void} |
|
* @throws {Error} If an invalid fix type is found. |
|
*/ |
|
function validateFixTypes(fixTypes) { |
|
for (const fixType of fixTypes) { |
|
if (!validFixTypes.has(fixType)) { |
|
throw new Error(`Invalid fix type "${fixType}" found.`); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* It will calculate the error and warning count for collection of messages per file |
|
* @param {LintMessage[]} messages Collection of messages |
|
* @returns {Object} Contains the stats |
|
* @private |
|
*/ |
|
function calculateStatsPerFile(messages) { |
|
return messages.reduce((stat, message) => { |
|
if (message.fatal || message.severity === 2) { |
|
stat.errorCount++; |
|
if (message.fatal) { |
|
stat.fatalErrorCount++; |
|
} |
|
if (message.fix) { |
|
stat.fixableErrorCount++; |
|
} |
|
} else { |
|
stat.warningCount++; |
|
if (message.fix) { |
|
stat.fixableWarningCount++; |
|
} |
|
} |
|
return stat; |
|
}, { |
|
errorCount: 0, |
|
fatalErrorCount: 0, |
|
warningCount: 0, |
|
fixableErrorCount: 0, |
|
fixableWarningCount: 0 |
|
}); |
|
} |
|
|
|
/** |
|
* It will calculate the error and warning count for collection of results from all files |
|
* @param {LintResult[]} results Collection of messages from all the files |
|
* @returns {Object} Contains the stats |
|
* @private |
|
*/ |
|
function calculateStatsPerRun(results) { |
|
return results.reduce((stat, result) => { |
|
stat.errorCount += result.errorCount; |
|
stat.fatalErrorCount += result.fatalErrorCount; |
|
stat.warningCount += result.warningCount; |
|
stat.fixableErrorCount += result.fixableErrorCount; |
|
stat.fixableWarningCount += result.fixableWarningCount; |
|
return stat; |
|
}, { |
|
errorCount: 0, |
|
fatalErrorCount: 0, |
|
warningCount: 0, |
|
fixableErrorCount: 0, |
|
fixableWarningCount: 0 |
|
}); |
|
} |
|
|
|
/** |
|
* Processes an source code using ESLint. |
|
* @param {Object} config The config object. |
|
* @param {string} config.text The source code to verify. |
|
* @param {string} config.cwd The path to the current working directory. |
|
* @param {string|undefined} config.filePath The path to the file of `text`. If this is undefined, it uses `<text>`. |
|
* @param {ConfigArray} config.config The config. |
|
* @param {boolean} config.fix If `true` then it does fix. |
|
* @param {boolean} config.allowInlineConfig If `true` then it uses directive comments. |
|
* @param {boolean} config.reportUnusedDisableDirectives If `true` then it reports unused `eslint-disable` comments. |
|
* @param {FileEnumerator} config.fileEnumerator The file enumerator to check if a path is a target or not. |
|
* @param {Linter} config.linter The linter instance to verify. |
|
* @returns {LintResult} The result of linting. |
|
* @private |
|
*/ |
|
function verifyText({ |
|
text, |
|
cwd, |
|
filePath: providedFilePath, |
|
config, |
|
fix, |
|
allowInlineConfig, |
|
reportUnusedDisableDirectives, |
|
fileEnumerator, |
|
linter |
|
}) { |
|
const filePath = providedFilePath || "<text>"; |
|
|
|
debug(`Lint ${filePath}`); |
|
|
|
/* |
|
* Verify. |
|
* `config.extractConfig(filePath)` requires an absolute path, but `linter` |
|
* doesn't know CWD, so it gives `linter` an absolute path always. |
|
*/ |
|
const filePathToVerify = filePath === "<text>" ? path.join(cwd, filePath) : filePath; |
|
const { fixed, messages, output } = linter.verifyAndFix( |
|
text, |
|
config, |
|
{ |
|
allowInlineConfig, |
|
filename: filePathToVerify, |
|
fix, |
|
reportUnusedDisableDirectives, |
|
|
|
/** |
|
* Check if the linter should adopt a given code block or not. |
|
* @param {string} blockFilename The virtual filename of a code block. |
|
* @returns {boolean} `true` if the linter should adopt the code block. |
|
*/ |
|
filterCodeBlock(blockFilename) { |
|
return fileEnumerator.isTargetPath(blockFilename); |
|
} |
|
} |
|
); |
|
|
|
// Tweak and return. |
|
const result = { |
|
filePath, |
|
messages, |
|
suppressedMessages: linter.getSuppressedMessages(), |
|
...calculateStatsPerFile(messages) |
|
}; |
|
|
|
if (fixed) { |
|
result.output = output; |
|
} |
|
if ( |
|
result.errorCount + result.warningCount > 0 && |
|
typeof result.output === "undefined" |
|
) { |
|
result.source = text; |
|
} |
|
|
|
return result; |
|
} |
|
|
|
/** |
|
* Returns result with warning by ignore settings |
|
* @param {string} filePath File path of checked code |
|
* @param {string} baseDir Absolute path of base directory |
|
* @returns {LintResult} Result with single warning |
|
* @private |
|
*/ |
|
function createIgnoreResult(filePath, baseDir) { |
|
let message; |
|
const isHidden = filePath.split(path.sep) |
|
.find(segment => /^\./u.test(segment)); |
|
const isInNodeModules = baseDir && path.relative(baseDir, filePath).startsWith("node_modules"); |
|
|
|
if (isHidden) { |
|
message = "File ignored by default. Use a negated ignore pattern (like \"--ignore-pattern '!<relative/path/to/filename>'\") to override."; |
|
} else if (isInNodeModules) { |
|
message = "File ignored by default. Use \"--ignore-pattern '!node_modules/*'\" to override."; |
|
} else { |
|
message = "File ignored because of a matching ignore pattern. Use \"--no-ignore\" to override."; |
|
} |
|
|
|
return { |
|
filePath: path.resolve(filePath), |
|
messages: [ |
|
{ |
|
fatal: false, |
|
severity: 1, |
|
message |
|
} |
|
], |
|
suppressedMessages: [], |
|
errorCount: 0, |
|
fatalErrorCount: 0, |
|
warningCount: 1, |
|
fixableErrorCount: 0, |
|
fixableWarningCount: 0 |
|
}; |
|
} |
|
|
|
/** |
|
* Get a rule. |
|
* @param {string} ruleId The rule ID to get. |
|
* @param {ConfigArray[]} configArrays The config arrays that have plugin rules. |
|
* @returns {Rule|null} The rule or null. |
|
*/ |
|
function getRule(ruleId, configArrays) { |
|
for (const configArray of configArrays) { |
|
const rule = configArray.pluginRules.get(ruleId); |
|
|
|
if (rule) { |
|
return rule; |
|
} |
|
} |
|
return builtInRules.get(ruleId) || null; |
|
} |
|
|
|
/** |
|
* Checks whether a message's rule type should be fixed. |
|
* @param {LintMessage} message The message to check. |
|
* @param {ConfigArray[]} lastConfigArrays The list of config arrays that the last `executeOnFiles` or `executeOnText` used. |
|
* @param {string[]} fixTypes An array of fix types to check. |
|
* @returns {boolean} Whether the message should be fixed. |
|
*/ |
|
function shouldMessageBeFixed(message, lastConfigArrays, fixTypes) { |
|
if (!message.ruleId) { |
|
return fixTypes.has("directive"); |
|
} |
|
|
|
const rule = message.ruleId && getRule(message.ruleId, lastConfigArrays); |
|
|
|
return Boolean(rule && rule.meta && fixTypes.has(rule.meta.type)); |
|
} |
|
|
|
/** |
|
* Collect used deprecated rules. |
|
* @param {ConfigArray[]} usedConfigArrays The config arrays which were used. |
|
* @returns {IterableIterator<DeprecatedRuleInfo>} Used deprecated rules. |
|
*/ |
|
function *iterateRuleDeprecationWarnings(usedConfigArrays) { |
|
const processedRuleIds = new Set(); |
|
|
|
// Flatten used configs. |
|
/** @type {ExtractedConfig[]} */ |
|
const configs = usedConfigArrays.flatMap(getUsedExtractedConfigs); |
|
|
|
// Traverse rule configs. |
|
for (const config of configs) { |
|
for (const [ruleId, ruleConfig] of Object.entries(config.rules)) { |
|
|
|
// Skip if it was processed. |
|
if (processedRuleIds.has(ruleId)) { |
|
continue; |
|
} |
|
processedRuleIds.add(ruleId); |
|
|
|
// Skip if it's not used. |
|
if (!ConfigOps.getRuleSeverity(ruleConfig)) { |
|
continue; |
|
} |
|
const rule = getRule(ruleId, usedConfigArrays); |
|
|
|
// Skip if it's not deprecated. |
|
if (!(rule && rule.meta && rule.meta.deprecated)) { |
|
continue; |
|
} |
|
|
|
// This rule was used and deprecated. |
|
yield { |
|
ruleId, |
|
replacedBy: rule.meta.replacedBy || [] |
|
}; |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Checks if the given message is an error message. |
|
* @param {LintMessage} message The message to check. |
|
* @returns {boolean} Whether or not the message is an error message. |
|
* @private |
|
*/ |
|
function isErrorMessage(message) { |
|
return message.severity === 2; |
|
} |
|
|
|
|
|
/** |
|
* return the cacheFile to be used by eslint, based on whether the provided parameter is |
|
* a directory or looks like a directory (ends in `path.sep`), in which case the file |
|
* name will be the `cacheFile/.cache_hashOfCWD` |
|
* |
|
* if cacheFile points to a file or looks like a file then it will just use that file |
|
* @param {string} cacheFile The name of file to be used to store the cache |
|
* @param {string} cwd Current working directory |
|
* @returns {string} the resolved path to the cache file |
|
*/ |
|
function getCacheFile(cacheFile, cwd) { |
|
|
|
/* |
|
* make sure the path separators are normalized for the environment/os |
|
* keeping the trailing path separator if present |
|
*/ |
|
const normalizedCacheFile = path.normalize(cacheFile); |
|
|
|
const resolvedCacheFile = path.resolve(cwd, normalizedCacheFile); |
|
const looksLikeADirectory = normalizedCacheFile.slice(-1) === path.sep; |
|
|
|
/** |
|
* return the name for the cache file in case the provided parameter is a directory |
|
* @returns {string} the resolved path to the cacheFile |
|
*/ |
|
function getCacheFileForDirectory() { |
|
return path.join(resolvedCacheFile, `.cache_${hash(cwd)}`); |
|
} |
|
|
|
let fileStats; |
|
|
|
try { |
|
fileStats = fs.lstatSync(resolvedCacheFile); |
|
} catch { |
|
fileStats = null; |
|
} |
|
|
|
|
|
/* |
|
* in case the file exists we need to verify if the provided path |
|
* is a directory or a file. If it is a directory we want to create a file |
|
* inside that directory |
|
*/ |
|
if (fileStats) { |
|
|
|
/* |
|
* is a directory or is a file, but the original file the user provided |
|
* looks like a directory but `path.resolve` removed the `last path.sep` |
|
* so we need to still treat this like a directory |
|
*/ |
|
if (fileStats.isDirectory() || looksLikeADirectory) { |
|
return getCacheFileForDirectory(); |
|
} |
|
|
|
// is file so just use that file |
|
return resolvedCacheFile; |
|
} |
|
|
|
/* |
|
* here we known the file or directory doesn't exist, |
|
* so we will try to infer if its a directory if it looks like a directory |
|
* for the current operating system. |
|
*/ |
|
|
|
// if the last character passed is a path separator we assume is a directory |
|
if (looksLikeADirectory) { |
|
return getCacheFileForDirectory(); |
|
} |
|
|
|
return resolvedCacheFile; |
|
} |
|
|
|
/** |
|
* Convert a string array to a boolean map. |
|
* @param {string[]|null} keys The keys to assign true. |
|
* @param {boolean} defaultValue The default value for each property. |
|
* @param {string} displayName The property name which is used in error message. |
|
* @throws {Error} Requires array. |
|
* @returns {Record<string,boolean>} The boolean map. |
|
*/ |
|
function toBooleanMap(keys, defaultValue, displayName) { |
|
if (keys && !Array.isArray(keys)) { |
|
throw new Error(`${displayName} must be an array.`); |
|
} |
|
if (keys && keys.length > 0) { |
|
return keys.reduce((map, def) => { |
|
const [key, value] = def.split(":"); |
|
|
|
if (key !== "__proto__") { |
|
map[key] = value === void 0 |
|
? defaultValue |
|
: value === "true"; |
|
} |
|
|
|
return map; |
|
}, {}); |
|
} |
|
return void 0; |
|
} |
|
|
|
/** |
|
* Create a config data from CLI options. |
|
* @param {CLIEngineOptions} options The options |
|
* @returns {ConfigData|null} The created config data. |
|
*/ |
|
function createConfigDataFromOptions(options) { |
|
const { |
|
ignorePattern, |
|
parser, |
|
parserOptions, |
|
plugins, |
|
rules |
|
} = options; |
|
const env = toBooleanMap(options.envs, true, "envs"); |
|
const globals = toBooleanMap(options.globals, false, "globals"); |
|
|
|
if ( |
|
env === void 0 && |
|
globals === void 0 && |
|
(ignorePattern === void 0 || ignorePattern.length === 0) && |
|
parser === void 0 && |
|
parserOptions === void 0 && |
|
plugins === void 0 && |
|
rules === void 0 |
|
) { |
|
return null; |
|
} |
|
return { |
|
env, |
|
globals, |
|
ignorePatterns: ignorePattern, |
|
parser, |
|
parserOptions, |
|
plugins, |
|
rules |
|
}; |
|
} |
|
|
|
/** |
|
* Checks whether a directory exists at the given location |
|
* @param {string} resolvedPath A path from the CWD |
|
* @throws {Error} As thrown by `fs.statSync` or `fs.isDirectory`. |
|
* @returns {boolean} `true` if a directory exists |
|
*/ |
|
function directoryExists(resolvedPath) { |
|
try { |
|
return fs.statSync(resolvedPath).isDirectory(); |
|
} catch (error) { |
|
if (error && (error.code === "ENOENT" || error.code === "ENOTDIR")) { |
|
return false; |
|
} |
|
throw error; |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// Public Interface |
|
//------------------------------------------------------------------------------ |
|
|
|
/** |
|
* Core CLI. |
|
*/ |
|
class CLIEngine { |
|
|
|
/** |
|
* Creates a new instance of the core CLI engine. |
|
* @param {CLIEngineOptions} providedOptions The options for this instance. |
|
* @param {Object} [additionalData] Additional settings that are not CLIEngineOptions. |
|
* @param {Record<string,Plugin>|null} [additionalData.preloadedPlugins] Preloaded plugins. |
|
*/ |
|
constructor(providedOptions, { preloadedPlugins } = {}) { |
|
const options = Object.assign( |
|
Object.create(null), |
|
defaultOptions, |
|
{ cwd: process.cwd() }, |
|
providedOptions |
|
); |
|
|
|
if (options.fix === void 0) { |
|
options.fix = false; |
|
} |
|
|
|
const additionalPluginPool = new Map(); |
|
|
|
if (preloadedPlugins) { |
|
for (const [id, plugin] of Object.entries(preloadedPlugins)) { |
|
additionalPluginPool.set(id, plugin); |
|
} |
|
} |
|
|
|
const cacheFilePath = getCacheFile( |
|
options.cacheLocation || options.cacheFile, |
|
options.cwd |
|
); |
|
const configArrayFactory = new CascadingConfigArrayFactory({ |
|
additionalPluginPool, |
|
baseConfig: options.baseConfig || null, |
|
cliConfig: createConfigDataFromOptions(options), |
|
cwd: options.cwd, |
|
ignorePath: options.ignorePath, |
|
resolvePluginsRelativeTo: options.resolvePluginsRelativeTo, |
|
rulePaths: options.rulePaths, |
|
specificConfigPath: options.configFile, |
|
useEslintrc: options.useEslintrc, |
|
builtInRules, |
|
loadRules, |
|
getEslintRecommendedConfig: () => require("../../conf/eslint-recommended.js"), |
|
getEslintAllConfig: () => require("../../conf/eslint-all.js") |
|
}); |
|
const fileEnumerator = new FileEnumerator({ |
|
configArrayFactory, |
|
cwd: options.cwd, |
|
extensions: options.extensions, |
|
globInputPaths: options.globInputPaths, |
|
errorOnUnmatchedPattern: options.errorOnUnmatchedPattern, |
|
ignore: options.ignore |
|
}); |
|
const lintResultCache = |
|
options.cache ? new LintResultCache(cacheFilePath, options.cacheStrategy) : null; |
|
const linter = new Linter({ cwd: options.cwd }); |
|
|
|
/** @type {ConfigArray[]} */ |
|
const lastConfigArrays = [configArrayFactory.getConfigArrayForFile()]; |
|
|
|
// Store private data. |
|
internalSlotsMap.set(this, { |
|
additionalPluginPool, |
|
cacheFilePath, |
|
configArrayFactory, |
|
defaultIgnores: IgnorePattern.createDefaultIgnore(options.cwd), |
|
fileEnumerator, |
|
lastConfigArrays, |
|
lintResultCache, |
|
linter, |
|
options |
|
}); |
|
|
|
// setup special filter for fixes |
|
if (options.fix && options.fixTypes && options.fixTypes.length > 0) { |
|
debug(`Using fix types ${options.fixTypes}`); |
|
|
|
// throw an error if any invalid fix types are found |
|
validateFixTypes(options.fixTypes); |
|
|
|
// convert to Set for faster lookup |
|
const fixTypes = new Set(options.fixTypes); |
|
|
|
// save original value of options.fix in case it's a function |
|
const originalFix = (typeof options.fix === "function") |
|
? options.fix : () => true; |
|
|
|
options.fix = message => shouldMessageBeFixed(message, lastConfigArrays, fixTypes) && originalFix(message); |
|
} |
|
} |
|
|
|
getRules() { |
|
const { lastConfigArrays } = internalSlotsMap.get(this); |
|
|
|
return new Map(function *() { |
|
yield* builtInRules; |
|
|
|
for (const configArray of lastConfigArrays) { |
|
yield* configArray.pluginRules; |
|
} |
|
}()); |
|
} |
|
|
|
/** |
|
* Returns results that only contains errors. |
|
* @param {LintResult[]} results The results to filter. |
|
* @returns {LintResult[]} The filtered results. |
|
*/ |
|
static getErrorResults(results) { |
|
const filtered = []; |
|
|
|
results.forEach(result => { |
|
const filteredMessages = result.messages.filter(isErrorMessage); |
|
const filteredSuppressedMessages = result.suppressedMessages.filter(isErrorMessage); |
|
|
|
if (filteredMessages.length > 0) { |
|
filtered.push({ |
|
...result, |
|
messages: filteredMessages, |
|
suppressedMessages: filteredSuppressedMessages, |
|
errorCount: filteredMessages.length, |
|
warningCount: 0, |
|
fixableErrorCount: result.fixableErrorCount, |
|
fixableWarningCount: 0 |
|
}); |
|
} |
|
}); |
|
|
|
return filtered; |
|
} |
|
|
|
/** |
|
* Outputs fixes from the given results to files. |
|
* @param {LintReport} report The report object created by CLIEngine. |
|
* @returns {void} |
|
*/ |
|
static outputFixes(report) { |
|
report.results.filter(result => Object.prototype.hasOwnProperty.call(result, "output")).forEach(result => { |
|
fs.writeFileSync(result.filePath, result.output); |
|
}); |
|
} |
|
|
|
/** |
|
* Resolves the patterns passed into executeOnFiles() into glob-based patterns |
|
* for easier handling. |
|
* @param {string[]} patterns The file patterns passed on the command line. |
|
* @returns {string[]} The equivalent glob patterns. |
|
*/ |
|
resolveFileGlobPatterns(patterns) { |
|
const { options } = internalSlotsMap.get(this); |
|
|
|
if (options.globInputPaths === false) { |
|
return patterns.filter(Boolean); |
|
} |
|
|
|
const extensions = (options.extensions || [".js"]).map(ext => ext.replace(/^\./u, "")); |
|
const dirSuffix = `/**/*.{${extensions.join(",")}}`; |
|
|
|
return patterns.filter(Boolean).map(pathname => { |
|
const resolvedPath = path.resolve(options.cwd, pathname); |
|
const newPath = directoryExists(resolvedPath) |
|
? pathname.replace(/[/\\]$/u, "") + dirSuffix |
|
: pathname; |
|
|
|
return path.normalize(newPath).replace(/\\/gu, "/"); |
|
}); |
|
} |
|
|
|
/** |
|
* Executes the current configuration on an array of file and directory names. |
|
* @param {string[]} patterns An array of file and directory names. |
|
* @throws {Error} As may be thrown by `fs.unlinkSync`. |
|
* @returns {LintReport} The results for all files that were linted. |
|
*/ |
|
executeOnFiles(patterns) { |
|
const { |
|
cacheFilePath, |
|
fileEnumerator, |
|
lastConfigArrays, |
|
lintResultCache, |
|
linter, |
|
options: { |
|
allowInlineConfig, |
|
cache, |
|
cwd, |
|
fix, |
|
reportUnusedDisableDirectives |
|
} |
|
} = internalSlotsMap.get(this); |
|
const results = []; |
|
const startTime = Date.now(); |
|
|
|
// Clear the last used config arrays. |
|
lastConfigArrays.length = 0; |
|
|
|
// Delete cache file; should this do here? |
|
if (!cache) { |
|
try { |
|
fs.unlinkSync(cacheFilePath); |
|
} catch (error) { |
|
const errorCode = error && error.code; |
|
|
|
// Ignore errors when no such file exists or file system is read only (and cache file does not exist) |
|
if (errorCode !== "ENOENT" && !(errorCode === "EROFS" && !fs.existsSync(cacheFilePath))) { |
|
throw error; |
|
} |
|
} |
|
} |
|
|
|
// Iterate source code files. |
|
for (const { config, filePath, ignored } of fileEnumerator.iterateFiles(patterns)) { |
|
if (ignored) { |
|
results.push(createIgnoreResult(filePath, cwd)); |
|
continue; |
|
} |
|
|
|
/* |
|
* Store used configs for: |
|
* - this method uses to collect used deprecated rules. |
|
* - `getRules()` method uses to collect all loaded rules. |
|
* - `--fix-type` option uses to get the loaded rule's meta data. |
|
*/ |
|
if (!lastConfigArrays.includes(config)) { |
|
lastConfigArrays.push(config); |
|
} |
|
|
|
// Skip if there is cached result. |
|
if (lintResultCache) { |
|
const cachedResult = |
|
lintResultCache.getCachedLintResults(filePath, config); |
|
|
|
if (cachedResult) { |
|
const hadMessages = |
|
cachedResult.messages && |
|
cachedResult.messages.length > 0; |
|
|
|
if (hadMessages && fix) { |
|
debug(`Reprocessing cached file to allow autofix: ${filePath}`); |
|
} else { |
|
debug(`Skipping file since it hasn't changed: ${filePath}`); |
|
results.push(cachedResult); |
|
continue; |
|
} |
|
} |
|
} |
|
|
|
// Do lint. |
|
const result = verifyText({ |
|
text: fs.readFileSync(filePath, "utf8"), |
|
filePath, |
|
config, |
|
cwd, |
|
fix, |
|
allowInlineConfig, |
|
reportUnusedDisableDirectives, |
|
fileEnumerator, |
|
linter |
|
}); |
|
|
|
results.push(result); |
|
|
|
/* |
|
* Store the lint result in the LintResultCache. |
|
* NOTE: The LintResultCache will remove the file source and any |
|
* other properties that are difficult to serialize, and will |
|
* hydrate those properties back in on future lint runs. |
|
*/ |
|
if (lintResultCache) { |
|
lintResultCache.setCachedLintResults(filePath, config, result); |
|
} |
|
} |
|
|
|
// Persist the cache to disk. |
|
if (lintResultCache) { |
|
lintResultCache.reconcile(); |
|
} |
|
|
|
debug(`Linting complete in: ${Date.now() - startTime}ms`); |
|
let usedDeprecatedRules; |
|
|
|
return { |
|
results, |
|
...calculateStatsPerRun(results), |
|
|
|
// Initialize it lazily because CLI and `ESLint` API don't use it. |
|
get usedDeprecatedRules() { |
|
if (!usedDeprecatedRules) { |
|
usedDeprecatedRules = Array.from( |
|
iterateRuleDeprecationWarnings(lastConfigArrays) |
|
); |
|
} |
|
return usedDeprecatedRules; |
|
} |
|
}; |
|
} |
|
|
|
/** |
|
* Executes the current configuration on text. |
|
* @param {string} text A string of JavaScript code to lint. |
|
* @param {string} [filename] An optional string representing the texts filename. |
|
* @param {boolean} [warnIgnored] Always warn when a file is ignored |
|
* @returns {LintReport} The results for the linting. |
|
*/ |
|
executeOnText(text, filename, warnIgnored) { |
|
const { |
|
configArrayFactory, |
|
fileEnumerator, |
|
lastConfigArrays, |
|
linter, |
|
options: { |
|
allowInlineConfig, |
|
cwd, |
|
fix, |
|
reportUnusedDisableDirectives |
|
} |
|
} = internalSlotsMap.get(this); |
|
const results = []; |
|
const startTime = Date.now(); |
|
const resolvedFilename = filename && path.resolve(cwd, filename); |
|
|
|
|
|
// Clear the last used config arrays. |
|
lastConfigArrays.length = 0; |
|
if (resolvedFilename && this.isPathIgnored(resolvedFilename)) { |
|
if (warnIgnored) { |
|
results.push(createIgnoreResult(resolvedFilename, cwd)); |
|
} |
|
} else { |
|
const config = configArrayFactory.getConfigArrayForFile( |
|
resolvedFilename || "__placeholder__.js" |
|
); |
|
|
|
/* |
|
* Store used configs for: |
|
* - this method uses to collect used deprecated rules. |
|
* - `getRules()` method uses to collect all loaded rules. |
|
* - `--fix-type` option uses to get the loaded rule's meta data. |
|
*/ |
|
lastConfigArrays.push(config); |
|
|
|
// Do lint. |
|
results.push(verifyText({ |
|
text, |
|
filePath: resolvedFilename, |
|
config, |
|
cwd, |
|
fix, |
|
allowInlineConfig, |
|
reportUnusedDisableDirectives, |
|
fileEnumerator, |
|
linter |
|
})); |
|
} |
|
|
|
debug(`Linting complete in: ${Date.now() - startTime}ms`); |
|
let usedDeprecatedRules; |
|
|
|
return { |
|
results, |
|
...calculateStatsPerRun(results), |
|
|
|
// Initialize it lazily because CLI and `ESLint` API don't use it. |
|
get usedDeprecatedRules() { |
|
if (!usedDeprecatedRules) { |
|
usedDeprecatedRules = Array.from( |
|
iterateRuleDeprecationWarnings(lastConfigArrays) |
|
); |
|
} |
|
return usedDeprecatedRules; |
|
} |
|
}; |
|
} |
|
|
|
/** |
|
* Returns a configuration object for the given file based on the CLI options. |
|
* This is the same logic used by the ESLint CLI executable to determine |
|
* configuration for each file it processes. |
|
* @param {string} filePath The path of the file to retrieve a config object for. |
|
* @throws {Error} If filepath a directory path. |
|
* @returns {ConfigData} A configuration object for the file. |
|
*/ |
|
getConfigForFile(filePath) { |
|
const { configArrayFactory, options } = internalSlotsMap.get(this); |
|
const absolutePath = path.resolve(options.cwd, filePath); |
|
|
|
if (directoryExists(absolutePath)) { |
|
throw Object.assign( |
|
new Error("'filePath' should not be a directory path."), |
|
{ messageTemplate: "print-config-with-directory-path" } |
|
); |
|
} |
|
|
|
return configArrayFactory |
|
.getConfigArrayForFile(absolutePath) |
|
.extractConfig(absolutePath) |
|
.toCompatibleObjectAsConfigFileContent(); |
|
} |
|
|
|
/** |
|
* Checks if a given path is ignored by ESLint. |
|
* @param {string} filePath The path of the file to check. |
|
* @returns {boolean} Whether or not the given path is ignored. |
|
*/ |
|
isPathIgnored(filePath) { |
|
const { |
|
configArrayFactory, |
|
defaultIgnores, |
|
options: { cwd, ignore } |
|
} = internalSlotsMap.get(this); |
|
const absolutePath = path.resolve(cwd, filePath); |
|
|
|
if (ignore) { |
|
const config = configArrayFactory |
|
.getConfigArrayForFile(absolutePath) |
|
.extractConfig(absolutePath); |
|
const ignores = config.ignores || defaultIgnores; |
|
|
|
return ignores(absolutePath); |
|
} |
|
|
|
return defaultIgnores(absolutePath); |
|
} |
|
|
|
/** |
|
* Returns the formatter representing the given format or null if the `format` is not a string. |
|
* @param {string} [format] The name of the format to load or the path to a |
|
* custom formatter. |
|
* @throws {any} As may be thrown by requiring of formatter |
|
* @returns {(FormatterFunction|null)} The formatter function or null if the `format` is not a string. |
|
*/ |
|
getFormatter(format) { |
|
|
|
// default is stylish |
|
const resolvedFormatName = format || "stylish"; |
|
|
|
// only strings are valid formatters |
|
if (typeof resolvedFormatName === "string") { |
|
|
|
// replace \ with / for Windows compatibility |
|
const normalizedFormatName = resolvedFormatName.replace(/\\/gu, "/"); |
|
|
|
const slots = internalSlotsMap.get(this); |
|
const cwd = slots ? slots.options.cwd : process.cwd(); |
|
const namespace = naming.getNamespaceFromTerm(normalizedFormatName); |
|
|
|
let formatterPath; |
|
|
|
// if there's a slash, then it's a file (TODO: this check seems dubious for scoped npm packages) |
|
if (!namespace && normalizedFormatName.includes("/")) { |
|
formatterPath = path.resolve(cwd, normalizedFormatName); |
|
} else { |
|
try { |
|
const npmFormat = naming.normalizePackageName(normalizedFormatName, "eslint-formatter"); |
|
|
|
formatterPath = ModuleResolver.resolve(npmFormat, path.join(cwd, "__placeholder__.js")); |
|
} catch { |
|
formatterPath = path.resolve(__dirname, "formatters", normalizedFormatName); |
|
} |
|
} |
|
|
|
try { |
|
return require(formatterPath); |
|
} catch (ex) { |
|
if (format === "table" || format === "codeframe") { |
|
ex.message = `The ${format} formatter is no longer part of core ESLint. Install it manually with \`npm install -D eslint-formatter-${format}\``; |
|
} else { |
|
ex.message = `There was a problem loading formatter: ${formatterPath}\nError: ${ex.message}`; |
|
} |
|
throw ex; |
|
} |
|
|
|
} else { |
|
return null; |
|
} |
|
} |
|
} |
|
|
|
CLIEngine.version = pkg.version; |
|
CLIEngine.getFormatter = CLIEngine.prototype.getFormatter; |
|
|
|
module.exports = { |
|
CLIEngine, |
|
|
|
/** |
|
* Get the internal slots of a given CLIEngine instance for tests. |
|
* @param {CLIEngine} instance The CLIEngine instance to get. |
|
* @returns {CLIEngineInternalSlots} The internal slots. |
|
*/ |
|
getCLIEngineInternalSlots(instance) { |
|
return internalSlotsMap.get(instance); |
|
} |
|
};
|
|
|