142 lines
4.5 KiB
JavaScript
142 lines
4.5 KiB
JavaScript
/**
|
|
* @fileoverview Config file operations. This file must be usable in the browser,
|
|
* so no Node-specific code can be here.
|
|
* @author Nicholas C. Zakas
|
|
*/
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Private
|
|
//------------------------------------------------------------------------------
|
|
|
|
const RULE_SEVERITY_STRINGS = ['off', 'warn', 'error'],
|
|
RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => {
|
|
map[value] = index;
|
|
return map;
|
|
}, {}),
|
|
VALID_SEVERITIES = new Set([0, 1, 2, 'off', 'warn', 'error']);
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Public Interface
|
|
//------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Normalizes the severity value of a rule's configuration to a number
|
|
* @param {(number|string|[number, ...*]|[string, ...*])} ruleConfig A rule's configuration value, generally
|
|
* received from the user. A valid config value is either 0, 1, 2, the string "off" (treated the same as 0),
|
|
* the string "warn" (treated the same as 1), the string "error" (treated the same as 2), or an array
|
|
* whose first element is one of the above values. Strings are matched case-insensitively.
|
|
* @returns {(0|1|2)} The numeric severity value if the config value was valid, otherwise 0.
|
|
*/
|
|
function getRuleSeverity(ruleConfig) {
|
|
const severityValue = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
|
|
|
|
if (severityValue === 0 || severityValue === 1 || severityValue === 2) {
|
|
return severityValue;
|
|
}
|
|
|
|
if (typeof severityValue === 'string') {
|
|
return RULE_SEVERITY[severityValue.toLowerCase()] || 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Converts old-style severity settings (0, 1, 2) into new-style
|
|
* severity settings (off, warn, error) for all rules. Assumption is that severity
|
|
* values have already been validated as correct.
|
|
* @param {Object} config The config object to normalize.
|
|
* @returns {void}
|
|
*/
|
|
function normalizeToStrings(config) {
|
|
if (config.rules) {
|
|
Object.keys(config.rules).forEach((ruleId) => {
|
|
const ruleConfig = config.rules[ruleId];
|
|
|
|
if (typeof ruleConfig === 'number') {
|
|
config.rules[ruleId] =
|
|
RULE_SEVERITY_STRINGS[ruleConfig] || RULE_SEVERITY_STRINGS[0];
|
|
} else if (
|
|
Array.isArray(ruleConfig) &&
|
|
typeof ruleConfig[0] === 'number'
|
|
) {
|
|
ruleConfig[0] =
|
|
RULE_SEVERITY_STRINGS[ruleConfig[0]] || RULE_SEVERITY_STRINGS[0];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if the severity for the given rule configuration represents an error.
|
|
* @param {int|string|Array} ruleConfig The configuration for an individual rule.
|
|
* @returns {boolean} True if the rule represents an error, false if not.
|
|
*/
|
|
function isErrorSeverity(ruleConfig) {
|
|
return getRuleSeverity(ruleConfig) === 2;
|
|
}
|
|
|
|
/**
|
|
* Checks whether a given config has valid severity or not.
|
|
* @param {number|string|Array} ruleConfig The configuration for an individual rule.
|
|
* @returns {boolean} `true` if the configuration has valid severity.
|
|
*/
|
|
function isValidSeverity(ruleConfig) {
|
|
let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
|
|
|
|
if (typeof severity === 'string') {
|
|
severity = severity.toLowerCase();
|
|
}
|
|
return VALID_SEVERITIES.has(severity);
|
|
}
|
|
|
|
/**
|
|
* Checks whether every rule of a given config has valid severity or not.
|
|
* @param {Object} config The configuration for rules.
|
|
* @returns {boolean} `true` if the configuration has valid severity.
|
|
*/
|
|
function isEverySeverityValid(config) {
|
|
return Object.keys(config).every((ruleId) => isValidSeverity(config[ruleId]));
|
|
}
|
|
|
|
/**
|
|
* Normalizes a value for a global in a config
|
|
* @param {(boolean|string|null)} configuredValue The value given for a global in configuration or in
|
|
* a global directive comment
|
|
* @returns {("readable"|"writeable"|"off")} The value normalized as a string
|
|
* @throws Error if global value is invalid
|
|
*/
|
|
function normalizeConfigGlobal(configuredValue) {
|
|
switch (configuredValue) {
|
|
case 'off':
|
|
return 'off';
|
|
|
|
case true:
|
|
case 'true':
|
|
case 'writeable':
|
|
case 'writable':
|
|
return 'writable';
|
|
|
|
case null:
|
|
case false:
|
|
case 'false':
|
|
case 'readable':
|
|
case 'readonly':
|
|
return 'readonly';
|
|
|
|
default:
|
|
throw new Error(
|
|
`'${configuredValue}' is not a valid configuration for a global (use 'readonly', 'writable', or 'off')`
|
|
);
|
|
}
|
|
}
|
|
|
|
export {
|
|
getRuleSeverity,
|
|
normalizeToStrings,
|
|
isErrorSeverity,
|
|
isValidSeverity,
|
|
isEverySeverityValid,
|
|
normalizeConfigGlobal,
|
|
};
|