refactor(fmt,html,internal,regexp,text,uuid,xml,yaml): add CONSTANT_CASE RegExp name lint check (#6994)

Author: timreichen

_tools/check_docs.ts

@@ -30,8 +30,8 @@ type DocNodeWithJsDoc<T = DocNodeBase> = T & {
   jsDoc: JsDoc;
 };
 
-const TS_SNIPPET = /```ts[\s\S]*?```/g;
-const ASSERTION_IMPORT =
+const TS_SNIPPET_REGEXP = /```ts[\s\S]*?```/g;
+const ASSERTION_IMPORT_REGEXP =
   /from "@std\/(assert(\/[a-z-]+)?|expect(\/[a-z-]+)?|testing\/(mock|snapshot|types))"/g;
 const NEWLINE = "\n";
 const diagnostics: DocumentError[] = [];
@@ -142,7 +142,7 @@ function assertHasSnippets(
   doc: string,
   document: { jsDoc: JsDoc; location: Location },
 ) {
-  const snippets = doc.match(TS_SNIPPET);
+  const snippets = doc.match(TS_SNIPPET_REGEXP);
   assert(
     snippets !== null,
     "@example tag must have a TypeScript code snippet",
@@ -155,7 +155,7 @@ function assertHasSnippets(
     snippet = snippet.split(NEWLINE).slice(1, -1).join(NEWLINE);
     if (!(delim?.includes("no-assert") || delim?.includes("ignore"))) {
       assert(
-        snippet.match(ASSERTION_IMPORT) !== null,
+        snippet.match(ASSERTION_IMPORT_REGEXP) !== null,
         "Snippet must contain assertion from `@std/assert`, `@std/expect` or `@std/testing`",
         document,
       );

_tools/lint_plugin.ts

@@ -11,9 +11,10 @@ import { toFileUrl } from "@std/path/to-file-url";
 import { resolve } from "@std/path/resolve";
 
 const PASCAL_CASE_REGEXP = /^_?(?:[A-Z][a-z0-9]*)*_?$/;
-const UPPER_CASE_ONLY = /^_?[A-Z]{2,}$/;
+const UPPER_CASE_ONLY_REGEXP = /^_?[A-Z]{2,}$/;
 function isPascalCase(string: string): boolean {
-  return PASCAL_CASE_REGEXP.test(string) && !UPPER_CASE_ONLY.test(string);
+  return PASCAL_CASE_REGEXP.test(string) &&
+    !UPPER_CASE_ONLY_REGEXP.test(string);
 }
 
 const CAMEL_CASE_REGEXP = /^[_a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*_?$/;
@@ -233,6 +234,38 @@ export default {
               if (id.type !== "Identifier") return;
               const name = id.name;
               if (!name) return;
+              if (isConstantCase(name)) {
+                if (
+                  declaration.init?.type === "NewExpression" &&
+                  declaration.init.callee.type === "Identifier"
+                ) {
+                  switch (declaration.init.callee.name) {
+                    case "RegExp": {
+                      if (name !== "REGEXP" && !name.endsWith("_REGEXP")) {
+                        context.report({
+                          node: id,
+                          message:
+                            `RegExp variable name '${name}' must end with _REGEXP.`,
+                          fix: (fixer) =>
+                            fixer.replaceText(id, `${name}_REGEXP`),
+                        });
+                      }
+                      break;
+                    }
+                  }
+                } else if (
+                  declaration.init?.type === "Literal" &&
+                  declaration.init.value instanceof RegExp &&
+                  name !== "REGEXP" && !name.endsWith("_REGEXP")
+                ) {
+                  context.report({
+                    node: id,
+                    message:
+                      `RegExp variable name '${name}' must end with _REGEXP.`,
+                    fix: (fixer) => fixer.replaceText(id, `${name}_REGEXP`),
+                  });
+                }
+              }
               if (
                 !isConstantCase(name) && !isCamelCase(name) &&
                 !isPascalCase(name)

fmt/colors.ts

@@ -976,7 +976,7 @@ export function bgRgb24(str: string, color: number | Rgb): string {
 }
 
 // https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
-const ANSI_PATTERN = new RegExp(
+const ANSI_REGEXP = new RegExp(
   [
     "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
     "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
@@ -998,5 +998,5 @@ const ANSI_PATTERN = new RegExp(
  * @returns The text without ANSI escape codes
  */
 export function stripAnsiCode(string: string): string {
-  return string.replace(ANSI_PATTERN, "");
+  return string.replace(ANSI_REGEXP, "");
 }

html/entities.ts

@@ -53,8 +53,8 @@ const defaultUnescapeOptions: UnescapeOptions = {
 
 const MAX_CODE_POINT = 0x10ffff;
 
-const RX_DEC_ENTITY = /&#([0-9]+);/g;
-const RX_HEX_ENTITY = /&#x(\p{AHex}+);/gu;
+const DEC_ENTITY_REGEXP = /&#([0-9]+);/g;
+const HEX_ENTITY_REGEXP = /&#x(\p{AHex}+);/gu;
 
 const entityListRegexCache = new WeakMap<EntityList, RegExp>();
 
@@ -111,8 +111,8 @@ export function unescape(
 
   return str
     .replaceAll(entityRe, (m) => entityList[m]!)
-    .replaceAll(RX_DEC_ENTITY, (_, dec) => codePointStrToChar(dec, 10))
-    .replaceAll(RX_HEX_ENTITY, (_, hex) => codePointStrToChar(hex, 16));
+    .replaceAll(DEC_ENTITY_REGEXP, (_, dec) => codePointStrToChar(dec, 10))
+    .replaceAll(HEX_ENTITY_REGEXP, (_, hex) => codePointStrToChar(hex, 16));
 }
 
 function codePointStrToChar(codePointStr: string, radix: number) {

html/unstable_is_valid_custom_element_name.ts

@@ -12,7 +12,7 @@ const FORBIDDEN_CUSTOM_ELEMENT_NAMES: string[] = [
   "missing-glyph",
 ] as const;
 
-const CUSTOM_ELEMENT_NAME_CHARS =
+const CUSTOM_ELEMENT_NAME_CHARS_REGEXP =
   /^[a-z](?:[-.0-9_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]|[\u{10000}-\u{EFFFF}])*-(?:[-.0-9_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF]|[\u{10000}-\u{EFFFF}])*$/u;
 
 /**
@@ -50,5 +50,5 @@ const CUSTOM_ELEMENT_NAME_CHARS =
  */
 export function isValidCustomElementName(elementName: string): boolean {
   return !FORBIDDEN_CUSTOM_ELEMENT_NAMES.includes(elementName) &&
-    CUSTOM_ELEMENT_NAME_CHARS.test(elementName);
+    CUSTOM_ELEMENT_NAME_CHARS_REGEXP.test(elementName);
 }

internal/diff_str.ts

@@ -35,7 +35,7 @@ export function unescape(string: string): string {
     );
 }
 
-const WHITESPACE_SYMBOLS =
+const WHITESPACE_SYMBOLS_REGEXP =
   /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
 
 /**
@@ -57,7 +57,7 @@ const WHITESPACE_SYMBOLS =
 export function tokenize(string: string, wordDiff = false): string[] {
   if (wordDiff) {
     return string
-      .split(WHITESPACE_SYMBOLS)
+      .split(WHITESPACE_SYMBOLS_REGEXP)
       .filter((token) => token);
   }
   const tokens: string[] = [];

internal/styles.ts

@@ -204,7 +204,7 @@ export function bgGreen(str: string): string {
 }
 
 // https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
-const ANSI_PATTERN = new RegExp(
+const ANSI_REGEXP = new RegExp(
   [
     "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
     "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
@@ -227,5 +227,5 @@ const ANSI_PATTERN = new RegExp(
  * ```
  */
 export function stripAnsiCode(string: string): string {
-  return string.replace(ANSI_PATTERN, "");
+  return string.replace(ANSI_REGEXP, "");
 }

path/posix/constants.ts

@@ -12,4 +12,5 @@ export const SEPARATOR = "/" as const;
 /**
  * A regular expression that matches one or more path separators.
  */
+// deno-lint-ignore deno-style-guide/naming-convention
 export const SEPARATOR_PATTERN = /\/+/;

path/windows/constants.ts

@@ -12,4 +12,5 @@ export const SEPARATOR = "\\" as const;
 /**
  * A regular expression that matches one or more path separators.
  */
+// deno-lint-ignore deno-style-guide/naming-convention
 export const SEPARATOR_PATTERN = /[\\/]+/;

regexp/escape.ts

@@ -65,7 +65,7 @@ const RESERVED_CHARS = {
   "|": "\\|",
 } as const;
 
-const RX_REGEXP_ESCAPE = new RegExp(
+const ESCAPE_REGEXP = new RegExp(
   `[${Object.values(RESERVED_CHARS).join("")}]`,
   "gu",
 );
@@ -91,7 +91,7 @@ const RX_REGEXP_ESCAPE = new RegExp(
  */
 export function escape(str: string): string {
   return str.replaceAll(
-    RX_REGEXP_ESCAPE,
+    ESCAPE_REGEXP,
     (m) => RESERVED_CHARS[m as keyof typeof RESERVED_CHARS],
   ).replace(/^[0-9a-zA-Z]/, (m) => `\\x${m.codePointAt(0)!.toString(16)}`);
 }