Add target option to regexp/prefer-range rule, and change default. (#56)

* Add `target` option to `regexp/prefer-range` rule, and change default.

* fix option schema

Author: ota-meshi

docs/rules/prefer-range.md

@@ -27,14 +27,94 @@ var foo = /[a-f]/
 /* ✗ BAD */
 var foo = /[abc]/
 var foo = /[a-cd-f]/
-
 ```
 
 </eslint-code-block>
 
 ## :wrench: Options
 
-Nothing.
+```json5
+{
+  "regexp/prefer-range": ["error",
+    {
+      "target": "alphanumeric" // or "all" or [...]
+    }
+  ]
+}
+```
+
+- `target` ... Specify the range of characters you want to check with this rule.
+  - `"alphanumeric"` ... Check only alphanumeric characters (`0-9`,`a-z` and `A-Z`). This is the default.
+  - `"all"` ... Check all characters. Use `"all"`, if you want to focus on regular expression optimization.
+  - `[...]` (Array) ... Specify as an array of character ranges. List the character ranges that your team is familiar with in this option, and replace redundant contiguous characters with ranges.
+    Specify the range as a three-character string in which the from and to characters are connected with a hyphen (`-`) using. e.g. `"!-/"` (U+0021 - U+002F), `"😀-😏"` (U+1F600 - U+1F60F)  
+    You can also use `"alphanumeric"`.
+
+### `"target": "alphanumeric"` (Default)
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/prefer-range: ["error", { "target": "alphanumeric" }] */
+
+/* ✓ GOOD */
+var foo = /[a-c]/
+var foo = /[a-f]/
+var foo = /[!-$]/
+var foo = /[!"#$]/
+var foo = /[😀-😄]/u
+var foo = /[😀😁😂😃😄]/u
+
+/* ✗ BAD */
+var foo = /[abc]/
+var foo = /[a-cd-f]/
+```
+
+</eslint-code-block>
+
+### `"target": "all"`
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/prefer-range: ["error", { "target": "all" }] */
+
+/* ✓ GOOD */
+var foo = /[a-c]/
+var foo = /[a-f]/
+var foo = /[!-$]/
+var foo = /[😀-😄]/u
+
+/* ✗ BAD */
+var foo = /[abc]/
+var foo = /[a-cd-f]/
+var foo = /[!"#$]/
+var foo = /[😀😁😂😃😄]/u
+```
+
+</eslint-code-block>
+
+### `"target": [ "alphanumeric", "😀-😏" ]`
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/prefer-range: ["error", { "target": [ "alphanumeric", "😀-😏" ] }] */
+
+/* ✓ GOOD */
+var foo = /[a-c]/
+var foo = /[a-f]/
+var foo = /[!-$]/
+var foo = /[!"#$]/
+var foo = /[😀-😄]/u
+
+/* ✗ BAD */
+var foo = /[abc]/
+var foo = /[a-cd-f]/
+var foo = /[😀😁😂😃😄]/u
+```
+
+</eslint-code-block>
 
 ## :rocket: Version
 

lib/rules/prefer-range.ts

@@ -1,7 +1,48 @@
 import type { Expression } from "estree"
 import type { RegExpVisitor } from "regexpp/visitor"
 import type { Character, CharacterClassRange } from "regexpp/ast"
-import { createRule, defineRegexpVisitor, getRegexpRange } from "../utils"
+import {
+    createRule,
+    defineRegexpVisitor,
+    getRegexpRange,
+    isDigit,
+    isLetter,
+} from "../utils"
+
+const reOptionRange = /^([\ud800-\udbff][\udc00-\udfff]|[^\ud800-\udfff])-([\ud800-\udbff][\udc00-\udfff]|[^\ud800-\udfff])$/
+
+/**
+ * Parse option
+ */
+function parseOption(
+    option:
+        | undefined
+        | {
+              target?: "all" | "alphanumeric" | string[]
+          },
+): (cp: number) => boolean {
+    const target = option?.target ?? ["alphanumeric"]
+    if (typeof target === "string") {
+        return parseOption({ target: [target] })
+    }
+    const predicates: ((cp: number) => boolean)[] = []
+    for (const t of target) {
+        if (t === "all") {
+            return () => true
+        }
+        if (t === "alphanumeric") {
+            predicates.push((cp) => isDigit(cp) || isLetter(cp))
+        }
+        const res = reOptionRange.exec(t)
+        if (!res) {
+            continue
+        }
+        const from = res[1].codePointAt(0)!
+        const to = res[2].codePointAt(0)!
+        predicates.push((cp) => from <= cp && cp <= to)
+    }
+    return (cp) => predicates.some((p) => p(cp))
+}
 
 export default createRule("prefer-range", {
     meta: {
@@ -12,14 +53,48 @@ export default createRule("prefer-range", {
             recommended: false,
         },
         fixable: "code",
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    target: {
+                        anyOf: [
+                            { enum: ["all", "alphanumeric"] },
+                            {
+                                type: "array",
+                                items: [{ enum: ["all", "alphanumeric"] }],
+                                minItems: 1,
+                                additionalItems: false,
+                            },
+                            {
+                                type: "array",
+                                items: {
+                                    anyOf: [
+                                        { const: "alphanumeric" },
+                                        {
+                                            type: "string",
+                                            pattern: reOptionRange.source,
+                                        },
+                                    ],
+                                },
+                                uniqueItems: true,
+                                minItems: 1,
+                                additionalItems: false,
+                            },
+                        ],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             unexpected:
                 'Unexpected multiple adjacent characters. Use "{{range}}" instead.',
         },
         type: "suggestion", // "problem",
     },
     create(context) {
+        const isTarget = parseOption(context.options[0])
         const sourceCode = context.getSourceCode()
 
         type CharacterGroup = {
@@ -66,8 +141,17 @@ export default createRule("prefer-range", {
                     for (const element of ccNode.elements) {
                         let data: { min: Character; max: Character }
                         if (element.type === "Character") {
+                            if (!isTarget(element.value)) {
+                                continue
+                            }
                             data = { min: element, max: element }
                         } else if (element.type === "CharacterClassRange") {
+                            if (
+                                !isTarget(element.min.value) &&
+                                !isTarget(element.max.value)
+                            ) {
+                                continue
+                            }
                             data = {
                                 min: element.min,
                                 max: element.max,

tests/lib/rules/prefer-range.ts

@@ -9,7 +9,40 @@ const tester = new RuleTester({
 })
 
 tester.run("prefer-range", rule as any, {
-    valid: [`/[a]/`, `/[ab]/`, `/[a-c]/`, `/[a-b]/`],
+    valid: [
+        `/[a]/`,
+        `/[ab]/`,
+        `/[a-c]/`,
+        `/[a-b]/`,
+        `/[0-9]/`,
+        `/[A-Z]/`,
+        `/[ !"#$]/`,
+        {
+            code: `/[ !"#$]/`,
+            options: [{ target: "alphanumeric" }],
+        },
+        {
+            code: `/[ !"#$]/`,
+            options: [{ target: ["alphanumeric"] }],
+        },
+        {
+            code: `/[ !"#$]/`,
+            options: [{ target: ["alphanumeric", "①-⑳"] }],
+        },
+        `/[ -$]/`,
+        {
+            code: `/[ -$]/`,
+            options: [{ target: "all" }],
+        },
+        {
+            code: `/[ -$]/`,
+            options: [{ target: ["all"] }],
+        },
+        {
+            code: `/[0123456789 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ]/`,
+            options: [{ target: ["😀-😏"] }],
+        },
+    ],
     invalid: [
         {
             code: `/[abc]/`,
@@ -25,6 +58,14 @@ tester.run("prefer-range", rule as any, {
                 },
             ],
         },
+        {
+            code: `/[ABC abc]/`,
+            output: `/[A-C a-c]/`,
+            errors: [
+                'Unexpected multiple adjacent characters. Use "A-C" instead.',
+                'Unexpected multiple adjacent characters. Use "a-c" instead.',
+            ],
+        },
         {
             code: `/[abc-f]/`,
             output: `/[a-f]/`,
@@ -156,5 +197,32 @@ tester.run("prefer-range", rule as any, {
                 'Unexpected multiple adjacent characters. Use "0-4" instead.',
             ],
         },
+        {
+            code: `/[ !"#$]/`,
+            output: `/[ -$]/`,
+            options: [{ target: "all" }],
+            errors: [
+                'Unexpected multiple adjacent characters. Use " -$" instead.',
+            ],
+        },
+        {
+            code: `/[abcd ①②③④⑤⑥⑦⑧⑨10⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳]/`,
+            output: `/[a-d ①-⑨10⑪-⑳]/`,
+            options: [{ target: ["alphanumeric", "①-⑳"] }],
+            errors: [
+                'Unexpected multiple adjacent characters. Use "a-d" instead.',
+                'Unexpected multiple adjacent characters. Use "①-⑨" instead.',
+                'Unexpected multiple adjacent characters. Use "⑪-⑳" instead.',
+            ],
+        },
+        {
+            code: `/[😀😁😂😃😄 😆😇😈😉😊]/u`,
+            output: `/[😀-😄 😆-😊]/u`,
+            options: [{ target: ["alphanumeric", "😀-😏"] }],
+            errors: [
+                'Unexpected multiple adjacent characters. Use "😀-😄" instead.',
+                'Unexpected multiple adjacent characters. Use "😆-😊" instead.',
+            ],
+        },
     ],
 })