jscodeshift transform to add metadata to all ESLint rules

README.md

jscodeshift transform to add metadata to all ESLint rules

This transform was created to programmatically add metadata to all ESLint rules (#5417).

here's a live example for the no-trailing-spaces rule.

Please note:

• The rule mappings were initially created by scraping eslint.org/docs/rules using jsdom.
• The scraping assumes all fixable rules are of fixable type whitespace. This is not true for 4 rules, which were fixed manually afterwards:
  • semi
  • no-extra-semi
  • jsx-quotes
  • quotes
• The transform does not check if the schema definition depends on previously defined variables which won't be defined yet when the schema definition is moved up in the file. An example is rule max-len. These will also be fixed manually.

transform.js

const ruleMapping = require('./ruleMapping.js');
const path = require('path');

export default function transformer(file, api, options) {
    const j = api.jscodeshift;
    const {expression, statement, statements} = j.template;
    const root = j(file.source);

    const ruleId = path.basename(file.path, '.js');
    const rule = ruleMapping[ruleId];

  	const createDocsObjectExpression = (rule) => {
      	const properties = [
            j.property('init', j.identifier('description'), j.literal(rule.description)),
            j.property('init', j.identifier('category'), j.literal(rule.category)),
            j.property('init', j.identifier('recommended'), j.literal(rule.recommended))
        ];

        return j.objectExpression(properties);
    };

    const createMetaObjectExpression = (rule, schemaNode) => {
        const properties = [
          	j.property('init', j.identifier('docs'), createDocsObjectExpression(rule)),
            j.property('init', j.identifier('schema'), schemaNode)
        ];

      	if (rule.fixable) {
            properties.splice(1, 0,
                j.property('init', j.identifier('fixable'), j.literal(rule.fixable))
            );
        }

        return j.objectExpression(properties);
    };

    const createExportsExpression = (rule, ruleDefinitionNode, schemaNode) =>
        j.assignmentExpression(
                '=',
                j.memberExpression(j.identifier('module'), j.identifier('exports'), false),
                j.objectExpression([
                    j.property('init', j.identifier('meta'), createMetaObjectExpression(rule, schemaNode)),
                    j.property('init', j.identifier('create'), ruleDefinitionNode)
                ])
        );

    // Find the schema definition, which will be in the format:
    // module.exports.schema = [ ... ];
    let schemaNode;
    root.find(j.AssignmentExpression)
        .filter(node => node.value.left.type === 'MemberExpression' &&
                            node.value.left.property.name === 'schema' &&
                            node.value.left.object.type === 'MemberExpression' &&
                            node.value.left.object.object.name === 'module' &&
                            node.value.left.object.property.name === 'exports')
        .forEach(node => { schemaNode = node.value.right })
        .remove();

    return root
        .find(j.AssignmentExpression)
        // Find the rule definition, which will be in the format:
        // module.exports = function(context) { ... };
        .filter(node => node.value.left.type === 'MemberExpression' &&
                            node.value.left.property.name === 'exports' &&
                            node.value.left.object.name === 'module' &&
                            node.value.right.type === 'FunctionExpression')
        // Replace it with our new rule definition format
        .replaceWith(node => createExportsExpression(rule, node.value.right, schemaNode))
        .toSource();
};

ruleMapping.js

module.exports = {
  'comma-dangle':
   { description: 'require or disallow trailing commas',
     category: 'Possible Errors',
     recommended: true },
  'no-cond-assign':
   { description: 'disallow assignment operators in conditional expressions',
     category: 'Possible Errors',
     recommended: true },
  'no-console':
   { description: 'disallow the use of `console`',
     category: 'Possible Errors',
     recommended: true },
  'no-constant-condition':
   { description: 'disallow constant expressions in conditions',
     category: 'Possible Errors',
     recommended: true },
  'no-control-regex':
   { description: 'disallow control characters in regular expressions',
     category: 'Possible Errors',
     recommended: true },
  'no-debugger':
   { description: 'disallow the use of `debugger`',
     category: 'Possible Errors',
     recommended: true },
  'no-dupe-args':
   { description: 'disallow duplicate arguments in `function` definitions',
     category: 'Possible Errors',
     recommended: true },
  'no-dupe-keys':
   { description: 'disallow duplicate keys in object literals',
     category: 'Possible Errors',
     recommended: true },
  'no-duplicate-case':
   { description: 'disallow duplicate case labels',
     category: 'Possible Errors',
     recommended: true },
  'no-empty':
   { description: 'disallow empty block statements',
     category: 'Possible Errors',
     recommended: true },
  'no-empty-character-class':
   { description: 'disallow empty character classes in regular expressions',
     category: 'Possible Errors',
     recommended: true },
  'no-ex-assign':
   { description: 'disallow reassigning exceptions in `catch` clauses',
     category: 'Possible Errors',
     recommended: true },
  'no-extra-boolean-cast':
   { description: 'disallow unnecessary boolean casts',
     category: 'Possible Errors',
     recommended: true },
  'no-extra-parens':
   { description: 'disallow unnecessary parentheses',
     category: 'Possible Errors',
     recommended: false },
  'no-extra-semi':
   { description: 'disallow unnecessary semicolons',
     category: 'Possible Errors',
     recommended: true,
     fixable: 'whitespace' },
  'no-func-assign':
   { description: 'disallow reassigning `function` declarations',
     category: 'Possible Errors',
     recommended: true },
  'no-inner-declarations':
   { description: 'disallow `function` or `var` declarations in nested blocks',
     category: 'Possible Errors',
     recommended: true },
  'no-invalid-regexp':
   { description: 'disallow invalid regular expression strings in `RegExp` constructors',
     category: 'Possible Errors',
     recommended: true },
  'no-irregular-whitespace':
   { description: 'disallow irregular whitespace outside of strings and comments',
     category: 'Possible Errors',
     recommended: true },
  'no-negated-in-lhs':
   { description: 'disallow negating the left operand in `in` expressions',
     category: 'Possible Errors',
     recommended: true },
  'no-obj-calls':
   { description: 'disallow calling global object properties as functions',
     category: 'Possible Errors',
     recommended: true },
  'no-regex-spaces':
   { description: 'disallow multiple spaces in regular expression literals',
     category: 'Possible Errors',
     recommended: true },
  'no-sparse-arrays':
   { description: 'disallow sparse arrays',
     category: 'Possible Errors',
     recommended: true },
  'no-unexpected-multiline':
   { description: 'disallow confusing multiline expressions',
     category: 'Possible Errors',
     recommended: true },
  'no-unreachable':
   { description: 'disallow unreachable code after `return`, `throw`, `continue`, and `break` statements',
     category: 'Possible Errors',
     recommended: true },
  'use-isnan':
   { description: 'require calls to `isNaN()` when checking for `NaN`',
     category: 'Possible Errors',
     recommended: true },
  'valid-jsdoc':
   { description: 'enforce valid JSDoc comments',
     category: 'Possible Errors',
     recommended: false },
  'valid-typeof':
   { description: 'enforce comparing `typeof` expressions against valid strings',
     category: 'Possible Errors',
     recommended: true },
  'accessor-pairs':
   { description: 'enforce getter and setter pairs in objects',
     category: 'Best Practices',
     recommended: false },
  'array-callback-return':
   { description: 'enforce `return` statements in callbacks of array methods',
     category: 'Best Practices',
     recommended: false },
  'block-scoped-var':
   { description: 'enforce the use of variables within the scope they are defined',
     category: 'Best Practices',
     recommended: false },
  complexity:
   { description: 'enforce a maximum cyclomatic complexity allowed in a program',
     category: 'Best Practices',
     recommended: false },
  'consistent-return':
   { description: 'require `return` statements to either always or never specify values',
     category: 'Best Practices',
     recommended: false },
  curly:
   { description: 'enforce consistent brace style for all control statements',
     category: 'Best Practices',
     recommended: false },
  'default-case':
   { description: 'require `default` cases in `switch` statements',
     category: 'Best Practices',
     recommended: false },
  'dot-location':
   { description: 'enforce consistent newlines before and after dots',
     category: 'Best Practices',
     recommended: false },
  'dot-notation':
   { description: 'enforce dot notation whenever possible',
     category: 'Best Practices',
     recommended: false },
  eqeqeq:
   { description: 'require the use of `===` and `!==`',
     category: 'Best Practices',
     recommended: false },
  'guard-for-in':
   { description: 'require `for-in` loops to include an `if` statement',
     category: 'Best Practices',
     recommended: false },
  'no-alert':
   { description: 'disallow the use of `alert`, `confirm`, and `prompt`',
     category: 'Best Practices',
     recommended: false },
  'no-caller':
   { description: 'disallow the use of `arguments.caller` or `arguments.callee`',
     category: 'Best Practices',
     recommended: false },
  'no-case-declarations':
   { description: 'disallow lexical declarations in case clauses',
     category: 'Best Practices',
     recommended: true },
  'no-div-regex':
   { description: 'disallow division operators explicitly at the beginning of regular expressions',
     category: 'Best Practices',
     recommended: false },
  'no-else-return':
   { description: 'disallow `else` blocks after `return` statements in `if` statements',
     category: 'Best Practices',
     recommended: false },
  'no-empty-function':
   { description: 'disallow empty functions',
     category: 'Best Practices',
     recommended: false },
  'no-empty-pattern':
   { description: 'disallow empty destructuring patterns',
     category: 'Best Practices',
     recommended: true },
  'no-eq-null':
   { description: 'disallow `null` comparisons without type-checking operators',
     category: 'Best Practices',
     recommended: false },
  'no-eval':
   { description: 'disallow the use of `eval()`',
     category: 'Best Practices',
     recommended: false },
  'no-extend-native':
   { description: 'disallow extending native types',
     category: 'Best Practices',
     recommended: false },
  'no-extra-bind':
   { description: 'disallow unnecessary calls to `.bind()`',
     category: 'Best Practices',
     recommended: false },
  'no-extra-label':
   { description: 'disallow unnecessary labels',
     category: 'Best Practices',
     recommended: false },
  'no-fallthrough':
   { description: 'disallow fallthrough of `case` statements',
     category: 'Best Practices',
     recommended: true },
  'no-floating-decimal':
   { description: 'disallow leading or trailing decimal points in numeric literals',
     category: 'Best Practices',
     recommended: false },
  'no-implicit-coercion':
   { description: 'disallow shorthand type conversions',
     category: 'Best Practices',
     recommended: false },
  'no-implicit-globals':
   { description: 'disallow `var` and named `function` declarations in the global scope',
     category: 'Best Practices',
     recommended: false },
  'no-implied-eval':
   { description: 'disallow the use of `eval()`-like methods',
     category: 'Best Practices',
     recommended: false },
  'no-invalid-this':
   { description: 'disallow `this` keywords outside of classes or class-like objects',
     category: 'Best Practices',
     recommended: false },
  'no-iterator':
   { description: 'disallow the use of the `__iterator__` property',
     category: 'Best Practices',
     recommended: false },
  'no-labels':
   { description: 'disallow labeled statements',
     category: 'Best Practices',
     recommended: false },
  'no-lone-blocks':
   { description: 'disallow unnecessary nested blocks',
     category: 'Best Practices',
     recommended: false },
  'no-loop-func':
   { description: 'disallow `function` declarations and expressions inside loop statements',
     category: 'Best Practices',
     recommended: false },
  'no-magic-numbers':
   { description: 'disallow magic numbers',
     category: 'Best Practices',
     recommended: false },
  'no-multi-spaces':
   { description: 'disallow multiple spaces',
     category: 'Best Practices',
     recommended: false,
     fixable: 'whitespace' },
  'no-multi-str':
   { description: 'disallow multiline strings',
     category: 'Best Practices',
     recommended: false },
  'no-native-reassign':
   { description: 'disallow reassigning native objects',
     category: 'Best Practices',
     recommended: false },
  'no-new':
   { description: 'disallow `new` operators outside of assignments or comparisons',
     category: 'Best Practices',
     recommended: false },
  'no-new-func':
   { description: 'disallow `new` operators with the `Function` object',
     category: 'Best Practices',
     recommended: false },
  'no-new-wrappers':
   { description: 'disallow `new` operators with the `String`, `Number`, and `Boolean` objects',
     category: 'Best Practices',
     recommended: false },
  'no-octal':
   { description: 'disallow octal literals',
     category: 'Best Practices',
     recommended: true },
  'no-octal-escape':
   { description: 'disallow octal escape sequences in string literals',
     category: 'Best Practices',
     recommended: false },
  'no-param-reassign':
   { description: 'disallow reassigning `function` parameters',
     category: 'Best Practices',
     recommended: false },
  'no-proto':
   { description: 'disallow the use of the `__proto__` property',
     category: 'Best Practices',
     recommended: false },
  'no-redeclare':
   { description: 'disallow `var` redeclaration',
     category: 'Best Practices',
     recommended: true },
  'no-return-assign':
   { description: 'disallow assignment operators in `return` statements',
     category: 'Best Practices',
     recommended: false },
  'no-script-url':
   { description: 'disallow `javascript',
     category: 'Best Practices',
     recommended: false },
  'no-self-assign':
   { description: 'disallow assignments where both sides are exactly the same',
     category: 'Best Practices',
     recommended: true },
  'no-self-compare':
   { description: 'disallow comparisons where both sides are exactly the same',
     category: 'Best Practices',
     recommended: false },
  'no-sequences':
   { description: 'disallow comma operators',
     category: 'Best Practices',
     recommended: false },
  'no-throw-literal':
   { description: 'disallow throwing literals as exceptions',
     category: 'Best Practices',
     recommended: false },
  'no-unmodified-loop-condition':
   { description: 'disallow unmodified loop conditions',
     category: 'Best Practices',
     recommended: false },
  'no-unused-expressions':
   { description: 'disallow unused expressions',
     category: 'Best Practices',
     recommended: false },
  'no-unused-labels':
   { description: 'disallow unused labels',
     category: 'Best Practices',
     recommended: true },
  'no-useless-call':
   { description: 'disallow unnecessary calls to `.call()` and `.apply()`',
     category: 'Best Practices',
     recommended: false },
  'no-useless-concat':
   { description: 'disallow unnecessary concatenation of literals or template literals',
     category: 'Best Practices',
     recommended: false },
  'no-useless-escape':
   { description: 'disallow unnecessary escape characters',
     category: 'Best Practices',
     recommended: false },
  'no-void':
   { description: 'disallow `void` operators',
     category: 'Best Practices',
     recommended: false },
  'no-warning-comments':
   { description: 'disallow specified warning terms in comments',
     category: 'Best Practices',
     recommended: false },
  'no-with':
   { description: 'disallow `with` statements',
     category: 'Best Practices',
     recommended: false },
  radix:
   { description: 'enforce the consistent use of the radix argument when using `parseInt()`',
     category: 'Best Practices',
     recommended: false },
  'vars-on-top':
   { description: 'require `var` declarations be placed at the top of their containing scope',
     category: 'Best Practices',
     recommended: false },
  'wrap-iife':
   { description: 'require parentheses around immediate `function` invocations',
     category: 'Best Practices',
     recommended: false },
  yoda:
   { description: 'require or disallow "Yoda" conditions',
     category: 'Best Practices',
     recommended: false },
  strict:
   { description: 'require or disallow strict mode directives',
     category: 'Strict Mode',
     recommended: false },
  'init-declarations':
   { description: 'require or disallow initialization in `var` declarations',
     category: 'Variables',
     recommended: false },
  'no-catch-shadow':
   { description: 'disallow `catch` clause parameters from shadowing variables in the outer scope',
     category: 'Variables',
     recommended: false },
  'no-delete-var':
   { description: 'disallow deleting variables',
     category: 'Variables',
     recommended: true },
  'no-label-var':
   { description: 'disallow labels that share a name with a variable',
     category: 'Variables',
     recommended: false },
  'no-restricted-globals':
   { description: 'disallow specified global variables',
     category: 'Variables',
     recommended: false },
  'no-shadow':
   { description: 'disallow `var` declarations from shadowing variables in the outer scope',
     category: 'Variables',
     recommended: false },
  'no-shadow-restricted-names':
   { description: 'disallow identifiers from shadowing restricted names',
     category: 'Variables',
     recommended: false },
  'no-undef':
   { description: 'disallow the use of undeclared variables unless mentioned in `/*global */` comments',
     category: 'Variables',
     recommended: true },
  'no-undef-init':
   { description: 'disallow initializing variables to `undefined`',
     category: 'Variables',
     recommended: false },
  'no-undefined':
   { description: 'disallow the use of `undefined` as an identifier',
     category: 'Variables',
     recommended: false },
  'no-unused-vars':
   { description: 'disallow unused variables',
     category: 'Variables',
     recommended: true },
  'no-use-before-define':
   { description: 'disallow the use of variables before they are defined',
     category: 'Variables',
     recommended: false },
  'callback-return':
   { description: 'require `return` statements after callbacks',
     category: 'Node.js and CommonJS',
     recommended: false },
  'global-require':
   { description: 'require `require()` calls to be placed at top-level module scope',
     category: 'Node.js and CommonJS',
     recommended: false },
  'handle-callback-err':
   { description: 'require error handling in callbacks',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-mixed-requires':
   { description: 'disallow `require` calls to be mixed with regular `var` declarations',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-new-require':
   { description: 'disallow `new` operators with calls to `require`',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-path-concat':
   { description: 'disallow string concatenation with `__dirname` and `__filename`',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-process-env':
   { description: 'disallow the use of `process.env`',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-process-exit':
   { description: 'disallow the use of `process.exit()`',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-restricted-modules':
   { description: 'disallow specified modules when loaded by `require`',
     category: 'Node.js and CommonJS',
     recommended: false },
  'no-sync':
   { description: 'disallow synchronous methods',
     category: 'Node.js and CommonJS',
     recommended: false },
  'array-bracket-spacing':
   { description: 'enforce consistent spacing inside array brackets',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'block-spacing':
   { description: 'enforce consistent spacing inside single-line blocks',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'brace-style':
   { description: 'enforce consistent brace style for blocks',
     category: 'Stylistic Issues',
     recommended: false },
  camelcase:
   { description: 'enforce camelcase naming convention',
     category: 'Stylistic Issues',
     recommended: false },
  'comma-spacing':
   { description: 'enforce consistent spacing before and after commas',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'comma-style':
   { description: 'enforce consistent comma style',
     category: 'Stylistic Issues',
     recommended: false },
  'computed-property-spacing':
   { description: 'enforce consistent spacing inside computed property brackets',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'consistent-this':
   { description: 'enforce consistent naming when capturing the current execution context',
     category: 'Stylistic Issues',
     recommended: false },
  'eol-last':
   { description: 'enforce at least one newline at the end of files',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'func-names':
   { description: 'enforce named `function` expressions',
     category: 'Stylistic Issues',
     recommended: false },
  'func-style':
   { description: 'enforce the consistent use of either `function` declarations or expressions',
     category: 'Stylistic Issues',
     recommended: false },
  'id-blacklist':
   { description: 'disallow specified identifiers',
     category: 'Stylistic Issues',
     recommended: false },
  'id-length':
   { description: 'enforce minimum and maximum identifier lengths',
     category: 'Stylistic Issues',
     recommended: false },
  'id-match':
   { description: 'require identifiers to match a specified regular expression',
     category: 'Stylistic Issues',
     recommended: false },
  indent:
   { description: 'enforce consistent indentation',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'jsx-quotes':
   { description: 'enforce the consistent use of either double or single quotes in JSX attributes',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'key-spacing':
   { description: 'enforce consistent spacing between keys and values in object literal properties',
     category: 'Stylistic Issues',
     recommended: false },
  'keyword-spacing':
   { description: 'enforce consistent spacing before and after keywords',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'linebreak-style':
   { description: 'enforce consistent linebreak style',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'lines-around-comment':
   { description: 'require empty lines around comments',
     category: 'Stylistic Issues',
     recommended: false },
  'max-depth':
   { description: 'enforce a maximum depth that blocks can be nested',
     category: 'Stylistic Issues',
     recommended: false },
  'max-len':
   { description: 'enforce a maximum line length',
     category: 'Stylistic Issues',
     recommended: false },
  'max-nested-callbacks':
   { description: 'enforce a maximum depth that callbacks can be nested',
     category: 'Stylistic Issues',
     recommended: false },
  'max-params':
   { description: 'enforce a maximum number of parameters in `function` definitions',
     category: 'Stylistic Issues',
     recommended: false },
  'max-statements':
   { description: 'enforce a maximum number of statements allowed in `function` blocks',
     category: 'Stylistic Issues',
     recommended: false },
  'max-statements-per-line':
   { description: 'enforce a maximum number of statements allowed per line',
     category: 'Stylistic Issues',
     recommended: false },
  'new-cap':
   { description: 'require constructor `function` names to begin with a capital letter',
     category: 'Stylistic Issues',
     recommended: false },
  'new-parens':
   { description: 'require parentheses when invoking a constructor with no arguments',
     category: 'Stylistic Issues',
     recommended: false },
  'newline-after-var':
   { description: 'require or disallow an empty line after `var` declarations',
     category: 'Stylistic Issues',
     recommended: false },
  'newline-before-return':
   { description: 'require an empty line before `return` statements',
     category: 'Stylistic Issues',
     recommended: false },
  'newline-per-chained-call':
   { description: 'require a newline after each call in a method chain',
     category: 'Stylistic Issues',
     recommended: false },
  'no-array-constructor':
   { description: 'disallow `Array` constructors',
     category: 'Stylistic Issues',
     recommended: false },
  'no-bitwise':
   { description: 'disallow bitwise operators',
     category: 'Stylistic Issues',
     recommended: false },
  'no-continue':
   { description: 'disallow `continue` statements',
     category: 'Stylistic Issues',
     recommended: false },
  'no-inline-comments':
   { description: 'disallow inline comments after code',
     category: 'Stylistic Issues',
     recommended: false },
  'no-lonely-if':
   { description: 'disallow `if` statements as the only statement in `else` blocks',
     category: 'Stylistic Issues',
     recommended: false },
  'no-mixed-spaces-and-tabs':
   { description: 'disallow mixed spaces and tabs for indentation',
     category: 'Stylistic Issues',
     recommended: true },
  'no-multiple-empty-lines':
   { description: 'disallow multiple empty lines',
     category: 'Stylistic Issues',
     recommended: false },
  'no-negated-condition':
   { description: 'disallow negated conditions',
     category: 'Stylistic Issues',
     recommended: false },
  'no-nested-ternary':
   { description: 'disallow nested ternary expressions',
     category: 'Stylistic Issues',
     recommended: false },
  'no-new-object':
   { description: 'disallow `Object` constructors',
     category: 'Stylistic Issues',
     recommended: false },
  'no-plusplus':
   { description: 'disallow the unary operators `++` and `--`',
     category: 'Stylistic Issues',
     recommended: false },
  'no-restricted-syntax':
   { description: 'disallow specified syntax',
     category: 'Stylistic Issues',
     recommended: false },
  'no-spaced-func':
   { description: 'disallow spacing between `function` identifiers and their applications',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'no-ternary':
   { description: 'disallow ternary operators',
     category: 'Stylistic Issues',
     recommended: false },
  'no-trailing-spaces':
   { description: 'disallow trailing whitespace at the end of lines',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'no-underscore-dangle':
   { description: 'disallow dangling underscores in identifiers',
     category: 'Stylistic Issues',
     recommended: false },
  'no-unneeded-ternary':
   { description: 'disallow ternary operators when simpler alternatives exist',
     category: 'Stylistic Issues',
     recommended: false },
  'no-whitespace-before-property':
   { description: 'disallow whitespace before properties',
     category: 'Stylistic Issues',
     recommended: false },
  'object-curly-spacing':
   { description: 'enforce consistent spacing inside braces',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'one-var':
   { description: 'enforce variables to be declared either together or separately in functions',
     category: 'Stylistic Issues',
     recommended: false },
  'one-var-declaration-per-line':
   { description: 'require or disallow newlines around `var` declarations',
     category: 'Stylistic Issues',
     recommended: false },
  'operator-assignment':
   { description: 'require or disallow assignment operator shorthand where possible',
     category: 'Stylistic Issues',
     recommended: false },
  'operator-linebreak':
   { description: 'enforce consistent linebreak style for operators',
     category: 'Stylistic Issues',
     recommended: false },
  'padded-blocks':
   { description: 'require or disallow padding within blocks',
     category: 'Stylistic Issues',
     recommended: false },
  'quote-props':
   { description: 'require quotes around object literal property names',
     category: 'Stylistic Issues',
     recommended: false },
  quotes:
   { description: 'enforce the consistent use of either backticks, double, or single quotes',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'require-jsdoc':
   { description: 'require JSDoc comments',
     category: 'Stylistic Issues',
     recommended: false },
  semi:
   { description: 'require or disallow semicolons instead of ASI',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'semi-spacing':
   { description: 'enforce consistent spacing before and after semicolons',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'sort-imports':
   { description: 'enforce sorted import declarations within module',
     category: 'Stylistic Issues',
     recommended: false },
  'sort-vars':
   { description: 'require variables within the same declaration block to be sorted',
     category: 'Stylistic Issues',
     recommended: false },
  'space-before-blocks':
   { description: 'enforce consistent spacing before blocks',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'space-before-function-paren':
   { description: 'enforce consistent spacing before `function` definition opening parenthesis',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'space-in-parens':
   { description: 'enforce consistent spacing inside parentheses',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'space-infix-ops':
   { description: 'require spacing around operators',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'space-unary-ops':
   { description: 'enforce consistent spacing before or after unary operators',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'spaced-comment':
   { description: 'enforce consistent spacing after the `//` or `/*` in a comment',
     category: 'Stylistic Issues',
     recommended: false,
     fixable: 'whitespace' },
  'wrap-regex':
   { description: 'require parenthesis around regex literals',
     category: 'Stylistic Issues',
     recommended: false },
  'arrow-body-style':
   { description: 'require braces around arrow function bodies',
     category: 'ECMAScript 6',
     recommended: false },
  'arrow-parens':
   { description: 'require parentheses around arrow function arguments',
     category: 'ECMAScript 6',
     recommended: false },
  'arrow-spacing':
   { description: 'enforce consistent spacing before and after the arrow in arrow functions',
     category: 'ECMAScript 6',
     recommended: false,
     fixable: 'whitespace' },
  'constructor-super':
   { description: 'require `super()` calls in constructors',
     category: 'ECMAScript 6',
     recommended: true },
  'generator-star-spacing':
   { description: 'enforce consistent spacing around `*` operators in generator functions',
     category: 'ECMAScript 6',
     recommended: false,
     fixable: 'whitespace' },
  'no-class-assign':
   { description: 'disallow reassigning class members',
     category: 'ECMAScript 6',
     recommended: true },
  'no-confusing-arrow':
   { description: 'disallow arrow functions where they could be confused with comparisons',
     category: 'ECMAScript 6',
     recommended: false },
  'no-const-assign':
   { description: 'disallow reassigning `const` variables',
     category: 'ECMAScript 6',
     recommended: true },
  'no-dupe-class-members':
   { description: 'disallow duplicate class members',
     category: 'ECMAScript 6',
     recommended: true },
  'no-duplicate-imports':
   { description: 'disallow duplicate module imports',
     category: 'ECMAScript 6',
     recommended: false },
  'no-new-symbol':
   { description: 'disallow `new` operators with the `Symbol` object',
     category: 'ECMAScript 6',
     recommended: true },
  'no-restricted-imports':
   { description: 'disallow specified modules when loaded by `import`',
     category: 'ECMAScript 6',
     recommended: false },
  'no-this-before-super':
   { description: 'disallow `this`/`super` before calling `super()` in constructors',
     category: 'ECMAScript 6',
     recommended: true },
  'no-useless-constructor':
   { description: 'disallow unnecessary constructors',
     category: 'ECMAScript 6',
     recommended: false },
  'no-var':
   { description: 'require `let` or `const` instead of `var`',
     category: 'ECMAScript 6',
     recommended: false },
  'object-shorthand':
   { description: 'require or disallow method and property shorthand syntax for object literals',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-arrow-callback':
   { description: 'require arrow functions as callbacks',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-const':
   { description: 'require `const` declarations for variables that are never reassigned after declared',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-reflect':
   { description: 'require `Reflect` methods where applicable',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-rest-params':
   { description: 'require rest parameters instead of `arguments`',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-spread':
   { description: 'require spread operators instead of `.apply()`',
     category: 'ECMAScript 6',
     recommended: false },
  'prefer-template':
   { description: 'require template literals instead of string concatenation',
     category: 'ECMAScript 6',
     recommended: false },
  'require-yield':
   { description: 'require generator functions to contain `yield`',
     category: 'ECMAScript 6',
     recommended: false },
  'template-curly-spacing':
   { description: 'require or disallow spacing around embedded expressions of template strings',
     category: 'ECMAScript 6',
     recommended: false,
     fixable: 'whitespace' },
  'yield-star-spacing':
   { description: 'require or disallow spacing around the `*` in `yield*` expressions',
     category: 'ECMAScript 6',
     recommended: false,
     fixable: 'whitespace' },
  'generator-star':
   { description: 'enforce consistent positioning of the `*` in generator functions (replaced by <a href="generator-star-spacing.md">generator-star-spacing</a>)',
     category: 'Removed',
     recommended: false },
  'global-strict':
   { description: 'require or disallow `"use strict"` in the global scope (replaced by <a href="strict.md">strict</a>)',
     category: 'Removed',
     recommended: false },
  'no-arrow-condition':
   { description: 'disallow arrow functions where conditions are expected (replaced by <a href="no-confusing-arrow.md">no-confusing-arrow</a> and <a href="no-constant-condition.md">no-constant-condition</a>)',
     category: 'Removed',
     recommended: false },
  'no-comma-dangle':
   { description: 'disallow trailing commas in object literals (replaced by <a href="comma-dangle.md">comma-dangle</a>)',
     category: 'Removed',
     recommended: false },
  'no-empty-class':
   { description: 'disallow empty character classes in regular expressions (replaced by <a href="no-empty-character-class.md">no-empty-character-class</a>)',
     category: 'Removed',
     recommended: false },
  'no-empty-label':
   { description: 'disallow labels for anything other than loops and switches (replaced by <a href="no-labels.md">no-labels</a>)',
     category: 'Removed',
     recommended: false },
  'no-extra-strict':
   { description: 'disallow `"use strict";` when already in strict mode (replaced by <a href="strict.md">strict</a>)',
     category: 'Removed',
     recommended: false },
  'no-reserved-keys':
   { description: 'disallow the use of reserved words as object literal keys (replaced by <a href="quote-props.md">quote-props</a>)',
     category: 'Removed',
     recommended: false },
  'no-space-before-semi':
   { description: 'disallow spacing before semicolons (replaced by <a href="semi-spacing.md">semi-spacing</a>)',
     category: 'Removed',
     recommended: false },
  'no-wrap-func':
   { description: 'disallow parentheses around non-IIFE statements (replaced by <a href="no-extra-parens.md">no-extra-parens</a>)',
     category: 'Removed',
     recommended: false },
  'space-after-function-name':
   { description: 'enforce consistent spacing after `function` names (replaced by <a href="space-before-function-paren.md">space-before-function-paren</a>)',
     category: 'Removed',
     recommended: false },
  'space-after-keywords':
   { description: 'enforce consistent spacing after specified keywords',
     category: 'Removed',
     recommended: false,
     fixable: 'whitespace' },
  'space-before-function-parentheses':
   { description: 'enforce consistent spacing before `function` parentheses (replaced by <a href="space-before-function-paren.md">space-before-function-paren</a>)',
     category: 'Removed',
     recommended: false },
  'space-before-keywords':
   { description: 'enforce consistent spacing before specified keywords',
     category: 'Removed',
     recommended: false,
     fixable: 'whitespace' },
  'space-in-brackets':
   { description: 'enforce consistent spacing inside brackets (replaced by <a href="object-curly-spacing.md">object-curly-spacing</a> and <a href="array-bracket-spacing.md">array-bracket-spacing</a>)',
     category: 'Removed',
     recommended: false },
  'space-return-throw-case':
   { description: 'require spacing after `return`, `throw`, and `case`',
     category: 'Removed',
     recommended: false,
     fixable: 'whitespace' },
  'space-unary-word-ops':
   { description: 'enforce consistent spacing before and after unary operators (replaced by <a href="space-unary-ops.md">space-unary-ops</a>)',
     category: 'Removed',
     recommended: false },
  'spaced-line-comment':
   { description: 'enforce consistent spacing after the `//` in line comments (replaced by <a href="spaced-comment.md">spaced-comment</a>)',
     category: 'Removed',
     recommended: false }
};