fast_regexp 0.5.0-aarch64-linux → 0.6.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d582628d35a655bddbc2957b25874b21ee2c7a53c3cde023c1cf7a2a7570ed2
-  data.tar.gz: 161d29c08b3897f77248b624904fa26ddf7512ae73f74f31d845ac545d70bfea
+  metadata.gz: 9e8f43c5d2a9aa1903943558c35ab6a46b15df0b752c652f6442bd6a328bce7c
+  data.tar.gz: 666effbf46f4db06dbc5b644c88202daac203e7c167cf060cbb5d1f2e63d66a5
 SHA512:
-  metadata.gz: d53c46c5cc47cc38d4b1b64c1c93473850ee5b9ae864538c0792a2675b9bf64496eb7328193678bff35990810be6dbe80340cd74d6dd099fedb6f4f79607a262
-  data.tar.gz: 280a5bc0c14b490089cc6a3098bceba67bd58dfb347a526c3ee979ad11561888fdb7342a53173c7a854727d352b8ab0cf4f900740f448958e867308ee47834de
+  metadata.gz: 38ca3692c0b727e5003acca7e24031b73c19fd2957bfbe715dae5c5edd2065fa93ba9e665d2f6cebbc721513957c25193c5c5ca3125e6be59bbc236244fefe52
+  data.tar.gz: '040688216ab69d2ab613548b3dab2b798e90a776c2cff4d107ddc9f4208943b0439cb8d8124128dcb6015b81a316eae4cf8f8cc49d44bdcf5a7126c6b6216146'

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/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: aarch64-linux
 authors:
 - Eric Jacobs