added semicolon rule converter plus tests

.vscode/settings.json

@@ -2,8 +2,11 @@
     "files.exclude": {
         "**/*.d.ts": true,
         "**/*.js.map": true,
-        "**/*.js": { "when": "$(basename).ts" }
+        "**/*.js": {
+            "when": "$(basename).ts"
+        }
     },
     "prettier.ignorePath": ".prettierignore",
-    "typescript.tsdk": "node_modules/typescript/lib"
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "editor.tabSize": 4
 }

src/rules/converters.ts

@@ -99,6 +99,7 @@ import { convertPreferTemplate } from "./converters/prefer-template";
 import { convertPromiseFunctionAsync } from "./converters/promise-function-async";
 import { convertRadix } from "./converters/radix";
 import { convertRestrictPlusOperands } from "./converters/restrict-plus-operands";
+import { semicolon } from "./converters/semicolon";
 import { convertSpaceBeforeFunctionParen } from "./converters/space-before-function-paren";
 import { convertSwitchDefault } from "./converters/switch-default";
 import { convertTypedefWhitespace } from "./converters/typedef-whitespace";
@@ -217,6 +218,7 @@ export const converters = new Map([
     ["quotemark", convertQuotemark],
     ["radix", convertRadix],
     ["restrict-plus-operands", convertRestrictPlusOperands],
+    ["semicolon", semicolon],
     ["space-before-function-paren", convertSpaceBeforeFunctionParen],
     ["switch-default", convertSwitchDefault],
     ["triple-equals", convertTripleEquals],

src/rules/converters/semicolon.ts

@@ -0,0 +1,52 @@
+import { RuleConverter } from "../converter";
+
+// for reference, see here
+// https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/semi.md
+export const semicolon: RuleConverter = tslintRule => {
+    const getMultilineDelimiter = (strategy: "always" | "never") => {
+        if (strategy === "always") {
+            return "semi";
+        }
+        return "none";
+    };
+
+    const ignoreInterfaces = tslintRule.ruleArguments.includes("ignore-interfaces");
+    const strictBoundClassMethods = tslintRule.ruleArguments.includes("strict-bound-class-methods");
+
+    return {
+        rules: [
+            {
+                ruleName: "@typescript-eslint/semi",
+                ruleArguments: [tslintRule.ruleArguments[0]],
+            },
+            ...(ignoreInterfaces
+                ? []
+                : [
+                      {
+                          ruleName: "@typescript-estlint/member-delimiter-style",
+                          ruleArguments: [
+                              "error",
+                              {
+                                  multiline: {
+                                      delimiter: getMultilineDelimiter(tslintRule.ruleArguments[0]),
+                                      requireLast: true,
+                                  },
+                                  singleline: {
+                                      delimiter: "semi",
+                                      requireLast: false,
+                                  },
+                              },
+                          ],
+                      },
+                  ]),
+        ],
+        notices: [
+            "You must disable the base rule (semi) as it can report incorrect errors.",
+            ...(strictBoundClassMethods
+                ? [
+                      "Option `strict-bound-class-methods` was found, there is no exact equivalent yet supported.",
+                  ]
+                : []),
+        ],
+    };
+};

src/rules/converters/tests/semicolon.test.ts

@@ -0,0 +1,207 @@
+import { semicolon } from "../semicolon";
+
+describe("semicolon", () => {
+    test("conversion with always", () => {
+        const result = semicolon({
+            ruleArguments: ["always"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["always"],
+                },
+                {
+                    ruleName: "@typescript-estlint/member-delimiter-style",
+                    ruleArguments: [
+                        "error",
+                        {
+                            multiline: {
+                                delimiter: "semi",
+                                requireLast: true,
+                            },
+                            singleline: {
+                                delimiter: "semi",
+                                requireLast: false,
+                            },
+                        },
+                    ],
+                },
+            ],
+            notices: ["You must disable the base rule (semi) as it can report incorrect errors."],
+        });
+    });
+
+    test("conversion with never", () => {
+        const result = semicolon({
+            ruleArguments: ["never"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["never"],
+                },
+                {
+                    ruleName: "@typescript-estlint/member-delimiter-style",
+                    ruleArguments: [
+                        "error",
+                        {
+                            multiline: {
+                                delimiter: "none",
+                                requireLast: true,
+                            },
+                            singleline: {
+                                delimiter: "semi",
+                                requireLast: false,
+                            },
+                        },
+                    ],
+                },
+            ],
+            notices: ["You must disable the base rule (semi) as it can report incorrect errors."],
+        });
+    });
+
+    test("conversion with always and strict bound class methods", () => {
+        const result = semicolon({
+            ruleArguments: ["always", "strict-bound-class-methods"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["always"],
+                },
+                {
+                    ruleName: "@typescript-estlint/member-delimiter-style",
+                    ruleArguments: [
+                        "error",
+                        {
+                            multiline: {
+                                delimiter: "semi",
+                                requireLast: true,
+                            },
+                            singleline: {
+                                delimiter: "semi",
+                                requireLast: false,
+                            },
+                        },
+                    ],
+                },
+            ],
+            notices: [
+                "You must disable the base rule (semi) as it can report incorrect errors.",
+                "Option `strict-bound-class-methods` was found, there is no exact equivalent yet supported.",
+            ],
+        });
+    });
+
+    test("conversion with never and strict bound class methods", () => {
+        const result = semicolon({
+            ruleArguments: ["never", "strict-bound-class-methods"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["never"],
+                },
+                {
+                    ruleName: "@typescript-estlint/member-delimiter-style",
+                    ruleArguments: [
+                        "error",
+                        {
+                            multiline: {
+                                delimiter: "none",
+                                requireLast: true,
+                            },
+                            singleline: {
+                                delimiter: "semi",
+                                requireLast: false,
+                            },
+                        },
+                    ],
+                },
+            ],
+            notices: [
+                "You must disable the base rule (semi) as it can report incorrect errors.",
+                "Option `strict-bound-class-methods` was found, there is no exact equivalent yet supported.",
+            ],
+        });
+    });
+
+    test("conversion with always and ignore interfaces", () => {
+        const result = semicolon({
+            ruleArguments: ["always", "ignore-interfaces"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["always"],
+                },
+            ],
+            notices: ["You must disable the base rule (semi) as it can report incorrect errors."],
+        });
+    });
+
+    test("conversion with never and ignore interfaces", () => {
+        const result = semicolon({
+            ruleArguments: ["never", "ignore-interfaces"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["never"],
+                },
+            ],
+            notices: ["You must disable the base rule (semi) as it can report incorrect errors."],
+        });
+    });
+
+    test("conversion with always, strict bound class methods and ignore interfaces", () => {
+        const result = semicolon({
+            ruleArguments: ["always", "ignore-interfaces", "strict-bound-class-methods"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["always"],
+                },
+            ],
+            notices: [
+                "You must disable the base rule (semi) as it can report incorrect errors.",
+                "Option `strict-bound-class-methods` was found, there is no exact equivalent yet supported.",
+            ],
+        });
+    });
+
+    test("conversion with always, strict bound class methods and ignore interfaces", () => {
+        const result = semicolon({
+            ruleArguments: ["never", "ignore-interfaces", "strict-bound-class-methods"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/semi",
+                    ruleArguments: ["never"],
+                },
+            ],
+            notices: [
+                "You must disable the base rule (semi) as it can report incorrect errors.",
+                "Option `strict-bound-class-methods` was found, there is no exact equivalent yet supported.",
+            ],
+        });
+    });
+});