Added converter for underscore-consistent-invocation (#1071)

* Added converter for underscore-consistent-invocation

* Switched to 0 for always, only

Author: Josh Goldberg

src/converters/lintConfigs/rules/ruleConverters.ts

@@ -140,6 +140,7 @@ import { convertTripleEquals } from "./ruleConverters/triple-equals";
 import { convertTypedefWhitespace } from "./ruleConverters/typedef-whitespace";
 import { convertTypeLiteralDelimiter } from "./ruleConverters/type-literal-delimiter";
 import { convertTypeofCompare } from "./ruleConverters/typeof-compare";
+import { convertUnderscoreConsistentInvocation } from "./ruleConverters/underscore-consistent-invocation";
 import { convertUnifiedSignatures } from "./ruleConverters/unified-signatures";
 import { convertUnnecessaryBind } from "./ruleConverters/unnecessary-bind";
 import { convertUnnecessaryConstructor } from "./ruleConverters/unnecessary-constructor";
@@ -431,6 +432,7 @@ export const ruleConverters = new Map([
     ["type-literal-delimiter", convertTypeLiteralDelimiter],
     ["typedef-whitespace", convertTypedefWhitespace],
     ["typeof-compare", convertTypeofCompare],
+    ["underscore-consistent-invocation", convertUnderscoreConsistentInvocation],
     ["unified-signatures", convertUnifiedSignatures],
     ["unnecessary-bind", convertUnnecessaryBind],
     ["unnecessary-constructor", convertUnnecessaryConstructor],

src/converters/lintConfigs/rules/ruleConverters/tests/underscore-consistent-invocation.test.ts

@@ -0,0 +1,51 @@
+import { convertUnderscoreConsistentInvocation } from "../underscore-consistent-invocation";
+
+describe(convertUnderscoreConsistentInvocation, () => {
+    test("conversion without arguments", () => {
+        const result = convertUnderscoreConsistentInvocation({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            plugins: ["eslint-plugin-lodash"],
+            rules: [
+                {
+                    ruleArguments: ['never'],
+                    ruleName: "lodash/chaining",
+                },
+            ],
+        });
+    });
+
+    test("conversion with an instance argument", () => {
+        const result = convertUnderscoreConsistentInvocation({
+            ruleArguments: ['instance'],
+        });
+
+        expect(result).toEqual({
+            plugins: ["eslint-plugin-lodash"],
+            rules: [
+                {
+                    ruleArguments: ['never'],
+                    ruleName: "lodash/chaining",
+                },
+            ],
+        });
+    });
+
+    test("conversion with a static argument", () => {
+        const result = convertUnderscoreConsistentInvocation({
+            ruleArguments: ['static'],
+        });
+
+        expect(result).toEqual({
+            plugins: ["eslint-plugin-lodash"],
+            rules: [
+                {
+                    ruleArguments: ['always', 0],
+                    ruleName: "lodash/chaining",
+                },
+            ],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/underscore-consistent-invocation.ts

@@ -0,0 +1,15 @@
+import { RuleConverter } from "../ruleConverter";
+
+export const convertUnderscoreConsistentInvocation: RuleConverter = (tslintRule) => {
+    return {
+        plugins: ["eslint-plugin-lodash"],
+        rules: [
+            {
+                ruleArguments: tslintRule.ruleArguments.length === 0 || tslintRule.ruleArguments[0] === 'instance'
+                    ? ['never']
+                    : ['always', 0],
+                ruleName: "lodash/chaining",
+            },
+        ],
+    };
+};