Respect the original TSLint configuration of ban-types (#353)

* Respect `ban-types` configuration of TSLint

In the past, this tool didn't respect the TSLint configuration of `ban-types`,
it means even if TSLint specified `ban-types` with the argument, generated
ESLint configuration doesn't contain the detailed configuration of that.

For example, when the TSLint configuration is like the following:

```
{
  "rules": {
    "ban-types": [true,
      ["Object", "Use {} instead."],
    ]
  }
}
```

then, older tool generates the following ESLint configuration:

```
  "rules": {
      "@typescript-eslint/ban-types": "error"
  }
```

According to the official documentation, probably this generated result
doesn't make sense because each rule requires the type name (and the message).

https://github.com/typescript-eslint/typescript-eslint/blob/f3160b471f8247e157555b6cf5b40a1f6ccdc233/packages/eslint-plugin/docs/rules/ban-types.md

So this commit makes the generated ESLint configuration to be suitable to the certainly
working configuration, like so:

```
  "rules": {
      "@typescript-eslint/ban-types": [
          "error",
          {
              "types": {
                  "Object": {
                      "message": "Use {} instead."
                  }
              }
          }
      ]
  }
```

See also: https://palantir.github.io/tslint/rules/ban-types/
Related ticket: #352

* Use the Record type instead of traditional dict decralation

Fix: #353 (comment)

* Simplify a variable name for banned-types

Fix: #353 (comment)

* Rename an unclear variable name for banned-type to self-descriptive name

Fix: #353 (comment)

* Use short-hand notation for variable substitution

Fix: #353 (comment)

* Check whether a rule is array object or not on `ban-types` converter

Author: moznion

src/rules/converters/ban-types.ts

@@ -1,10 +1,33 @@
 import { RuleConverter } from "../converter";
 
-export const convertBanTypes: RuleConverter = () => {
+export const convertBanTypes: RuleConverter = tslintRule => {
+    type ConvertBanTypeArgument = {
+        message: string;
+    };
+
+    const bannedTypes: Record<string, ConvertBanTypeArgument | null> = {};
+
+    for (const rule of tslintRule.ruleArguments) {
+        if (!Array.isArray(rule)) {
+            break;
+        }
+
+        const [bannedType, message] = rule;
+        if (!bannedType) {
+            break;
+        }
+
+        bannedTypes[bannedType] = message ? { message } : null;
+    }
+
+    const ruleArguments =
+        Object.keys(bannedTypes).length === 0 ? undefined : [{ types: bannedTypes }];
+
     return {
         rules: [
             {
                 ruleName: "@typescript-eslint/ban-types",
+                ...{ ruleArguments },
             },
         ],
     };

src/rules/converters/tests/ban-types.test.ts

@@ -14,4 +14,73 @@ describe(convertBanTypes, () => {
             ],
         });
     });
+
+    test("conversion with arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: [
+                ["Object", "Use {} instead."],
+                ["String"],
+                ["Number"],
+                ["Boolean", "Use 'boolean' instead."],
+                [], // empty array: this should be ignored
+            ],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                    ruleArguments: [
+                        {
+                            types: {
+                                Object: {
+                                    message: "Use {} instead.",
+                                },
+                                String: null,
+                                Number: null,
+                                Boolean: {
+                                    message: "Use 'boolean' instead.",
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with duplicated arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: [["Object", "Use {} instead."], ["Object"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                    ruleArguments: [
+                        {
+                            types: {
+                                Object: null,
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with duplicated arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: ["!!!this-is-not-array!!!"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                },
+            ],
+        });
+    });
 });