fast_regexp 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8403654241b531547ec912289ab9420155c9e85a33caa4069583bea84fb7608
-  data.tar.gz: 76f09be683665969fc78fe6bd69fb4b818b886bc634f241d584224ec5595a42e
+  metadata.gz: b7e4b114057d201c62b2d8ec4405b3d2554c1cebf1399433d275e111b93864dd
+  data.tar.gz: da33511a662b556bcd9d085d0d3a52e2a138120b040a79b37015970486630ee5
 SHA512:
-  metadata.gz: fe1ab72d32fc050eabee5cd970970455ac61d468d3a3b9948d74e97956d87b0008c405e82b6504540327865cc4279696ba9eb2018ed070ca06fdaad85577547c
-  data.tar.gz: ad1862de8f1fd879ef5cc6a8b2baf109a97b404f855d1954135f67553c958f1f1b1e140f7c8c5188aa8db87e5827b32b5869cb4daf71647c42ae7e8d2ce93732
+  metadata.gz: 6417817f643dd1f81979e02f75b5c211c2921e87fa448fdf33c2a7da4c44980ebe6e53f9a91feb18e494e2feafbbfb03d004d3c97e51a91e3de182d0b09132a1
+  data.tar.gz: 6ad069ffca51038fe5f74a6ad8496a672c25c8044e76cb084dd965a8cd380beaebba99908460431e41d223f96ac9168d0f02d6fca2e05f3d3fcf3c5661e8b1e2

data/Cargo.lock

@@ -72,7 +72,6 @@ name = "fast_regexp"
 version = "0.1.0"
 dependencies = [
  "magnus",
- "rb-sys",
  "regex",
 ]
 

data/README.md

@@ -5,12 +5,10 @@
 
 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
 
-Install [Rust](https://www.rust-lang.org/) via [rustup](https://rustup.rs/) or in any other way.
-
 Add as a dependency:
 
 ```ruby
@@ -21,6 +19,14 @@ gem "fast_regexp"
 gem install fast_regexp
 ```
 
+Precompiled native gems are published for **arm64-darwin**, **x86_64-linux**,
+and **aarch64-linux** against Ruby **3.3**, **3.4**, and **4.0** — no Rust
+toolchain required on those platforms.
+
+On any other platform/Ruby combo, Bundler/RubyGems falls back to the source
+gem and compiles the extension at install time. That path needs
+[Rust](https://www.rust-lang.org/) (install via [rustup](https://rustup.rs/)).
+
 Include in your code:
 
 ```ruby
@@ -155,6 +161,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 +244,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 +266,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/ext/fast_regexp/Cargo.toml

@@ -9,4 +9,3 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = "0.8"
 regex = "1"
-rb-sys = "0.9"

data/ext/fast_regexp/src/lib.rs

@@ -6,67 +6,9 @@ use magnus::{
 };
 use regex::bytes::{NoExpand, Regex, RegexBuilder, RegexSet, RegexSetBuilder};
 use std::collections::HashMap;
-use std::ffi::c_void;
-use std::ptr;
 use std::sync::Arc;
 
-/// Skip GVL release for haystacks smaller than this — the release/reacquire
-/// overhead (~µs) dwarfs the cost of a regex match on a tiny string.
-const GVL_RELEASE_THRESHOLD: usize = 1024;
-
-/// Run `func` with the GVL released so other Ruby threads (and the fiber
-/// scheduler on its host thread) can make progress during a long regex match.
-///
-/// The callback runs on the same OS thread — `Send` is not required, and the
-/// borrow checker enforces that any references stay valid for the call.
-fn without_gvl<F, R>(func: F) -> R
-where
-    F: FnOnce() -> R,
-{
-    struct Pack<F, R> {
-        func: Option<F>,
-        result: Option<R>,
-    }
-
-    unsafe extern "C" fn trampoline<F, R>(data: *mut c_void) -> *mut c_void
-    where
-        F: FnOnce() -> R,
-    {
-        let pack = &mut *(data as *mut Pack<F, R>);
-        let func = pack.func.take().expect("trampoline called twice");
-        pack.result = Some(func());
-        ptr::null_mut()
-    }
-
-    let mut pack: Pack<F, R> = Pack {
-        func: Some(func),
-        result: None,
-    };
-    unsafe {
-        rb_sys::rb_thread_call_without_gvl(
-            Some(trampoline::<F, R>),
-            &mut pack as *mut _ as *mut c_void,
-            None,
-            ptr::null_mut(),
-        );
-    }
-    pack.result.take().expect("callback did not run")
-}
-
-fn run_regex<F, R>(haystack_len: usize, func: F) -> R
-where
-    F: FnOnce() -> R,
-{
-    if haystack_len >= GVL_RELEASE_THRESHOLD {
-        without_gvl(func)
-    } else {
-        func()
-    }
-}
-
 fn haystack_bytes(haystack: &RString) -> Vec<u8> {
-    // Copy out of the Ruby heap so the bytes are safe to read after the GVL is
-    // released (Ruby 4's compacting GC can otherwise move the string).
     unsafe { haystack.as_slice() }.to_vec()
 }
 
@@ -157,12 +99,10 @@ impl FastRegexp {
         let regex = &self.0.regex;
         let bytes = haystack_bytes(&haystack);
 
-        let offsets = run_regex(bytes.len(), || {
-            regex.captures(&bytes).map(|caps| {
-                (0..regex.captures_len())
-                    .map(|i| caps.get(i).map(|m| (m.start(), m.end())))
-                    .collect::<Vec<_>>()
-            })
+        let offsets = regex.captures(&bytes).map(|caps| {
+            (0..regex.captures_len())
+                .map(|i| caps.get(i).map(|m| (m.start(), m.end())))
+                .collect::<Vec<_>>()
         })?;
 
         Some(self.build_match_data(Arc::new(bytes), offsets))
@@ -173,29 +113,25 @@ impl FastRegexp {
         let bytes = haystack_bytes(&haystack);
 
         if regex.captures_len() == 1 {
-            let ranges: Vec<(usize, usize)> = run_regex(bytes.len(), || {
-                regex
-                    .find_iter(&bytes)
-                    .map(|m| (m.start(), m.end()))
-                    .collect()
-            });
+            let ranges: Vec<(usize, usize)> = regex
+                .find_iter(&bytes)
+                .map(|m| (m.start(), m.end()))
+                .collect();
             let result = ruby.ary_new_capa(ranges.len());
             for (s, e) in ranges {
                 result.push(utf8_string(ruby, &bytes[s..e]))?;
             }
             Ok(result)
         } else {
-            let groups: Vec<Vec<CaptureOffset>> = run_regex(bytes.len(), || {
-                regex
-                    .captures_iter(&bytes)
-                    .map(|caps| {
-                        caps.iter()
-                            .skip(1)
-                            .map(|c| c.map(|m| (m.start(), m.end())))
-                            .collect()
-                    })
-                    .collect()
-            });
+            let groups: Vec<Vec<CaptureOffset>> = regex
+                .captures_iter(&bytes)
+                .map(|caps| {
+                    caps.iter()
+                        .skip(1)
+                        .map(|c| c.map(|m| (m.start(), m.end())))
+                        .collect()
+                })
+                .collect();
             let result = ruby.ary_new_capa(groups.len());
             for group_ranges in groups {
                 let group = ruby.ary_new_capa(group_ranges.len());
@@ -216,16 +152,14 @@ impl FastRegexp {
         let bytes = haystack_bytes(&haystack);
         let n_groups = regex.captures_len();
 
-        let all: Vec<Vec<CaptureOffset>> = run_regex(bytes.len(), || {
-            regex
-                .captures_iter(&bytes)
-                .map(|caps| {
-                    (0..n_groups)
-                        .map(|i| caps.get(i).map(|m| (m.start(), m.end())))
-                        .collect()
-                })
-                .collect()
-        });
+        let all: Vec<Vec<CaptureOffset>> = regex
+            .captures_iter(&bytes)
+            .map(|caps| {
+                (0..n_groups)
+                    .map(|i| caps.get(i).map(|m| (m.start(), m.end())))
+                    .collect()
+            })
+            .collect();
 
         let shared = Arc::new(bytes);
         let result = ruby.ary_new_capa(all.len());
@@ -238,7 +172,7 @@ impl FastRegexp {
     pub fn is_match(&self, haystack: RString) -> bool {
         let regex = &self.0.regex;
         let bytes = haystack_bytes(&haystack);
-        run_regex(bytes.len(), || regex.is_match(&bytes))
+        regex.is_match(&bytes)
     }
 
     pub fn sub_str(
@@ -251,13 +185,11 @@ impl FastRegexp {
         let regex = &rb_self.0.regex;
         let bytes = haystack_bytes(&haystack);
         let repl = haystack_bytes(&replacement);
-        let out = run_regex(bytes.len(), || -> Vec<u8> {
-            if literal {
-                regex.replace(&bytes, NoExpand(&repl)).into_owned()
-            } else {
-                regex.replace(&bytes, &repl[..]).into_owned()
-            }
-        });
+        let out: Vec<u8> = if literal {
+            regex.replace(&bytes, NoExpand(&repl)).into_owned()
+        } else {
+            regex.replace(&bytes, &repl[..]).into_owned()
+        };
         utf8_string(ruby, &out)
     }
 
@@ -271,13 +203,11 @@ impl FastRegexp {
         let regex = &rb_self.0.regex;
         let bytes = haystack_bytes(&haystack);
         let repl = haystack_bytes(&replacement);
-        let out = run_regex(bytes.len(), || -> Vec<u8> {
-            if literal {
-                regex.replace_all(&bytes, NoExpand(&repl)).into_owned()
-            } else {
-                regex.replace_all(&bytes, &repl[..]).into_owned()
-            }
-        });
+        let out: Vec<u8> = if literal {
+            regex.replace_all(&bytes, NoExpand(&repl)).into_owned()
+        } else {
+            regex.replace_all(&bytes, &repl[..]).into_owned()
+        };
         utf8_string(ruby, &out)
     }
 
@@ -482,13 +412,13 @@ impl FastRegexpSet {
     pub fn matches(&self, haystack: RString) -> Vec<usize> {
         let set = &self.0;
         let bytes = haystack_bytes(&haystack);
-        run_regex(bytes.len(), || set.matches(&bytes).iter().collect())
+        set.matches(&bytes).iter().collect()
     }
 
     pub fn is_match(&self, haystack: RString) -> bool {
         let set = &self.0;
         let bytes = haystack_bytes(&haystack);
-        run_regex(bytes.len(), || set.is_match(&bytes))
+        set.is_match(&bytes)
     }
 
     pub fn patterns(&self) -> Vec<String> {

data/lib/fast_regexp/version.rb

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

data/lib/fast_regexp.rb

@@ -6,16 +6,27 @@ 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
+    NATIVE_EXTENSIONS = %w[.bundle .so .rb].freeze
+
+    # Precompiled native gems ship per-ABI subdirs (`fast_regexp/4.0/...`),
+    # the source-gem `rake compile` build lands flat (`fast_regexp/...`).
+    # Pick whichever exists for the current Ruby ABI, with the per-ABI path
+    # winning when both are present.
+    def self.locate_native(base, ruby_version: RUBY_VERSION)
+      abi = ruby_version[/\d+\.\d+/]
+      candidates = [File.join(base, abi, "fast_regexp"), File.join(base, "fast_regexp")]
+      candidates.find { |stem| NATIVE_EXTENSIONS.any? { |ext| File.exist?(stem + ext) } }
+    end
   end
 end
 
-# Load the native extension AFTER the Fast::Regexp class shell exists — the
-# Rust init() looks up Fast::Regexp and registers Native under it.
-require_relative "fast_regexp/fast_regexp"
+native = Fast::Regexp.locate_native(File.expand_path("fast_regexp", __dir__))
+raise LoadError, "could not locate fast_regexp native extension" unless native
+require native
 
 module Fast
   class Regexp
@@ -34,6 +45,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 +66,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 +204,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.1
 platform: ruby
 authors:
 - Eric Jacobs