add a RegExp module to packages/effect, closes #2488 (#2493)

Author: gcanti

.changeset/gentle-actors-sing.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+add a `RegExp` module to `packages/effect`, closes #2488

packages/effect/src/RegExp.ts

@@ -0,0 +1,17 @@
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Escapes special characters in a regular expression pattern.
+ *
+ * @example
+ * import * as RegExp from "effect/RegExp"
+ *
+ * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ *
+ * @since 2.0.0
+ */
+export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

packages/effect/src/index.ts

@@ -599,6 +599,13 @@ export * as RedBlackTree from "./RedBlackTree.js"
  */
 export * as Ref from "./Ref.js"
 
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as RegExp from "./RegExp.js"
+
 /**
  * @since 2.0.0
  */

packages/effect/src/internal/configProvider.ts

@@ -13,6 +13,7 @@ import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
+import * as regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
@@ -595,7 +596,7 @@ export const within = dual<
 })
 
 const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
-  const split = text.split(new RegExp(`\\s*${escapeRegex(delim)}\\s*`))
+  const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
 
@@ -626,8 +627,6 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-
 const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),

packages/effect/test/RegExp.test.ts

@@ -0,0 +1,32 @@
+import * as RegExp from "effect/RegExp"
+import { describe, expect, it } from "vitest"
+
+describe("RegExp", () => {
+  describe("escape", () => {
+    it("should escape special characters correctly", () => {
+      const testCases: Array<[string, string]> = [
+        ["abc", "abc"],
+        ["a*b", "a\\*b"],
+        ["a.b", "a\\.b"],
+        ["a|b", "a\\|b"],
+        ["a?b", "a\\?b"],
+        ["a+b", "a\\+b"],
+        ["a(b", "a\\(b"],
+        ["a)b", "a\\)b"],
+        ["a[b", "a\\[b"],
+        ["a]b", "a\\]b"],
+        ["a{b", "a\\{b"],
+        ["a}b", "a\\}b"],
+        ["a^b", "a\\^b"],
+        ["a$b", "a\\$b"],
+        ["a\\b", "a\\\\b"],
+        ["a/b", "a\\/b"]
+      ]
+
+      testCases.forEach(([input, expected]) => {
+        const result = RegExp.escape(input)
+        expect(result).toEqual(expected)
+      })
+    })
+  })
+})

packages/schema/src/AST.ts

@@ -11,6 +11,7 @@ import * as Option from "effect/Option"
 import * as Order from "effect/Order"
 import * as Predicate from "effect/Predicate"
 import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as regexp from "effect/RegExp"
 import type { Concurrency } from "effect/Types"
 import * as util_ from "./internal/util.js"
 import type { ParseIssue } from "./ParseResult.js"
@@ -1834,29 +1835,22 @@ export const annotations = (ast: AST, annotations: Annotations): AST => {
  */
 export const keyof = (ast: AST): AST => Union.unify(_keyof(ast))
 
-const specialCharsRegex = /[.*+?^${}()|[\]\\]/g
-
-const escapeSpecialChars = (s: string): string =>
-  specialCharsRegex.test(s) ?
-    s.replace(specialCharsRegex, "\\$&") // $& means the whole matched string
-    : s
-
 const STRING_KEYWORD_PATTERN = ".*"
 const NUMBER_KEYWORD_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
 
 /**
  * @since 1.0.0
  */
 export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^${escapeSpecialChars(ast.head)}`
+  let pattern = `^${regexp.escape(ast.head)}`
 
   for (const span of ast.spans) {
     if (isStringKeyword(span.type)) {
       pattern += STRING_KEYWORD_PATTERN
     } else if (isNumberKeyword(span.type)) {
       pattern += NUMBER_KEYWORD_PATTERN
     }
-    pattern += escapeSpecialChars(span.literal)
+    pattern += regexp.escape(span.literal)
   }
 
   pattern += "$"