fast_regexp 0.5.0-aarch64-linux → 0.6.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d582628d35a655bddbc2957b25874b21ee2c7a53c3cde023c1cf7a2a7570ed2
-  data.tar.gz: 161d29c08b3897f77248b624904fa26ddf7512ae73f74f31d845ac545d70bfea
+  metadata.gz: '039084596a2999534c4e78c9c3fc008ddcf0712a573c93234f4191d9b8e6fd3d'
+  data.tar.gz: 8f2629a2a40c5a82c26f73ce9826954bf8de24ab879757c7e672808a3b1edf26
 SHA512:
-  metadata.gz: d53c46c5cc47cc38d4b1b64c1c93473850ee5b9ae864538c0792a2675b9bf64496eb7328193678bff35990810be6dbe80340cd74d6dd099fedb6f4f79607a262
-  data.tar.gz: 280a5bc0c14b490089cc6a3098bceba67bd58dfb347a526c3ee979ad11561888fdb7342a53173c7a854727d352b8ab0cf4f900740f448958e867308ee47834de
+  metadata.gz: 415c361fe5761dfcb68d734c970e120189cd2f7770dc8997af51e4572c42ba17f72fa1d04465d3b67d9f191ffc58054b8bff98498a42ff41ad25145ecad0eed1
+  data.tar.gz: 2a011e1aa4c1b1c45107fbe93ed9dffe1e5d94e61bfb429e57daa58feeeabf8dca954d85c041dee7cdb5844e5cd7df1b39be1f696fa419e2c65477036cb2a950

data/README.md

@@ -5,7 +5,7 @@
 
 Fast, drop-in regex for Ruby — backed by [rust/regex](https://docs.rs/regex/latest/regex/) with transparent fallback to the stdlib `::Regexp` engine for features rust/regex doesn't support (lookaround, backreferences, possessive quantifiers, etc.).
 
-You get rust/regex's speed and GVL-releasing matching on the common path, and a single uniform API (`Fast::Regexp`, `Fast::Regexp::MatchData`) regardless of which engine actually ran underneath.
+You get rust/regex's speed on the common path, and a single uniform API (`Fast::Regexp`, `Fast::Regexp::MatchData`) regardless of which engine actually ran underneath.
 
 ## Installation
 
@@ -155,6 +155,14 @@ slow.match?("foobar")  # => true
 / `#stdlib` accessors. Replacement templates use rust/regex syntax (`$1`,
 `${name}`, `$$`) on both paths; the stdlib fallback translates them for you.
 
+You can force a specific engine via the `backend:` kwarg:
+
+```ruby
+Fast::Regexp.new('\w+', backend: :fast)     # rust/regex only; raises on unsupported
+Fast::Regexp.new(pat,   backend: :stdlib)   # skip rust/regex; use ::Regexp directly
+Fast::Regexp.new('\w+', backend: :auto)     # default — try rust, fall back on reject
+```
+
 > [!NOTE]
 > The fast path is byte-based (rust/regex's `regex::bytes`), so `#=~` returns
 > a *byte* offset. The stdlib fallback path returns the byte offset too, for
@@ -230,7 +238,7 @@ In-depth docs live under [`docs/`](docs/README.md), organized via the
 - **Tutorial:** [Getting started](docs/tutorials/getting-started.md)
 - **How-to:** [Migrate from stdlib `::Regexp`](docs/how-to/migrate-from-stdlib-regexp.md), [Handle unsupported syntax](docs/how-to/handle-unsupported-syntax.md)
 - **Reference:** [`Fast::Regexp`](docs/reference/fast-regexp.md), [`MatchData`](docs/reference/fast-regexp-matchdata.md), [`Set`](docs/reference/fast-regexp-set.md)
-- **Explainers:** [Engine fallback](docs/explainers/engine-fallback.md), [Concurrency and GVL](docs/explainers/concurrency-and-gvl.md)
+- **Explainers:** [Engine fallback](docs/explainers/engine-fallback.md)
 
 ## Development
 
@@ -252,8 +260,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jetpks
 huge thanks for the original bindings and the clean magnus integration that
 made this work easy to extend. This fork rebrands the gem, reshapes the
 public API (`Fast::Regexp`, real `MatchData`, `sub`/`gsub`, `===`/`=~`,
-`Regexp`-constructor coercion), releases the GVL around regex execution for
-thread/fiber-friendly matching, and adds transparent fallback to stdlib
+`Regexp`-constructor coercion), and adds transparent fallback to stdlib
 `::Regexp` for patterns rust/regex can't compile.
 
 ## License

data/lib/fast_regexp/version.rb

@@ -2,6 +2,6 @@
 
 module Fast
   class Regexp
-    VERSION = "0.5.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/fast_regexp.rb

@@ -6,9 +6,9 @@ module Fast
   # Façade over rust/regex with a transparent fallback to stdlib `::Regexp`.
   #
   # `Fast::Regexp.new(pattern)` first tries to compile with rust/regex (fast,
-  # GVL-releasing, byte-based). If the pattern uses features rust/regex does
-  # not support (lookaround, backreferences, possessive quantifiers, etc.) we
-  # fall back to `::Regexp` so consumers don't have to juggle two libraries.
+  # byte-based). If the pattern uses features rust/regex does not support
+  # (lookaround, backreferences, possessive quantifiers, etc.) we fall back
+  # to `::Regexp` so consumers don't have to juggle two libraries.
   class Regexp
   end
 end
@@ -34,6 +34,15 @@ module Fast
         allocate.tap { |re| re.send(:initialize, translated, original: pattern, **opts) }
       end
 
+      # Bulk-compile a symbol-keyed hash of patterns. Handy for defining a set
+      # of regex constants in one shot:
+      #
+      #   RE = Fast::Regexp.create_many(word: '\w+', num: '\d+').freeze
+      #   RE[:word].match("hello")
+      def create_many(**patterns)
+        patterns.transform_values { |pat| new(pat) }
+      end
+
       private
 
       def translate_regexp(regexp)
@@ -46,11 +55,17 @@ module Fast
 
     attr_reader :pattern, :backend
 
+    BACKENDS = %i[auto fast stdlib].freeze
+
     # Internal — use `Fast::Regexp.new`. `original` is the unmodified input
     # (String or ::Regexp) so we can build an accurate stdlib fallback.
-    def initialize(pattern, original: pattern, **opts)
+    # `backend:` forces a specific engine: `:auto` (default) tries rust/regex
+    # and falls back to stdlib, `:fast` raises if rust/regex rejects the
+    # pattern, `:stdlib` skips rust/regex entirely.
+    def initialize(pattern, original: pattern, backend: :auto, **opts)
+      raise ArgumentError, "backend must be one of #{BACKENDS.inspect}" unless BACKENDS.include?(backend)
       @pattern = pattern
-      @backend = compile_backend(pattern, original, opts)
+      @backend = compile_backend(pattern, original, backend, opts)
     end
 
     def fast? = @backend.is_a?(Native)
@@ -178,17 +193,22 @@ module Fast
       count
     end
 
-    def compile_backend(pattern, original, opts)
+    def compile_backend(pattern, original, backend, opts)
+      return compile_stdlib(pattern, original) if backend == :stdlib
       Native._native_new(pattern, **opts)
     rescue ArgumentError => e
+      raise if backend == :fast
+      compile_stdlib(pattern, original, fallback_from: e)
+    end
+
+    def compile_stdlib(pattern, original, fallback_from: nil)
       return original if original.is_a?(::Regexp)
-      begin
-        ::Regexp.new(pattern)
-      rescue ::RegexpError
-        # Pattern is malformed in both engines — surface the original
-        # rust/regex error so the user sees the more detailed message.
-        raise ArgumentError, e.message
-      end
+      ::Regexp.new(pattern)
+    rescue ::RegexpError => e
+      # Pattern is malformed in both engines (auto path) — surface the
+      # original rust/regex error since it's typically more detailed.
+      # Otherwise propagate the stdlib error as-is.
+      raise(fallback_from ? ArgumentError.new(fallback_from.message) : e)
     end
 
     # Maps positional capture indices to names for the stdlib backend so we

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_regexp
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: aarch64-linux
 authors:
 - Eric Jacobs