Standardized around alphabetization and blank arrays (#259)

* Standardized around alphabetization and blank arrays

* Dialed back on a triple-equals change

Author: Josh Goldberg

src/reporting/reportConversionResults.ts

@@ -100,7 +100,7 @@ const logNotices = (converted: Map<string, ESLintRuleOptions>, logger: Logger) =
         ruleOptions => ruleOptions.notices && ruleOptions.notices.length >= 1,
     ) as RuleWithNotices[];
 
-    if (rulesWithNotices.length > 0) {
+    if (rulesWithNotices.length !== 0) {
         logger.stdout.write(chalk.yellowBright(`📢 ${rulesWithNotices.length} ESLint`));
         logger.stdout.write(
             chalk.yellowBright(rulesWithNotices.length === 1 ? ` rule behaves` : ` rules behave`),
@@ -109,11 +109,12 @@ const logNotices = (converted: Map<string, ESLintRuleOptions>, logger: Logger) =
             chalk.yellowBright(` differently from their TSLint counterparts: 📢${EOL}`),
         );
 
-        rulesWithNotices.forEach(rule => {
+        for (const rule of rulesWithNotices) {
             logger.stdout.write(chalk.yellow(`* ${rule.ruleName}:${EOL}`));
-            rule.notices.forEach(notice => {
+
+            for (const notice of rule.notices) {
                 logger.stdout.write(chalk.yellow(`  - ${notice}${EOL}`));
-            });
-        });
+            }
+        }
     }
 };

src/rules/converters/comment-format.ts

@@ -12,17 +12,13 @@ export const convertCommentFormat: RuleConverter = tslintRule => {
     const spaceCommentRuleArguments: string[] = [];
     const capitalizedNotices: string[] = [];
 
-    const hasCheckSpace = tslintRule.ruleArguments.includes("check-space");
-    const hasCheckLowercase = tslintRule.ruleArguments.includes("check-lowercase");
-    const hasCheckUppercase = tslintRule.ruleArguments.includes("check-uppercase");
-
-    if (!hasCheckSpace) {
+    if (!tslintRule.ruleArguments.includes("check-space")) {
         spaceCommentRuleArguments.push("never");
     }
 
-    if (hasCheckUppercase) {
+    if (tslintRule.ruleArguments.includes("check-uppercase")) {
         capitalizedRuleArguments.push("always");
-    } else if (hasCheckLowercase) {
+    } else if (tslintRule.ruleArguments.includes("check-lowercase")) {
         capitalizedRuleArguments.push("never");
     }
 
@@ -41,12 +37,16 @@ export const convertCommentFormat: RuleConverter = tslintRule => {
         rules: [
             {
                 ruleName: "capitalized-comments",
-                ruleArguments: capitalizedRuleArguments,
-                notices: capitalizedNotices,
+                ...(capitalizedRuleArguments.length !== 0 && {
+                    ruleArguments: capitalizedRuleArguments,
+                }),
+                ...(capitalizedNotices.length !== 0 && { notices: capitalizedNotices }),
             },
             {
                 ruleName: "spaced-comment",
-                ruleArguments: spaceCommentRuleArguments,
+                ...(spaceCommentRuleArguments.length !== 0 && {
+                    ruleArguments: spaceCommentRuleArguments,
+                }),
             },
         ],
     };

src/rules/converters/curly.ts

@@ -12,6 +12,11 @@ export const convertCurly: RuleConverter = tslintRule => {
     }
 
     return {
-        rules: [{ ruleArguments, ruleName: "curly" }],
+        rules: [
+            {
+                ...(ruleArguments.length !== 0 && { ruleArguments }),
+                ruleName: "curly",
+            },
+        ],
     };
 };

src/rules/converters/file-name-casing.ts

@@ -24,7 +24,7 @@ export const convertFileNameCasing: RuleConverter = tslintRule => {
 
 const collectArguments = (ruleArguments: any[]) => {
     const notices: string[] = [];
-    const foundCases: { [k: string]: boolean } = {};
+    const cases: Record<string, boolean> = {};
 
     if (ruleArguments.length === 0 || ruleArguments[0] === false || ruleArguments.length < 2) {
         return undefined;
@@ -35,7 +35,7 @@ const collectArguments = (ruleArguments: any[]) => {
         if (casings === "ignore") {
             notices.push(IGNORE_CASE_NOTICE);
         } else {
-            foundCases[CASES_MAP[casings]] = true;
+            cases[CASES_MAP[casings]] = true;
         }
     }
 
@@ -45,17 +45,19 @@ const collectArguments = (ruleArguments: any[]) => {
             if (casings[casing] === "ignore") {
                 notices.push(IGNORE_CASE_NOTICE);
             } else {
-                foundCases[CASES_MAP[casings[casing]]] = true;
+                cases[CASES_MAP[casings[casing]]] = true;
             }
         }
     }
 
     return {
-        ...(notices.length > 0 && { notices }),
-        ruleArguments: [
-            {
-                cases: foundCases,
-            },
-        ],
+        ...(notices.length !== 0 && { notices }),
+        ...(Object.keys(cases).length !== 0 && {
+            ruleArguments: [
+                {
+                    cases,
+                },
+            ],
+        }),
     };
 };

src/rules/converters/max-line-length.ts

@@ -31,12 +31,12 @@ const collectArguments = (ruleArguments: any[]) => {
     return {
         ruleArguments: [
             {
-                ...("limit" in argument && { code: argument.limit }),
-                ...("ignore-pattern" in argument && { ignorePattern: argument["ignore-pattern"] }),
-                ...("check-strings" in argument && { ignoreStrings: !argument["check-strings"] }),
                 ...("check-regex" in argument && {
                     ignoreRegExpLiterals: !argument["check-regex"],
                 }),
+                ...("check-strings" in argument && { ignoreStrings: !argument["check-strings"] }),
+                ...("ignore-pattern" in argument && { ignorePattern: argument["ignore-pattern"] }),
+                ...("limit" in argument && { code: argument.limit }),
             },
         ],
     };

src/rules/converters/member-access.ts

@@ -14,17 +14,16 @@ export enum MemberAccessArguments {
 
 type MemberAccessSchema = {
     accessibility: string;
-    overrides?: { [key: string]: string };
+    overrides?: Record<string, string>;
 };
 
 export const convertMemberAccess: RuleConverter = tslintRule => {
-    const tslintRuleArguments = tslintRule.ruleArguments;
     const schema: MemberAccessSchema = {
         accessibility: AccessibilityLevel.Explicit,
     };
 
-    if (tslintRuleArguments.length >= 2 || tslintRuleArguments[0] === true) {
-        tslintRuleArguments.forEach(ruleArg => {
+    if (tslintRule.ruleArguments.length >= 2 || tslintRule.ruleArguments[0] === true) {
+        for (const ruleArg of tslintRule.ruleArguments) {
             if (typeof ruleArg === "string") {
                 switch (ruleArg) {
                     case MemberAccessArguments.NoPublic:
@@ -50,14 +49,14 @@ export const convertMemberAccess: RuleConverter = tslintRule => {
                         break;
                 }
             }
-        });
+        }
     }
 
     return {
         rules: [
             {
-                ruleName: "@typescript-eslint/explicit-member-accessibility",
                 ruleArguments: [schema],
+                ruleName: "@typescript-eslint/explicit-member-accessibility",
             },
         ],
     };

src/rules/converters/no-empty.ts

@@ -23,9 +23,9 @@ const convertNoEmptyRule = (tslintRule: RuleConverterOptions) => {
 };
 
 const convertNoEmptyFunctionRule = (tslintRule: RuleConverterOptions) => {
-    return !tslintRule.ruleArguments.includes("allow-empty-functions")
-        ? {
+    return tslintRule.ruleArguments.includes("allow-empty-functions")
+        ? undefined
+        : {
               ruleName: "@typescript-eslint/no-empty-function",
-          }
-        : undefined;
+          };
 };

src/rules/converters/no-implicit-dependencies.ts

@@ -1,27 +1,29 @@
 import { RuleConverter } from "../converter";
 
+type ExtraneousDependenciesArgument = Partial<
+    Record<"devDependencies" | "optionalDependencies", boolean>
+>;
+
 export const convertNoImplicitDependencies: RuleConverter = tslintRule => {
-    const ruleArgs: {
-        [eslintOption in "devDependencies" | "optionalDependencies"]?: boolean;
-    }[] = [];
+    const ruleArguments: ExtraneousDependenciesArgument[] = [];
     const notices: string[] = [];
 
-    tslintRule.ruleArguments.forEach(element => {
+    for (const element of tslintRule.ruleArguments) {
         if (element === "dev") {
-            ruleArgs.push({ devDependencies: false });
+            ruleArguments.push({ devDependencies: false });
         } else if (element === "optional") {
-            ruleArgs.push({ optionalDependencies: false });
+            ruleArguments.push({ optionalDependencies: false });
         } else {
             notices.push("ESLint does not support whitelisting modules");
         }
-    });
+    }
 
     return {
         rules: [
             {
+                ...(notices.length !== 0 && { notices }),
+                ...(ruleArguments.length !== 0 && { ruleArguments }),
                 ruleName: "import/no-extraneous-dependencies",
-                ...(ruleArgs.length > 0 && { ruleArguments: ruleArgs }),
-                ...(notices.length > 0 && { notices }),
             },
         ],
 

src/rules/converters/no-import-side-effect.ts

@@ -1,20 +1,15 @@
 import { RuleConverter } from "../converter";
 
 export const convertNoImportSideEffect: RuleConverter = tsLintRule => {
-    const notices = [];
-
-    if (tsLintRule.ruleArguments.length > 0) {
-        notices.push(
-            "ESLint's no-import-side-effect now accepts a glob pattern for ignores; you'll need to manually convert your ignore-module settings.",
-        );
-    }
-
     return {
         rules: [
             {
-                ruleArguments: [],
                 ruleName: "no-import-side-effect",
-                notices: notices,
+                ...(tsLintRule.ruleArguments.length !== 0 && {
+                    notices: [
+                        "ESLint's no-import-side-effect now accepts a glob pattern for ignores; you'll need to manually convert your ignore-module settings.",
+                    ],
+                }),
             },
         ],
     };

src/rules/converters/no-magic-numbers.ts

@@ -26,14 +26,12 @@ const collectArgumentsAndNotices = (ruleArguments: any[]) => {
         };
     }
 
-    const [argument] = ruleArguments;
-
     return {
-        ...("ignore-jsx" in argument && {
+        ...("ignore-jsx" in ruleArguments[0] && {
             notices: ["JSX syntax will no longer be ignored."],
         }),
-        ...("allowed-numbers" in argument && {
-            ruleArguments: [{ ignore: argument["allowed-numbers"] }],
+        ...("allowed-numbers" in ruleArguments[0] && {
+            ruleArguments: [{ ignore: ruleArguments[0]["allowed-numbers"] }],
         }),
     };
 };