Merge branch 'master' into feature/opt-in-flag-convert-disable-comments

Author: KingDarBoja

.circleci/config.yml

@@ -91,7 +91,7 @@ jobs:
             - attach_workspace:
                   at: "."
 
-            - run: npm run test -- --coverage
+            - run: npm run test:ci
 
     tsc:
         docker:

.gitignore

@@ -4,6 +4,7 @@
 *.map
 coverage/
 node_modules/
+pnpm-lock.yaml
 src/**/*.js
 test/*.js
 ~test/jest.config.js

.npmrc

@@ -0,0 +1 @@
+engine-strict=true

README.md

@@ -4,7 +4,7 @@
 ![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-orange.svg)
 ![TypeScript: Strict](https://img.shields.io/badge/typescript-strict-yellow.svg)
 [![NPM version](https://badge.fury.io/js/tslint-to-eslint-config.svg)](http://badge.fury.io/js/tslint-to-eslint-config)
-[![Circle CI](https://img.shields.io/circleci/build/github/typescript-eslint/tslint-to-eslint-config.svg)](https://circleci.com/gh/typescript-eslint/tslint-to-eslint-config)	
+[![Circle CI](https://img.shields.io/circleci/build/github/typescript-eslint/tslint-to-eslint-config.svg)](https://circleci.com/gh/typescript-eslint/tslint-to-eslint-config)
 [![Join the chat at https://gitter.im/tslint-to-eslint-config/community](https://img.shields.io/badge/chat-gitter-informational.svg)](https://gitter.im/tslint-to-eslint-config/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Code Style: Prettier](https://img.shields.io/badge/speed-blazingly_fast-blueviolet.svg)](https://prettier.io)
 
@@ -32,7 +32,7 @@ The `tslint-to-eslint-config` command reads in any existing linter, TypeScript,
 For any TSLint rules with corresponding ESLint equivalents, those equivalents will be used in the new configuration.
 TSLint rules without ESLint equivalents will be wrapped with [eslint-plugin-tslint](https://github.com/typescript-eslint/typescript-eslint/tree/master/packages/eslint-plugin-tslint).
 
-> Requires Node 8+ (LTS)
+> Requires Node 10+ (LTS) and TSLint 5.18+
 
 ### CLI Flags
 

package-lock.json

@@ -6,6 +6,9 @@
         "url": "https://github.com/typescript-eslint/tslint-to-eslint-config/issues"
     },
     "description": "Converts your TSLint configuration to the closest reasonable ESLint equivalent.",
+    "engines": {
+        "node": ">=8.0.0"
+    },
     "dependencies": {
         "chalk": "3.0.0",
         "commander": "4.0.1",
@@ -61,7 +64,8 @@
         "prettier": "prettier \"./src/*.{js,json,ts,xml,yaml}\" \"./src/**/*.{js,json,ts,xml,yaml}\" --ignore-path .prettierignore",
         "prettier:write": "npm run prettier -- --write",
         "test": "jest",
+        "test:ci": "jest --coverage --maxWorkers=2",
         "tsc": "tsc"
     },
-    "version": "0.5.0"
+    "version": "0.5.2"
 }

package.json

@@ -172,7 +172,7 @@ describe("reportConversionResults", () => {
         );
         expectEqualWrites(
             logger.info.write,
-            "tslint-rule-one does not yet have an ESLint equivalent.",
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-rule-one"',
         );
     });
 
@@ -206,8 +206,8 @@ describe("reportConversionResults", () => {
         );
         expectEqualWrites(
             logger.info.write,
-            "tslint-rule-one does not yet have an ESLint equivalent.",
-            "tslint-rule-two does not yet have an ESLint equivalent.",
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-rule-one"',
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-rule-two"',
         );
     });
 

src/reporting/reportConversionResults.test.ts

@@ -29,7 +29,7 @@ export const reportConversionResults = (
         logMissingConversionTarget(
             "rule",
             (setting: TSLintRuleOptions) =>
-                `${setting.ruleName} does not yet have an ESLint equivalent.${EOL}`,
+                `tslint-to-eslint-config does not know the ESLint equivalent for TSLint's "${setting.ruleName}"${EOL}`,
             ruleConversionResults.missing,
             dependencies.logger,
             [

src/reporting/reportConversionResults.ts

@@ -126,7 +126,7 @@ describe("reportEditorSettingConversionResults", () => {
         );
         expectEqualWrites(
             logger.info.write,
-            "tslint-editor-setting-one does not yet have an ESLint equivalent.",
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-editor-setting-one"',
         );
     });
 
@@ -156,8 +156,8 @@ describe("reportEditorSettingConversionResults", () => {
         );
         expectEqualWrites(
             logger.info.write,
-            "tslint-editor-setting-one does not yet have an ESLint equivalent.",
-            "tslint-editor-setting-two does not yet have an ESLint equivalent.",
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-editor-setting-one"',
+            'tslint-to-eslint-config does not know the ESLint equivalent for TSLint\'s "tslint-editor-setting-two"',
         );
     });
 });

src/reporting/reportEditorSettingConversionResults.test.ts

@@ -28,7 +28,8 @@ export const reportEditorSettingConversionResults = (
     if (editorSettingConversionResults.missing.length !== 0) {
         const missingEditorSettingOutputMapping = (
             editorSetting: Pick<EditorSetting, "editorSettingName">,
-        ) => `${editorSetting.editorSettingName} does not yet have an ESLint equivalent.${EOL}`;
+        ) =>
+            `tslint-to-eslint-config does not know the ESLint equivalent for TSLint's "${editorSetting.editorSettingName}"${EOL}`;
         logMissingConversionTarget(
             "editor setting",
             missingEditorSettingOutputMapping,

src/reporting/reportEditorSettingConversionResults.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",
             },
         ],

src/rules/converters/array-type.ts

@@ -2,9 +2,10 @@ import { RuleConverter } from "../converter";
 
 export const convertArrowParens: RuleConverter = tslintRule => {
     const ruleArguments = [
-        tslintRule.ruleArguments.length !== 0 && tslintRule.ruleArguments[0] === "always"
-            ? "always"
-            : "as-needed",
+        tslintRule.ruleArguments.length !== 0 &&
+        tslintRule.ruleArguments[0] === "ban-single-arg-parens"
+            ? "as-needed"
+            : "always",
     ];
 
     return {

src/rules/converters/arrow-parens.ts

@@ -0,0 +1,60 @@
+import { RuleConverter } from "../converter";
+import { RequireAtLeastOne } from "../../utils";
+
+type ESLintOptionPath = {
+    name: string;
+    importNames: string[];
+    message?: string;
+};
+type ESLintSimpleOption = string[];
+type ESLintComplexOption = RequireAtLeastOne<{
+    paths: (string | ESLintOptionPath)[];
+    patterns: string[];
+}>;
+type ESLintOptions = ESLintSimpleOption | ESLintComplexOption;
+
+const NOTICE_MATCH_PATTERNS =
+    "ESLint and TSLint use different strategies to match patterns. TSLint uses standard regular expressions, but ESLint .gitignore spec.";
+
+export const convertImportBlacklist: RuleConverter = tslintRule => {
+    let ruleArguments: ESLintOptions = [];
+    const notices = [];
+
+    if (tslintRule.ruleArguments.every(isString)) {
+        ruleArguments = tslintRule.ruleArguments;
+    } else {
+        const objectOption = tslintRule.ruleArguments.reduce((rules, rule) => {
+            if (!Array.isArray(rule)) {
+                const eslintRule = isString(rule)
+                    ? rule
+                    : {
+                          name: Object.keys(rule)[0],
+                          importNames: Object.values(rule)[0] as string[],
+                      };
+                return { ...rules, paths: [...(rules.paths || []), eslintRule] };
+            }
+
+            return { ...rules, patterns: [...(rules.patterns || []), ...rule] };
+        }, {} as ESLintComplexOption);
+
+        if ("patterns" in objectOption && objectOption.patterns.length > 0) {
+            notices.push(NOTICE_MATCH_PATTERNS);
+        }
+
+        ruleArguments = [objectOption];
+    }
+
+    return {
+        rules: [
+            {
+                ruleArguments,
+                ...(notices.length > 0 && { notices }),
+                ruleName: "no-restricted-imports",
+            },
+        ],
+    };
+};
+
+function isString(value: string): boolean {
+    return typeof value === "string";
+}

src/rules/converters/import-blacklist.ts

@@ -0,0 +1,22 @@
+import { RuleConverter, ConvertedRuleChanges } from "../converter";
+
+export const JSDocNoticeMsg =
+    "ESLint does not support enforcing the first line of multiline JSDoc comments be empty.";
+
+export const convertJSDocFormat: RuleConverter = () => {
+    const ruleNames = [
+        "jsdoc/check-alignment",
+        "jsdoc/check-indentation",
+        "jsdoc/newline-after-description",
+    ];
+
+    const mappedRuleNames: ConvertedRuleChanges[] = ruleNames.map(ruleName => {
+        return { ruleName };
+    });
+
+    return {
+        rules: [...mappedRuleNames],
+        notices: [JSDocNoticeMsg],
+        plugins: ["eslint-plugin-jsdoc"],
+    };
+};

src/rules/converters/jsdoc-format.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) {

src/rules/converters/member-access.ts

@@ -0,0 +1,11 @@
+import { RuleConverter } from "../converter";
+
+export const convertNoBooleanLiteralCompare: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "@typescript-eslint/no-unnecessary-boolean-literal-compare",
+            },
+        ],
+    };
+};

src/rules/converters/no-boolean-literal-compare.ts

@@ -7,7 +7,7 @@ export const convertPreferReadonly: RuleConverter = tslintRule => {
                 ...(tslintRule.ruleArguments.includes("only-inline-lambdas") && {
                     ruleArguments: [{ onlyInlineLambdas: true }],
                 }),
-                ruleName: "prefer-readonly",
+                ruleName: "@typescript-eslint/prefer-readonly",
             },
         ],
     };

src/rules/converters/prefer-readonly.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 {
@@ -16,7 +16,7 @@ export const convertSpaceWithinParens: RuleConverter = tslintRule => {
             {
                 ...(notices !== undefined && { notices }),
                 ruleArguments: [arg],
-                ruleName: "@typescript-eslint/space-within-parens",
+                ruleName: "space-in-parens",
             },
         ],
     };

src/rules/converters/space-within-parens.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" }],
+                },
+            ],
+        });
+    });
 });