Ignore all unknown editor settings in conversion

typescript-eslint · Jul 25, 2020 · 2fc9dc2 · 2fc9dc2
1 parent bea0c63
commit 2fc9dc2
Show file tree

Hide file tree

Showing 2 changed files with 55 additions and 35 deletions.
diff --git a/src/editorSettings/convertEditorSettings.test.ts b/src/editorSettings/convertEditorSettings.test.ts
@@ -13,29 +13,26 @@ describe("convertEditorSettings", () => {
         };
 
         // Act
-        const { converted, missing, failed } = convertEditorSettings(
-            { converters },
-            editorConfiguration,
-        );
+        const result = convertEditorSettings({ converters }, editorConfiguration);
 
         // Assert
-        expect(converted.size).toEqual(0);
-        expect(missing.length).toEqual(0);
-        expect(failed.length).toEqual(0);
+        expect(result).toEqual({
+            converted: new Map(),
+            failed: [],
+            missing: [],
+        });
     });
 
     it("skips a configuration if not an editor setting", () => {
         // Arrange
-        const conversionResult: EditorSettingConversionResult = {
+        const { editorSetting, converters } = setupConversionEnvironment({
             settings: [
                 {
                     editorSettingName: "editor.eslint-setting-a",
                     value: "a",
                 },
             ],
-        };
-
-        const { editorSetting, converters } = setupConversionEnvironment(conversionResult);
+        });
 
         const editorConfiguration = {
             notAnEditorSetting: "a",
@@ -44,29 +41,40 @@ describe("convertEditorSettings", () => {
         };
 
         // Act
-        const { converted, missing, failed } = convertEditorSettings(
-            { converters },
-            editorConfiguration,
-        );
+        const result = convertEditorSettings({ converters }, editorConfiguration);
 
         // Assert
-        expect(converted.size).toEqual(1);
-        expect(missing.length).toEqual(0);
-        expect(failed.length).toEqual(0);
+        expect(result).toEqual({
+            converted: new Map([
+                [
+                    "editor.eslint-setting-a",
+                    {
+                        editorSettingName: "editor.eslint-setting-a",
+                        value: "a",
+                    },
+                ],
+            ]),
+            failed: [],
+            missing: [],
+        });
     });
 
     it("marks a setting as missing when its converter returns undefined", () => {
         // Arrange
         const { editorSetting, converters } = setupConversionEnvironment();
 
         // Act
-        const { missing } = convertEditorSettings(
+        const result = convertEditorSettings(
             { converters },
             { [editorSetting.editorSettingName]: editorSetting },
         );
 
         // Assert
-        expect(missing).toEqual([{ editorSettingName: editorSetting.editorSettingName }]);
+        expect(result).toEqual({
+            converted: new Map(),
+            failed: [],
+            missing: [{ editorSettingName: editorSetting.editorSettingName }],
+        });
     });
 
     it("marks a conversion as failed when returned a conversion error", () => {
@@ -76,45 +84,50 @@ describe("convertEditorSettings", () => {
         converters.set(editorSetting.editorSettingName, () => conversionError);
 
         // Act
-        const { failed } = convertEditorSettings(
+        const result = convertEditorSettings(
             { converters },
             { [editorSetting.editorSettingName]: editorSetting },
         );
 
         // Assert
-        expect(failed).toEqual([conversionError]);
+        expect(result).toEqual({
+            converted: new Map(),
+            failed: [conversionError],
+            missing: [],
+        });
     });
 
     it("marks a converted setting name as converted when a conversion has settings", () => {
         // Arrange
-        const conversionResult: EditorSettingConversionResult = {
+        const { editorSetting, converters } = setupConversionEnvironment({
             settings: [
                 {
-                    editorSettingName: "editor.eslint-setting-a",
+                    editorSettingName: "eslint.configFile",
                     value: "a",
                 },
             ],
-        };
-        const { editorSetting, converters } = setupConversionEnvironment(conversionResult);
+        });
 
         // Act
-        const { converted } = convertEditorSettings(
+        const result = convertEditorSettings(
             { converters },
             { [editorSetting.editorSettingName]: editorSetting.value },
         );
 
         // Assert
-        expect(converted).toEqual(
-            new Map([
+        expect(result).toEqual({
+            converted: new Map([
                 [
-                    "editor.eslint-setting-a",
+                    "eslint.configFile",
                     {
-                        editorSettingName: "editor.eslint-setting-a",
+                        editorSettingName: "eslint.configFile",
                         value: "a",
                     },
                 ],
             ]),
-        );
+            failed: [],
+            missing: [],
+        });
     });
 });
 
@@ -127,7 +140,7 @@ function setupConversionEnvironment(conversionResult?: EditorSettingConversionRe
 
 function createSampleEditorSetting(): EditorSetting {
     return {
-        editorSettingName: "editor.tslint-editor-setting-a",
+        editorSettingName: "tslint.configFile",
         value: "a",
     };
 }

diff --git a/src/editorSettings/convertEditorSettings.ts b/src/editorSettings/convertEditorSettings.ts
@@ -4,7 +4,14 @@ import { convertEditorSetting } from "./convertEditorSetting";
 import { EditorSettingConverter } from "./converter";
 import { EditorSetting } from "./types";
 
-const EDITOR_SETTINGS_PREFIX = "editor.";
+const knownEditorSettings = new Set([
+    "tslint.configFile",
+    "tslint.jsEnable",
+    "tslint.ignoreDefinitionFiles",
+    "tslint.exclude",
+    "tslint.alwaysShowRuleFailuresAsWarnings",
+    "tslint.suppressWhileTypeErrorsPresent",
+]);
 
 export type ConvertEditorSettingsDependencies = {
     converters: Map<string, EditorSettingConverter>;
@@ -30,7 +37,7 @@ export const convertEditorSettings = (
     for (const [configurationName, value] of Object.entries(rawEditorConfiguration)) {
         // Configurations other than editor settings will be ignored.
         // See: https://marketplace.visualstudio.com/items?itemName=ms-vscode.vscode-typescript-tslint-plugin#configuration
-        if (!configurationName.startsWith(EDITOR_SETTINGS_PREFIX)) {
+        if (!knownEditorSettings.has(configurationName)) {
             continue;
         }