feat(configuration): set js rules to all valid active rules

docs/usage/configuration/index.md

@@ -29,7 +29,7 @@ A path to a directory or an array of paths to directories of [custom rules][2].
   - A boolean value may be specified instead of the above object, and is equivalent to setting no options with default severity.
   - Any rules specified in this block will override those configured in any base configuration being extended.
   - [Check out the full rules list here][3].
-* `jsRules?: any`: Same format as `rules`. These rules are applied to `.js` and `.jsx` files.
+* `jsRules?: any | boolean`: Same format as `rules` or explicit `true` to copy all valid active rules from rules. These rules are applied to `.js` and `.jsx` files.
 * `defaultSeverity?: "error" | "warning" | "off"`: The severity level that is applied to rules in this config file as well as rules in any inherited config files which have their severity set to "default". If undefined, "error" is used as the defaultSeverity.
 * `linterOptions?: { exclude?: string[] }`:
   - `exclude: string[]`: An array of globs. Any file matching these globs will not be linted. All exclude patterns are relative to the configuration file they were specified in.

src/configuration.ts

@@ -23,6 +23,7 @@ import * as resolve from "resolve";
 import { FatalError, showWarningOnce } from "./error";
 
 import { IOptions, RuleSeverity } from "./language/rule/rule";
+import { findRule } from "./ruleLoader";
 import { arrayify, hasOwnProperty, stripComments } from "./utils";
 
 export interface IConfigurationFile {
@@ -462,7 +463,7 @@ export interface RawConfigFile {
     rulesDirectory?: string | string[];
     defaultSeverity?: string;
     rules?: RawRulesConfig;
-    jsRules?: RawRulesConfig;
+    jsRules?: RawRulesConfig | boolean;
 }
 export interface RawRulesConfig {
     [key: string]: RawRuleConfig;
@@ -510,12 +511,18 @@ export function parseConfigFile(
     }
 
     function parse(config: RawConfigFile, dir?: string): IConfigurationFile {
+        const rulesDirectory: string | string[] = getRulesDirectories(config.rulesDirectory, dir);
+        const rules = parseRules(config.rules);
+        const jsRules = typeof config.jsRules === "boolean" ?
+                            filterValidJsRules(rules, config.jsRules, rulesDirectory) :
+                            parseRules(config.jsRules);
+
         return {
             extends: arrayify(config.extends),
-            jsRules: parseRules(config.jsRules),
+            jsRules,
             linterOptions: parseLinterOptions(config.linterOptions, dir),
-            rules: parseRules(config.rules),
-            rulesDirectory: getRulesDirectories(config.rulesDirectory, dir),
+            rules,
+            rulesDirectory,
         };
     }
 
@@ -531,6 +538,24 @@ export function parseConfigFile(
         return map;
     }
 
+    function filterValidJsRules(rules: Map<string, Partial<IOptions>>,
+                                copyRulestoJsRules = false,
+                                rulesDirectory?: string | string[]): Map<string, Partial<IOptions>> {
+        const validJsRules = new Map<string, Partial<IOptions>>();
+        if (copyRulestoJsRules) {
+            rules.forEach((ruleOptions, ruleName) => {
+                if (ruleOptions.ruleSeverity !== "off") {
+                    const Rule = findRule(ruleName, rulesDirectory);
+                    if ((Rule !== undefined && (Rule.metadata === undefined || !Rule.metadata.typescriptOnly))) {
+                    validJsRules.set(ruleName, ruleOptions);
+                    }
+                }
+            });
+        }
+
+        return validJsRules;
+    }
+
     function parseLinterOptions(raw: RawConfigFile["linterOptions"], dir?: string): IConfigurationFile["linterOptions"] {
         if (raw === undefined || raw.exclude === undefined) {
             return {};

test/configurationTests.ts

@@ -119,6 +119,53 @@ describe("Configuration", () => {
                 },
             );
         });
+
+        it("parses jsRules when jsRules is a config", () => {
+            const rawConfig: RawConfigFile = {
+                jsRules: {
+                    a: true,
+                },
+            };
+
+            const expected = getEmptyConfig();
+            expected.jsRules.set("a", { ruleArguments: [], ruleSeverity: "error" });
+            assertConfigEquals(parseConfigFile(rawConfig), expected);
+        });
+
+        it("copies valid rules to jsRules when jsRules is a boolean", () => {
+            let rawConfig: RawConfigFile = {
+                jsRules: true,
+                rules: {},
+            };
+
+            const expected = getEmptyConfig();
+            assertConfigEquals(parseConfigFile(rawConfig), expected);
+
+            rawConfig = {
+                jsRules: true,
+                rules: {
+                    eofline: true,
+                },
+            };
+
+            let {rules, jsRules} = parseConfigFile(rawConfig);
+            assert.deepEqual(demap(rules), demap(jsRules));
+
+            rawConfig = {
+                jsRules: true,
+                rules: {
+                    eofline: true,
+                    typedef: true,
+                },
+            };
+
+            ({rules, jsRules} = parseConfigFile(rawConfig));
+            assert(jsRules.has("eofline"));
+            assert(!jsRules.has("typedef"));
+
+            rules.delete("typedef");
+            assert.deepEqual(demap(rules), demap(jsRules));
+        });
     });
 
     describe("defaultSeverity", () => {