Generating space-before-function-paren (#147)

src/rules/converters/space-before-function-paren.ts

@@ -1,11 +1,26 @@
 import { RuleConverter } from "../converter";
 
+const NOT_SUPPORTED_OPTIONS = ["constructor", "method"];
+
+function isExistedESLintOption(rule: string) {
+    return !NOT_SUPPORTED_OPTIONS.includes(rule);
+}
+
 export const convertSpaceBeforeFunctionParen: RuleConverter = tslintRule => {
+    const ruleArguments = tslintRule.ruleArguments.filter(isExistedESLintOption);
+    const notices = NOT_SUPPORTED_OPTIONS.reduce<string[]>((acc, option) => {
+        if (tslintRule.ruleArguments.includes(option)) {
+            acc.push(`Option "${option}" is not supported by ESLint.`);
+        }
+        return acc;
+    }, []);
+
     return {
         rules: [
             {
                 ...(tslintRule.ruleArguments.length !== 0 && {
-                    ruleArguments: tslintRule.ruleArguments,
+                    ruleArguments,
+                    ...(notices.length !== 0 && { notices }),
                 }),
                 ruleName: "space-before-function-paren",
             },

src/rules/converters/tests/space-before-function-paren.test.ts

@@ -29,4 +29,42 @@ describe(convertSpaceBeforeFunctionParen, () => {
             ],
         });
     });
+
+    test("conversion with all existing arguments", () => {
+        const result = convertSpaceBeforeFunctionParen({
+            ruleArguments: ["anonymous", "named", "asyncArrow", "method", "constructor"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: [
+                        'Option "constructor" is not supported by ESLint.',
+                        'Option "method" is not supported by ESLint.',
+                    ],
+                    ruleArguments: ["anonymous", "named", "asyncArrow"],
+                    ruleName: "space-before-function-paren",
+                },
+            ],
+        });
+    });
+
+    test('conversion with not supported options ["method", "constructor"]', () => {
+        const result = convertSpaceBeforeFunctionParen({
+            ruleArguments: ["method", "constructor"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: [
+                        'Option "constructor" is not supported by ESLint.',
+                        'Option "method" is not supported by ESLint.',
+                    ],
+                    ruleArguments: [],
+                    ruleName: "space-before-function-paren",
+                },
+            ],
+        });
+    });
 });