mirror of
https://github.com/10h30/odin-javascript-exercises.git
synced 2026-07-13 11:46:03 +09:00
remove timer and simon
This commit is contained in:
Cody Loyd
+365
@@ -0,0 +1,365 @@
|
||||
/**
|
||||
* @fileoverview Responsible for loading config files
|
||||
* @author Seth McLaughlin
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const path = require("path"),
|
||||
os = require("os"),
|
||||
ConfigOps = require("./config/config-ops"),
|
||||
ConfigFile = require("./config/config-file"),
|
||||
ConfigCache = require("./config/config-cache"),
|
||||
Plugins = require("./config/plugins"),
|
||||
FileFinder = require("./file-finder"),
|
||||
isResolvable = require("is-resolvable");
|
||||
|
||||
const debug = require("debug")("eslint:config");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Constants
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const PERSONAL_CONFIG_DIR = os.homedir();
|
||||
const SUBCONFIG_SEP = ":";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Determines if any rules were explicitly passed in as options.
|
||||
* @param {Object} options The options used to create our configuration.
|
||||
* @returns {boolean} True if rules were passed in as options, false otherwise.
|
||||
* @private
|
||||
*/
|
||||
function hasRules(options) {
|
||||
return options.rules && Object.keys(options.rules).length > 0;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// API
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Configuration class
|
||||
*/
|
||||
class Config {
|
||||
|
||||
/**
|
||||
* @param {Object} options Options to be passed in
|
||||
* @param {Linter} linterContext Linter instance object
|
||||
*/
|
||||
constructor(options, linterContext) {
|
||||
options = options || {};
|
||||
|
||||
this.linterContext = linterContext;
|
||||
this.plugins = new Plugins(linterContext.environments, linterContext.rules);
|
||||
|
||||
this.options = options;
|
||||
this.ignore = options.ignore;
|
||||
this.ignorePath = options.ignorePath;
|
||||
this.parser = options.parser;
|
||||
this.parserOptions = options.parserOptions || {};
|
||||
|
||||
this.configCache = new ConfigCache();
|
||||
|
||||
this.baseConfig = options.baseConfig
|
||||
? ConfigOps.merge({}, ConfigFile.loadObject(options.baseConfig, this))
|
||||
: { rules: {} };
|
||||
this.baseConfig.filePath = "";
|
||||
this.baseConfig.baseDirectory = this.options.cwd;
|
||||
|
||||
this.configCache.setConfig(this.baseConfig.filePath, this.baseConfig);
|
||||
this.configCache.setMergedVectorConfig(this.baseConfig.filePath, this.baseConfig);
|
||||
|
||||
this.useEslintrc = (options.useEslintrc !== false);
|
||||
|
||||
this.env = (options.envs || []).reduce((envs, name) => {
|
||||
envs[name] = true;
|
||||
return envs;
|
||||
}, {});
|
||||
|
||||
/*
|
||||
* Handle declared globals.
|
||||
* For global variable foo, handle "foo:false" and "foo:true" to set
|
||||
* whether global is writable.
|
||||
* If user declares "foo", convert to "foo:false".
|
||||
*/
|
||||
this.globals = (options.globals || []).reduce((globals, def) => {
|
||||
const parts = def.split(SUBCONFIG_SEP);
|
||||
|
||||
globals[parts[0]] = (parts.length > 1 && parts[1] === "true");
|
||||
|
||||
return globals;
|
||||
}, {});
|
||||
|
||||
this.loadSpecificConfig(options.configFile);
|
||||
|
||||
// Empty values in configs don't merge properly
|
||||
const cliConfigOptions = {
|
||||
env: this.env,
|
||||
rules: this.options.rules,
|
||||
globals: this.globals,
|
||||
parserOptions: this.parserOptions,
|
||||
plugins: this.options.plugins
|
||||
};
|
||||
|
||||
this.cliConfig = {};
|
||||
Object.keys(cliConfigOptions).forEach(configKey => {
|
||||
const value = cliConfigOptions[configKey];
|
||||
|
||||
if (value) {
|
||||
this.cliConfig[configKey] = value;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the config options from a config specified on the command line.
|
||||
* @param {string} [config] A shareable named config or path to a config file.
|
||||
* @returns {void}
|
||||
*/
|
||||
loadSpecificConfig(config) {
|
||||
if (config) {
|
||||
debug(`Using command line config ${config}`);
|
||||
const isNamedConfig =
|
||||
isResolvable(config) ||
|
||||
isResolvable(`eslint-config-${config}`) ||
|
||||
config.charAt(0) === "@";
|
||||
|
||||
if (!isNamedConfig) {
|
||||
config = path.resolve(this.options.cwd, config);
|
||||
}
|
||||
|
||||
this.specificConfig = ConfigFile.load(config, this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the personal config object from user's home directory.
|
||||
* @returns {Object} the personal config object (null if there is no personal config)
|
||||
* @private
|
||||
*/
|
||||
getPersonalConfig() {
|
||||
if (typeof this.personalConfig === "undefined") {
|
||||
let config;
|
||||
const filename = ConfigFile.getFilenameForDirectory(PERSONAL_CONFIG_DIR);
|
||||
|
||||
if (filename) {
|
||||
debug("Using personal config");
|
||||
config = ConfigFile.load(filename, this);
|
||||
}
|
||||
|
||||
this.personalConfig = config || null;
|
||||
}
|
||||
|
||||
return this.personalConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a hierarchy of config objects, including the base config, all local configs from the directory tree,
|
||||
* and a config file specified on the command line, if applicable.
|
||||
* @param {string} directory a file in whose directory we start looking for a local config
|
||||
* @returns {Object[]} The config objects, in ascending order of precedence
|
||||
* @private
|
||||
*/
|
||||
getConfigHierarchy(directory) {
|
||||
debug(`Constructing config file hierarchy for ${directory}`);
|
||||
|
||||
// Step 1: Always include baseConfig
|
||||
let configs = [this.baseConfig];
|
||||
|
||||
// Step 2: Add user-specified config from .eslintrc.* and package.json files
|
||||
if (this.useEslintrc) {
|
||||
debug("Using .eslintrc and package.json files");
|
||||
configs = configs.concat(this.getLocalConfigHierarchy(directory));
|
||||
} else {
|
||||
debug("Not using .eslintrc or package.json files");
|
||||
}
|
||||
|
||||
// Step 3: Merge in command line config file
|
||||
if (this.specificConfig) {
|
||||
debug("Using command line config file");
|
||||
configs.push(this.specificConfig);
|
||||
}
|
||||
|
||||
return configs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a list of config objects extracted from local config files that apply to the current directory, in
|
||||
* descending order, beginning with the config that is highest in the directory tree.
|
||||
* @param {string} directory The directory to start looking in for local config files.
|
||||
* @returns {Object[]} The shallow local config objects, in ascending order of precedence (closest to the current
|
||||
* directory at the end), or an empty array if there are no local configs.
|
||||
* @private
|
||||
*/
|
||||
getLocalConfigHierarchy(directory) {
|
||||
const localConfigFiles = this.findLocalConfigFiles(directory),
|
||||
projectConfigPath = ConfigFile.getFilenameForDirectory(this.options.cwd),
|
||||
searched = [],
|
||||
configs = [];
|
||||
|
||||
for (const localConfigFile of localConfigFiles) {
|
||||
const localConfigDirectory = path.dirname(localConfigFile);
|
||||
const localConfigHierarchyCache = this.configCache.getHierarchyLocalConfigs(localConfigDirectory);
|
||||
|
||||
if (localConfigHierarchyCache) {
|
||||
const localConfigHierarchy = localConfigHierarchyCache.concat(configs.reverse());
|
||||
|
||||
this.configCache.setHierarchyLocalConfigs(searched, localConfigHierarchy);
|
||||
return localConfigHierarchy;
|
||||
}
|
||||
|
||||
/*
|
||||
* Don't consider the personal config file in the home directory,
|
||||
* except if the home directory is the same as the current working directory
|
||||
*/
|
||||
if (localConfigDirectory === PERSONAL_CONFIG_DIR && localConfigFile !== projectConfigPath) {
|
||||
continue;
|
||||
}
|
||||
|
||||
debug(`Loading ${localConfigFile}`);
|
||||
const localConfig = ConfigFile.load(localConfigFile, this);
|
||||
|
||||
// Ignore empty config files
|
||||
if (!localConfig) {
|
||||
continue;
|
||||
}
|
||||
|
||||
debug(`Using ${localConfigFile}`);
|
||||
configs.push(localConfig);
|
||||
searched.push(localConfigDirectory);
|
||||
|
||||
// Stop traversing if a config is found with the root flag set
|
||||
if (localConfig.root) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!configs.length && !this.specificConfig) {
|
||||
|
||||
// Fall back on the personal config from ~/.eslintrc
|
||||
debug("Using personal config file");
|
||||
const personalConfig = this.getPersonalConfig();
|
||||
|
||||
if (personalConfig) {
|
||||
configs.push(personalConfig);
|
||||
} else if (!hasRules(this.options) && !this.options.baseConfig) {
|
||||
|
||||
// No config file, no manual configuration, and no rules, so error.
|
||||
const noConfigError = new Error("No ESLint configuration found.");
|
||||
|
||||
noConfigError.messageTemplate = "no-config-found";
|
||||
noConfigError.messageData = {
|
||||
directory,
|
||||
filesExamined: localConfigFiles
|
||||
};
|
||||
|
||||
throw noConfigError;
|
||||
}
|
||||
}
|
||||
|
||||
// Set the caches for the parent directories
|
||||
this.configCache.setHierarchyLocalConfigs(searched, configs.reverse());
|
||||
|
||||
return configs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the vector of applicable configs and subconfigs from the hierarchy for a given file. A vector is an array of
|
||||
* entries, each of which in an object specifying a config file path and an array of override indices corresponding
|
||||
* to entries in the config file's overrides section whose glob patterns match the specified file path; e.g., the
|
||||
* vector entry { configFile: '/home/john/app/.eslintrc', matchingOverrides: [0, 2] } would indicate that the main
|
||||
* project .eslintrc file and its first and third override blocks apply to the current file.
|
||||
* @param {string} filePath The file path for which to build the hierarchy and config vector.
|
||||
* @returns {Array<Object>} config vector applicable to the specified path
|
||||
* @private
|
||||
*/
|
||||
getConfigVector(filePath) {
|
||||
const directory = filePath ? path.dirname(filePath) : this.options.cwd;
|
||||
|
||||
return this.getConfigHierarchy(directory).map(config => {
|
||||
const vectorEntry = {
|
||||
filePath: config.filePath,
|
||||
matchingOverrides: []
|
||||
};
|
||||
|
||||
if (config.overrides) {
|
||||
const relativePath = path.relative(config.baseDirectory, filePath || directory);
|
||||
|
||||
config.overrides.forEach((override, i) => {
|
||||
if (ConfigOps.pathMatchesGlobs(relativePath, override.files, override.excludedFiles)) {
|
||||
vectorEntry.matchingOverrides.push(i);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return vectorEntry;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds local config files from the specified directory and its parent directories.
|
||||
* @param {string} directory The directory to start searching from.
|
||||
* @returns {GeneratorFunction} The paths of local config files found.
|
||||
*/
|
||||
findLocalConfigFiles(directory) {
|
||||
if (!this.localConfigFinder) {
|
||||
this.localConfigFinder = new FileFinder(ConfigFile.CONFIG_FILES, this.options.cwd);
|
||||
}
|
||||
|
||||
return this.localConfigFinder.findAllInDirectoryAndParents(directory);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the authoritative config object for the specified file path by merging the hierarchy of config objects
|
||||
* that apply to the current file, including the base config (conf/eslint-recommended), the user's personal config
|
||||
* from their homedir, all local configs from the directory tree, any specific config file passed on the command
|
||||
* line, any configuration overrides set directly on the command line, and finally the environment configs
|
||||
* (conf/environments).
|
||||
* @param {string} filePath a file in whose directory we start looking for a local config
|
||||
* @returns {Object} config object
|
||||
*/
|
||||
getConfig(filePath) {
|
||||
const vector = this.getConfigVector(filePath);
|
||||
let config = this.configCache.getMergedConfig(vector);
|
||||
|
||||
if (config) {
|
||||
debug("Using config from cache");
|
||||
return config;
|
||||
}
|
||||
|
||||
// Step 1: Merge in the filesystem configurations (base, local, and personal)
|
||||
config = ConfigOps.getConfigFromVector(vector, this.configCache);
|
||||
|
||||
// Step 2: Merge in command line configurations
|
||||
config = ConfigOps.merge(config, this.cliConfig);
|
||||
|
||||
if (this.cliConfig.plugins) {
|
||||
this.plugins.loadAll(this.cliConfig.plugins);
|
||||
}
|
||||
|
||||
/*
|
||||
* Step 3: Override parser only if it is passed explicitly through the command line
|
||||
* or if it's not defined yet (because the final object will at least have the parser key)
|
||||
*/
|
||||
if (this.parser || !config.parser) {
|
||||
config = ConfigOps.merge(config, { parser: this.parser });
|
||||
}
|
||||
|
||||
// Step 4: Apply environments to the config
|
||||
config = ConfigOps.applyEnvironments(config, this.linterContext.environments);
|
||||
|
||||
this.configCache.setMergedConfig(vector, config);
|
||||
|
||||
return config;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Config;
|
||||
Reference in New Issue
Block a user