Factor in 'raw' configurations on top of 'reported' ones

package.json

@@ -9,6 +9,7 @@
     "dependencies": {
         "chalk": "2.4.2",
         "commander": "3.0.2",
+        "strip-json-comments": "^3.0.1",
         "tslint": "5.20.0",
         "typescript": "3.6.3"
     },

src/adapters/importer.ts → src/adapters/nativeImporter.ts

@@ -1,4 +1,4 @@
-export type Importer = (moduleName: string) => unknown | Error;
+export type NativeImporter = (moduleName: string) => unknown | Error;
 
 export const nativeImporter = async (moduleName: string) => {
     try {

src/cli/main.ts

@@ -1,9 +1,9 @@
 import { EOL } from "os";
 
-import { nativeImporter } from "../adapters/importer";
-import { processLogger } from "../adapters/processLogger";
 import { childProcessExec } from "../adapters/childProcessExec";
 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 { removeExtendsDuplicatedRules } from "../creation/simplification/removeExtendsDuplicatedRules";
@@ -27,6 +27,7 @@ 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,
@@ -42,8 +43,17 @@ const convertRulesDependencies = {
     mergers,
 };
 
+const nativeImporterDependencies: ImporterDependencies = {
+    fileSystem: fsFileSystem,
+    getCwd: () => process.cwd(),
+    nativeImporter: nativeImporter,
+};
+
+const boundImporter = bind(importer, nativeImporterDependencies);
+
 const findConfigurationDependencies = {
     exec: childProcessExec,
+    importer: boundImporter,
 };
 
 const findOriginalConfigurationsDependencies: FindOriginalConfigurationsDependencies = {
@@ -59,7 +69,7 @@ const reportConversionResultsDependencies: ReportConversionResultsDependencies =
 };
 
 const retrieveExtendsValuesDependencies: RetrieveExtendsValuesDependencies = {
-    importer: nativeImporter,
+    importer: boundImporter,
 };
 
 const simplifyPackageRulesDependencies: SimplifyPackageRulesDependencies = {

src/conversion/convertConfig.test.ts

@@ -21,8 +21,11 @@ const createStubDependencies = (
 
 const createStubOriginalConfigurationsData = () => ({
     tslint: {
-        rules: [],
-        rulesDirectory: [],
+        full: {
+            rules: [],
+            rulesDirectory: [],
+        },
+        raw: {},
     },
 });
 

src/conversion/convertConfig.ts

@@ -30,7 +30,7 @@ export const convertConfig = async (
 
     // 2. TSLint rules are converted into their ESLint configurations
     const ruleConversionResults = dependencies.convertRules(
-        originalConfigurations.data.tslint.rules,
+        originalConfigurations.data.tslint.full.rules,
     );
 
     // 3. ESLint configurations are simplified based on extended ESLint presets

src/creation/eslint/createEnv.ts

@@ -1,9 +1,9 @@
-import { OriginalConfigurations } from "../../input/findOriginalConfigurations";
+import { AllOriginalConfigurations } from "../../input/findOriginalConfigurations";
 
 export const createEnv = ({
     packages,
     typescript,
-}: Pick<OriginalConfigurations, "packages" | "typescript">) => {
+}: Pick<AllOriginalConfigurations, "packages" | "typescript">) => {
     const browser =
         typescript === undefined ||
         typescript.compilerOptions.lib === undefined ||

src/creation/formatting/formatters/formatJsOutput.ts

@@ -1,4 +1,7 @@
 import { EOL } from "os";
 
-export const formatJsOutput = (configuration: unknown) =>
-    `module.exports = ${JSON.stringify(configuration, undefined, 4)};${EOL}`;
+import { withKeysSorted } from "./withKeysSorted";
+
+export const formatJsOutput = (configuration: any) => {
+    return `module.exports = ${JSON.stringify(withKeysSorted(configuration), undefined, 4)};${EOL}`;
+};

src/creation/formatting/formatters/formatJsonOutput.ts

@@ -1,4 +1,7 @@
 import { EOL } from "os";
 
-export const formatJsonOutput = (configuration: unknown) =>
-    `${JSON.stringify(configuration, undefined, 4)}${EOL}`;
+import { withKeysSorted } from "./withKeysSorted";
+
+export const formatJsonOutput = (configuration: any) => {
+    return `${JSON.stringify(withKeysSorted(configuration), undefined, 4)}${EOL}`;
+};

src/creation/formatting/formatters/withKeysSorted.ts

@@ -0,0 +1,7 @@
+export const withKeysSorted = (input: any) => {
+    return Object.fromEntries(
+        Object.keys(input)
+            .sort((a, b) => a.localeCompare(b))
+            .map(key => [key, input[key]]),
+    );
+};

src/creation/simplification/retrieveExtendsValues.ts

@@ -1,31 +1,18 @@
-import { Importer } from "../../adapters/importer";
+import { SansDependencies } from "../../binding";
 import { ConfigurationError } from "../../errors/configurationError";
 import { ESLintConfiguration } from "../../input/findESLintConfiguration";
+import { importer } from "../../input/importer";
 import { resolveExtensionNames } from "./resolveExtensionNames";
 
 export type RetrieveExtendsValuesDependencies = {
-    importer: Importer;
+    importer: SansDependencies<typeof importer>;
 };
 
 export type RetrievedExtensionValues = {
     configurationErrors: ConfigurationError[];
     importedExtensions: Partial<ESLintConfiguration>[];
 };
 
-const builtInExtensionGetters = new Map<
-    string,
-    (importer: Importer) => Promise<ESLintConfiguration>
->([
-    [
-        "eslint:all",
-        async importer => (await importer("eslint/conf/eslint-all")) as ESLintConfiguration,
-    ],
-    [
-        "eslint:recommended",
-        async importer => (await importer("eslint/conf/eslint-recommended")) as ESLintConfiguration,
-    ],
-]);
-
 export const retrieveExtendsValues = async (
     dependencies: RetrieveExtendsValuesDependencies,
     rawExtensionNames: string | string[],
@@ -34,11 +21,26 @@ export const retrieveExtendsValues = async (
     const configurationErrors: ConfigurationError[] = [];
     const extensionNames = resolveExtensionNames(rawExtensionNames);
 
+    const builtInExtensionGetters = new Map<string, () => Promise<ESLintConfiguration>>([
+        [
+            "eslint:all",
+            async () =>
+                (await dependencies.importer("eslint/conf/eslint-all")) as ESLintConfiguration,
+        ],
+        [
+            "eslint:recommended",
+            async () =>
+                (await dependencies.importer(
+                    "eslint/conf/eslint-recommended",
+                )) as ESLintConfiguration,
+        ],
+    ]);
+
     await Promise.all(
         extensionNames.map(async extensionName => {
             const getBuiltInExtension = builtInExtensionGetters.get(extensionName);
             if (getBuiltInExtension !== undefined) {
-                importedExtensions.push(await getBuiltInExtension(dependencies.importer));
+                importedExtensions.push(await getBuiltInExtension());
                 return;
             }
 

src/creation/simplification/simplifyPackageRules.test.ts

@@ -8,6 +8,14 @@ const createStubDependencies = () => ({
     retrieveExtendsValues: jest.fn(),
 });
 
+const createStubESLintConfiguration = (fullExtends: string | string[]) => ({
+    full: {
+        env: {},
+        extends: fullExtends,
+        rules: {},
+    },
+});
+
 describe("simplifyPackageRules", () => {
     it("returns the conversion results directly when there is no loaded eslint configuration", async () => {
         // Arrange
@@ -26,29 +34,10 @@ describe("simplifyPackageRules", () => {
         expect(simplifiedResults).toBe(ruleConversionResults);
     });
 
-    it("returns the conversion results directly when the eslint configuration doesn't extend", async () => {
-        // Arrange
-        const dependencies = createStubDependencies();
-        const eslint = {};
-        const ruleConversionResults = createEmptyConversionResults();
-
-        // Act
-        const simplifiedResults = await simplifyPackageRules(
-            dependencies,
-            eslint,
-            ruleConversionResults,
-        );
-
-        // Assert
-        expect(simplifiedResults).toBe(ruleConversionResults);
-    });
-
     it("returns the conversion results directly when the eslint configuration has an empty extends", async () => {
         // Arrange
         const dependencies = createStubDependencies();
-        const eslint = {
-            extends: [],
-        };
+        const eslint = createStubESLintConfiguration([]);
         const ruleConversionResults = createEmptyConversionResults();
 
         // Act
@@ -82,9 +71,7 @@ describe("simplifyPackageRules", () => {
                 importedExtensions: [],
             }),
         };
-        const eslint = {
-            extends: ["extension-name"],
-        };
+        const eslint = createStubESLintConfiguration(["extension-name"]);
         const ruleConversionResults = createEmptyConversionResults();
 
         // Act

src/creation/simplification/simplifyPackageRules.ts

@@ -3,6 +3,7 @@ import { RuleConversionResults } from "../../rules/convertRules";
 import { removeExtendsDuplicatedRules } from "./removeExtendsDuplicatedRules";
 import { retrieveExtendsValues } from "./retrieveExtendsValues";
 import { ESLintConfiguration } from "../../input/findESLintConfiguration";
+import { OriginalConfigurations } from "../../input/findOriginalConfigurations";
 
 export type SimplifyPackageRulesDependencies = {
     removeExtendsDuplicatedRules: typeof removeExtendsDuplicatedRules;
@@ -13,15 +14,15 @@ export type SimplifiedRuleConversionResults = Pick<RuleConversionResults, "conve
 
 export const simplifyPackageRules = async (
     dependencies: SimplifyPackageRulesDependencies,
-    eslint: Partial<ESLintConfiguration> | undefined,
+    eslint: Pick<OriginalConfigurations<ESLintConfiguration>, "full"> | undefined,
     ruleConversionResults: SimplifiedRuleConversionResults,
 ): Promise<SimplifiedRuleConversionResults> => {
-    if (eslint === undefined || eslint.extends === undefined || eslint.extends.length === 0) {
+    if (eslint === undefined || eslint.full.extends.length === 0) {
         return ruleConversionResults;
     }
 
     const { configurationErrors, importedExtensions } = await dependencies.retrieveExtendsValues(
-        eslint.extends,
+        eslint.full.extends,
     );
 
     const converted = dependencies.removeExtendsDuplicatedRules(