Add missing converter: file-name-casing (#204)

* Add missing converter: file-name-casing

Linked to issue: #161

* Add test case for coverage

* Fix linting issues

* Fixes after review. #161

* Add notice for changed behavior
* Change map to object
* Correct notice about the 'ignore' case
* Specify map typing

Author: da-snap

src/rules/converters.ts

@@ -13,6 +13,7 @@ import { convertCurly } from "./converters/curly";
 import { convertCyclomaticComplexity } from "./converters/cyclomatic-complexity";
 import { convertEofline } from "./converters/eofline";
 import { convertMemberAccess } from "./converters/member-access";
+import { convertFileNameCasing } from "./converters/file-name-casing";
 import { convertForin } from "./converters/forin";
 import { convertFunctionConstructor } from "./converters/function-constructor";
 import { convertIncrementDecrement } from "./converters/increment-decrement";
@@ -128,6 +129,7 @@ export const converters = new Map([
     ["curly", convertCurly],
     ["cyclomatic-complexity", convertCyclomaticComplexity],
     ["eofline", convertEofline],
+    ["file-name-casing", convertFileNameCasing],
     ["forin", convertForin],
     ["function-constructor", convertFunctionConstructor],
     ["increment-decrement", convertIncrementDecrement],

src/rules/converters/file-name-casing.ts

@@ -0,0 +1,61 @@
+import { RuleConverter } from "../converter";
+
+const IGNORE_CASE_NOTICE = "ESLint (Unicorn plugin) does not support the 'ignore' case.";
+const CASING_BY_FILETYPE_CHANGE =
+    "ESLint (Unicorn Plugin) does not support file name casing by file type, so all previously configured casings are now allowed.";
+const CASES_MAP: { [s: string]: string } = {
+    "camel-case": "camelCase",
+    "pascal-case": "pascalCase",
+    "kebab-case": "kebabCase",
+    "snake-case": "snakeCase",
+};
+
+export const convertFileNameCasing: RuleConverter = tslintRule => {
+    return {
+        rules: [
+            {
+                ruleName: "unicorn/filename-case",
+                ...collectArguments(tslintRule.ruleArguments),
+            },
+        ],
+        plugins: ["unicorn"],
+    };
+};
+
+const collectArguments = (ruleArguments: any[]) => {
+    const notices: string[] = [];
+    const foundCases: { [k: string]: boolean } = {};
+
+    if (ruleArguments.length === 0 || ruleArguments[0] === false || ruleArguments.length < 2) {
+        return undefined;
+    }
+
+    const casings = ruleArguments[1];
+    if (typeof casings === "string") {
+        if (casings === "ignore") {
+            notices.push(IGNORE_CASE_NOTICE);
+        } else {
+            foundCases[CASES_MAP[casings]] = true;
+        }
+    }
+
+    if (ruleArguments[1] instanceof Object) {
+        notices.push(CASING_BY_FILETYPE_CHANGE);
+        for (const casing in casings) {
+            if (casings[casing] === "ignore") {
+                notices.push(IGNORE_CASE_NOTICE);
+            } else {
+                foundCases[CASES_MAP[casings[casing]]] = true;
+            }
+        }
+    }
+
+    return {
+        ...(notices.length > 0 && { notices }),
+        ruleArguments: [
+            {
+                cases: foundCases,
+            },
+        ],
+    };
+};

src/rules/converters/tests/file-name-casing.test.ts

@@ -0,0 +1,112 @@
+import { convertFileNameCasing } from "../file-name-casing";
+
+describe(convertFileNameCasing, () => {
+    test("conversion without parameter", () => {
+        const result = convertFileNameCasing({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "unicorn/filename-case",
+                },
+            ],
+            plugins: ["unicorn"],
+        });
+    });
+
+    test("conversion without string value", () => {
+        const result = convertFileNameCasing({
+            ruleArguments: [true, "camel-case"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "unicorn/filename-case",
+                    ruleArguments: [
+                        {
+                            cases: {
+                                camelCase: true,
+                            },
+                        },
+                    ],
+                },
+            ],
+            plugins: ["unicorn"],
+        });
+    });
+
+    test("conversion with object for filetypes", () => {
+        const result = convertFileNameCasing({
+            ruleArguments: [true, { ".ts": "ignore", ".tsx": "pascal-case", ".js": "snake-case" }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: [
+                        "ESLint (Unicorn Plugin) does not support file name casing by file type, so all previously configured casings are now allowed.",
+                        "ESLint (Unicorn plugin) does not support the 'ignore' case.",
+                    ],
+                    ruleName: "unicorn/filename-case",
+                    ruleArguments: [
+                        {
+                            cases: {
+                                snakeCase: true,
+                                pascalCase: true,
+                            },
+                        },
+                    ],
+                },
+            ],
+            plugins: ["unicorn"],
+        });
+    });
+
+    test("conversion with ignore as case", () => {
+        const result = convertFileNameCasing({
+            ruleArguments: [true, "ignore"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: ["ESLint (Unicorn plugin) does not support the 'ignore' case."],
+                    ruleName: "unicorn/filename-case",
+                    ruleArguments: [
+                        {
+                            cases: {},
+                        },
+                    ],
+                },
+            ],
+            plugins: ["unicorn"],
+        });
+    });
+
+    test("conversion with ignore in object", () => {
+        const result = convertFileNameCasing({
+            ruleArguments: [true, { ".ts": "ignore" }],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: [
+                        "ESLint (Unicorn Plugin) does not support file name casing by file type, so all previously configured casings are now allowed.",
+                        "ESLint (Unicorn plugin) does not support the 'ignore' case.",
+                    ],
+                    ruleName: "unicorn/filename-case",
+                    ruleArguments: [
+                        {
+                            cases: {},
+                        },
+                    ],
+                },
+            ],
+            plugins: ["unicorn"],
+        });
+    });
+});