Add comment-format converter (#240)

* Add comment-format converter

* Fix lint error and provide type to comment format options

* Remove unnecessary check at comment-format converter

* Provide extra test to ignore-words on comment-format

Author: KingDarBoja

src/rules/converters.ts

@@ -9,6 +9,7 @@ import { convertBanTypes } from "./converters/ban-types";
 import { convertBinaryExpressionOperandOrder } from "./converters/binary-expression-operand-order";
 import { convertCallableTypes } from "./converters/callable-types";
 import { convertClassName } from "./converters/class-name";
+import { convertCommentFormat } from "./converters/comment-format";
 import { convertCurly } from "./converters/curly";
 import { convertCyclomaticComplexity } from "./converters/cyclomatic-complexity";
 import { convertEofline } from "./converters/eofline";
@@ -140,6 +141,7 @@ export const converters = new Map([
     ["binary-expression-operand-order", convertBinaryExpressionOperandOrder],
     ["callable-types", convertCallableTypes],
     ["class-name", convertClassName],
+    ["comment-format", convertCommentFormat],
     ["curly", convertCurly],
     ["cyclomatic-complexity", convertCyclomaticComplexity],
     ["eofline", convertEofline],

src/rules/converters/comment-format.ts

@@ -0,0 +1,53 @@
+import { RuleConverter } from "../converter";
+
+type CommentFormatOptions = {
+    "ignore-words": string[];
+    "ignore-pattern": string;
+};
+
+export const CapitalizedIgnoreMessage = "Only accepts a single string pattern to be ignored.";
+
+export const convertCommentFormat: RuleConverter = tslintRule => {
+    const capitalizedRuleArguments: string[] = [];
+    const spaceCommentRuleArguments: string[] = [];
+    const capitalizedNotices: string[] = [];
+
+    const hasCheckSpace = tslintRule.ruleArguments.includes("check-space");
+    const hasCheckLowercase = tslintRule.ruleArguments.includes("check-lowercase");
+    const hasCheckUppercase = tslintRule.ruleArguments.includes("check-uppercase");
+
+    if (!hasCheckSpace) {
+        spaceCommentRuleArguments.push("never");
+    }
+
+    if (hasCheckUppercase) {
+        capitalizedRuleArguments.push("always");
+    } else if (hasCheckLowercase) {
+        capitalizedRuleArguments.push("never");
+    }
+
+    if (typeof tslintRule.ruleArguments[tslintRule.ruleArguments.length - 1] === "object") {
+        const objectArgument: CommentFormatOptions =
+            tslintRule.ruleArguments[tslintRule.ruleArguments.length - 1];
+        if (
+            (objectArgument["ignore-words"] && objectArgument["ignore-words"].length) ||
+            objectArgument["ignore-pattern"]
+        ) {
+            capitalizedNotices.push(CapitalizedIgnoreMessage);
+        }
+    }
+
+    return {
+        rules: [
+            {
+                ruleName: "capitalized-comments",
+                ruleArguments: capitalizedRuleArguments,
+                notices: capitalizedNotices,
+            },
+            {
+                ruleName: "spaced-comment",
+                ruleArguments: spaceCommentRuleArguments,
+            },
+        ],
+    };
+};

src/rules/converters/tests/comment-format.test.ts

@@ -0,0 +1,149 @@
+import { convertCommentFormat, CapitalizedIgnoreMessage } from "../comment-format";
+
+describe(convertCommentFormat, () => {
+    test("conversion without arguments", () => {
+        const result = convertCommentFormat({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: [],
+                    notices: [],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: ["never"],
+                },
+            ],
+        });
+    });
+
+    test("conversion with check-space argument", () => {
+        const result = convertCommentFormat({
+            ruleArguments: ["check-space"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: [],
+                    notices: [],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: [],
+                },
+            ],
+        });
+    });
+
+    test("conversion with check-lowercase arguments", () => {
+        const result = convertCommentFormat({
+            ruleArguments: ["check-lowercase"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: ["never"],
+                    notices: [],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: ["never"],
+                },
+            ],
+        });
+    });
+
+    test("conversion with ignore-pattern argument", () => {
+        const result = convertCommentFormat({
+            ruleArguments: [{ "ignore-pattern": "STD\\w{2,3}\\b" }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: [],
+                    notices: [CapitalizedIgnoreMessage],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: ["never"],
+                },
+            ],
+        });
+    });
+
+    test("conversion with empty ignore-words argument", () => {
+        const result = convertCommentFormat({
+            ruleArguments: [{ "ignore-words": [] }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: [],
+                    notices: [],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: ["never"],
+                },
+            ],
+        });
+    });
+
+    test("conversion with ignore-words argument", () => {
+        const result = convertCommentFormat({
+            ruleArguments: [{ "ignore-words": ["TODO", "HACK"] }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: [],
+                    notices: [CapitalizedIgnoreMessage],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: ["never"],
+                },
+            ],
+        });
+    });
+
+    test("conversion with all arguments", () => {
+        const result = convertCommentFormat({
+            ruleArguments: [
+                "check-space",
+                "check-lowercase",
+                "check-uppercase",
+                "allow-trailing-lowercase",
+                { "ignore-words": ["TODO", "HACK"], "ignore-pattern": "STD\\w{2,3}\\b" },
+            ],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "capitalized-comments",
+                    ruleArguments: ["always"],
+                    notices: [CapitalizedIgnoreMessage],
+                },
+                {
+                    ruleName: "spaced-comment",
+                    ruleArguments: [],
+                },
+            ],
+        });
+    });
+});