mirror of
https://github.com/JamesIves/github-pages-deploy-action.git
synced 2023-12-15 20:03:39 +08:00
517 lines
20 KiB
JavaScript
517 lines
20 KiB
JavaScript
"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)));
|
|
}, {});
|
|
}
|