refactor: add notice, pass test coverage

Author: dimabory

src/rules/converters/import-blacklist.ts

@@ -13,34 +13,42 @@ type ESLintComplexOption = RequireAtLeastOne<{
 }>;
 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 => {
-    const tslintRules = tslintRule.ruleArguments;
     let ruleArguments: ESLintOptions = [];
+    const notices = [];
 
-    if (tslintRules.every(isString)) {
-        ruleArguments = tslintRules;
+    if (tslintRule.ruleArguments.every(isString)) {
+        ruleArguments = tslintRule.ruleArguments;
     } else {
-        ruleArguments = [
-            tslintRules.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] };
-                } else if (Array.isArray(rule)) {
-                    return { ...rules, patterns: [...(rules.patterns || []), ...rule] };
-                }
-                return rules;
-            }, {} as ESLintComplexOption),
-        ];
+        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",
             },
         ],

src/rules/converters/tests/import-blacklist.test.ts

@@ -55,10 +55,17 @@ describe(convertImportBlacklist, () => {
         ],
     ] as any[][])("convert %j", (ruleArguments: any[], expected: any[]) => {
         const result = convertImportBlacklist({ ruleArguments });
+        const hasPatterns = typeof expected[0] === "object" && "patterns" in expected[0];
+
         expect(result).toEqual({
             rules: [
                 {
                     ruleArguments: expected,
+                    ...(hasPatterns && {
+                        notices: [
+                            "ESLint and TSLint use different strategies to match patterns. TSLint uses standard regular expressions, but ESLint .gitignore spec.",
+                        ],
+                    }),
                     ruleName: "no-restricted-imports",
                 },
             ],