eslint-plugin-restrict-replace-import 1.0.0 → 1.2.0

package/README.md

@@ -33,7 +33,7 @@ Then configure the rules you want to use under the rules section.
 ```json
 {
   "rules": {
-    "restrict-import/rule-name": [
+    "restrict-replace-import/restrict-import": [
       "error",
       ["restricted-package1", "restricted-package2"]
     ]
@@ -46,16 +46,35 @@ You can also specify an alternative package to import instead:
 ```json
 {
   "rules": {
-    "restrict-import/rule-name": [
+    "restrict-replace-import/restrict-import": [
       "error",
       [
         {
-          "name": "restricted-package1",
-          "alternative": "replacement-package1"
+          "target": "restricted-package1",
+          "replacement": "replacement-package1"
         },
         {
-          "name": "restricted-package2",
-          "alternative": "replacement-package2"
+          "target": "restricted-package2",
+          "replacement": "replacement-package2"
+        }
+      ]
+    ]
+  }
+}
+```
+
+You can use RegExp for package name:
+
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [
+        "with(?:-regex)?-support",
+        {
+          "target": "restricted-.*",
+          "replacement": "replacement-package"
         }
       ]
     ]

package/docs/rules/restrict-import.md

@@ -10,6 +10,8 @@ With additional configuration, this rule can also suggest an alternative package
 
 If the alternative package is specified, auto-fixing will replace the import statement with the alternative package.
 
+You can use RegExp to match multiple packages.
+
 ## Rule Details
 
 Example configuration:
@@ -21,25 +23,29 @@ Example configuration:
       "error",
       [
         {
-          "name": "test-package",
-          "alternative": "replacement-package"
+          "target": "test-package",
+          "replacement": "replacement-package"
         },
         "another-package"
+        "with(?:-regex)?-support"
       ]
     ]
   }
 }
 ```
 
-Examples of **incorrect** code for this rule:
+Examples of **incorrect** code for this rule with options above:
 
 ```js
 import testPackage from "test-package";
 
 import anotherPackage from "another-package";
+
+import withRegexSupport from "with-regex-support";
+import withSupport from "with-support";
 ```
 
-Examples of **correct** code for this rule:
+Examples of **correct** code for this rule with options above:
 
 ```js
 import testPackage from "replacement-package";

package/lib/rules/restrict-import.js

@@ -23,51 +23,43 @@ module.exports = {
         "`{{ name }}` is restricted from being used. Replace it with `{{ replacement }}`.",
     },
 
-    schema: [
-      {
-        type: "object",
-        properties: {
-          restrictedPackages: {
-            type: "array",
-            items: {
-              anyOf: [
-                {
-                  type: "string",
-                },
-                {
-                  type: "object",
-                  properties: {
-                    target: {
-                      type: "string",
-                      required: true,
-                    },
-                    replacement: {
-                      type: "string",
-                      required: false,
-                    },
-                  },
-                },
-              ],
+    schema: {
+      type: "array",
+      items: {
+        anyOf: [
+          {
+            type: "string",
+          },
+          {
+            type: "object",
+            properties: {
+              target: {
+                type: "string",
+              },
+              replacement: {
+                type: "string",
+              },
             },
           },
-        },
+        ],
       },
-    ],
+    },
   },
 
   create(context) {
-    const option = context.options[0];
-
     const restrictedPackages = new Map();
 
-    option.restrictedPackages.forEach((packageName) => {
+    context.options.forEach((packageName) => {
       if (typeof packageName === "string") {
-        restrictedPackages.set(packageName, null);
+        restrictedPackages.set(
+          new RegExp(`^${packageName}$`),
+          null
+        );
         return;
       }
 
       restrictedPackages.set(
-        packageName.target,
+        new RegExp(`^${packageName.target}$`),
         packageName.replacement
           ? packageName.replacement
           : null
@@ -75,15 +67,22 @@ module.exports = {
     });
 
     const checkRestricted = (importSource) => {
-      const isRestricted =
-        restrictedPackages.has(importSource);
-
-      return isRestricted;
+      const restrictedRegExp = Array.from(
+        restrictedPackages.keys()
+      ).find((packageName) => {
+        return packageName.test(importSource);
+      });
+
+      return {
+        isRestricted: !!restrictedRegExp,
+        restrictedRegExp,
+      };
     };
 
-    const getReplacement = (importSource) => {
-      const replacement =
-        restrictedPackages.get(importSource);
+    const getReplacement = (restrictedRegExp) => {
+      const replacement = restrictedPackages.get(
+        restrictedRegExp
+      );
 
       return replacement;
     };
@@ -93,7 +92,8 @@ module.exports = {
         const importSource = node.source.value;
         const importSourceType = node.source.type;
 
-        const isRestricted = checkRestricted(importSource);
+        const { isRestricted, restrictedRegExp } =
+          checkRestricted(importSource);
 
         if (
           !isRestricted ||
@@ -102,7 +102,9 @@ module.exports = {
           return;
         }
 
-        const replacement = getReplacement(importSource);
+        const replacement = getReplacement(
+          restrictedRegExp
+        );
         const quote = node.source.raw.includes("'")
           ? "'"
           : '"';
@@ -113,7 +115,7 @@ module.exports = {
             ? "ImportRestrictionWithReplacement"
             : "ImportRestriction",
           data: {
-            name: importSource,
+            name: restrictedRegExp.toString().slice(2, -2),
             replacement,
           },
           fix: (fixer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-restrict-replace-import",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "ESLint Plugin for Restricting and Replacing Import",
   "keywords": [
     "eslint",

package/tests/lib/rules/restrict-import.js

@@ -1,79 +0,0 @@
-/**
- * @fileoverview Prevent the Import of a Specific Package
- * @author shiwoo.park
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const rule = require("../../../lib/rules/restrict-import"),
-  RuleTester = require("eslint").RuleTester;
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    sourceType: "module",
-  },
-});
-
-const OPTIONS = [
-  {
-    restrictedPackages: [
-      "lodash",
-      {
-        target: "react",
-        replacement: "preact",
-      },
-    ],
-  },
-];
-
-ruleTester.run("restrict-import", rule, {
-  valid: [
-    {
-      code: "import _ from 'underscore'",
-      options: OPTIONS,
-    },
-    {
-      code: "import _ from 'lodash-es'",
-      options: OPTIONS,
-    },
-    {
-      code: "import { useState } from 'preact'",
-      options: OPTIONS,
-    },
-  ],
-
-  invalid: [
-    {
-      code: "import _ from 'lodash'",
-      errors: [
-        {
-          message:
-            "`lodash` is restricted from being used.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output: null,
-    },
-    {
-      code: "import { useState } from 'react'",
-      errors: [
-        {
-          message:
-            "`react` is restricted from being used. Replace it with `preact`.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output: "import { useState } from 'preact'",
-    },
-  ],
-});