Add regexp/letter-case rule (#35)

ota-meshi · web-flow · commit 97c1beaaa611 · 2021-03-06T13:04:31.000+09:00
diff --git a/README.md b/README.md
@@ -79,6 +79,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [regexp/letter-case](https://ota-meshi.github.io/eslint-plugin-regexp/rules/letter-case.html) | enforce into your favorite case | :wrench: |
 | [regexp/match-any](https://ota-meshi.github.io/eslint-plugin-regexp/rules/match-any.html) | enforce match any character style | :star::wrench: |
 | [regexp/no-assertion-capturing-group](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-assertion-capturing-group.html) | disallow capturing group that captures assertions. | :star: |
 | [regexp/no-dupe-characters-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-characters-character-class.html) | disallow duplicate characters in the RegExp character class | :star: |
diff --git a/docs/rules/README.md b/docs/rules/README.md
@@ -11,6 +11,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [regexp/letter-case](./letter-case.md) | enforce into your favorite case | :wrench: |
 | [regexp/match-any](./match-any.md) | enforce match any character style | :star::wrench: |
 | [regexp/no-assertion-capturing-group](./no-assertion-capturing-group.md) | disallow capturing group that captures assertions. | :star: |
 | [regexp/no-dupe-characters-character-class](./no-dupe-characters-character-class.md) | disallow duplicate characters in the RegExp character class | :star: |
diff --git a/docs/rules/letter-case.md b/docs/rules/letter-case.md
@@ -0,0 +1,56 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/letter-case"
+description: "enforce into your favorite case"
+---
+# regexp/letter-case
+
+> enforce into your favorite case
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the problems reported by this rule.
+
+## :book: Rule Details
+
+This rule aims to unify the case of letters.
+
+<eslint-code-block fix>
+
+```js
+/* eslint regexp/letter-case: "error" */
+
+/* ✓ GOOD */
+var foo = /a/i
+var foo = /\u000a/
+
+/* ✗ BAD */
+var foo = /A/i
+var foo = /\u000A/
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+```json5
+{
+  "regexp/letter-case": ["error", {
+    "caseInsensitive": "lowercase", // or "uppercase" or "ignore"
+    "unicodeEscape": "lowercase" // or "uppercase" or "ignore"
+  }]
+}
+```
+
+- String options
+  - `"lowercase"` ... Enforce lowercase letters. This is default.
+  - `"uppercase"` ... Enforce uppercase letters.
+  - `"ignore"` ... Does not force case.
+- Properties
+  - `caseInsensitive` ... Specifies the letter case when the `i` flag is present.
+  - `unicodeEscape` ... Specifies the letter case when the unicode escapes.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/letter-case.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/letter-case.ts)
diff --git a/lib/rules/letter-case.ts b/lib/rules/letter-case.ts
@@ -0,0 +1,207 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import type { Character, CharacterClassRange } from "regexpp/ast"
+import {
+    createRule,
+    defineRegexpVisitor,
+    getRegexpLocation,
+    getRegexpRange,
+    isLetter,
+    isLowercaseLetter,
+    isUppercaseLetter,
+} from "../utils"
+
+const CASE_SCHEMA = ["lowercase", "uppercase", "ignore"] as const
+type Case = typeof CASE_SCHEMA[number]
+
+/** Parse option */
+function parseOptions(option?: {
+    caseInsensitive?: Case
+    unicodeEscape?: Case
+}): { caseInsensitive: Case; unicodeEscape: Case } {
+    if (!option) {
+        return { caseInsensitive: "lowercase", unicodeEscape: "lowercase" }
+    }
+    return {
+        caseInsensitive: option.caseInsensitive || "lowercase",
+        unicodeEscape: option.unicodeEscape || "lowercase",
+    }
+}
+
+const CODE_POINT_CASE_CHECKER = {
+    lowercase: isLowercaseLetter,
+    uppercase: isUppercaseLetter,
+}
+const STRING_CASE_CHECKER = {
+    lowercase: (s: string) => s.toLowerCase() === s,
+    uppercase: (s: string) => s.toUpperCase() === s,
+}
+const CONVERTER = {
+    lowercase: (s: string) => s.toLowerCase(),
+    uppercase: (s: string) => s.toUpperCase(),
+}
+
+export default createRule("letter-case", {
+    meta: {
+        docs: {
+            description: "enforce into your favorite case",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    caseInsensitive: { enum: CASE_SCHEMA },
+                    unicodeEscape: { enum: CASE_SCHEMA },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpected: "'{{char}}' is not in {{case}}",
+        },
+        type: "layout", // "problem",
+    },
+    create(context) {
+        const options = parseOptions(context.options[0])
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Report
+         */
+        function report(
+            node: Expression,
+            reportNode: CharacterClassRange | Character,
+            letterCase: "lowercase" | "uppercase",
+            convertText: (converter: (s: string) => string) => string,
+        ) {
+            context.report({
+                node,
+                loc: getRegexpLocation(sourceCode, node, reportNode),
+                messageId: "unexpected",
+                data: {
+                    char: reportNode.raw,
+                    case: letterCase,
+                },
+                fix(fixer) {
+                    const range = getRegexpRange(sourceCode, node, reportNode)
+                    if (range == null) {
+                        return null
+                    }
+                    const newText = convertText(CONVERTER[letterCase])
+                    return fixer.replaceTextRange(range, newText)
+                },
+            })
+        }
+
+        /** Verify for Character in case insensitive */
+        function verifyCharacterInCaseInsensitive(
+            node: Expression,
+            cNode: Character,
+        ) {
+            if (
+                cNode.parent.type === "CharacterClassRange" ||
+                options.caseInsensitive === "ignore"
+            ) {
+                return
+            }
+            if (
+                CODE_POINT_CASE_CHECKER[options.caseInsensitive](cNode.value) ||
+                !isLetter(cNode.value)
+            ) {
+                return
+            }
+
+            report(node, cNode, options.caseInsensitive, (converter) =>
+                converter(String.fromCodePoint(cNode.value)),
+            )
+        }
+
+        /** Verify for CharacterClassRange in case insensitive */
+        function verifyCharacterClassRangeInCaseInsensitive(
+            node: Expression,
+            ccrNode: CharacterClassRange,
+        ) {
+            if (options.caseInsensitive === "ignore") {
+                return
+            }
+            if (
+                CODE_POINT_CASE_CHECKER[options.caseInsensitive](
+                    ccrNode.min.value,
+                ) ||
+                !isLetter(ccrNode.min.value) ||
+                CODE_POINT_CASE_CHECKER[options.caseInsensitive](
+                    ccrNode.max.value,
+                ) ||
+                !isLetter(ccrNode.max.value)
+            ) {
+                return
+            }
+            report(
+                node,
+                ccrNode,
+                options.caseInsensitive,
+                (converter) =>
+                    `${converter(
+                        String.fromCodePoint(ccrNode.min.value),
+                    )}-${converter(String.fromCodePoint(ccrNode.max.value))}`,
+            )
+        }
+
+        /** Verify for Character in unicode escape */
+        function verifyCharacterInUnicodeEscape(
+            node: Expression,
+            cNode: Character,
+        ) {
+            if (options.unicodeEscape === "ignore") {
+                return
+            }
+            const parts = /(\\u\{?)(.*)(\}?)/u.exec(cNode.raw)!
+            if (STRING_CASE_CHECKER[options.unicodeEscape](parts[2])) {
+                return
+            }
+            report(
+                node,
+                cNode,
+                options.unicodeEscape,
+                (converter) => `${parts[1]}${converter(parts[2])}${parts[3]}`,
+            )
+        }
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(
+            node: Expression,
+            _pattern: string,
+            flags: string,
+        ): RegExpVisitor.Handlers {
+            return {
+                onCharacterEnter(cNode) {
+                    if (flags.includes("i")) {
+                        verifyCharacterInCaseInsensitive(node, cNode)
+                    }
+                    if (cNode.raw.startsWith("\\u")) {
+                        verifyCharacterInUnicodeEscape(node, cNode)
+                    }
+                },
+                ...(flags.includes("i")
+                    ? {
+                          onCharacterClassRangeEnter(ccrNode) {
+                              verifyCharacterClassRangeInCaseInsensitive(
+                                  node,
+                                  ccrNode,
+                              )
+                          },
+                      }
+                    : {}),
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})
diff --git a/lib/utils/rules.ts b/lib/utils/rules.ts
@@ -1,4 +1,5 @@
 import type { RuleModule } from "../types"
+import letterCase from "../rules/letter-case"
 import matchAny from "../rules/match-any"
 import noAssertionCapturingGroup from "../rules/no-assertion-capturing-group"
 import noDupeCharactersCharacterClass from "../rules/no-dupe-characters-character-class"
@@ -24,6 +25,7 @@ import preferUnicodeCodepointEscapes from "../rules/prefer-unicode-codepoint-esc
 import preferW from "../rules/prefer-w"
 
 export const rules = [
+    letterCase,
     matchAny,
     noAssertionCapturingGroup,
     noDupeCharactersCharacterClass,
diff --git a/lib/utils/unicode.ts b/lib/utils/unicode.ts
@@ -89,16 +89,29 @@ function isCodePointInRange(
 export function isDigit(codePoint: number): boolean {
     return isCodePointInRange(codePoint, CP_RANGE_DIGIT)
 }
+/**
+ * Checks if the given code point is lowercase.
+ * @param codePoint The code point to check
+ * @returns {boolean} `true` if the given code point is lowercase.
+ */
+export function isLowercaseLetter(codePoint: number): boolean {
+    return isCodePointInRange(codePoint, CP_RANGE_SMALL_LETTER)
+}
+/**
+ * Checks if the given code point is uppercase.
+ * @param codePoint The code point to check
+ * @returns {boolean} `true` if the given code point is uppercase.
+ */
+export function isUppercaseLetter(codePoint: number): boolean {
+    return isCodePointInRange(codePoint, CP_RANGE_CAPITAL_LETTER)
+}
 /**
  * Checks if the given code point is letter.
  * @param codePoint The code point to check
  * @returns {boolean} `true` if the given code point is letter.
  */
 export function isLetter(codePoint: number): boolean {
-    return (
-        isCodePointInRange(codePoint, CP_RANGE_SMALL_LETTER) ||
-        isCodePointInRange(codePoint, CP_RANGE_CAPITAL_LETTER)
-    )
+    return isLowercaseLetter(codePoint) || isUppercaseLetter(codePoint)
 }
 /**
  * Checks if the given code point is symbol.
diff --git a/tests/lib/rules/letter-case.ts b/tests/lib/rules/letter-case.ts
