Fixed crash when ESLint rule has multiple rule arguments (#586)

Author: Josh Goldberg

src/creation/summarization/normalizeESLintRules.test.ts

@@ -15,6 +15,30 @@ describe("normalizeESLintRules", () => {
         expect(result).toEqual(new Map());
     });
 
+    it("converts a rule when given as a severity level", () => {
+        // Arrange
+        const userRules: ESLintConfigurationRules = {
+            [ruleName]: "error",
+        };
+
+        // Act
+        const result = normalizeESLintRules(userRules);
+
+        // Assert
+        expect(result).toEqual(
+            new Map([
+                [
+                    ruleName,
+                    {
+                        ruleArguments: [{}],
+                        ruleName: "rule-a",
+                        ruleSeverity: "error",
+                    },
+                ],
+            ]),
+        );
+    });
+
     it("converts a rule when given as an array", () => {
         // Arrange
         const userRules: ESLintConfigurationRules = {
@@ -30,7 +54,7 @@ describe("normalizeESLintRules", () => {
                 [
                     ruleName,
                     {
-                        ruleArguments: {},
+                        ruleArguments: [{}],
                         ruleName: "rule-a",
                         ruleSeverity: "error",
                     },
@@ -39,10 +63,10 @@ describe("normalizeESLintRules", () => {
         );
     });
 
-    it("converts a rule when given as a severity level", () => {
+    it("converts a rule when given as an array with multiple arguments", () => {
         // Arrange
         const userRules: ESLintConfigurationRules = {
-            [ruleName]: "error",
+            [ruleName]: ["error", 4, { value: true }],
         };
 
         // Act
@@ -54,7 +78,7 @@ describe("normalizeESLintRules", () => {
                 [
                     ruleName,
                     {
-                        ruleArguments: {},
+                        ruleArguments: [4, { value: true }],
                         ruleName: "rule-a",
                         ruleSeverity: "error",
                     },

src/creation/summarization/normalizeESLintRules.ts

@@ -1,5 +1,8 @@
-import { ESLintConfigurationRules } from "../../input/findESLintConfiguration";
-import { ESLintRuleOptions } from "../../rules/types";
+import {
+    ESLintConfigurationRules,
+    ESLintConfigurationRuleValue,
+} from "../../input/findESLintConfiguration";
+import { ESLintRuleOptions, RawESLintRuleSeverity } from "../../rules/types";
 import { normalizeRawESLintRuleSeverity } from "../pruning/normalizeRawESLintRuleSeverity";
 
 /**
@@ -8,13 +11,20 @@ import { normalizeRawESLintRuleSeverity } from "../pruning/normalizeRawESLintRul
 export const normalizeESLintRules = (userRules: ESLintConfigurationRules | undefined) => {
     const output: Map<string, ESLintRuleOptions> = new Map();
 
-    for (const [ruleName, configuration] of Object.entries(userRules ?? {})) {
-        const [rawRuleSeverity, ruleArguments] =
-            configuration instanceof Array ? configuration : [configuration, {}];
+    for (const [ruleName, rawRuleValue] of Object.entries(userRules ?? {})) {
+        const [rawRuleSeverity, ruleArguments] = parseRawRuleValue(rawRuleValue);
         const ruleSeverity = normalizeRawESLintRuleSeverity(rawRuleSeverity);
 
         output.set(ruleName, { ruleArguments, ruleName, ruleSeverity });
     }
 
     return output;
 };
+
+const parseRawRuleValue = (
+    configuration: ESLintConfigurationRuleValue,
+): [RawESLintRuleSeverity, any[]] => {
+    return configuration instanceof Array
+        ? [configuration[0], configuration.slice(1)]
+        : [configuration, [{}]];
+};

src/creation/writeConversionResults.ts

@@ -34,10 +34,7 @@ export const writeConversionResults = async (
             sourceType: "module",
         },
         plugins,
-        rules: {
-            // ...trimESLintRules(eslint?.full.rules, summarizedResults.extensionRules),
-            ...formatConvertedRules(summarizedResults, tslint.full),
-        },
+        rules: formatConvertedRules(summarizedResults, tslint.full),
     });
 
     return await dependencies.fileSystem.writeFile(outputPath, formatOutput(outputPath, output));

src/input/findESLintConfiguration.ts

@@ -21,8 +21,7 @@ export type ESLintConfigurationRules = {
 
 export type ESLintConfigurationRuleValue =
     | RawESLintRuleSeverity
-    | [RawESLintRuleSeverity]
-    | [RawESLintRuleSeverity, any];
+    | [RawESLintRuleSeverity, ...any[]];
 
 const defaultESLintConfiguration = {
     env: {},