| /** |
| * @fileoverview Config file operations. This file must be usable in the browser, |
| * so no Node-specific code can be here. |
| * @author Nicholas C. Zakas |
| */ |
| "use strict"; |
| |
| //------------------------------------------------------------------------------ |
| // Private |
| //------------------------------------------------------------------------------ |
| |
| const RULE_SEVERITY_STRINGS = ["off", "warn", "error"], |
| RULE_SEVERITY = RULE_SEVERITY_STRINGS.reduce((map, value, index) => { |
| map[value] = index; |
| return map; |
| }, {}), |
| VALID_SEVERITIES = [0, 1, 2, "off", "warn", "error"]; |
| |
| //------------------------------------------------------------------------------ |
| // Public Interface |
| //------------------------------------------------------------------------------ |
| |
| module.exports = { |
| |
| /** |
| * 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. |
| */ |
| 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} |
| */ |
| 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. |
| */ |
| isErrorSeverity(ruleConfig) { |
| return module.exports.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. |
| */ |
| isValidSeverity(ruleConfig) { |
| let severity = Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig; |
| |
| if (typeof severity === "string") { |
| severity = severity.toLowerCase(); |
| } |
| return VALID_SEVERITIES.indexOf(severity) !== -1; |
| }, |
| |
| /** |
| * 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. |
| */ |
| isEverySeverityValid(config) { |
| return Object.keys(config).every(ruleId => this.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 |
| */ |
| 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')`); |
| } |
| } |
| }; |