ESLint - Require capture and custom message (#3220)

* added require capture to eslint no direct import rule

* fixed autofix

* removed extra import

* added custom message option

* added a more complex require example

* change imp to use the utils

* removed autofix change

* fixed identation

* combined implemetation

Author: nitzanyiz

eslint-rules/lib/rules/no-direct-import.js

@@ -1,4 +1,4 @@
-const {handleError} = require('../utils');
+const {handleError, addToImports} = require('../utils');
 
 const RULE_ID = 'no-direct-import';
 const MAP_SCHEMA = {
@@ -50,19 +50,29 @@ module.exports = {
     schema: [MAP_SCHEMA]
   },
   create(context) {
-    function reportDirectImport(node, rule) {
+    function getErrorMessage(rule, type) {
+      const {origin, destination, applyAutofix, customMessage} = rule;
+      const autofixMessage = applyAutofix ? ' (autofix available)' : '';
+      return customMessage || `Do not ${type} directly from '${origin}'. Please use '${destination}'${autofixMessage}.`;
+    }
+
+    function checkAndReport(node, type, importedModuleNameToReplace) {
+      const imports = [];
+      addToImports(node, imports);
+      const modules = new Set(collectModulesFromImports(imports));
+      const rule = getRules().find((rule) => modules.has(rule.origin));
+      if (!rule) {
+        return;
+      }
       try {
-        const origin = rule.origin;
-        const destination = rule.destination;
-        const applyAutofix = rule.applyAutofix;
-        const autofixMessage = applyAutofix ? ' (autofix available)' : '';
-        const message = `Do not import directly from '${origin}'. Please use '${destination}'${autofixMessage}.`;
+        const {applyAutofix, destination} = rule;
+        const message = getErrorMessage(rule, type);
         context.report({
           node,
           message,
           fix(fixer) {
             if (node && applyAutofix && destination) {
-              return fixer.replaceText(node.source, `'${destination}'`);
+              return fixer.replaceText(importedModuleNameToReplace, `'${destination}'`);
             }
           }
         });
@@ -76,17 +86,25 @@ module.exports = {
       return context.options[0].rules || [context.options[0]];
     }
 
-    function checkImportDeclaration(node) {
-      const source = node.source.value;
-      const rule = getRules().find((rule) => rule.origin === source);
-      
-      if (rule) {
-        reportDirectImport(node, rule);
-      }
+    function collectModulesFromImports(imports) {
+      const collection = [];
+      imports.forEach((moduleImports) => {
+        collection.push(...Object.keys(moduleImports));
+      });
+      return collection;
+    }
+
+    function getModuleNameFromRequire(node) {
+      return (node.init.object ? node.init.object.arguments : node.init.arguments)[0]
+    }
+
+    function getModuleNameFromImport(node) {
+      return node.source;
     }
 
     return {
-      ImportDeclaration: checkImportDeclaration
+      ImportDeclaration: (node) => checkAndReport(node, 'import', getModuleNameFromImport(node)),
+      VariableDeclarator: (node) => checkAndReport(node, 'require', getModuleNameFromRequire(node)),
     };
   }
 };

eslint-rules/tests/lib/rules/no-direct-import.js

@@ -14,6 +14,11 @@ const ruleOptionsArray = [
   }
 ];
 
+customErrorMessage = 'This is a custom message';
+const ruleWithCustomMessage = [
+  {origin: 'some-module', destination: 'another-module', applyAutofix: true, customMessage: customErrorMessage}
+]
+
 RuleTester.setDefaultConfig({
   parser: 'babel-eslint',
   parserOptions: {ecmaVersion: 6, ecmaFeatures: {jsx: true}}
@@ -23,26 +28,45 @@ const ruleTester = new RuleTester();
 
 const validExample1 = `import {Component} from 'another-module';`;
 const validExample2 = `import {Component} from 'new-module';`;
+const validExample3 = `const {Component} = require('another-module');`;
+const validExample4 = `const test = require('new-module').test;`;
 
 const invalidExample1 = `import {Component} from 'some-module';`;
 const invalidExample2 = `import {Component} from 'old-module';`;
+const invalidExample3 = `const {Component} = require('some-module');`;
+const invalidExample4 = `const {Component} = require('old-module');`;
+const invalidExample5 = `const test = require(\'some-module\').test;`;
 
 const error1 = `Do not import directly from 'some-module'. Please use 'another-module' (autofix available).`;
 const error2 = `Do not import directly from 'old-module'. Please use 'new-module' (autofix available).`;
+const requireError1 = `Do not require directly from 'some-module'. Please use 'another-module' (autofix available).`;
+const requireError2 = `Do not require directly from 'old-module'. Please use 'new-module' (autofix available).`;
 
 ruleTester.run('no-direct-import', rule, {
   valid: [
     {
       options: ruleOptions,
-      code: validExample1 
+      code: validExample1
+    },
+    {
+      options: ruleOptions,
+      code: validExample3
     },
     {
       options: ruleOptionsArray,
       code: validExample1
     },
     {
       options: ruleOptionsArray,
-      code: validExample2 
+      code: validExample2
+    },
+    {
+      options: ruleOptionsArray,
+      code: validExample3
+    },
+    {
+      options: ruleOptionsArray,
+      code: validExample4
     }
   ],
   invalid: [
@@ -69,6 +93,44 @@ ruleTester.run('no-direct-import', rule, {
       errors: [
         {message: error2}
       ]
+    },
+    {
+      options: ruleOptions,
+      code: invalidExample3,
+      output: `const {Component} = require('another-module');`,
+      errors: [
+        {message: requireError1}
+      ]
+    },
+    {
+      options: ruleOptionsArray,
+      code: invalidExample4,
+      output: `const {Component} = require('new-module');`,
+      errors: [
+        {message: requireError2}
+      ]
+    },
+    {
+      options: ruleWithCustomMessage,
+      code: invalidExample1,
+      errors: [
+        {message: customErrorMessage}
+      ]
+    },
+    {
+      options: ruleWithCustomMessage,
+      code: invalidExample3,
+      errors: [
+        {message: customErrorMessage}
+      ]
+    },
+    {
+      options: ruleOptions,
+      code: invalidExample5,
+      output: 'const test = require(\'another-module\').test;',
+      errors: [
+        {message: requireError1}
+      ]
     }
   ]
 });