Feature/convert editor settings 133 (#250)

* feat (editor): add cli option to specify editor config path to convert (defaults to vscode)

* fix (editor): remove option configuration to fix default value

* feat (editor): add editor cli option to TSLintToESLintSettings

* feat(editor): conversion of multiple configs, read config and replace

* test(editor): adjust tests to receive convertConfigs array

* style (editor): fix incorrect import statement with js ending

* fix(editor): get error return value instead of try/catch

* style: format with prettier

* fix: capture every error while processing multiple configs

* fix: log success only once

* feat(editor): add error for editor settings conversion

* feat(editor): make editor conversion extendable like rule conversion, no reporting

* refactor(editor): extract vscode settings path and editor config into new type files

* fix: remove file ending from import statement

* fix: change import of DeepPartial

* feat(editor): report converted settings

* refactor: extract general log outputs from report rules and settings convertions

* test: report setting conversion results

* test: conversion of editor.codeActions source.fixAll.tslint into eslint.autoFixOnSave

* test: convert setting

* test: convert settings, adjust missing and converted conversion results

* test: exlcude settings converters from coverage

* test: find editor configuration, stub file system

* feat: simplify convertSettings because multiple setting changes don't apply yet

* refactor: adjust naming of test variable

* test: write editor config conversion results to proper path

* test: write editor config output with sorted keys to file system

* test: conversion of editor config

* refactor: change generics into actual types

* refactor: rename converters to specific rulesConverters and settingsConverters

* test: clean up outcommented code

* fix: change ignored coverage path

* fix: add typing and dependency property name

* fix: only convert editor settings from the editor configuration

* fix: set the already converted setting properly to the conversion result (not the original setting)

* feat: use findRawConfiguration to read editor configuration with json comments

* test: adjust tests for usage of findRawConfiguration in findEditorConfiguration

* refactor: specify naming, every "setting" to be an "editorSetting"

* style: format imports

* style: change sample name of editor-setting in tests

* fix: revert removal of no-explicit-any

Author: MrCube42

jest.config.js

@@ -4,7 +4,8 @@ module.exports = {
         "!./src/**/*.d.ts",
         "!./src/**/*.stubs.ts",
         "!./src/adapters/*.ts",
-        "!./src/rules/converters.ts",
+        "!./src/rules/rulesConverters.ts",
+        "!./src/editorSettings/editorSettingsConverters.ts",
         "!./src/rules/mergers.ts",
         "!./src/cli/main.ts",
     ],

src/adapters/fileSystem.stub.ts

@@ -0,0 +1,11 @@
+export const createStubFileSystem = ({ data = {}, exists = true } = {}) => ({
+    fileExists: jest.fn().mockReturnValue(exists),
+    readFile: jest.fn().mockReturnValue(Promise.resolve(data)),
+    writeFile: jest.fn(),
+});
+
+export const createStubThrowingFileSystem = ({ err = "" } = {}) => ({
+    fileExists: jest.fn().mockRejectedValue(Promise.resolve(new Error(err))),
+    readFile: jest.fn().mockRejectedValue(Promise.resolve(new Error(err))),
+    writeFile: jest.fn().mockRejectedValue(Promise.resolve(new Error(err))),
+});

src/cli/main.ts

@@ -5,11 +5,15 @@ import { fsFileSystem } from "../adapters/fsFileSystem";
 import { nativeImporter } from "../adapters/nativeImporter";
 import { processLogger } from "../adapters/processLogger";
 import { bind } from "../binding";
-import { ConvertConfigDependencies, convertConfig } from "../conversion/convertConfig";
+import { convertConfig, ConvertConfigDependencies } from "../conversion/convertConfig";
+import {
+    convertEditorConfig,
+    ConvertEditorConfigDependencies,
+} from "../conversion/convertEditorConfig";
 import { removeExtendsDuplicatedRules } from "../creation/simplification/removeExtendsDuplicatedRules";
 import {
-    RetrieveExtendsValuesDependencies,
     retrieveExtendsValues,
+    RetrieveExtendsValuesDependencies,
 } from "../creation/simplification/retrieveExtendsValues";
 import {
     simplifyPackageRules,
@@ -19,30 +23,43 @@ import {
     writeConversionResults,
     WriteConversionResultsDependencies,
 } from "../creation/writeConversionResults";
+import { writeConversionResults as writeEditorConfigConversionResults } from "../creation/writeEditorConfigConversionResults";
+import {
+    convertEditorSettings,
+    ConvertEditorSettingsDependencies,
+} from "../editorSettings/convertEditorSettings";
+import { editorSettingsConverters } from "../editorSettings/editorSettingsConverters";
+import {
+    findEditorConfiguration,
+    FindEditorConfigurationDependencies,
+} from "../input/findEditorConfiguration";
+import { findESLintConfiguration } from "../input/findESLintConfiguration";
 import {
     findOriginalConfigurations,
     FindOriginalConfigurationsDependencies,
 } from "../input/findOriginalConfigurations";
 import { findPackagesConfiguration } from "../input/findPackagesConfiguration";
-import { findESLintConfiguration } from "../input/findESLintConfiguration";
 import { findTSLintConfiguration } from "../input/findTSLintConfiguration";
 import { findTypeScriptConfiguration } from "../input/findTypeScriptConfiguration";
 import { importer, ImporterDependencies } from "../input/importer";
 import { mergeLintConfigurations } from "../input/mergeLintConfigurations";
-import {
-    reportConversionResults,
-    ReportConversionResultsDependencies,
-} from "../reporting/reportConversionResults";
-import { converters } from "../rules/converters";
-import { convertRules } from "../rules/convertRules";
+import { ReportConversionResultsDependencies } from "../reporting/dependencies";
+import { reportConversionResults } from "../reporting/reportConversionResults";
+import { reportEditorSettingConversionResults } from "../reporting/reportEditorSettingConversionResults";
+import { convertRules, ConvertRulesDependencies } from "../rules/convertRules";
 import { mergers } from "../rules/mergers";
+import { rulesConverters } from "../rules/rulesConverters";
 import { runCli, RunCliDependencies } from "./runCli";
 
-const convertRulesDependencies = {
-    converters,
+const convertRulesDependencies: ConvertRulesDependencies = {
+    converters: rulesConverters,
     mergers,
 };
 
+const convertEditorSettingsDependencies: ConvertEditorSettingsDependencies = {
+    converters: editorSettingsConverters,
+};
+
 const nativeImporterDependencies: ImporterDependencies = {
     fileSystem: fsFileSystem,
     getCwd: () => process.cwd(),
@@ -56,6 +73,10 @@ const findConfigurationDependencies = {
     importer: boundImporter,
 };
 
+const findEditorConfigurationDependencies: FindEditorConfigurationDependencies = {
+    importer: boundImporter,
+};
+
 const findOriginalConfigurationsDependencies: FindOriginalConfigurationsDependencies = {
     findESLintConfiguration: bind(findESLintConfiguration, findConfigurationDependencies),
     findPackagesConfiguration: bind(findPackagesConfiguration, findConfigurationDependencies),
@@ -81,6 +102,19 @@ const writeConversionResultsDependencies: WriteConversionResultsDependencies = {
     fileSystem: fsFileSystem,
 };
 
+const convertEditorConfigDependencies: ConvertEditorConfigDependencies = {
+    findEditorConfiguration: bind(findEditorConfiguration, findEditorConfigurationDependencies),
+    convertEditorSettings: bind(convertEditorSettings, convertEditorSettingsDependencies),
+    reportConversionResults: bind(
+        reportEditorSettingConversionResults,
+        reportConversionResultsDependencies,
+    ),
+    writeConversionResults: bind(
+        writeEditorConfigConversionResults,
+        writeConversionResultsDependencies,
+    ),
+};
+
 const convertConfigDependencies: ConvertConfigDependencies = {
     convertRules: bind(convertRules, convertRulesDependencies),
     findOriginalConfigurations: bind(
@@ -93,7 +127,10 @@ const convertConfigDependencies: ConvertConfigDependencies = {
 };
 
 const runCliDependencies: RunCliDependencies = {
-    convertConfig: bind(convertConfig, convertConfigDependencies),
+    convertConfigs: [
+        bind(convertConfig, convertConfigDependencies),
+        bind(convertEditorConfig, convertEditorConfigDependencies),
+    ],
     logger: processLogger,
 };
 

src/cli/runCli.test.ts

@@ -8,9 +8,11 @@ import { runCli, RunCliDependencies } from "./runCli";
 const createStubArgv = (argv: string[] = []) => ["node", "some/path/bin/file", ...argv];
 
 const createStubRunCliDependencies = (
-    overrides: Partial<Pick<RunCliDependencies, "convertConfig">> = {},
+    overrides: Partial<Pick<RunCliDependencies, "convertConfigs">> = {},
 ) => ({
-    convertConfig: async (): Promise<TSLintToESLintResult> => ({ status: ResultStatus.Succeeded }),
+    convertConfigs: [
+        async (): Promise<TSLintToESLintResult> => ({ status: ResultStatus.Succeeded }),
+    ],
     logger: createStubLogger(),
     ...overrides,
 });
@@ -32,7 +34,7 @@ describe("runCli", () => {
         // Arrange
         const message = "Oh no";
         const dependencies = createStubRunCliDependencies({
-            convertConfig: () => Promise.reject(new Error(message)),
+            convertConfigs: [() => Promise.reject(new Error(message))],
         });
 
         // Act
@@ -49,11 +51,13 @@ describe("runCli", () => {
         // Arrange
         const complaint = "too much unit testing coverage";
         const dependencies = createStubRunCliDependencies({
-            convertConfig: () =>
-                Promise.resolve({
-                    complaints: [complaint],
-                    status: ResultStatus.ConfigurationError,
-                }),
+            convertConfigs: [
+                () =>
+                    Promise.resolve({
+                        complaints: [complaint],
+                        status: ResultStatus.ConfigurationError,
+                    }),
+            ],
         });
 
         // Act
@@ -72,11 +76,13 @@ describe("runCli", () => {
         // Arrange
         const error = new Error("too much unit testing coverage");
         const dependencies = createStubRunCliDependencies({
-            convertConfig: () =>
-                Promise.resolve({
-                    errors: [error],
-                    status: ResultStatus.Failed,
-                }),
+            convertConfigs: [
+                () =>
+                    Promise.resolve({
+                        errors: [error],
+                        status: ResultStatus.Failed,
+                    }),
+            ],
         });
 
         // Act
@@ -98,11 +104,13 @@ describe("runCli", () => {
             new Error("too much branch coverage"),
         ];
         const dependencies = createStubRunCliDependencies({
-            convertConfig: () =>
-                Promise.resolve({
-                    errors,
-                    status: ResultStatus.Failed,
-                }),
+            convertConfigs: [
+                () =>
+                    Promise.resolve({
+                        errors,
+                        status: ResultStatus.Failed,
+                    }),
+            ],
         });
 
         // Act
@@ -133,12 +141,14 @@ describe("runCli", () => {
     it("default output should be .eslintrc.js", async () => {
         let defaultConfig;
         const dependencies = createStubRunCliDependencies({
-            convertConfig: parsedArgs => {
-                defaultConfig = parsedArgs.config;
-                return Promise.resolve({
-                    status: ResultStatus.Succeeded,
-                });
-            },
+            convertConfigs: [
+                parsedArgs => {
+                    defaultConfig = parsedArgs.config;
+                    return Promise.resolve({
+                        status: ResultStatus.Succeeded,
+                    });
+                },
+            ],
         });
 
         const status = await runCli(dependencies, createStubArgv());

src/cli/runCli.ts

@@ -1,15 +1,16 @@
 import chalk from "chalk";
-import { EOL } from "os";
 import { Command } from "commander";
+import { EOL } from "os";
 
 import { version } from "../../package.json";
 import { Logger } from "../adapters/logger";
 import { SansDependencies } from "../binding";
 import { convertConfig } from "../conversion/convertConfig";
-import { TSLintToESLintSettings, TSLintToESLintResult, ResultStatus } from "../types";
+import { DEFAULT_VSCODE_SETTINGS_PATH } from "../input/vsCodeSettings";
+import { ResultStatus, ResultWithStatus, TSLintToESLintSettings } from "../types";
 
 export type RunCliDependencies = {
-    convertConfig: SansDependencies<typeof convertConfig>;
+    convertConfigs: SansDependencies<typeof convertConfig>[];
     logger: Logger;
 };
 
@@ -24,6 +25,11 @@ export const runCli = async (
         .option("--package [package]", "package configuration file to convert using")
         .option("--tslint [tslint]", "tslint configuration file to convert using")
         .option("--typescript [typescript]", "typescript configuration file to convert using")
+        .option(
+            "--editor [editor]",
+            "editor configuration file to convert using",
+            DEFAULT_VSCODE_SETTINGS_PATH,
+        )
         .option("-V --version", "output the package version");
 
     const parsedArgv = {
@@ -36,22 +42,38 @@ export const runCli = async (
         return ResultStatus.Succeeded;
     }
 
-    let result: TSLintToESLintResult;
+    for (const convertConfig of dependencies.convertConfigs) {
+        const result = await tryConvertConfig(convertConfig, parsedArgv);
+        if (result.status !== ResultStatus.Succeeded) {
+            logErrorResult(result, dependencies);
+            return result.status;
+        }
+    }
+
+    dependencies.logger.stdout.write(chalk.greenBright("✅ All is well! ✅\n"));
+    return ResultStatus.Succeeded;
+};
+
+const tryConvertConfig = async (
+    config: SansDependencies<typeof convertConfig>,
+    argv: Partial<TSLintToESLintSettings>,
+): Promise<ResultWithStatus> => {
+    let result: ResultWithStatus;
 
     try {
-        result = await dependencies.convertConfig(parsedArgv);
+        result = await config(argv as TSLintToESLintSettings);
     } catch (error) {
         result = {
             errors: [error as Error],
             status: ResultStatus.Failed,
         };
     }
 
-    switch (result.status) {
-        case ResultStatus.Succeeded:
-            dependencies.logger.stdout.write(chalk.greenBright("✅ All is well! ✅\n"));
-            break;
+    return result;
+};
 
+const logErrorResult = (result: ResultWithStatus, dependencies: RunCliDependencies) => {
+    switch (result.status) {
         case ResultStatus.ConfigurationError:
             dependencies.logger.stderr.write(chalk.redBright("❌ "));
             dependencies.logger.stderr.write(chalk.red("Could not start tslint-to-eslint:"));
@@ -72,6 +94,4 @@ export const runCli = async (
             }
             break;
     }
-
-    return result.status;
 };

src/conversion/conversionResults.stubs.ts

@@ -1,3 +1,4 @@
+import { EditorSettingConversionResults } from "../editorSettings/convertEditorSettings";
 import { RuleConversionResults } from "../rules/convertRules";
 
 export const createEmptyConversionResults = (
@@ -9,3 +10,12 @@ export const createEmptyConversionResults = (
     plugins: new Set(),
     ...overrides,
 });
+
+export const createEmptySettingConversionResults = (
+    overrides: Partial<EditorSettingConversionResults> = {},
+): EditorSettingConversionResults => ({
+    converted: new Map(),
+    failed: [],
+    missing: [],
+    ...overrides,
+});