eslint-plugin-smarthr 0.0.0 → 0.0.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.1](https://github.com/kufu/eslint-plugin-smarthr/compare/v0.0.0...v0.0.1) (2022-02-08)
+
+
+### Features
+
+* add type property function params redundant ([758df90](https://github.com/kufu/eslint-plugin-smarthr/commit/758df90f89bd27dd589aeeb55165e27c8e072b08))
+* redundant-name の修正候補を操作できるように改修 ([20991e8](https://github.com/kufu/eslint-plugin-smarthr/commit/20991e874890556e84e7c682e789e4b2650a85b0))
+
 ### [0.0.2](https://github.com/kufu/eslint-plugin-smarthr/compare/v0.0.1...v0.0.2) (2022-01-26)
 
 ### [0.0.1](https://github.com/kufu/eslint-plugin-smarthr/compare/v0.0.0...v0.0.1) (2022-01-26)

package/README.md

@@ -305,47 +305,14 @@ import { PrimaryButton, SecondaryButton } from 'smarthr-ui'
 ### config
 
 - tsconfig.json の compilerOptions.pathsに '@/*' としてroot path を指定する必要があります
-- 以下の設定を記述する必要があります
+- 以下の設定を行えます。全て省略可能です。
   - ignoreKeywords
     - ディレクトリ名から生成されるキーワードに含めたくない文字列を指定します
-  - keywordGenerator
-    - ディレクトリ名から生成されるキーワードを元に最終的なキーワードを生成します
-  - suffixGenerator:
+  - betterNames
+    - 対象の名前を修正する候補を指定します
+  - suffix:
     - type のみ指定出来ます
-    - type のsuffixを生成します
-
-#### 指定例
-```
-const ignorekeywords = ['views', 'parts']
-const keywordGenerator = ({ keywords }) => (
-  keywords.reduce((prev, keyword, index) => {
-    switch (keyword) {
-      case 'repositories':
-        return [...prev, keyword, 'repository']
-    }
-
-    const replacedKeyword = keyword.replace(/(repository|s)$/, '')
-    if (keyword !== replacedKeyword) {
-      return [...prev, keyword, replacedKeyword]
-    }
-
-    return [...prev, keyword]
-  }, [])
-)
-// 例: actions 以下の場合だけ 'Action' もしくは `Actions` のSuffixを許可する
-const suffixGenerator = ({ node, filename }) => {
-  let suffix = ['Props', 'Type']
-
-  if (filename.match(/\/actions\//)) {
-    suffix = [
-      isUnionType || (node.typeAnnotation.type === 'TSTypeReference' && node.id.name.match(/Actions$/))
-        ? 'Actions'
-        : 'Action',
-      ...suffix,
-    ]
-  }
-}
-```
+    - type のsuffixを指定します
 
 #### ファイル例
 - `@/crews/index/views/page.tsx` の場合
@@ -359,17 +326,33 @@ const suffixGenerator = ({ node, filename }) => {
 ### rules
 
 ```js
+const ignorekeywords = ['views', 'parts']
+const betterNames = {
+  '\/repositories\/': {
+    operator: '-',
+    names: ['repository', 'Repository'],
+  },
+  '\/entities\/': {
+    operator: '+',
+    names: ['entity'],
+  },
+  '\/slices\/': {
+    operator: '=',
+    names: ['index'],
+  },
+}
+
 {
   rules: {
     'smarthr/redundant-name': [
       'error', // 'warn', 'off'
       {
-        type: { ignorekeywords, keywordGenerator, suffixGenerator },
-        file: { ignorekeywords, keywordGenerator },
-        // property: { ignorekeywords, keywordGenerator },
-        // function: { ignorekeywords, keywordGenerator },
-        // variable: { ignorekeywords, keywordGenerator },
-        // class: { ignorekeywords, keywordGenerator },
+        type: { ignorekeywords, suffix: ['Props', 'Type'] },
+        file: { ignorekeywords, betternames },
+        // property: { ignorekeywords },
+        // function: { ignorekeywords },
+        // variable: { ignorekeywords },
+        // class: { ignorekeywords },
       }
     ]
   },

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+	moduleFileExtensions: ['js'],
+	testMatch: ['**/test/**/*.+(js)'],
+	roots: ['<rootDir>/']
+}

package/libs/common_domain.js

@@ -6,7 +6,6 @@ const BASE_SCHEMA_PROPERTIES = {
   globalModuleDir: { type: 'array', items: { type: 'string' } },
   domainModuleDir: { type: 'array', items: { type: 'string' }, default: [] },
   domainConstituteDir: { type: 'array', items: { type: 'string' } },
-  isDomain: { type: 'function' },
 }
 
 const calculateDomainContext = (context) => {
@@ -87,13 +86,14 @@ const calculateDomainNode = (calclatedContext, node) => {
   let filteredDirs = dirs
   let filteredPaths = paths
 
+  const deductedNames = []
   const recursiveDeductionEq = () => {
     if (dirs.length === 0 || paths.length === 0) {
       return
     }
 
     if (dirs[0] === paths[0]) {
-      dirs.shift()
+      deductedNames.push(dirs.shift())
       paths.shift()
       recursiveDeductionEq()
     }
@@ -102,21 +102,22 @@ const calculateDomainNode = (calclatedContext, node) => {
   filteredDirs = dirs
   filteredPaths = paths
 
+  let isDomainConstitute = false
+
   if (option.domainConstituteDir) {
+    const { domainConstituteDir } = option
+    isDomainConstitute =
+      !!deductedNames.find((d) => domainConstituteDir.includes(d)) || // 同一dirを削り、その中にconstitute dir があれば同一ドメイン
+      domainConstituteDir.includes(dirs[0]) && domainConstituteDir.includes(paths[0]) // 同一を削りきった先頭が両方constitute dirならば同一ドメイン
+
     // HINT: 同一ドメイン内（例: workflows/index）で定形で利用されるディレクトリ名を省くことで
     // ドメインの識別に利用される文字を抽出する
     dirs = dirs.filter((k) => !option.domainConstituteDir.includes(k))
     paths = paths.filter((k) => !option.domainConstituteDir.includes(k))
   }
 
-  if (option.isDomain) {
-    // HINT: ドメインの識別に利用される文字を抽出する
-    dirs = dirs.filter((k) => option.isDomain(k))
-    paths = paths.filter((k) => option.isDomain(k))
-  }
-
   const isLowerImport = filteredDirs.length === 0 // 同一階層、もしくは下層からのimport
-  const isDomainImport = dirs.length === 0 // 同一ドメイン内、もしくは同一階層・下層からのimport
+  const isDomainImport = dirs.length === 0 || isDomainConstitute // 同一ドメイン内、もしくは同一階層・下層からのimport
   const isModuleImport = paths.length > 0 && option.domainModuleDir.includes(paths[0]) // ドメイン内共通パーツ
 
   return {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "eslint-plugin-smarthr",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "author": "SmartHR",
   "license": "MIT",
   "description": "A sharable ESLint plugin for SmartHR",
   "main": "index.js",
   "scripts": {
+    "test": "jest",
     "release:dryrun": "standard-version --dry-run",
     "release": "standard-version"
   },
@@ -21,9 +22,12 @@
     "url": "https://github.com/kufu/eslint-plugin-smarthr/issues"
   },
   "dependencies": {
+    "inflected": "^2.1.0",
     "json5": "^2.2.0"
   },
   "devDependencies": {
+    "eslint": "^8.8.0",
+    "jest": "^27.4.7",
     "standard-version": "^9.3.2"
   },
   "peerDependencies": {

package/rules/prohibit-import.js

@@ -1,15 +1,30 @@
-const SCHEMA = [
-  {
-    type: 'object',
-    properties: {
-      targets: { type: 'object', default: {} },
-      generateReportMessage: { type: 'function' },
+const SCHEMA = [{
+  type: "object",
+  patternProperties: {
+    ".+": {
+      type: "object",
+      required: [
+        "imported",
+      ],
+      properties: {
+        imported: {
+            type: ["boolean", "array"],
+            items: {
+              type: "string"
+            }
+        },
+        reportMessage: {
+            type: "string"
+        }
+      },
+      additionalProperties: false
+      }
     },
-    additionalProperties: false,
+    additionalProperties: true,
   }
 ]
 
-const generateDefaultReportMessage = (source, imported) => `${source}${imported && `/${imported}`} は利用しないでください`
+const defaultReportMessage = (moduleName, exportName) => `${moduleName}${typeof exportName == 'string' ? `/${exportName}`: ''} は利用しないでください`
 
 module.exports = {
   meta: {
@@ -20,32 +35,32 @@ module.exports = {
     schema: SCHEMA,
   },
   create(context) {
-    const option = context.options[0]
-    const parsedOption = Object.entries(option.targets)
-    const generateReportMessage = option.generateReportMessage || generateDefaultReportMessage
-
+    const options = context.options[0]
+    const targetModules = Object.keys(options)
     return {
       ImportDeclaration: (node) => {
-        parsedOption.forEach(([matchText, importNames]) => {
-          if (!node.source.value.match(new RegExp(matchText))) {
+        targetModules.forEach((targetModule) => {
+          if (!node.source.value.match(new RegExp(targetModule))) {
             return
           }
-
-          const imported = (() => {
-            if (!Array.isArray(importNames)) {
-              return !!importNames
+          
+          const {imported, reportMessage} = Object.assign({imported: true}, options[targetModule])
+          const useImported = (() => {
+            if (!Array.isArray(imported)) {
+              return !!imported
             }
-            const specifier = node.specifiers.find((s) => importNames.includes(s.imported.name))
+
+            const specifier = node.specifiers.find((s) => s.imported && imported.includes(s.imported.name))
 
             return specifier ? specifier.imported.name : false
           })()
 
-          if (imported) {
+          if (useImported) {
             context.report({
               node,
               messageId: 'prohibit_import',
               data: {
-                message: generateReportMessage(node.source.value, imported === true ? '' : imported),
+                message: reportMessage ? reportMessage.replace('{{module}}', node.source.value).replace('{{export}}', useImported) : defaultReportMessage(node.source.value, useImported)
               },
             });
           }
@@ -54,4 +69,5 @@ module.exports = {
     }
   },
 }
+
 module.exports.schema = SCHEMA

package/rules/redundant-name.js

@@ -1,8 +1,13 @@
 const path = require('path')
+const Inflector = require('inflected')
+
 const { rootPath } = require('../libs/common')
 
 const uniq = (array) => array.filter((elem, index, self) => self.indexOf(elem) === index)
 
+const COMMON_DEFAULT_CONFIG = {
+  IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
+}
 const DEFAULT_CONFIG = {
   type: {
     IGNORE_KEYWORDS: [
@@ -11,44 +16,56 @@ const DEFAULT_CONFIG = {
     ],
     SUFFIX: ['Props', 'Type'],
   },
-  file: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
-  property: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
-  function: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
-  variable: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
-  class: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
-  method: {
-    IGNORE_KEYWORDS: ['redux', 'views', 'pages', 'parts'],
-  },
+  typeProperty: COMMON_DEFAULT_CONFIG,
+  file: COMMON_DEFAULT_CONFIG,
+  property: COMMON_DEFAULT_CONFIG,
+  function: COMMON_DEFAULT_CONFIG,
+  functionParams: COMMON_DEFAULT_CONFIG,
+  variable: COMMON_DEFAULT_CONFIG,
+  class: COMMON_DEFAULT_CONFIG,
+  method: COMMON_DEFAULT_CONFIG,
 }
 
+const BETTER_NAMES_CALCULATER_PROPERTY = {
+  type: 'object',
+  properties: {
+    operator: ['-', '+', '='],
+    names:  {
+      type: 'array',
+      items: 'string',
+    },
+  },
+}
 const DEFAULT_SCHEMA_PROPERTY = {
   ignoreKeywords: { type: 'array', items: { type: 'string' } },
-  keywordGenerator: { type: 'function' },
+  betterNames: {
+    type: 'object',
+    properties: {
+      operator: ['-', '+', '='],
+      names:  {
+        type: 'array',
+        items: 'string',
+      },
+    },
+  },
 }
 
 const SCHEMA = [
   {
     type: 'object',
     properties: {
-      file: DEFAULT_SCHEMA_PROPERTY,
       type: {
         ...DEFAULT_SCHEMA_PROPERTY,
-        suffixGenerator: { type: 'function' },
+        suffix: { type: 'array', items: { type: 'string' } },
       },
+      typeProperty: DEFAULT_SCHEMA_PROPERTY,
+      file: DEFAULT_SCHEMA_PROPERTY,
       property: DEFAULT_SCHEMA_PROPERTY,
       function: DEFAULT_SCHEMA_PROPERTY,
+      functionParams: DEFAULT_SCHEMA_PROPERTY,
       variable: DEFAULT_SCHEMA_PROPERTY,
       class: DEFAULT_SCHEMA_PROPERTY,
+      method: DEFAULT_SCHEMA_PROPERTY,
     },
     additionalProperties: false,
   }
@@ -68,21 +85,22 @@ const generateRedundantKeywords = ({ args, key, terminalImportName }) => {
   const option = args.option[key] || {}
   const ignoreKeywords = option.ignoreKeywords || DEFAULT_CONFIG[key].IGNORE_KEYWORDS
   const terminalImportKeyword = terminalImportName ? terminalImportName.toLowerCase() : '' 
-  const filterKeywords = (keys) => keys.filter((k) => k !== terminalImportKeyword && !ignoreKeywords.includes(k))
 
-  let redundantKeywords = filterKeywords(args.keywords)
-  if (option.keywordGenerator) {
-    redundantKeywords = option.keywordGenerator({
-      ...args,
-      redundantKeywords,
-    })
-  }
+  return args.keywords.reduce((prev, keyword) => {
+    if (keyword === terminalImportKeyword || ignoreKeywords.includes(keyword)) {
+      return prev
+    }
+
+    const singularized = Inflector.singularize(keyword)
 
-  return redundantKeywords
+    return singularized === keyword ? [...prev, keyword] : [...prev, keyword, singularized]
+  }, [])
 }
 const handleReportBetterName = ({
   key, 
   context,
+  option,
+  filename,
   redundantKeywords,
   defaultBetterName,
   fetchName,
@@ -99,40 +117,75 @@ const handleReportBetterName = ({
       return
     }
 
-    let hitCount = 0
-    let betterName = redundantKeywords.reduce((prev, keyword) => {
-      const replaced = prev.replace(new RegExp(keyword, 'i'), '')
+    let candidates = []
+    let conciseName = redundantKeywords.reduce((prev, keyword) => {
+      const regex = new RegExp(`(${keyword})`, 'i')
+      const matcher = prev.match(regex)
+
+      if (matcher) {
+        candidates.push(matcher[1])
 
-      if (prev !== replaced) {
-        hitCount++
+        return prev.replace(regex, '')
       }
 
-      return replaced
+      return prev
     }, name)
 
-    if (name !== betterName) {
-      betterName = betterName
+    if (name !== conciseName) {
+      conciseName = conciseName
                      .replace(/^_+/, '')
                      .replace(/_+$/, '')
                      .replace(/_+/, '_')
+      let fullRedundant = false
 
-      if (!betterName) {
+      if (!conciseName) {
+        fullRedundant = true
         // HINT: 1keywordで構成されている名称はそのままにする
-        betterName = hitCount === 1 ? name : defaultBetterName
+        conciseName = candidates.length === 1 ? name : defaultBetterName
       }
 
       // HINT: camelCase、lower_snake_case の場合、keywordが取り除かれた結果違うケースになってしまう場合があるので対応する
-      if (name.match(/^[a-z]/) && betterName.match(/^[A-Z]/)) {
-        betterName = `${betterName[0].toLowerCase()}${betterName.slice(1)}`
+      if (name.match(/^[a-z]/) && conciseName.match(/^[A-Z]/)) {
+        conciseName = `${conciseName[0].toLowerCase()}${conciseName.slice(1)}`
+      }
+
+      if (fullRedundant) {
+        if (name.match(/^[A-Z]/)) {
+          candidates = candidates.map((k) => `${k[0].toUpperCase()}${k.slice(1)}`)
+        }
+      } else {
+        candidates = []
       }
+
+      candidates = uniq([conciseName, ...candidates].filter((k) => !!k))
+
+      if (option.betterNames) {
+        Object.entries(option.betterNames).forEach(([regex, calc]) => {
+          if (calc && filename.match(new RegExp(regex))) {
+            switch(calc.operator) {
+              case '=': 
+                candidates = calc.names
+                break
+              case '-': 
+                candidates = candidates.filter((c) => !calc.names.includes(c))
+                break
+              case '+': 
+                candidates = uniq([...candidates, ...calc.names])
+                break
+            }
+          }
+        })
+      }
+
+      candidates = candidates.filter((c) => c !== name)
     }
 
-    if (name !== betterName) {
+    if (candidates.length > 0) {
       context.report({
         node,
         messageId: `${key}-name`,
         data: {
-          message: generateMessage({ name, betterName }),
+          message: generateMessage({ name, betterName: candidates.join(', ') }),
         },
       });
     }
@@ -145,17 +198,10 @@ const generateTypeRedundant = (args) => {
   const redundantKeywords = generateRedundantKeywords({ args, key })
   const option = args.option[key]
   const defaultConfig = DEFAULT_CONFIG[key]
-  const actualArgs = {
-    ...args,
-    redundantKeywords,
-  }
 
   return (node) => {
     const typeName = node.id.name
-    const suffix = option.suffixGenerator ? option.suffixGenerator({
-      ...actualArgs,
-      node,
-    }) : defaultConfig.SUFFIX
+    const suffix = option.suffix || defaultConfig.SUFFIX
 
     let SuffixedName = typeName
     let report = null
@@ -197,12 +243,41 @@ const generateTypeRedundant = (args) => {
   }
 }
 
+const generateTypePropertyRedundant = (args) => {
+  const key = 'typeProperty'
+
+  return handleReportBetterName({
+    ...args,
+    key,
+    option: args.option[key],
+    redundantKeywords: generateRedundantKeywords({ args, key }),
+    defaultBetterName: '',
+    fetchName: (node) => node.key.name,
+  })
+}
+const generateTypePropertyFunctionParamsRedundant = (args) => {
+  const key = 'typeProperty'
+  const redundant = handleReportBetterName({
+    ...args,
+    key,
+    option: args.option[key],
+    redundantKeywords: generateRedundantKeywords({ args, key }),
+    defaultBetterName: '',
+    fetchName: (node) => node.name,
+  })
+
+  return (node) => {
+    node.params.forEach((param) => redundant(param))
+  }
+}
+
 const generatePropertyRedundant = (args) => {
   const key = 'property'
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key }),
     defaultBetterName: 'item',
     fetchName: (node) => node.key.name,
@@ -214,8 +289,9 @@ const generateFileRedundant = (args) => {
   const terminalImportName = fetchTerminalImportName(args.filename)
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key, terminalImportName }),
     defaultBetterName: 'index',
     fetchName: () => terminalImportName,
@@ -227,20 +303,37 @@ const generateFunctionRedundant = (args) => {
   const key = 'function'
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key, terminalImportName: fetchTerminalImportName(args.filename) }),
     defaultBetterName: '',
     fetchName: (node) => node.id.name,
   })
 }
+const generateFunctionParamsRedundant = (args) => {
+  const key = 'functionParams'
+  const redundant = handleReportBetterName({
+    ...args,
+    key,
+    option: args.option[key],
+    redundantKeywords: generateRedundantKeywords({ args, key }),
+    defaultBetterName: '',
+    fetchName: (node) => node.name,
+  })
+
+  return (node) => {
+    node.params.forEach((param) => redundant(param))
+  }
+}
 
 const generateVariableRedundant = (args) => {
   const key = 'variable'
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key, terminalImportName: fetchTerminalImportName(args.filename) }),
     defaultBetterName: '',
     fetchName: (node) => node.id.name,
@@ -251,8 +344,9 @@ const generateClassRedundant = (args) => {
   const key = 'class'
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key, terminalImportName: fetchTerminalImportName(args.filename) }),
     defaultBetterName: '',
     fetchName: (node) => node.id.name,
@@ -263,8 +357,9 @@ const generateMethodRedundant = (args) => {
   const key = 'method'
 
   return handleReportBetterName({
+    ...args,
     key,
-    context: args.context,
+    option: args.option[key],
     redundantKeywords: generateRedundantKeywords({ args, key }),
     defaultBetterName: 'item',
     fetchName: (node) => node.key.name,
@@ -278,8 +373,10 @@ module.exports = {
       'file-name': ' {{ message }}',
       'type-name': '{{ message }}',
       'type-name/invalid-suffix': '{{ message }}',
+      'typeProperty-name': '{{ message }}',
       'property-name': ' {{ message }}',
       'function-name': ' {{ message }}',
+      'functionParams-name': ' {{ message }}',
       'variable-name': ' {{ message }}',
       'class-name': ' {{ message }}',
       'method-name': ' {{ message }}',
@@ -324,50 +421,73 @@ module.exports = {
       keywords,
     }
 
+    const addRule = (key, redundant) => {
+      const addedRules = rules[key] || []
+
+      rules[key] = [...addedRules, redundant]
+    }
+
     if (option.type) {
-      rules = {
-        ...rules,
-        TSTypeAliasDeclaration: generateTypeRedundant(args),
-      }
+      addRule('TSTypeAliasDeclaration', generateTypeRedundant(args))
+      // addRule('TSInterfaceDeclaration', generateTypeRedundant(args)) // 必要になったら実装する
+    }
+    if (option.typeProperty) {
+      const typePropRedundant = generateTypePropertyRedundant(args)
+      const typeFuncParamRedundant = generateTypePropertyFunctionParamsRedundant(args)
+
+      addRule('TSPropertySignature', (node) => {
+        typePropRedundant(node)
+
+        if (node.typeAnnotation.typeAnnotation.type === 'TSFunctionType') {
+          typeFuncParamRedundant(node.typeAnnotation.typeAnnotation)
+        }
+      })
     }
     if (option.property) {
-      propRedundant = generatePropertyRedundant(args)
+      const redundant = generatePropertyRedundant(args)
 
-      rules = {
-        ...rules,
-        Property: propRedundant,
-        PropertyDefinition: propRedundant,
-      }
+      addRule('Property', redundant)
+      addRule('PropertyDefinition', redundant)
     }
     if (option.file) {
-      rules = {
-        ...rules,
-        Program: generateFileRedundant(args),
-      }
+      addRule('Program', generateFileRedundant(args))
     }
     if (option.function) {
-      rules = {
-        ...rules,
-        FunctionDeclaration: generateFunctionRedundant(args),
-      }
+      addRule('FunctionDeclaration', generateFunctionRedundant(args))
+    }
+    if (option.functionParams) {
+      const redundant = generateFunctionParamsRedundant(args)
+
+      addRule('FunctionDeclaration', redundant)
+      addRule('ArrowFunctionExpression', redundant)
+      addRule('MethodDefinition', (node) => {
+        if (node.value.type === 'FunctionExpression') {
+          redundant(node.value)
+        }
+      })
     }
     if (option.variable) {
       const redundant = generateVariableRedundant(args)
 
-      rules = {
-        ...rules,
-        VariableDeclarator: redundant,
-        TSEnumDeclaration: redundant,
-      }
+      addRule('VariableDeclarator', redundant)
+      addRule('TSEnumDeclaration', redundant)
     }
     if (option.class) {
-      rules = {
-        ...rules,
-        ClassDeclaration: generateClassRedundant(args),
-        MethodDefinition: generateMethodRedundant(args) ,
-      }
+      addRule('ClassDeclaration', generateClassRedundant(args))
+    }
+    if (option.method) {
+      addRule('MethodDefinition', generateMethodRedundant(args))
     }
 
+    Object.keys(rules).forEach((key) => {
+      const redundants = rules[key]
+      rules[key] = (node) => {
+        redundants.forEach((redundant) => {
+          redundant(node)
+        })
+      }
+    })
+
     return rules
   },
 }

package/test/prohibit-import.js

@@ -0,0 +1,116 @@
+const rule = require("../rules/prohibit-import")
+const RuleTester = require("eslint").RuleTester
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    sourceType: "module",
+    ecmaVersion: 2015
+  },
+})
+
+ruleTester.run("prohibit-import-lodash", rule, {
+  valid: [
+    {
+      code: `import _ from 'lodash-es'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: true,
+          },
+        }
+      ]
+    },
+    {
+      code: `import { isEqual } from 'lodash-es'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: ['isEqual']
+          },
+        }
+      ]
+    },
+    {
+      code: `import { isEqaul } from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: ['isEqual']
+          },
+        }
+      ]
+    },
+    {
+      code: `import _ from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: ['isEqual']
+          },
+        }
+      ]
+    }
+  ],
+  invalid: [
+    {
+      code: `import _ from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: true
+          },
+        }
+      ],
+      errors: [{ message: 'lodash は利用しないでください' }]
+    },
+    {
+      code: `import { isEqual } from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: true
+          },
+        }
+      ],
+      errors: [{ message: 'lodash は利用しないでください' }]
+    },
+    {
+      code: `import { isEqual } from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: ['isEqual']
+          },
+        }
+      ],
+      errors: [{message: 'lodash/isEqual は利用しないでください'}]
+    },
+    {
+      code: `import { isEqual } from 'lodash'`,
+      options: [
+        {
+          '^lodash$': {
+            imported: ['isEqual'],
+            "reportMessage": "must not use {{module}}/{{export}}"
+          },
+        }
+      ],
+      errors: [{message: 'must not use lodash/isEqual'}]
+    },
+    {
+      code: `import { isEqual } from 'lodash'`,
+      options: [
+        {
+          'example': {
+            imported: true,
+          },
+          '^lodash$': {
+            imported: ['isEqual'],
+            reportMessage: "must not use {{module}}/{{export}}",
+          },
+        }
+      ],
+      errors: [{message: 'must not use lodash/isEqual'}]
+    }
+  ]
+})