Fix member access converter (#231)

* Handle rule options on member access tslint

* Improve code for member-access converter

* Fix unused default statement and change interface for type

* Add missing test

Author: KingDarBoja

src/rules/converters/member-access.ts

@@ -1,15 +1,63 @@
 import { RuleConverter } from "../converter";
 
-export const convertMemberAccess: RuleConverter = () => {
+export enum AccessibilityLevel {
+    Explicit = "explicit",
+    NoPublic = "no-public",
+}
+
+export enum MemberAccessArguments {
+    NoPublic = "no-public",
+    Accessor = "check-accessor",
+    Constructor = "check-constructor",
+    ParameterProp = "check-parameter-property",
+}
+
+type MemberAccessSchema = {
+    accessibility: string;
+    overrides?: { [key: string]: string };
+};
+
+export const convertMemberAccess: RuleConverter = tslintRule => {
+    const tslintRuleArguments = tslintRule.ruleArguments;
+    const schema: MemberAccessSchema = {
+        accessibility: AccessibilityLevel.Explicit,
+    };
+
+    if (tslintRuleArguments.length >= 2 || tslintRuleArguments[0] === true) {
+        tslintRuleArguments.forEach(ruleArg => {
+            if (typeof ruleArg === "string") {
+                switch (ruleArg) {
+                    case MemberAccessArguments.NoPublic:
+                        schema.accessibility = AccessibilityLevel.NoPublic;
+                        break;
+                    case MemberAccessArguments.Accessor:
+                        schema.overrides = {
+                            ...schema.overrides,
+                            accessors: AccessibilityLevel.Explicit,
+                        };
+                        break;
+                    case MemberAccessArguments.Constructor:
+                        schema.overrides = {
+                            ...schema.overrides,
+                            constructors: AccessibilityLevel.Explicit,
+                        };
+                        break;
+                    case MemberAccessArguments.ParameterProp:
+                        schema.overrides = {
+                            ...schema.overrides,
+                            parameterProperties: AccessibilityLevel.Explicit,
+                        };
+                        break;
+                }
+            }
+        });
+    }
+
     return {
         rules: [
             {
                 ruleName: "@typescript-eslint/explicit-member-accessibility",
-                ruleArguments: [
-                    {
-                        overrides: { constructors: "off" },
-                    },
-                ],
+                ruleArguments: [schema],
             },
         ],
     };

src/rules/converters/tests/member-access.test.ts

@@ -1,17 +1,141 @@
-import { convertMemberAccess } from "../member-access";
+import { convertMemberAccess, AccessibilityLevel } from "../member-access";
 
 describe(convertMemberAccess, () => {
     test("conversion without arguments", () => {
         const result = convertMemberAccess({
             ruleArguments: [],
         });
 
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [{ accessibility: AccessibilityLevel.Explicit }],
+                },
+            ],
+        });
+    });
+
+    test("conversion with true argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [true],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [{ accessibility: AccessibilityLevel.Explicit }],
+                },
+            ],
+        });
+    });
+
+    test("conversion with no-public argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [true, "no-public"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [{ accessibility: AccessibilityLevel.NoPublic }],
+                },
+            ],
+        });
+    });
+
+    test("conversion with check-accessor argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [true, "check-accessor"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [
+                        {
+                            accessibility: AccessibilityLevel.Explicit,
+                            overrides: {
+                                accessors: AccessibilityLevel.Explicit,
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with check-constructor argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [true, "check-constructor"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [
+                        {
+                            accessibility: AccessibilityLevel.Explicit,
+                            overrides: {
+                                constructors: AccessibilityLevel.Explicit,
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with check-parameter-property argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [true, "check-parameter-property"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                    ruleArguments: [
+                        {
+                            accessibility: AccessibilityLevel.Explicit,
+                            overrides: {
+                                parameterProperties: AccessibilityLevel.Explicit,
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with all arguments", () => {
+        const result = convertMemberAccess({
+            ruleArguments: [
+                true,
+                "no-public",
+                "check-accessor",
+                "check-constructor",
+                "check-parameter-property",
+            ],
+        });
+
         expect(result).toEqual({
             rules: [
                 {
                     ruleName: "@typescript-eslint/explicit-member-accessibility",
                     ruleArguments: [
-                        { overrides: { constructors: "off" } },
+                        {
+                            accessibility: AccessibilityLevel.NoPublic,
+                            overrides: {
+                                accessors: AccessibilityLevel.Explicit,
+                                constructors: AccessibilityLevel.Explicit,
+                                parameterProperties: AccessibilityLevel.Explicit,
+                            },
+                        },
                     ],
                 },
             ],