merges

Author: asponda

.circleci/config.yml

@@ -91,7 +91,6 @@ jobs:
             - attach_workspace:
                   at: "."
 
-            - run: npm i -g ts-node
             - run: npm run test:end-to-end
 
     test-unit:
@@ -144,6 +143,10 @@ workflows:
             - prettier:
                   requires:
                       - build
+            - test-end-to-end:
+                  requires:
+                      - build
+                      - tsc
             - test-unit:
                   requires:
                       - build

.eslintrc.js

@@ -23,6 +23,7 @@ module.exports = {
         "@typescript-eslint/generic-type-naming": 0,
         "@typescript-eslint/indent": 0,
         "@typescript-eslint/member-ordering": 0,
+        "@typescript-eslint/no-empty-function": 0,
         "@typescript-eslint/no-explicit-any": 0,
         "@typescript-eslint/no-extra-parens": 0,
         "@typescript-eslint/no-magic-numbers": 0,
@@ -47,7 +48,6 @@ module.exports = {
         "import/prefer-default-export": 0,
         "no-console": 0,
         "no-continue": 0,
-        "no-empty-function": 0,
         "no-restricted-syntax": 0,
         "no-param-reassign": 0,
         "no-return-await": 0,

docs/Testing.md

@@ -42,3 +42,5 @@ Within each directory, a test suite will execute `bin/tslint-to-eslint` and vali
 
 Use `npm run test:end-to-end:accept` to overwrite the expected contents of files with what is actually written.
 These behave similarly to updating snapshots in snapshot testing.
+
+> Note: these end-to-end tests use the compiled result of `npm run tsc`, so if you update source code, re-run `npm run tsc` before `npm run test:end-to-end`.

package-lock.json

@@ -65,5 +65,5 @@
         "test:end-to-end:accept": "jest --config=test/jest.config.js --globals=\"{\\\"acceptTestChanges\\\": true }\"  --runInBand",
         "tsc": "tsc"
     },
-    "version": "0.2.6"
+    "version": "0.2.7"
 }

package.json

@@ -12,7 +12,7 @@ import { convertClassName } from "./converters/class-name";
 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";
@@ -24,9 +24,11 @@ import { convertLinebreakStyle } from "./converters/linebreak-style";
 import { convertMaxClassesPerFile } from "./converters/max-classes-per-file";
 import { convertMaxFileLineCount } from "./converters/max-file-line-count";
 import { convertMaxLineLength } from "./converters/max-line-length";
+import { convertMemberAccess } from "./converters/member-access";
 import { convertMemberOrdering } from "./converters/member-ordering";
-import { convertNewlinePerChainedCall } from "./converters/newline-per-chained-call";
 import { convertNewParens } from "./converters/new-parens";
+import { convertNewlineBeforeReturn } from "./converters/newline-before-return";
+import { convertNewlinePerChainedCall } from "./converters/newline-per-chained-call";
 import { convertNoAngleBracketTypeAssertion } from "./converters/no-angle-bracket-type-assertion";
 import { convertNoArg } from "./converters/no-arg";
 import { convertNoAsyncWithoutAwait } from "./converters/no-async-without-await";
@@ -39,6 +41,7 @@ import { convertNoConstantCondition } from "./converters/no-constant-condition";
 import { convertNoConstruct } from "./converters/no-construct";
 import { convertNoControlRegex } from "./converters/no-control-regex";
 import { convertNoDebugger } from "./converters/no-debugger";
+import { convertNoDuplicateImports } from "./converters/no-duplicate-imports";
 import { convertNoDuplicateSuper } from "./converters/no-duplicate-super";
 import { convertNoDuplicateSwitchCase } from "./converters/no-duplicate-switch-case";
 import { convertNoEmpty } from "./converters/no-empty";
@@ -95,19 +98,19 @@ import { convertPreferObjectSpread } from "./converters/prefer-object-spread";
 import { convertPreferReadonly } from "./converters/prefer-readonly";
 import { convertPreferTemplate } from "./converters/prefer-template";
 import { convertPromiseFunctionAsync } from "./converters/promise-function-async";
+import { convertQuotemark } from "./converters/quotemark";
 import { convertRadix } from "./converters/radix";
 import { convertRestrictPlusOperands } from "./converters/restrict-plus-operands";
 import { convertSpaceBeforeFunctionParen } from "./converters/space-before-function-paren";
 import { convertSwitchDefault } from "./converters/switch-default";
-import { convertTypedefWhitespace } from "./converters/typedef-whitespace";
+import { convertTripleEquals } from "./converters/triple-equals";
 import { convertTypeLiteralDelimiter } from "./converters/type-literal-delimiter";
+import { convertTypedefWhitespace } from "./converters/typedef-whitespace";
 import { convertTypeofCompare } from "./converters/typeof-compare";
 import { convertUnifiedSignatures } from "./converters/unified-signatures";
 import { convertUnnecessaryBind } from "./converters/unnecessary-bind";
 import { convertUnnecessaryConstructor } from "./converters/unnecessary-constructor";
 import { convertUseIsnan } from "./converters/use-isnan";
-import { convertQuotemark } from "./converters/quotemark";
-import { convertTripleEquals } from "./converters/triple-equals";
 
 /**
  * Keys TSLint rule names to their ESLint rule converters.
@@ -116,113 +119,116 @@ export const converters = new Map([
     ["adjacent-overload-signatures", convertAdjacentOverloadSignatures],
     ["array-type", convertArrayType],
     ["arrow-parens", convertArrowParens],
+    ["arrow-return-shorthand", convertArrowReturnShorthand],
     ["await-promise", convertAwaitPromise],
     ["ban-comma-operator", convertBanCommaOperator],
     ["ban-ts-ignore", convertBanTsIgnore],
     ["ban-types", convertBanTypes],
     ["binary-expression-operand-order", convertBinaryExpressionOperandOrder],
     ["callable-types", convertCallableTypes],
     ["class-name", convertClassName],
+    ["curly", convertCurly],
+    ["cyclomatic-complexity", convertCyclomaticComplexity],
     ["eofline", convertEofline],
+    ["file-name-casing", convertFileNameCasing],
     ["forin", convertForin],
     ["function-constructor", convertFunctionConstructor],
+    ["increment-decrement", convertIncrementDecrement],
     ["indent", convertIndent],
     ["interface-name", convertInterfaceName],
     ["interface-over-type-literal", convertInterfaceOverTypeLiteral],
     ["label-position", convertLabelPosition],
+    ["linebreak-style", convertLinebreakStyle],
+    ["max-classes-per-file", convertMaxClassesPerFile],
+    ["max-file-line-count", convertMaxFileLineCount],
+    ["max-line-length", convertMaxLineLength],
     ["member-access", convertMemberAccess],
     ["member-ordering", convertMemberOrdering],
     ["new-parens", convertNewParens],
+    ["newline-before-return", convertNewlineBeforeReturn],
     ["newline-per-chained-call", convertNewlinePerChainedCall],
     ["no-angle-bracket-type-assertion", convertNoAngleBracketTypeAssertion],
     ["no-any", convertNoExplicitAny],
     ["no-arg", convertNoArg],
     ["no-async-without-await", convertNoAsyncWithoutAwait],
+    ["no-banned-terms", convertNoBannedTerms],
     ["no-bitwise", convertNoBitwise],
     ["no-conditional-assignment", convertNoConditionalAssignment],
+    ["no-consecutive-blank-lines", convertNoConsecutiveBlankLines],
+    ["no-console", convertNoConsole],
+    ["no-constant-condition", convertNoConstantCondition],
     ["no-construct", convertNoConstruct],
+    ["no-control-regex", convertNoControlRegex],
     ["no-debugger", convertNoDebugger],
+    ["no-duplicate-imports", convertNoDuplicateImports],
     ["no-duplicate-super", convertNoDuplicateSuper],
     ["no-duplicate-switch-case", convertNoDuplicateSwitchCase],
     ["no-empty-interface", convertNoEmptyInterface],
+    ["no-empty", convertNoEmpty],
     ["no-eval", convertNoEval],
     ["no-floating-promises", convertNoFloatingPromises],
-    ["no-for-in", convertNoForIn],
     ["no-for-in-array", convertNoForInArray],
+    ["no-for-in", convertNoForIn],
     ["no-inferrable-types", convertNoInferrableTypes],
     ["no-internal-module", convertNoInternalModule],
+    ["no-invalid-regexp", convertNoInvalidRegexp],
+    ["no-invalid-template-strings", convertNoInvalidTemplateStrings],
+    ["no-invalid-this", convertNoInvalidThis],
     ["no-irregular-whitespace", convertNoIrregularWhitespace],
+    ["no-magic-numbers", convertNoMagicNumbers],
     ["no-misused-new", convertNoMisusedNew],
+    ["no-multiline-string", convertNoMultilineString],
     ["no-namespace", convertNoNamespace],
     ["no-non-null-assertion", convertNoNonNullAssertion],
     ["no-object-literal-type-assertion", convertNoObjectLiteralTypeAssertion],
+    ["no-octal-literal", convertNoOctalLiteral],
     ["no-parameter-properties", convertNoParameterProperties],
     ["no-parameter-reassignment", convertNoParameterReassignment],
     ["no-reference", convertNoReference],
+    ["no-regex-spaces", convertNoRegexSpaces],
     ["no-require-imports", convertNoRequireImports],
     ["no-return-await", convertNoReturnAwait],
     ["no-sparse-arrays", convertNoSparseArrays],
     ["no-string-literal", convertNoStringLiteral],
     ["no-string-throw", convertNoStringThrow],
     ["no-switch-case-fall-through", convertNoSwitchCaseFallThrough],
-    ["no-trailing-whitespace", convertNoTrailingWhitespace],
     ["no-this-assignment", convertNoThisAssignment],
+    ["no-trailing-whitespace", convertNoTrailingWhitespace],
     ["no-unbound-method", convertNoUnboundMethod],
     ["no-unnecessary-class", convertNoUnnecessaryClass],
     ["no-unnecessary-initializer", convertNoUnnecessaryInitializer],
     ["no-unnecessary-qualifier", convertNoUnnecessaryQualifier],
+    ["no-unnecessary-semicolons", convertNoUnnecessarySemicolons],
     ["no-unnecessary-type-assertion", convertNoUnnecessaryTypeAssertion],
     ["no-unsafe-finally", convertNoUnsafeFinally],
     ["no-use-before-declare", convertNoUseBeforeDeclare],
     ["no-var-keyword", convertNoVarKeyword],
     ["no-var-requires", convertNoVarRequires],
     ["no-void-expression", convertNoVoidExpression],
+    ["object-literal-key-quotes", convertObjectLiteralKeyQuotes],
+    ["object-literal-shorthand", convertObjectLiteralShorthand],
+    ["one-variable-per-declaration", convertOneVariablePerDeclaration],
+    ["only-arrow-functions", convertOnlyArrowFunctions],
+    ["prefer-const", convertPreferConst],
     ["prefer-for-of", convertPreferForOf],
+    ["prefer-function-over-method", convertPreferFunctionOverMethod],
     ["prefer-object-spread", convertPreferObjectSpread],
+    ["prefer-readonly", convertPreferReadonly],
+    ["prefer-template", convertPreferTemplate],
     ["promise-function-async", convertPromiseFunctionAsync],
+    ["quotemark", convertQuotemark],
     ["radix", convertRadix],
     ["restrict-plus-operands", convertRestrictPlusOperands],
+    ["space-before-function-paren", convertSpaceBeforeFunctionParen],
+    ["switch-default", convertSwitchDefault],
+    ["triple-equals", convertTripleEquals],
     ["type-literal-delimiter", convertTypeLiteralDelimiter],
     ["typedef-whitespace", convertTypedefWhitespace],
     ["typeof-compare", convertTypeofCompare],
     ["unified-signatures", convertUnifiedSignatures],
     ["unnecessary-bind", convertUnnecessaryBind],
     ["unnecessary-constructor", convertUnnecessaryConstructor],
     ["use-isnan", convertUseIsnan],
-    ["arrow-return-shorthand", convertArrowReturnShorthand],
-    ["curly", convertCurly],
-    ["cyclomatic-complexity", convertCyclomaticComplexity],
-    ["increment-decrement", convertIncrementDecrement],
-    ["linebreak-style", convertLinebreakStyle],
-    ["max-classes-per-file", convertMaxClassesPerFile],
-    ["max-file-line-count", convertMaxFileLineCount],
-    ["max-line-length", convertMaxLineLength],
-    ["no-consecutive-blank-lines", convertNoConsecutiveBlankLines],
-    ["no-console", convertNoConsole],
-    ["no-empty", convertNoEmpty],
-    ["no-invalid-template-strings", convertNoInvalidTemplateStrings],
-    ["no-invalid-this", convertNoInvalidThis],
-    ["no-magic-numbers", convertNoMagicNumbers],
-    ["object-literal-key-quotes", convertObjectLiteralKeyQuotes],
-    ["object-literal-shorthand", convertObjectLiteralShorthand],
-    ["one-variable-per-declaration", convertOneVariablePerDeclaration],
-    ["only-arrow-functions", convertOnlyArrowFunctions],
-    ["prefer-const", convertPreferConst],
-    ["prefer-function-over-method", convertPreferFunctionOverMethod],
-    ["prefer-readonly", convertPreferReadonly],
-    ["prefer-template", convertPreferTemplate],
-    ["space-before-function-paren", convertSpaceBeforeFunctionParen],
-    ["switch-default", convertSwitchDefault],
-    ["no-banned-terms", convertNoBannedTerms],
-    ["no-constant-condition", convertNoConstantCondition],
-    ["no-control-regex", convertNoControlRegex],
-    ["no-multiline-string", convertNoMultilineString],
-    ["no-invalid-regexp", convertNoInvalidRegexp],
-    ["no-octal-literal", convertNoOctalLiteral],
-    ["no-regex-spaces", convertNoRegexSpaces],
-    ["no-unnecessary-semicolons", convertNoUnnecessarySemicolons],
-    ["quotemark", convertQuotemark],
-    ["triple-equals", convertTripleEquals],
 
     // These converters are all for rules that need more complex option conversions.
     // Some of them will likely need to have notices about changed lint behaviors...
@@ -232,12 +238,9 @@ export const converters = new Map([
     // TSLint core rules:
     // ["ban", convertBan], // no-restricted-properties
     // ["import-blacklist", convertImportBlacklist], // no-restricted-imports
-    // ["newline-before-return", convertNewlineBeforeReturn],
     // ["no-duplicate-variable", convertNoDuplicateVariable], // no-redeclare
     // ["no-shadowed-variable", convertNoShadowedVariable], // no-shadow
-    // ["no-trailing-whitespace", convertNoTrailingWhitespace], //  no-trailing-spaces
     // ["no-unused-expression", convertNoUnusedExpression], // no-unused-expressions
-    // ["no-void-expression", convertNoVoidExpression], // (no exact equivalent)
     // ["space-within-parens", convertSpaceWithinParens], // space-in-parens
     // ["variable-name", convertVariableName], // a bunch of rules...
 

src/rules/converters.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/file-name-casing.ts

@@ -12,22 +12,22 @@ export const convertMaxLineLength: RuleConverter = tslintRule => {
 };
 
 const collectArguments = (ruleArguments: any[]) => {
-    if (ruleArguments.length === 0 || ruleArguments[0] === false || ruleArguments.length < 2) {
+    if (ruleArguments.length === 0) {
         return undefined;
     }
 
-    if (ruleArguments.length === 2 && typeof ruleArguments[1] === "number") {
+    const argument = ruleArguments[0];
+
+    if (typeof argument === "number") {
         return {
             ruleArguments: [
                 {
-                    code: ruleArguments[1],
+                    code: argument,
                 },
             ],
         };
     }
 
-    const argument = ruleArguments[1];
-
     return {
         ruleArguments: [
             {

src/rules/converters/max-line-length.ts

@@ -0,0 +1,19 @@
+import { RuleConverter } from "../converter";
+
+export const convertNewlineBeforeReturn: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "padding-line-between-statements",
+                ruleArguments: [
+                    "error",
+                    {
+                        blankLine: "always",
+                        prev: "*",
+                        next: "return",
+                    },
+                ],
+            },
+        ],
+    };
+};

src/rules/converters/newline-before-return.ts

@@ -0,0 +1,14 @@
+import { RuleConverter } from "../converter";
+
+export const convertNoDuplicateImports: RuleConverter = tslintRule => {
+    return {
+        rules: [
+            {
+                ...(tslintRule.ruleArguments.includes("allow-namespace-imports") && {
+                    notices: ["ESLint does not support optional config allow-namespace-imports."],
+                }),
+                ruleName: "no-duplicate-imports",
+            },
+        ],
+    };
+};