Merge branch 'master' of https://github.com/typescript-eslint/tslint-to-eslint-config

Author: JoshuaKGoldberg

src/creation/writeConversionResults.test.ts

@@ -46,7 +46,6 @@ describe("writeConversionResults", () => {
                     sourceType: "module",
                 },
                 plugins: ["@typescript-eslint"],
-                rules: {},
             }),
         );
     });
@@ -137,8 +136,6 @@ describe("writeConversionResults", () => {
                     es6: true,
                     node: true,
                 },
-                extends: [],
-                rules: {},
                 parser: "@typescript-eslint/parser",
                 parserOptions: {
                     project: "tsconfig.json",
@@ -182,7 +179,6 @@ describe("writeConversionResults", () => {
                     sourceType: "module",
                 },
                 plugins: ["@typescript-eslint"],
-                rules: {},
             }),
         );
     });
@@ -224,8 +220,6 @@ describe("writeConversionResults", () => {
                     es6: true,
                     node: true,
                 },
-                extends: [],
-                rules: {},
                 globals: {
                     Promise: true,
                 },

src/creation/writeConversionResults.ts

@@ -1,5 +1,6 @@
 import { FileSystem } from "../adapters/fileSystem";
 import { AllOriginalConfigurations } from "../input/findOriginalConfigurations";
+import { removeEmptyMembers } from "../utils";
 import { createEnv } from "./eslint/createEnv";
 import { formatConvertedRules } from "./formatConvertedRules";
 import { formatOutput } from "./formatting/formatOutput";
@@ -22,11 +23,11 @@ export const writeConversionResults = async (
         plugins.push("@typescript-eslint/tslint");
     }
 
-    const output = {
+    const output = removeEmptyMembers({
         ...eslint?.full,
         env: createEnv(originalConfigurations),
         ...(eslint && { globals: eslint.raw.globals }),
-        ...(summarizedResults.extends?.length !== 0 && { extends: summarizedResults.extends }),
+        ...(summarizedResults.extends && { extends: summarizedResults.extends }),
         parser: "@typescript-eslint/parser",
         parserOptions: {
             project: "tsconfig.json",
@@ -37,7 +38,7 @@ export const writeConversionResults = async (
             // ...trimESLintRules(eslint?.full.rules, summarizedResults.extensionRules),
             ...formatConvertedRules(summarizedResults, tslint.full),
         },
-    };
+    });
 
     return await dependencies.fileSystem.writeFile(outputPath, formatOutput(outputPath, output));
 };

src/rules/converters/codelyzer/no-conflicting-lifecycle.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../converter";
+
+export const convertNoConflictingLifecycle: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "@angular-eslint/no-conflicting-lifecycle",
+            },
+        ],
+        plugins: ["@angular-eslint/eslint-plugin"],
+    };
+};

src/rules/converters/codelyzer/no-lifecycle-call.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../converter";
+
+export const convertNoLifecycleCall: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "@angular-eslint/no-lifecycle-call",
+            },
+        ],
+        plugins: ["@angular-eslint/eslint-plugin"],
+    };
+};

src/rules/converters/codelyzer/tests/no-conflicting-lifecycle.test.ts

@@ -0,0 +1,18 @@
+import { convertNoConflictingLifecycle } from "../no-conflicting-lifecycle";
+
+describe(convertNoConflictingLifecycle, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoConflictingLifecycle({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@angular-eslint/no-conflicting-lifecycle",
+                },
+            ],
+            plugins: ["@angular-eslint/eslint-plugin"],
+        });
+    });
+});

src/rules/converters/codelyzer/tests/no-lifecycle-call.test.ts

@@ -0,0 +1,18 @@
+import { convertNoLifecycleCall } from "../no-lifecycle-call";
+
+describe(convertNoLifecycleCall, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoLifecycleCall({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@angular-eslint/no-lifecycle-call",
+                },
+            ],
+            plugins: ["@angular-eslint/eslint-plugin"],
+        });
+    });
+});

src/rules/rulesConverters.ts

@@ -145,12 +145,14 @@ import { convertContextualLifecycle } from "./converters/codelyzer/contextual-li
 import { convertDirectiveClassSuffix } from "./converters/codelyzer/directive-class-suffix";
 import { convertDirectiveSelector } from "./converters/codelyzer/directive-selector";
 import { convertNoAttributeDecorator } from "./converters/codelyzer/no-attribute-decorator";
-import { convertUsePipeDecorator } from "./converters/codelyzer/use-pipe-decorator";
+import { convertNoConflictingLifecycle } from "./converters/codelyzer/no-conflicting-lifecycle";
 import { convertNoForwardRef } from "./converters/codelyzer/no-forward-ref";
 import { convertNoHostMetadataProperty } from "./converters/codelyzer/no-host-metadata-property";
 import { convertNoInputPrefix } from "./converters/codelyzer/no-input-prefix";
 import { convertNoInputRename } from "./converters/codelyzer/no-input-rename";
 import { convertNoInputsMetadataProperty } from "./converters/codelyzer/no-inputs-metadata-property";
+import { convertNoLifecycleCall } from "./converters/codelyzer/no-lifecycle-call";
+import { convertUsePipeDecorator } from "./converters/codelyzer/use-pipe-decorator";
 
 /**
  * Keys TSLint rule names to their ESLint rule converters.
@@ -207,6 +209,7 @@ export const rulesConverters = new Map([
     ["no-bitwise", convertNoBitwise],
     ["no-boolean-literal-compare", convertNoBooleanLiteralCompare],
     ["no-conditional-assignment", convertNoConditionalAssignment],
+    ["no-conflicting-lifecycle", convertNoConflictingLifecycle],
     ["no-consecutive-blank-lines", convertNoConsecutiveBlankLines],
     ["no-console", convertNoConsole],
     ["no-constant-condition", convertNoConstantCondition],
@@ -237,6 +240,7 @@ export const rulesConverters = new Map([
     ["no-invalid-template-strings", convertNoInvalidTemplateStrings],
     ["no-invalid-this", convertNoInvalidThis],
     ["no-irregular-whitespace", convertNoIrregularWhitespace],
+    ["no-lifecycle-call", convertNoLifecycleCall],
     ["no-magic-numbers", convertNoMagicNumbers],
     ["no-misused-new", convertNoMisusedNew],
     ["no-multiline-string", convertNoMultilineString],

src/utils.test.ts

@@ -1,4 +1,4 @@
-import { isDefined, isError, uniqueFromSources, separateErrors } from "./utils";
+import { isDefined, isError, uniqueFromSources, separateErrors, removeEmptyMembers } from "./utils";
 
 describe("isDefined", () => {
     it("returns true when the item is defined", () => {
@@ -48,6 +48,41 @@ describe("isError", () => {
     });
 });
 
+describe("removeEmptyMembers", () => {
+    it("remove an object member when it is empty", () => {
+        // Arrange
+        const items = { kept: { value: true }, removed: {} };
+
+        // Act
+        const result = removeEmptyMembers(items);
+
+        // Assert
+        expect(result).toEqual({ kept: { value: true } });
+    });
+
+    it("removes an array member when it is empty", () => {
+        // Arrange
+        const items = { kept: [true], removed: [] };
+
+        // Act
+        const result = removeEmptyMembers(items);
+
+        // Assert
+        expect(result).toEqual({ kept: [true] });
+    });
+
+    it("keeps a member when it isn't an array or object", () => {
+        // Arrange
+        const items = { kept: true };
+
+        // Act
+        const result = removeEmptyMembers(items);
+
+        // Assert
+        expect(result).toEqual({ kept: true });
+    });
+});
+
 describe("separateErrors", () => {
     it("splits the input array into errors and items", () => {
         // Arrange

src/utils.ts

@@ -4,6 +4,21 @@ export const isError = <Item>(item: Item | Error): item is Error => item instanc
 
 export const isTruthy = <Item>(item: Item | false | undefined | null | 0): item is Item => !!item;
 
+export const removeEmptyMembers = <Item>(items: Item): Item => {
+    const result: any = {};
+
+    for (const [key, value] of Object.entries(items)) {
+        if (
+            !(value instanceof Array && value.length === 0) &&
+            !(value instanceof Object && Object.keys(value).length === 0)
+        ) {
+            result[key] = value;
+        }
+    }
+
+    return result;
+};
+
 export const separateErrors = <Item>(mixed: (Error | Item)[]): [Error[], Item[]] => {
     const errors: Error[] = [];
     const items: Item[] = [];