+++ /dev/null
-/**
- * @fileoverview Create configurations for a rule
- * @author Ian VanSchooten
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const builtInRules = require("../rules");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Wrap all of the elements of an array into arrays.
- * @param {*[]} xs Any array.
- * @returns {Array[]} An array of arrays.
- */
-function explodeArray(xs) {
- return xs.reduce((accumulator, x) => {
- accumulator.push([x]);
- return accumulator;
- }, []);
-}
-
-/**
- * Mix two arrays such that each element of the second array is concatenated
- * onto each element of the first array.
- *
- * For example:
- * combineArrays([a, [b, c]], [x, y]); // -> [[a, x], [a, y], [b, c, x], [b, c, y]]
- * @param {Array} arr1 The first array to combine.
- * @param {Array} arr2 The second array to combine.
- * @returns {Array} A mixture of the elements of the first and second arrays.
- */
-function combineArrays(arr1, arr2) {
- const res = [];
-
- if (arr1.length === 0) {
- return explodeArray(arr2);
- }
- if (arr2.length === 0) {
- return explodeArray(arr1);
- }
- arr1.forEach(x1 => {
- arr2.forEach(x2 => {
- res.push([].concat(x1, x2));
- });
- });
- return res;
-}
-
-/**
- * Group together valid rule configurations based on object properties
- *
- * e.g.:
- * groupByProperty([
- * {before: true},
- * {before: false},
- * {after: true},
- * {after: false}
- * ]);
- *
- * will return:
- * [
- * [{before: true}, {before: false}],
- * [{after: true}, {after: false}]
- * ]
- * @param {Object[]} objects Array of objects, each with one property/value pair
- * @returns {Array[]} Array of arrays of objects grouped by property
- */
-function groupByProperty(objects) {
- const groupedObj = objects.reduce((accumulator, obj) => {
- const prop = Object.keys(obj)[0];
-
- accumulator[prop] = accumulator[prop] ? accumulator[prop].concat(obj) : [obj];
- return accumulator;
- }, {});
-
- return Object.keys(groupedObj).map(prop => groupedObj[prop]);
-}
-
-
-//------------------------------------------------------------------------------
-// Private
-//------------------------------------------------------------------------------
-
-/**
- * Configuration settings for a rule.
- *
- * A configuration can be a single number (severity), or an array where the first
- * element in the array is the severity, and is the only required element.
- * Configs may also have one or more additional elements to specify rule
- * configuration or options.
- * @typedef {Array|number} ruleConfig
- * @param {number} 0 The rule's severity (0, 1, 2).
- */
-
-/**
- * Object whose keys are rule names and values are arrays of valid ruleConfig items
- * which should be linted against the target source code to determine error counts.
- * (a ruleConfigSet.ruleConfigs).
- *
- * e.g. rulesConfig = {
- * "comma-dangle": [2, [2, "always"], [2, "always-multiline"], [2, "never"]],
- * "no-console": [2]
- * }
- * @typedef rulesConfig
- */
-
-
-/**
- * Create valid rule configurations by combining two arrays,
- * with each array containing multiple objects each with a
- * single property/value pair and matching properties.
- *
- * e.g.:
- * combinePropertyObjects(
- * [{before: true}, {before: false}],
- * [{after: true}, {after: false}]
- * );
- *
- * will return:
- * [
- * {before: true, after: true},
- * {before: true, after: false},
- * {before: false, after: true},
- * {before: false, after: false}
- * ]
- * @param {Object[]} objArr1 Single key/value objects, all with the same key
- * @param {Object[]} objArr2 Single key/value objects, all with another key
- * @returns {Object[]} Combined objects for each combination of input properties and values
- */
-function combinePropertyObjects(objArr1, objArr2) {
- const res = [];
-
- if (objArr1.length === 0) {
- return objArr2;
- }
- if (objArr2.length === 0) {
- return objArr1;
- }
- objArr1.forEach(obj1 => {
- objArr2.forEach(obj2 => {
- const combinedObj = {};
- const obj1Props = Object.keys(obj1);
- const obj2Props = Object.keys(obj2);
-
- obj1Props.forEach(prop1 => {
- combinedObj[prop1] = obj1[prop1];
- });
- obj2Props.forEach(prop2 => {
- combinedObj[prop2] = obj2[prop2];
- });
- res.push(combinedObj);
- });
- });
- return res;
-}
-
-/**
- * Creates a new instance of a rule configuration set
- *
- * A rule configuration set is an array of configurations that are valid for a
- * given rule. For example, the configuration set for the "semi" rule could be:
- *
- * ruleConfigSet.ruleConfigs // -> [[2], [2, "always"], [2, "never"]]
- *
- * Rule configuration set class
- */
-class RuleConfigSet {
-
- // eslint-disable-next-line jsdoc/require-description
- /**
- * @param {ruleConfig[]} configs Valid rule configurations
- */
- constructor(configs) {
-
- /**
- * Stored valid rule configurations for this instance
- * @type {Array}
- */
- this.ruleConfigs = configs || [];
- }
-
- /**
- * Add a severity level to the front of all configs in the instance.
- * This should only be called after all configs have been added to the instance.
- * @returns {void}
- */
- addErrorSeverity() {
- const severity = 2;
-
- this.ruleConfigs = this.ruleConfigs.map(config => {
- config.unshift(severity);
- return config;
- });
-
- // Add a single config at the beginning consisting of only the severity
- this.ruleConfigs.unshift(severity);
- }
-
- /**
- * Add rule configs from an array of strings (schema enums)
- * @param {string[]} enums Array of valid rule options (e.g. ["always", "never"])
- * @returns {void}
- */
- addEnums(enums) {
- this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, enums));
- }
-
- /**
- * Add rule configurations from a schema object
- * @param {Object} obj Schema item with type === "object"
- * @returns {boolean} true if at least one schema for the object could be generated, false otherwise
- */
- addObject(obj) {
- const objectConfigSet = {
- objectConfigs: [],
- add(property, values) {
- for (let idx = 0; idx < values.length; idx++) {
- const optionObj = {};
-
- optionObj[property] = values[idx];
- this.objectConfigs.push(optionObj);
- }
- },
-
- combine() {
- this.objectConfigs = groupByProperty(this.objectConfigs).reduce((accumulator, objArr) => combinePropertyObjects(accumulator, objArr), []);
- }
- };
-
- /*
- * The object schema could have multiple independent properties.
- * If any contain enums or booleans, they can be added and then combined
- */
- Object.keys(obj.properties).forEach(prop => {
- if (obj.properties[prop].enum) {
- objectConfigSet.add(prop, obj.properties[prop].enum);
- }
- if (obj.properties[prop].type && obj.properties[prop].type === "boolean") {
- objectConfigSet.add(prop, [true, false]);
- }
- });
- objectConfigSet.combine();
-
- if (objectConfigSet.objectConfigs.length > 0) {
- this.ruleConfigs = this.ruleConfigs.concat(combineArrays(this.ruleConfigs, objectConfigSet.objectConfigs));
- return true;
- }
-
- return false;
- }
-}
-
-/**
- * Generate valid rule configurations based on a schema object
- * @param {Object} schema A rule's schema object
- * @returns {Array[]} Valid rule configurations
- */
-function generateConfigsFromSchema(schema) {
- const configSet = new RuleConfigSet();
-
- if (Array.isArray(schema)) {
- for (const opt of schema) {
- if (opt.enum) {
- configSet.addEnums(opt.enum);
- } else if (opt.type && opt.type === "object") {
- if (!configSet.addObject(opt)) {
- break;
- }
-
- // TODO (IanVS): support oneOf
- } else {
-
- // If we don't know how to fill in this option, don't fill in any of the following options.
- break;
- }
- }
- }
- configSet.addErrorSeverity();
- return configSet.ruleConfigs;
-}
-
-/**
- * Generate possible rule configurations for all of the core rules
- * @param {boolean} noDeprecated Indicates whether ignores deprecated rules or not.
- * @returns {rulesConfig} Hash of rule names and arrays of possible configurations
- */
-function createCoreRuleConfigs(noDeprecated = false) {
- return Array.from(builtInRules).reduce((accumulator, [id, rule]) => {
- const schema = (typeof rule === "function") ? rule.schema : rule.meta.schema;
- const isDeprecated = (typeof rule === "function") ? rule.deprecated : rule.meta.deprecated;
-
- if (noDeprecated && isDeprecated) {
- return accumulator;
- }
-
- accumulator[id] = generateConfigsFromSchema(schema);
- return accumulator;
- }, {});
-}
-
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-module.exports = {
- generateConfigsFromSchema,
- createCoreRuleConfigs
-};
projects / dotfiles / .git / blobdiff