initial commit
This commit is contained in:
516
node_modules/tslint/lib/configuration.js
generated
vendored
Normal file
516
node_modules/tslint/lib/configuration.js
generated
vendored
Normal file
@@ -0,0 +1,516 @@
|
||||
"use strict";
|
||||
/**
|
||||
* @license
|
||||
* Copyright 2013 Palantir Technologies, Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
var tslib_1 = require("tslib");
|
||||
var fs = require("fs");
|
||||
var yaml = require("js-yaml");
|
||||
var minimatch_1 = require("minimatch");
|
||||
var os = require("os");
|
||||
var path = require("path");
|
||||
var error_1 = require("./error");
|
||||
var ruleLoader_1 = require("./ruleLoader");
|
||||
var utils_1 = require("./utils");
|
||||
// Note: eslint prefers yaml over json, while tslint prefers json over yaml
|
||||
// for backward-compatibility.
|
||||
exports.JSON_CONFIG_FILENAME = "tslint.json";
|
||||
/** @deprecated use `JSON_CONFIG_FILENAME` or `CONFIG_FILENAMES` instead. */
|
||||
exports.CONFIG_FILENAME = exports.JSON_CONFIG_FILENAME;
|
||||
exports.CONFIG_FILENAMES = [exports.JSON_CONFIG_FILENAME, "tslint.yaml", "tslint.yml"];
|
||||
exports.DEFAULT_CONFIG = {
|
||||
defaultSeverity: "error",
|
||||
extends: ["tslint:recommended"],
|
||||
jsRules: new Map(),
|
||||
rules: new Map(),
|
||||
rulesDirectory: [],
|
||||
};
|
||||
exports.EMPTY_CONFIG = {
|
||||
defaultSeverity: "error",
|
||||
extends: [],
|
||||
jsRules: new Map(),
|
||||
rules: new Map(),
|
||||
rulesDirectory: [],
|
||||
};
|
||||
var BUILT_IN_CONFIG = /^tslint:(.*)$/;
|
||||
function findConfiguration(configFile, inputFilePath) {
|
||||
var configPath = findConfigurationPath(configFile, inputFilePath);
|
||||
var loadResult = { path: configPath };
|
||||
try {
|
||||
loadResult.results = loadConfigurationFromPath(configPath);
|
||||
return loadResult;
|
||||
}
|
||||
catch (error) {
|
||||
throw new error_1.FatalError("Failed to load " + configPath + ": " + error.message, error);
|
||||
}
|
||||
}
|
||||
exports.findConfiguration = findConfiguration;
|
||||
function findConfigurationPath(suppliedConfigFilePath, inputFilePath) {
|
||||
if (suppliedConfigFilePath != undefined) {
|
||||
if (!fs.existsSync(suppliedConfigFilePath)) {
|
||||
throw new error_1.FatalError("Could not find config file at: " + path.resolve(suppliedConfigFilePath));
|
||||
}
|
||||
else {
|
||||
return path.resolve(suppliedConfigFilePath);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// convert to dir if it's a file or doesn't exist
|
||||
var useDirName = false;
|
||||
try {
|
||||
var stats = fs.statSync(inputFilePath);
|
||||
if (stats.isFile()) {
|
||||
useDirName = true;
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
// throws if file doesn't exist
|
||||
useDirName = true;
|
||||
}
|
||||
if (useDirName) {
|
||||
inputFilePath = path.dirname(inputFilePath);
|
||||
}
|
||||
// search for tslint.json from input file location
|
||||
var configFilePath = findup(exports.CONFIG_FILENAMES, path.resolve(inputFilePath));
|
||||
if (configFilePath !== undefined) {
|
||||
return configFilePath;
|
||||
}
|
||||
// search for tslint.json in home directory
|
||||
var homeDir = os.homedir();
|
||||
for (var _i = 0, CONFIG_FILENAMES_1 = exports.CONFIG_FILENAMES; _i < CONFIG_FILENAMES_1.length; _i++) {
|
||||
var configFilename = CONFIG_FILENAMES_1[_i];
|
||||
configFilePath = path.join(homeDir, configFilename);
|
||||
if (fs.existsSync(configFilePath)) {
|
||||
return path.resolve(configFilePath);
|
||||
}
|
||||
}
|
||||
// no path could be found
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
exports.findConfigurationPath = findConfigurationPath;
|
||||
/**
|
||||
* Find a file by names in a directory or any ancestor directory.
|
||||
* Will try each filename in filenames before recursing to a parent directory.
|
||||
* This is case-insensitive, so it can find 'TsLiNt.JsOn' when searching for 'tslint.json'.
|
||||
*/
|
||||
function findup(filenames, directory) {
|
||||
while (true) {
|
||||
var res = findFile(directory);
|
||||
if (res !== undefined) {
|
||||
return path.join(directory, res);
|
||||
}
|
||||
var parent = path.dirname(directory);
|
||||
if (parent === directory) {
|
||||
return undefined;
|
||||
}
|
||||
directory = parent;
|
||||
}
|
||||
function findFile(cwd) {
|
||||
var dirFiles = fs.readdirSync(cwd);
|
||||
var _loop_1 = function (filename) {
|
||||
var index = dirFiles.indexOf(filename);
|
||||
if (index > -1) {
|
||||
return { value: filename };
|
||||
}
|
||||
// TODO: remove in v6.0.0
|
||||
// Try reading in the entire directory and looking for a file with different casing.
|
||||
var result = dirFiles.find(function (entry) { return entry.toLowerCase() === filename; });
|
||||
if (result !== undefined) {
|
||||
error_1.showWarningOnce("Using mixed case " + filename + " is deprecated. Found: " + path.join(cwd, result));
|
||||
return { value: result };
|
||||
}
|
||||
};
|
||||
for (var _i = 0, filenames_1 = filenames; _i < filenames_1.length; _i++) {
|
||||
var filename = filenames_1[_i];
|
||||
var state_1 = _loop_1(filename);
|
||||
if (typeof state_1 === "object")
|
||||
return state_1.value;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Used Node semantics to load a configuration file given configFilePath.
|
||||
* For example:
|
||||
* '/path/to/config' will be treated as an absolute path
|
||||
* './path/to/config' will be treated as a relative path
|
||||
* 'path/to/config' will attempt to load a to/config file inside a node module named path
|
||||
* @param configFilePath The configuration to load
|
||||
* @param originalFilePath (deprecated) The entry point configuration file
|
||||
* @returns a configuration object for TSLint loaded from the file at configFilePath
|
||||
*/
|
||||
function loadConfigurationFromPath(configFilePath, _originalFilePath) {
|
||||
if (configFilePath == undefined) {
|
||||
return exports.DEFAULT_CONFIG;
|
||||
}
|
||||
else {
|
||||
var resolvedConfigFilePath = resolveConfigurationPath(configFilePath);
|
||||
var rawConfigFile = readConfigurationFile(resolvedConfigFilePath);
|
||||
return parseConfigFile(rawConfigFile, path.dirname(resolvedConfigFilePath), readConfigurationFile);
|
||||
}
|
||||
}
|
||||
exports.loadConfigurationFromPath = loadConfigurationFromPath;
|
||||
/** Reads the configuration file from disk and parses it as raw JSON, YAML or JS depending on the extension. */
|
||||
function readConfigurationFile(filepath) {
|
||||
var resolvedConfigFileExt = path.extname(filepath);
|
||||
if (/\.(json|ya?ml)/.test(resolvedConfigFileExt)) {
|
||||
var fileContent = fs.readFileSync(filepath, "utf8").replace(/^\uFEFF/, "");
|
||||
try {
|
||||
if (resolvedConfigFileExt === ".json") {
|
||||
return JSON.parse(utils_1.stripComments(fileContent));
|
||||
}
|
||||
else {
|
||||
return yaml.safeLoad(fileContent);
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
var error = e;
|
||||
// include the configuration file being parsed in the error since it may differ from the directly referenced config
|
||||
throw new Error(error.message + " in " + filepath);
|
||||
}
|
||||
}
|
||||
else {
|
||||
var rawConfigFile = require(filepath);
|
||||
// tslint:disable-next-line no-dynamic-delete
|
||||
delete require.cache[filepath];
|
||||
return rawConfigFile;
|
||||
}
|
||||
}
|
||||
exports.readConfigurationFile = readConfigurationFile;
|
||||
/**
|
||||
* Resolve configuration file path or node_module reference
|
||||
* @param filePath Relative ("./path"), absolute ("/path"), node module ("path"), or built-in ("tslint:path")
|
||||
*/
|
||||
function resolveConfigurationPath(filePath, relativeTo) {
|
||||
var matches = filePath.match(BUILT_IN_CONFIG);
|
||||
var isBuiltInConfig = matches !== null && matches.length > 0;
|
||||
if (isBuiltInConfig) {
|
||||
var configName = matches[1];
|
||||
try {
|
||||
return require.resolve("./configs/" + configName);
|
||||
}
|
||||
catch (err) {
|
||||
throw new Error(filePath + " is not a built-in config, try \"tslint:recommended\" instead.");
|
||||
}
|
||||
}
|
||||
var basedir = relativeTo !== undefined ? relativeTo : process.cwd();
|
||||
try {
|
||||
var resolvedPackagePath = utils_1.tryResolvePackage(filePath, basedir);
|
||||
if (resolvedPackagePath === undefined) {
|
||||
resolvedPackagePath = require.resolve(filePath);
|
||||
}
|
||||
return resolvedPackagePath;
|
||||
}
|
||||
catch (err) {
|
||||
throw new Error("Invalid \"extends\" configuration value - could not require \"" + filePath + "\". " +
|
||||
"Review the Node lookup algorithm (https://nodejs.org/api/modules.html#modules_all_together) " +
|
||||
"for the approximate method TSLint uses to find the referenced configuration file.");
|
||||
}
|
||||
}
|
||||
function extendConfigurationFile(targetConfig, nextConfigSource) {
|
||||
function combineProperties(targetProperty, nextProperty) {
|
||||
var combinedProperty = {};
|
||||
add(targetProperty);
|
||||
// next config source overwrites the target config object
|
||||
add(nextProperty);
|
||||
return combinedProperty;
|
||||
function add(property) {
|
||||
if (property !== undefined) {
|
||||
for (var _i = 0, _a = Object.keys(property); _i < _a.length; _i++) {
|
||||
var name = _a[_i];
|
||||
combinedProperty[name] = property[name];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function combineMaps(target, next) {
|
||||
var combined = new Map();
|
||||
target.forEach(function (options, ruleName) {
|
||||
combined.set(ruleName, options);
|
||||
});
|
||||
next.forEach(function (options, ruleName) {
|
||||
var combinedRule = combined.get(ruleName);
|
||||
if (combinedRule !== undefined) {
|
||||
combined.set(ruleName, combineProperties(combinedRule, options));
|
||||
}
|
||||
else {
|
||||
combined.set(ruleName, options);
|
||||
}
|
||||
});
|
||||
return combined;
|
||||
}
|
||||
var combinedRulesDirs = targetConfig.rulesDirectory.concat(nextConfigSource.rulesDirectory);
|
||||
var dedupedRulesDirs = Array.from(new Set(combinedRulesDirs));
|
||||
return {
|
||||
extends: [],
|
||||
jsRules: combineMaps(targetConfig.jsRules, nextConfigSource.jsRules),
|
||||
linterOptions: combineProperties(targetConfig.linterOptions, nextConfigSource.linterOptions),
|
||||
rules: combineMaps(targetConfig.rules, nextConfigSource.rules),
|
||||
rulesDirectory: dedupedRulesDirs,
|
||||
};
|
||||
}
|
||||
exports.extendConfigurationFile = extendConfigurationFile;
|
||||
/**
|
||||
* returns the absolute path (contrary to what the name implies)
|
||||
*
|
||||
* @deprecated use `path.resolve` instead
|
||||
*/
|
||||
// tslint:disable-next-line no-null-undefined-union
|
||||
function getRelativePath(directory, relativeTo) {
|
||||
if (directory != undefined) {
|
||||
var basePath = relativeTo !== undefined ? relativeTo : process.cwd();
|
||||
return path.resolve(basePath, directory);
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
exports.getRelativePath = getRelativePath;
|
||||
// check if directory should be used as path or if it should be resolved like a module
|
||||
// matches if directory starts with '/', './', '../', 'node_modules/' or equals '.' or '..'
|
||||
function useAsPath(directory) {
|
||||
return /^(?:\.?\.?(?:\/|$)|node_modules\/)/.test(directory);
|
||||
}
|
||||
exports.useAsPath = useAsPath;
|
||||
/**
|
||||
* @param directories A path(s) to a directory of custom rules
|
||||
* @param relativeTo A path that directories provided are relative to.
|
||||
* For example, if the directories come from a tslint.json file, this path
|
||||
* should be the path to the tslint.json file.
|
||||
* @return An array of absolute paths to directories potentially containing rules
|
||||
*/
|
||||
function getRulesDirectories(directories, relativeTo) {
|
||||
return utils_1.arrayify(directories).map(function (dir) {
|
||||
if (!useAsPath(dir)) {
|
||||
var resolvedPackagePath = utils_1.tryResolvePackage(dir, relativeTo);
|
||||
if (resolvedPackagePath !== undefined) {
|
||||
return path.dirname(resolvedPackagePath);
|
||||
}
|
||||
}
|
||||
var absolutePath = relativeTo === undefined ? path.resolve(dir) : path.resolve(relativeTo, dir);
|
||||
if (absolutePath !== undefined) {
|
||||
if (!fs.existsSync(absolutePath)) {
|
||||
throw new error_1.FatalError("Could not find custom rule directory: " + dir);
|
||||
}
|
||||
}
|
||||
return absolutePath;
|
||||
});
|
||||
}
|
||||
exports.getRulesDirectories = getRulesDirectories;
|
||||
/**
|
||||
* Parses the options of a single rule and upgrades legacy settings such as `true`, `[true, "option"]`
|
||||
*
|
||||
* @param ruleConfigValue The raw option setting of a rule
|
||||
*/
|
||||
function parseRuleOptions(ruleConfigValue, rawDefaultRuleSeverity) {
|
||||
var ruleArguments;
|
||||
var defaultRuleSeverity = "error";
|
||||
if (rawDefaultRuleSeverity !== undefined) {
|
||||
switch (rawDefaultRuleSeverity.toLowerCase()) {
|
||||
case "warn":
|
||||
case "warning":
|
||||
defaultRuleSeverity = "warning";
|
||||
break;
|
||||
case "off":
|
||||
case "none":
|
||||
defaultRuleSeverity = "off";
|
||||
break;
|
||||
default:
|
||||
defaultRuleSeverity = "error";
|
||||
}
|
||||
}
|
||||
var ruleSeverity = defaultRuleSeverity;
|
||||
if (ruleConfigValue == undefined) {
|
||||
ruleArguments = [];
|
||||
ruleSeverity = "off";
|
||||
}
|
||||
else if (Array.isArray(ruleConfigValue)) {
|
||||
if (ruleConfigValue.length > 0) {
|
||||
// old style: array
|
||||
ruleArguments = ruleConfigValue.slice(1);
|
||||
ruleSeverity = ruleConfigValue[0] === true ? defaultRuleSeverity : "off";
|
||||
}
|
||||
}
|
||||
else if (typeof ruleConfigValue === "boolean") {
|
||||
// old style: boolean
|
||||
ruleArguments = [];
|
||||
ruleSeverity = ruleConfigValue ? defaultRuleSeverity : "off";
|
||||
}
|
||||
else if (typeof ruleConfigValue === "object") {
|
||||
if (ruleConfigValue.severity !== undefined) {
|
||||
switch (ruleConfigValue.severity.toLowerCase()) {
|
||||
case "default":
|
||||
ruleSeverity = defaultRuleSeverity;
|
||||
break;
|
||||
case "error":
|
||||
ruleSeverity = "error";
|
||||
break;
|
||||
case "warn":
|
||||
case "warning":
|
||||
ruleSeverity = "warning";
|
||||
break;
|
||||
case "off":
|
||||
case "none":
|
||||
ruleSeverity = "off";
|
||||
break;
|
||||
default:
|
||||
console.warn("Invalid severity level: " + ruleConfigValue.severity);
|
||||
ruleSeverity = defaultRuleSeverity;
|
||||
}
|
||||
}
|
||||
if (ruleConfigValue.options != undefined) {
|
||||
ruleArguments = utils_1.arrayify(ruleConfigValue.options);
|
||||
}
|
||||
}
|
||||
return {
|
||||
ruleArguments: ruleArguments,
|
||||
ruleSeverity: ruleSeverity,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Parses a config file and normalizes legacy config settings.
|
||||
* If `configFileDir` and `readConfig` are provided, this function will load all base configs and reduce them to the final configuration.
|
||||
*
|
||||
* @param configFile The raw object read from the JSON of a config file
|
||||
* @param configFileDir The directory of the config file
|
||||
* @param readConfig Will be used to load all base configurations while parsing. The function is called with the resolved path.
|
||||
*/
|
||||
function parseConfigFile(configFile, configFileDir, readConfig) {
|
||||
var defaultSeverity = configFile.defaultSeverity;
|
||||
if (readConfig === undefined || configFileDir === undefined) {
|
||||
return parse(configFile, configFileDir);
|
||||
}
|
||||
return loadExtendsRecursive(configFile, configFileDir)
|
||||
.map(function (_a) {
|
||||
var dir = _a.dir, config = _a.config;
|
||||
return parse(config, dir);
|
||||
})
|
||||
.reduce(extendConfigurationFile, exports.EMPTY_CONFIG);
|
||||
/** Read files in order, depth first, and assign `defaultSeverity` (last config in extends wins). */
|
||||
function loadExtendsRecursive(raw, dir) {
|
||||
var configs = [];
|
||||
for (var _i = 0, _a = utils_1.arrayify(raw.extends); _i < _a.length; _i++) {
|
||||
var relativePath = _a[_i];
|
||||
var resolvedPath = resolveConfigurationPath(relativePath, dir);
|
||||
var extendedRaw = readConfig(resolvedPath);
|
||||
configs.push.apply(configs, loadExtendsRecursive(extendedRaw, path.dirname(resolvedPath)));
|
||||
}
|
||||
if (raw.defaultSeverity !== undefined) {
|
||||
defaultSeverity = raw.defaultSeverity;
|
||||
}
|
||||
configs.push({ dir: dir, config: raw });
|
||||
return configs;
|
||||
}
|
||||
function parse(config, dir) {
|
||||
var rulesDirectory = getRulesDirectories(config.rulesDirectory, dir);
|
||||
var rules = parseRules(config.rules);
|
||||
var jsRules = typeof config.jsRules === "boolean"
|
||||
? filterValidJsRules(rules, config.jsRules, rulesDirectory)
|
||||
: parseRules(config.jsRules);
|
||||
return {
|
||||
extends: utils_1.arrayify(config.extends),
|
||||
jsRules: jsRules,
|
||||
linterOptions: parseLinterOptions(config.linterOptions, dir),
|
||||
rules: rules,
|
||||
rulesDirectory: rulesDirectory,
|
||||
};
|
||||
}
|
||||
function parseRules(config) {
|
||||
var map = new Map();
|
||||
if (config !== undefined) {
|
||||
for (var _i = 0, _a = Object.keys(config); _i < _a.length; _i++) {
|
||||
var ruleName = _a[_i];
|
||||
map.set(ruleName, parseRuleOptions(config[ruleName], defaultSeverity));
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
function filterValidJsRules(rules, copyRulestoJsRules, rulesDirectory) {
|
||||
if (copyRulestoJsRules === void 0) { copyRulestoJsRules = false; }
|
||||
var validJsRules = new Map();
|
||||
if (copyRulestoJsRules) {
|
||||
rules.forEach(function (ruleOptions, ruleName) {
|
||||
var Rule = ruleLoader_1.findRule(ruleName, rulesDirectory);
|
||||
if (Rule !== undefined &&
|
||||
(Rule.metadata === undefined || !Rule.metadata.typescriptOnly)) {
|
||||
validJsRules.set(ruleName, ruleOptions);
|
||||
}
|
||||
});
|
||||
}
|
||||
return validJsRules;
|
||||
}
|
||||
function parseLinterOptions(raw, dir) {
|
||||
if (raw === undefined) {
|
||||
return {};
|
||||
}
|
||||
return tslib_1.__assign({}, (raw.exclude !== undefined
|
||||
? {
|
||||
exclude: utils_1.arrayify(raw.exclude).map(function (pattern) {
|
||||
return dir === undefined ? path.resolve(pattern) : path.resolve(dir, pattern);
|
||||
}),
|
||||
}
|
||||
: {}), (raw.format !== undefined
|
||||
? {
|
||||
format: raw.format,
|
||||
}
|
||||
: {}));
|
||||
}
|
||||
}
|
||||
exports.parseConfigFile = parseConfigFile;
|
||||
/**
|
||||
* Fills in default values for `IOption` properties and outputs an array of `IOption`
|
||||
*/
|
||||
function convertRuleOptions(ruleConfiguration) {
|
||||
var output = [];
|
||||
ruleConfiguration.forEach(function (_a, ruleName) {
|
||||
var ruleArguments = _a.ruleArguments, ruleSeverity = _a.ruleSeverity;
|
||||
var options = {
|
||||
disabledIntervals: [],
|
||||
ruleArguments: ruleArguments != undefined ? ruleArguments : [],
|
||||
ruleName: ruleName,
|
||||
ruleSeverity: ruleSeverity != undefined ? ruleSeverity : "error",
|
||||
};
|
||||
output.push(options);
|
||||
});
|
||||
return output;
|
||||
}
|
||||
exports.convertRuleOptions = convertRuleOptions;
|
||||
function isFileExcluded(filepath, configFile) {
|
||||
if (configFile === undefined ||
|
||||
configFile.linterOptions == undefined ||
|
||||
configFile.linterOptions.exclude == undefined) {
|
||||
return false;
|
||||
}
|
||||
var fullPath = path.resolve(filepath);
|
||||
return configFile.linterOptions.exclude.some(function (pattern) { return new minimatch_1.Minimatch(pattern).match(fullPath); });
|
||||
}
|
||||
exports.isFileExcluded = isFileExcluded;
|
||||
function stringifyConfiguration(configFile) {
|
||||
return JSON.stringify({
|
||||
extends: configFile.extends,
|
||||
jsRules: convertRulesMapToObject(configFile.jsRules),
|
||||
linterOptions: configFile.linterOptions,
|
||||
rules: convertRulesMapToObject(configFile.rules),
|
||||
rulesDirectory: configFile.rulesDirectory,
|
||||
}, undefined, 2);
|
||||
}
|
||||
exports.stringifyConfiguration = stringifyConfiguration;
|
||||
function convertRulesMapToObject(rules) {
|
||||
return Array.from(rules).reduce(function (result, _a) {
|
||||
var _b;
|
||||
var key = _a[0], value = _a[1];
|
||||
return (tslib_1.__assign({}, result, (_b = {}, _b[key] = value, _b)));
|
||||
}, {});
|
||||
}
|
||||
Reference in New Issue
Block a user