refactor: use regexp-groups to simplify ignores (#2776)

Co-authored-by: Flo Edelmann <git@flo-edelmann.de>

Author: ST-DDT

lib/rules/attribute-hyphenation.js

@@ -6,7 +6,7 @@
 
 const utils = require('../utils')
 const casing = require('../utils/casing')
-const { toRegExp } = require('../utils/regexp')
+const { toRegExpGroupMatcher } = require('../utils/regexp')
 const svgAttributes = require('../utils/svg-attributes-weird-case.json')
 
 /**
@@ -79,11 +79,7 @@ module.exports = {
     const option = context.options[0]
     const optionsPayload = context.options[1]
     const useHyphenated = option !== 'never'
-    /** @type {RegExp[]} */
-    const ignoredTagsRegexps = (
-      (optionsPayload && optionsPayload.ignoreTags) ||
-      []
-    ).map(toRegExp)
+    const isIgnoredTagName = toRegExpGroupMatcher(optionsPayload?.ignoreTags)
     const ignoredAttributes = ['data-', 'aria-', 'slot-scope', ...svgAttributes]
 
     if (optionsPayload && optionsPayload.ignore) {
@@ -142,11 +138,6 @@ module.exports = {
       return useHyphenated ? value.toLowerCase() === value : !/-/.test(value)
     }
 
-    /** @param {string} name */
-    function isIgnoredTagName(name) {
-      return ignoredTagsRegexps.some((re) => re.test(name))
-    }
-
     return utils.defineTemplateBodyVisitor(context, {
       VAttribute(node) {
         const element = node.parent.parent

lib/rules/component-name-in-template-casing.js

@@ -6,7 +6,7 @@
 
 const utils = require('../utils')
 const casing = require('../utils/casing')
-const { toRegExp } = require('../utils/regexp')
+const { toRegExpGroupMatcher } = require('../utils/regexp')
 
 const allowedCaseOptions = ['PascalCase', 'kebab-case']
 const defaultCase = 'PascalCase'
@@ -81,8 +81,7 @@ module.exports = {
     const caseType = allowedCaseOptions.includes(caseOption)
       ? caseOption
       : defaultCase
-    /** @type {RegExp[]} */
-    const ignores = (options.ignores || []).map(toRegExp)
+    const isIgnored = toRegExpGroupMatcher(options.ignores)
     /** @type {string[]} */
     const globals = (options.globals || []).map(casing.pascalCase)
     const registeredComponentsOnly = options.registeredComponentsOnly !== false
@@ -116,7 +115,7 @@ module.exports = {
      * @returns {boolean} `true` if the given node is the verification target node.
      */
     function isVerifyTarget(node) {
-      if (ignores.some((re) => re.test(node.rawName))) {
+      if (isIgnored(node.rawName)) {
         // ignore
         return false
       }

lib/rules/custom-event-name-casing.js

@@ -7,7 +7,7 @@
 const { findVariable } = require('@eslint-community/eslint-utils')
 const utils = require('../utils')
 const casing = require('../utils/casing')
-const { toRegExp } = require('../utils/regexp')
+const { toRegExpGroupMatcher } = require('../utils/regexp')
 
 /**
  * @typedef {import('../utils').VueObjectData} VueObjectData
@@ -92,8 +92,7 @@ module.exports = {
     const caseType = context.options[0] || DEFAULT_CASE
     const objectOption = context.options[1] || {}
     const caseChecker = casing.getChecker(caseType)
-    /** @type {RegExp[]} */
-    const ignores = (objectOption.ignores || []).map(toRegExp)
+    const isIgnored = toRegExpGroupMatcher(objectOption.ignores)
 
     /**
      * Check whether the given event name is valid.
@@ -109,7 +108,7 @@ module.exports = {
      */
     function verify(nameWithLoc) {
       const name = nameWithLoc.name
-      if (isValidEventName(name) || ignores.some((re) => re.test(name))) {
+      if (isValidEventName(name) || isIgnored(name)) {
         return
       }
       context.report({

lib/rules/no-restricted-block.js

@@ -12,30 +12,16 @@ const regexp = require('../utils/regexp')
  * @property {string} [message]
  */
 
-/**
- * @param {string} str
- * @returns {(str: string) => boolean}
- */
-function buildMatcher(str) {
-  if (regexp.isRegExp(str)) {
-    const re = regexp.toRegExp(str)
-    return (s) => {
-      re.lastIndex = 0
-      return re.test(s)
-    }
-  }
-  return (s) => s === str
-}
 /**
  * @param {any} option
  * @returns {ParsedOption}
  */
 function parseOption(option) {
   if (typeof option === 'string') {
-    const matcher = buildMatcher(option)
+    const matcher = regexp.toRegExp(option, { remove: 'g' })
     return {
       test(block) {
-        return matcher(block.rawName)
+        return matcher.test(block.rawName)
       }
     }
   }

lib/rules/no-restricted-class.js

@@ -12,20 +12,10 @@ const regexp = require('../utils/regexp')
  * @param {string} className
  * @param {*} node
  * @param {RuleContext} context
- * @param {Set<string>} forbiddenClasses
- * @param {Array<RegExp>} forbiddenClassesRegexps
+ * @param {(name: string) => boolean} isForbiddenClass
  */
-const reportForbiddenClass = (
-  className,
-  node,
-  context,
-  forbiddenClasses,
-  forbiddenClassesRegexps
-) => {
-  if (
-    forbiddenClasses.has(className) ||
-    forbiddenClassesRegexps.some((re) => re.test(className))
-  ) {
+const reportForbiddenClass = (className, node, context, isForbiddenClass) => {
+  if (isForbiddenClass(className)) {
     const loc = node.value ? node.value.loc : node.loc
     context.report({
       node,
@@ -123,24 +113,16 @@ module.exports = {
 
   /** @param {RuleContext} context */
   create(context) {
-    const forbiddenClasses = new Set(context.options || [])
-    const forbiddenClassesRegexps = (context.options || [])
-      .filter((cl) => regexp.isRegExp(cl))
-      .map((cl) => regexp.toRegExp(cl))
+    const { options = [] } = context
+    const isForbiddenClass = regexp.toRegExpGroupMatcher(options)
 
     return utils.defineTemplateBodyVisitor(context, {
       /**
        * @param {VAttribute & { value: VLiteral } } node
        */
       'VAttribute[directive=false][key.name="class"][value!=null]'(node) {
         for (const className of node.value.value.split(/\s+/)) {
-          reportForbiddenClass(
-            className,
-            node,
-            context,
-            forbiddenClasses,
-            forbiddenClassesRegexps
-          )
+          reportForbiddenClass(className, node, context, isForbiddenClass)
         }
       },
 
@@ -155,13 +137,7 @@ module.exports = {
         for (const { className, reportNode } of extractClassNames(
           /** @type {Expression} */ (node.expression)
         )) {
-          reportForbiddenClass(
-            className,
-            reportNode,
-            context,
-            forbiddenClasses,
-            forbiddenClassesRegexps
-          )
+          reportForbiddenClass(className, reportNode, context, isForbiddenClass)
         }
       }
     })

lib/rules/no-restricted-component-names.js

@@ -22,7 +22,7 @@ const { isRegExp, toRegExp } = require('../utils/regexp')
  */
 function buildMatcher(str) {
   if (isRegExp(str)) {
-    const regex = toRegExp(str)
+    const regex = toRegExp(str, { remove: 'g' })
     return (s) => regex.test(s)
   }
   return (s) => s === casing.pascalCase(str) || s === casing.kebabCase(str)

lib/rules/no-restricted-component-options.js

@@ -23,21 +23,6 @@ const regexp = require('../utils/regexp')
  * @typedef { (node: Property | SpreadElement) => (MatchResult | null) } Tester
  */
 
-/**
- * @param {string} str
- * @returns {Matcher}
- */
-function buildMatcher(str) {
-  if (regexp.isRegExp(str)) {
-    const re = regexp.toRegExp(str)
-    return (s) => {
-      re.lastIndex = 0
-      return re.test(s)
-    }
-  }
-  return (s) => s === str
-}
-
 /**
  * @param {string | string[] | { name: string | string[], message?: string } } option
  * @returns {ParsedOption}
@@ -65,7 +50,8 @@ function parseOption(option) {
     if (name === '*') {
       steps.push({ wildcard: true })
     } else {
-      steps.push({ test: buildMatcher(name) })
+      const matcher = regexp.toRegExp(name, { remove: 'g' })
+      steps.push({ test: (value) => matcher.test(value) })
     }
   }
   const message = option.message

lib/rules/no-restricted-custom-event.js

@@ -15,30 +15,16 @@ const regexp = require('../utils/regexp')
  * @property {string|undefined} [suggest]
  */
 
-/**
- * @param {string} str
- * @returns {(str: string) => boolean}
- */
-function buildMatcher(str) {
-  if (regexp.isRegExp(str)) {
-    const re = regexp.toRegExp(str)
-    return (s) => {
-      re.lastIndex = 0
-      return re.test(s)
-    }
-  }
-  return (s) => s === str
-}
 /**
  * @param {string|{event: string, message?: string, suggest?: string}} option
  * @returns {ParsedOption}
  */
 function parseOption(option) {
   if (typeof option === 'string') {
-    const matcher = buildMatcher(option)
+    const matcher = regexp.toRegExp(option, { remove: 'g' })
     return {
       test(name) {
-        return matcher(name)
+        return matcher.test(name)
       }
     }
   }

lib/rules/no-restricted-props.js

@@ -18,30 +18,16 @@ const regexp = require('../utils/regexp')
  * @property {string|undefined} [suggest]
  */
 
-/**
- * @param {string} str
- * @returns {(str: string) => boolean}
- */
-function buildMatcher(str) {
-  if (regexp.isRegExp(str)) {
-    const re = regexp.toRegExp(str)
-    return (s) => {
-      re.lastIndex = 0
-      return re.test(s)
-    }
-  }
-  return (s) => s === str
-}
 /**
  * @param {string|{name:string, message?: string, suggest?:string}} option
  * @returns {ParsedOption}
  */
 function parseOption(option) {
   if (typeof option === 'string') {
-    const matcher = buildMatcher(option)
+    const matcher = regexp.toRegExp(option, { remove: 'g' })
     return {
       test(name) {
-        return matcher(name)
+        return matcher.test(name)
       }
     }
   }

lib/rules/no-restricted-static-attribute.js

@@ -15,30 +15,16 @@ const regexp = require('../utils/regexp')
  * @property {string} [message]
  */
 
-/**
- * @param {string} str
- * @returns {(str: string) => boolean}
- */
-function buildMatcher(str) {
-  if (regexp.isRegExp(str)) {
-    const re = regexp.toRegExp(str)
-    return (s) => {
-      re.lastIndex = 0
-      return re.test(s)
-    }
-  }
-  return (s) => s === str
-}
 /**
  * @param {any} option
  * @returns {ParsedOption}
  */
 function parseOption(option) {
   if (typeof option === 'string') {
-    const matcher = buildMatcher(option)
+    const matcher = regexp.toRegExp(option, { remove: 'g' })
     return {
       test({ key }) {
-        return matcher(key.rawName)
+        return matcher.test(key.rawName)
       }
     }
   }
@@ -53,25 +39,25 @@ function parseOption(option) {
         return node.value == null || node.value.value === node.key.rawName
       }
     } else {
-      const valueMatcher = buildMatcher(option.value)
+      const valueMatcher = regexp.toRegExp(option.value, { remove: 'g' })
       parsed.test = (node) => {
         if (!keyTest(node)) {
           return false
         }
-        return node.value != null && valueMatcher(node.value.value)
+        return node.value != null && valueMatcher.test(node.value.value)
       }
     }
     parsed.useValue = true
   }
   if (option.element) {
     const argTest = parsed.test
-    const tagMatcher = buildMatcher(option.element)
+    const tagMatcher = regexp.toRegExp(option.element, { remove: 'g' })
     parsed.test = (node) => {
       if (!argTest(node)) {
         return false
       }
       const element = node.parent.parent
-      return tagMatcher(element.rawName)
+      return tagMatcher.test(element.rawName)
     }
     parsed.useElement = true
   }