typescript-eslint · JoshuaKGoldberg · Apr 25, 2020 · Apr 25, 2020
diff --git a/src/adapters/logger.stubs.ts b/src/adapters/logger.stubs.ts
@@ -40,7 +40,9 @@ const removeOddCharactersAndTrim = (text: string) =>
         .trim();
 
 export const expectEqualWrites = (fn: jest.Mock, ...actual: string[]) => {
-    const realCalls = removeOddCharactersAndTrim(fn.mock.calls.map(args => args.join("")).join(""));
+    const realCalls = removeOddCharactersAndTrim(
+        fn.mock.calls.map((args) => args.join("")).join(""),
+    );
     const actualCalls = removeOddCharactersAndTrim(actual.join(EOL) + EOL);
 
     expect(realCalls).toEqual(actualCalls);

diff --git a/src/cli/runCli.test.ts b/src/cli/runCli.test.ts
@@ -142,7 +142,7 @@ describe("runCli", () => {
         let defaultConfig;
         const dependencies = createStubRunCliDependencies({
             convertConfigs: [
-                parsedArgs => {
+                (parsedArgs) => {
                     defaultConfig = parsedArgs.config;
                     return Promise.resolve({
                         status: ResultStatus.Succeeded,

diff --git a/src/creation/eslint/createEnv.ts b/src/creation/eslint/createEnv.ts
@@ -16,7 +16,7 @@ export const createEnv = ({
     const node =
         packages === undefined ||
         [...Object.keys(packages.dependencies), ...Object.keys(packages.devDependencies)].some(
-            dependency => dependency.toLowerCase() === "@types/node",
+            (dependency) => dependency.toLowerCase() === "@types/node",
         );
 
     return {

diff --git a/src/creation/formatConvertedRules.ts b/src/creation/formatConvertedRules.ts
@@ -8,9 +8,9 @@ export const formatConvertedRules = (
     tslintConfiguration: TSLintConfiguration,
 ) => {
     const output: { [i: string]: string | any[] } = {};
-    const sortedRuleEntries = Array.from(conversionResults.converted).sort(
-        ([ruleNameA], [ruleNameB]) => ruleNameA.localeCompare(ruleNameB),
-    );
+    const sortedRuleEntries = Array.from(
+        conversionResults.converted,
+    ).sort(([ruleNameA], [ruleNameB]) => ruleNameA.localeCompare(ruleNameB));
 
     for (const [ruleName, rule] of sortedRuleEntries) {
         output[ruleName] = formatConvertedRule(rule);

diff --git a/src/creation/simplification/resolveExtensionNames.ts b/src/creation/simplification/resolveExtensionNames.ts
@@ -3,7 +3,7 @@ export const resolveExtensionNames = (rawExtensionNames: string | string[]) => {
         rawExtensionNames = [rawExtensionNames];
     }
 
-    return rawExtensionNames.map(rawExtensionName =>
+    return rawExtensionNames.map((rawExtensionName) =>
         rawExtensionName.startsWith(".") ||
         rawExtensionName.startsWith("eslint-plugin-") ||
         rawExtensionName.startsWith("eslint:") ||

diff --git a/src/creation/simplification/retrieveExtendsValues.ts b/src/creation/simplification/retrieveExtendsValues.ts
@@ -45,7 +45,7 @@ export const retrieveExtendsValues = async (
     const extensionNames = resolveExtensionNames(rawExtensionNames);
 
     await Promise.all(
-        extensionNames.map(async extensionName => {
+        extensionNames.map(async (extensionName) => {
             const builtInExtension = builtInExtensions.get(extensionName);
             if (builtInExtension !== undefined) {
                 importedExtensions.push(

diff --git a/src/editorSettings/converters/editor-code-actions-on-save.ts b/src/editorSettings/converters/editor-code-actions-on-save.ts
@@ -2,7 +2,9 @@ import { EditorSettingConverter } from "../converter";
 
 const SUB_SETTING_SOURCE_FIXALL = "source.fixAll.tslint";
 
-export const convertEditorCodeActionsOnSave: EditorSettingConverter = originalCodeActionsOnSave => {
+export const convertEditorCodeActionsOnSave: EditorSettingConverter = (
+    originalCodeActionsOnSave,
+) => {
     // Split properties to replace (into parent) and original ones.
     const {
         [SUB_SETTING_SOURCE_FIXALL]: originalSourceFixAllTsLint,

diff --git a/src/input/importer.ts b/src/input/importer.ts
@@ -48,7 +48,7 @@ export const importer = async (
 
     return new Error(
         `Could not find '${moduleName}' after trying: ${pathAttempts
-            .map(attempt => `'${attempt}'`)
+            .map((attempt) => `'${attempt}'`)
             .join(", ")}`,
     );
 };
diff --git a/src/reporting/reportConversionResults.ts b/src/reporting/reportConversionResults.ts
@@ -52,7 +52,7 @@ type RuleWithNotices = {
 
 const logNotices = (converted: Map<string, ESLintRuleOptions>, logger: Logger) => {
     const rulesWithNotices = Array.from(converted.values()).filter(
-        ruleOptions => ruleOptions.notices && ruleOptions.notices.length >= 1,
+        (ruleOptions) => ruleOptions.notices && ruleOptions.notices.length >= 1,
     ) as RuleWithNotices[];
 
     if (rulesWithNotices.length !== 0) {

diff --git a/src/reporting/reportOutputs.ts b/src/reporting/reportOutputs.ts
@@ -27,7 +27,7 @@ export const logFailedConversions = (failed: ErrorSummary[], logger: Logger) =>
     logger.stderr.write(chalk.red(` error${failed.length === 1 ? "" : "s"}`));
     logger.stderr.write(chalk.red(" thrown."));
     logger.stderr.write(chalk.redBright(` ❌${EOL}`));
-    logger.info.write(failed.map(failed => failed.getSummary()).join("\n\n") + "\n\n");
+    logger.info.write(failed.map((failed) => failed.getSummary()).join("\n\n") + "\n\n");
     logger.stderr.write(chalk.gray(`  Check ${logger.debugFileName} for details.${EOL}`));
 };
 
@@ -60,7 +60,7 @@ export const logMissingConversionTarget = <T>(
     }
 
     logger.info.write(
-        chalk.yellow(missing.map(conversion => missingOutputMapping(conversion)).join("")),
+        chalk.yellow(missing.map((conversion) => missingOutputMapping(conversion)).join("")),
     );
     logger.stdout.write(chalk.yellow(EOL));
 };
@@ -74,7 +74,7 @@ export const logMissingPlugins = (plugins: Set<string>, logger: Logger) => {
 
     logger.stdout.write(
         Array.from(plugins)
-            .map(pluginName => `  ${chalk.cyanBright(pluginName)}${EOL}`)
+            .map((pluginName) => `  ${chalk.cyanBright(pluginName)}${EOL}`)
             .join(""),
     );
     logger.stdout.write(EOL);

diff --git a/src/rules/converters/align.ts b/src/rules/converters/align.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertAlign: RuleConverter = tslintRule => {
+export const convertAlign: RuleConverter = (tslintRule) => {
     const alignArguments = tslintRule.ruleArguments.includes("arguments");
     const alignElements = tslintRule.ruleArguments.includes("elements");
     const alignMembers = tslintRule.ruleArguments.includes("members");

diff --git a/src/rules/converters/array-type.ts b/src/rules/converters/array-type.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertArrayType: RuleConverter = tslintRule => {
+export const convertArrayType: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/arrow-parens.ts b/src/rules/converters/arrow-parens.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertArrowParens: RuleConverter = tslintRule => {
+export const convertArrowParens: RuleConverter = (tslintRule) => {
     const ruleArguments = [
         tslintRule.ruleArguments.length !== 0 &&
         tslintRule.ruleArguments[0] === "ban-single-arg-parens"

diff --git a/src/rules/converters/arrow-return-shorthand.ts b/src/rules/converters/arrow-return-shorthand.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertArrowReturnShorthand: RuleConverter = tslintRule => {
+export const convertArrowReturnShorthand: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/ban-types.ts b/src/rules/converters/ban-types.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertBanTypes: RuleConverter = tslintRule => {
+export const convertBanTypes: RuleConverter = (tslintRule) => {
     type ConvertBanTypeArgument = {
         message: string;
     };

diff --git a/src/rules/converters/comment-format.ts b/src/rules/converters/comment-format.ts
@@ -7,7 +7,7 @@ type CommentFormatOptions = {
 
 export const CapitalizedIgnoreMessage = "Only accepts a single string pattern to be ignored.";
 
-export const convertCommentFormat: RuleConverter = tslintRule => {
+export const convertCommentFormat: RuleConverter = (tslintRule) => {
     const capitalizedRuleArguments: string[] = [];
     const spaceCommentRuleArguments: string[] = [];
     const capitalizedNotices: string[] = [];

diff --git a/src/rules/converters/curly.ts b/src/rules/converters/curly.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertCurly: RuleConverter = tslintRule => {
+export const convertCurly: RuleConverter = (tslintRule) => {
     const ruleArguments: string[] = [];
 
     if (tslintRule.ruleArguments.includes("ignore-same-line")) {

diff --git a/src/rules/converters/cyclomatic-complexity.ts b/src/rules/converters/cyclomatic-complexity.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertCyclomaticComplexity: RuleConverter = tslintRule => {
+export const convertCyclomaticComplexity: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/file-name-casing.ts b/src/rules/converters/file-name-casing.ts
@@ -10,7 +10,7 @@ const CASES_MAP: { [s: string]: string } = {
     "snake-case": "snakeCase",
 };
 
-export const convertFileNameCasing: RuleConverter = tslintRule => {
+export const convertFileNameCasing: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/increment-decrement.ts b/src/rules/converters/increment-decrement.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertIncrementDecrement: RuleConverter = tslintRule => {
+export const convertIncrementDecrement: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/indent.ts b/src/rules/converters/indent.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertIndent: RuleConverter = tslintRule => {
+export const convertIndent: RuleConverter = (tslintRule) => {
     let indentSize: number | string = 4; // @typescript-eslint/indent default
 
     if (tslintRule.ruleArguments[0] === "tabs") {

diff --git a/src/rules/converters/jsdoc-format.ts b/src/rules/converters/jsdoc-format.ts
@@ -10,7 +10,7 @@ export const convertJSDocFormat: RuleConverter = () => {
         "jsdoc/newline-after-description",
     ];
 
-    const mappedRuleNames: ConvertedRuleChanges[] = ruleNames.map(ruleName => {
+    const mappedRuleNames: ConvertedRuleChanges[] = ruleNames.map((ruleName) => {
         return { ruleName };
     });
 

diff --git a/src/rules/converters/linebreak-style.ts b/src/rules/converters/linebreak-style.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertLinebreakStyle: RuleConverter = tslintRule => {
+export const convertLinebreakStyle: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/max-classes-per-file.ts b/src/rules/converters/max-classes-per-file.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertMaxClassesPerFile: RuleConverter = tslintRule => {
+export const convertMaxClassesPerFile: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/max-file-line-count.ts b/src/rules/converters/max-file-line-count.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertMaxFileLineCount: RuleConverter = tslintRule => {
+export const convertMaxFileLineCount: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/max-line-length.ts b/src/rules/converters/max-line-length.ts
@@ -1,43 +1,43 @@
-import { RuleConverter } from "../converter";
-
-export const convertMaxLineLength: RuleConverter = tslintRule => {
-    return {
-        rules: [
-            {
-                ...collectArguments(tslintRule.ruleArguments),
-                ruleName: "max-len",
-            },
-        ],
-    };
-};
-
-const collectArguments = (ruleArguments: any[]) => {
-    if (ruleArguments.length === 0) {
-        return undefined;
-    }
-
-    const argument = ruleArguments[0];
-
-    if (typeof argument === "number") {
-        return {
-            ruleArguments: [
-                {
-                    code: argument,
-                },
-            ],
-        };
-    }
-
-    return {
-        ruleArguments: [
-            {
-                ...("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 }),
-            },
-        ],
-    };
-};
+import { RuleConverter } from "../converter";
+
+export const convertMaxLineLength: RuleConverter = (tslintRule) => {
+    return {
+        rules: [
+            {
+                ...collectArguments(tslintRule.ruleArguments),
+                ruleName: "max-len",
+            },
+        ],
+    };
+};
+
+const collectArguments = (ruleArguments: any[]) => {
+    if (ruleArguments.length === 0) {
+        return undefined;
+    }
+
+    const argument = ruleArguments[0];
+
+    if (typeof argument === "number") {
+        return {
+            ruleArguments: [
+                {
+                    code: argument,
+                },
+            ],
+        };
+    }
+
+    return {
+        ruleArguments: [
+            {
+                ...("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 }),
+            },
+        ],
+    };
+};
diff --git a/src/rules/converters/member-access.ts b/src/rules/converters/member-access.ts
@@ -17,7 +17,7 @@ type MemberAccessSchema = {
     overrides?: Record<string, string>;
 };
 
-export const convertMemberAccess: RuleConverter = tslintRule => {
+export const convertMemberAccess: RuleConverter = (tslintRule) => {
     const schema: MemberAccessSchema = {
         accessibility: AccessibilityLevel.Explicit,
     };

diff --git a/src/rules/converters/no-async-without-await.ts b/src/rules/converters/no-async-without-await.ts
@@ -1,11 +1,11 @@
-import { RuleConverter } from "../converter";
-
-export const convertNoAsyncWithoutAwait: RuleConverter = () => {
-    return {
-        rules: [
-            {
-                ruleName: "@typescript-eslint/require-await",
-            },
-        ],
-    };
-};
+import { RuleConverter } from "../converter";
+
+export const convertNoAsyncWithoutAwait: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "@typescript-eslint/require-await",
+            },
+        ],
+    };
+};
diff --git a/src/rules/converters/no-consecutive-blank-lines.ts b/src/rules/converters/no-consecutive-blank-lines.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertNoConsecutiveBlankLines: RuleConverter = tslintRule => {
+export const convertNoConsecutiveBlankLines: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {

diff --git a/src/rules/converters/no-console.ts b/src/rules/converters/no-console.ts
@@ -1,6 +1,6 @@
 import { RuleConverter } from "../converter";
 
-export const convertNoConsole: RuleConverter = tslintRule => {
+export const convertNoConsole: RuleConverter = (tslintRule) => {
     return {
         rules: [
             {
@@ -9,7 +9,7 @@ export const convertNoConsole: RuleConverter = tslintRule => {
                     ruleArguments: [
                         {
                             allow: Object.keys(console).filter(
-                                method => !tslintRule.ruleArguments.includes(method),
+                                (method) => !tslintRule.ruleArguments.includes(method),
                             ),
                         },
                     ],