Repository: typescript-eslint/tslint-to-eslint-config (ts)

Issue:
array-type does not keep argument
### 🐛 Bug Report

-   `tslint-to-eslint-config` version: 0.5.1

#### Actual Behavior

```yaml
  array-type:
    options:
      - generic
```

Is converted into `'@typescript-eslint/array-type': error`

#### Expected Behavior

It should be converted into
```yaml
  '@typescript-eslint/array-type':
    - error
    -
      default: generic
```

See <https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/array-type.md>

#### Reproduction

See PR for reproduction.


Pull request description:
Fix arguments passed to array-type
## PR Checklist

-   [x] Addresses an existing issue: fixes #333
-   [ ] That issue was marked as [`status: accepting prs`](https://github.com/typescript-eslint/tslint-to-eslint-config/labels/status%3A%20accepting%20prs)

## Overview

Options are now kept. See See https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/array-type.md.


Patch:
diff --git a/src/rules/converters/array-type.ts b/src/rules/converters/array-type.ts
index 5911cd4..186d403 100644
--- a/src/rules/converters/array-type.ts
+++ b/src/rules/converters/array-type.ts
@@ -1,9 +1,12 @@
 import { RuleConverter } from "../converter";
 
-export const convertArrayType: RuleConverter = () => {
+export const convertArrayType: RuleConverter = tslintRule => {
     return {
         rules: [
             {
+                ...(tslintRule.ruleArguments.length > 0 && {
+                    ruleArguments: [{ default: tslintRule.ruleArguments[0] }],
+                }),
                 ruleName: "@typescript-eslint/array-type",
             },
         ],
diff --git a/src/rules/converters/member-access.ts b/src/rules/converters/member-access.ts
index 1635f91..3d84131 100644
--- a/src/rules/converters/member-access.ts
+++ b/src/rules/converters/member-access.ts
@@ -22,7 +22,7 @@ export const convertMemberAccess: RuleConverter = tslintRule => {
         accessibility: AccessibilityLevel.Explicit,
     };
 
-    if (tslintRule.ruleArguments.length >= 2 || tslintRule.ruleArguments[0] === true) {
+    if (tslintRule.ruleArguments.length >= 1 || tslintRule.ruleArguments[0] === true) {
         for (const ruleArg of tslintRule.ruleArguments) {
             if (typeof ruleArg === "string") {
                 switch (ruleArg) {
diff --git a/src/rules/converters/space-within-parens.ts b/src/rules/converters/space-within-parens.ts
index f24c898..01779e0 100644
--- a/src/rules/converters/space-within-parens.ts
+++ b/src/rules/converters/space-within-parens.ts
@@ -4,7 +4,7 @@ export const convertSpaceWithinParens: RuleConverter = tslintRule => {
     let notices: string[] | undefined;
     let arg: string;
 
-    if (tslintRule.ruleArguments.length === 1) {
+    if (tslintRule.ruleArguments.length === 1 && tslintRule.ruleArguments[0] !== 0) {
         arg = "always";
         notices = ["The number of spaces will be ignored"];
     } else {


Test patch:
diff --git a/src/rules/converters/tests/array-type.test.ts b/src/rules/converters/tests/array-type.test.ts
index c5b1361..76a79e2 100644
--- a/src/rules/converters/tests/array-type.test.ts
+++ b/src/rules/converters/tests/array-type.test.ts
@@ -14,4 +14,46 @@ describe(convertArrayType, () => {
             ],
         });
     });
+    test("conversion with argument array-simple", () => {
+        const result = convertArrayType({
+            ruleArguments: ["array-simple"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/array-type",
+                    ruleArguments: [{ default: "array-simple" }],
+                },
+            ],
+        });
+    });
+    test("conversion with argument generic", () => {
+        const result = convertArrayType({
+            ruleArguments: ["generic"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/array-type",
+                    ruleArguments: [{ default: "generic" }],
+                },
+            ],
+        });
+    });
+    test("conversion with argument simple", () => {
+        const result = convertArrayType({
+            ruleArguments: ["simple"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/array-type",
+                    ruleArguments: [{ default: "simple" }],
+                },
+            ],
+        });
+    });
 });
diff --git a/src/rules/converters/tests/member-access.test.ts b/src/rules/converters/tests/member-access.test.ts
index ed87558..bdbabf6 100644
--- a/src/rules/converters/tests/member-access.test.ts
+++ b/src/rules/converters/tests/member-access.test.ts
@@ -32,6 +32,21 @@ describe(convertMemberAccess, () => {
     });
 
     test("conversion with no-public argument", () => {
+        const result = convertMemberAccess({
+            ruleArguments: ["no-public"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: [{ accessibility: AccessibilityLevel.NoPublic }],
+                    ruleName: "@typescript-eslint/explicit-member-accessibility",
+                },
+            ],
+        });
+    });
+
+    test("conversion with true and no-public argument", () => {
         const result = convertMemberAccess({
             ruleArguments: [true, "no-public"],
         });
@@ -46,7 +61,7 @@ describe(convertMemberAccess, () => {
         });
     });
 
-    test("conversion with check-accessor argument", () => {
+    test("conversion with true and check-accessor argument", () => {
         const result = convertMemberAccess({
             ruleArguments: [true, "check-accessor"],
         });
@@ -68,7 +83,7 @@ describe(convertMemberAccess, () => {
         });
     });
 
-    test("conversion with check-constructor argument", () => {
+    test("conversion with true and check-constructor argument", () => {
         const result = convertMemberAccess({
             ruleArguments: [true, "check-constructor"],
         });
@@ -90,7 +105,7 @@ describe(convertMemberAccess, () => {
         });
     });
 
-    test("conversion with check-parameter-property argument", () => {
+    test("conversion with true and check-parameter-property argument", () => {
         const result = convertMemberAccess({
             ruleArguments: [true, "check-parameter-property"],
         });
diff --git a/src/rules/converters/tests/space-within-parens.test.ts b/src/rules/converters/tests/space-within-parens.test.ts
index 32aed65..83fe604 100644
--- a/src/rules/converters/tests/space-within-parens.test.ts
+++ b/src/rules/converters/tests/space-within-parens.test.ts
@@ -16,6 +16,21 @@ describe(convertSpaceWithinParens, () => {
         });
     });
 
+    test("conversion with 0 spaces required", () => {
+        const result = convertSpaceWithinParens({
+            ruleArguments: [0],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: ["never"],
+                    ruleName: "space-in-parens",
+                },
+            ],
+        });
+    });
+
     test("conversion with min spaces arguement", () => {
         const result = convertSpaceWithinParens({
             ruleArguments: [5],