fast_regexp 0.4.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d198fcd2737203f54d11eb85aa27fa8984c80707b063656a9935213866bcf637
+  data.tar.gz: a41f3e686257d687ab331047b16e68154a4b083f1abb87c3a42f0eb4e8543405
+SHA512:
+  metadata.gz: 1b6d6fae53917230d07d711a3d6b1c704c1fe56d5f41bebc8d27721cd3ccd13f06e2539362e58dcd369b04abb6bd249411d02608082518713d6352757cc82c20
+  data.tar.gz: a8766de6e78b32ca0d7dc6f032095f5773a24f2c083c005502f9a35d21d201b23be73195929b921feeec54306419af1cd27005d52ac1e147888e442b39651d5a

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dmytro Horoshko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,217 @@
+# fast_regexp
+
+[![Gem Version](https://badge.fury.io/rb/fast_regexp.svg)](https://badge.fury.io/rb/fast_regexp)
+[![Test](https://github.com/jetpks/fast_regexp/workflows/CI/badge.svg)](https://github.com/jetpks/fast_regexp/actions)
+
+Ruby bindings for [rust/regex](https://docs.rs/regex/latest/regex/) library.
+
+## Installation
+
+Install [Rust](https://www.rust-lang.org/) via [rustup](https://rustup.rs/) or in any other way.
+
+Add as a dependency:
+
+```ruby
+# In your Gemfile
+gem "fast_regexp"
+
+# Or without Bundler
+gem install fast_regexp
+```
+
+Include in your code:
+
+```ruby
+require "fast_regexp"
+```
+
+## Usage
+
+Regular expressions should be pre-compiled before use:
+
+```ruby
+re = Fast::Regexp.new('p.t{2}ern*')
+# => #<Fast::Regexp:...>
+```
+
+> [!TIP]
+> Note the use of *single quotes* when passing the regular expression as
+> a string to `rust/regex` so that the backslashes aren't interpreted as escapes.
+
+You can also build from an existing Ruby `Regexp` — trailing flags (`/i`,
+`/x`, `/m`) are translated to inline form for the rust engine:
+
+```ruby
+Fast::Regexp.new(/foo/i).pattern    # => "(?i)foo"
+Fast::Regexp.new(/foo.bar/m).match?("foo\nbar")  # => true (Ruby's /m = dotall)
+```
+
+### Matching
+
+`#match` returns a `Fast::Regexp::MatchData` on a hit and `nil` on no match —
+matching Ruby's `Regexp#match` shape:
+
+```ruby
+m = Fast::Regexp.new('(\w+):(\d+)').match("ruby:123, rust:456")
+m[0]              # => "ruby:123"   (whole match)
+m[1]              # => "ruby"
+m[2]              # => "123"
+m.pre_match       # => ""
+m.post_match      # => ", rust:456"
+m.captures        # => ["ruby", "123"]
+m.to_a            # => ["ruby:123", "ruby", "123"]
+m.byteoffset(0)   # => [0, 8]
+
+Fast::Regexp.new('\d+').match("abc")  # => nil
+```
+
+Named captures use rust/regex's `(?P<name>...)` syntax:
+
+```ruby
+m = Fast::Regexp.new('(?P<word>\w+):(?P<num>\d+)').match("ruby:123")
+m[:word]            # => "ruby"
+m["num"]            # => "123"
+m.named_captures    # => { "word" => "ruby", "num" => "123" }
+```
+
+`#match?`, `#===`, and `#=~` are also available:
+
+```ruby
+re = Fast::Regexp.new('\d+')
+re.match?("123")                          # => true
+re === "abc 42"                           # => true (works in case/when)
+re =~ "abc 42"                            # => 4 (byte offset of first match)
+```
+
+### Scanning
+
+```ruby
+Fast::Regexp.new('\w+:\d+').scan("ruby:123, rust:456")
+# => ["ruby:123", "rust:456"]
+
+Fast::Regexp.new('(\w+):(\d+)').scan("ruby:123, rust:456")
+# => [["ruby", "123"], ["rust", "456"]]
+```
+
+For per-match positions and pre/post-match access, use `#scan_matches`:
+
+```ruby
+Fast::Regexp.new('(\w+):(\d+)').scan_matches("ruby:123, rust:456").map { |m| m.byteoffset(0) }
+# => [[0, 8], [10, 18]]
+```
+
+### Substitution
+
+`#sub` and `#gsub` use rust/regex's native replacement template — `$1`,
+`${name}`, and `$$` for a literal `$`:
+
+```ruby
+re = Fast::Regexp.new('(\w+):(\d+)')
+re.sub("ruby:123 rust:456",  '$2-$1')   # => "123-ruby rust:456"
+re.gsub("ruby:123 rust:456", '$2-$1')   # => "123-ruby 456-rust"
+```
+
+Block form receives a `MatchData`:
+
+```ruby
+Fast::Regexp.new('\d+').gsub("a1 b22 c333") { |m| "<#{m[0].size}>" }
+# => "a<1> b<2> c<3>"
+```
+
+Pass `literal: true` to disable `$`-expansion entirely.
+
+### Other
+
+```ruby
+Fast::Regexp.new('\w+:\d+').pattern         # => "\\w+:\\d+"
+Fast::Regexp.new('(?P<n>\w+)').names        # => ["n"]
+Fast::Regexp.new('(a)(b)').captures_count   # => 2
+```
+
+> [!WARNING]
+> `rust/regex` regular expression syntax differs from Ruby's built-in
+> [`Regexp`](https://docs.ruby-lang.org/en/3.4/Regexp.html) library, see the
+> [official syntax page](https://docs.rs/regex/latest/regex/index.html#syntax) for more
+> details.
+
+### Searching simultaneously
+
+`Fast::Regexp::Set` represents a collection of
+regular expressions that can be searched for simultaneously. Calling `Fast::Regexp::Set#match` will return an array containing the indices of all the patterns that matched.
+
+```ruby
+set = Fast::Regexp::Set.new(["abc", "def", "ghi", "xyz"])
+
+set.match("abcdefghi") # => [0, 1, 2]
+set.match("ghidefabc") # => [0, 1, 2]
+```
+
+> [!NOTE]
+> Matches arrive in the order the constituent patterns were declared,
+> not the order they appear in the haystack.
+
+To check whether at least one pattern from the set matches the haystack:
+
+```ruby
+Fast::Regexp::Set.new(["abc", "def"]).match?("abc")
+# => true
+
+Fast::Regexp::Set.new(["abc", "def"]).match?("123")
+# => false
+```
+
+Inspect original patterns:
+
+```ruby
+Fast::Regexp::Set.new(["abc", "def"]).patterns
+# => ["abc", "def"]
+```
+
+## Encoding
+
+Currently, `fast_regexp` expects the haystack to be an UTF-8 string.
+
+It also supports parsing of strings with invalid UTF-8 characters by default. It's achieved via using `regex::bytes` instead of plain `regex` under the hood, so any byte sequence can be matched. The output match is encoded as UTF-8 string.
+
+In case unicode awarness of matchers should be disabled, both `Fast::Regexp` and `Fast::Regexp::Set` support `unicode: false` option:
+
+```ruby
+Fast::Regexp.new('\w+').match('ю٤夏')
+# => ["ю٤夏"]
+
+Fast::Regexp.new('\w+', unicode: false).match('ю٤夏')
+# => []
+
+Fast::Regexp::Set.new(['\w', '\d', '\s']).match("ю٤\u2000")
+# => [0, 1, 2]
+
+Fast::Regexp::Set.new(['\w', '\d', '\s'], unicode: false).match("ю٤\u2000")
+# => []
+```
+
+## Development
+
+```sh
+bin/setup     # install deps
+bin/console   # interactive prompt to play around
+rake compile  # (re)compile extension
+rake spec     # run tests
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jetpks/fast_regexp.
+
+## Credits
+
+`fast_regexp` is a fork of
+[`rust_regexp`](https://github.com/ocvit/rust_regexp) by Dmytro Horoshko —
+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), and releases the GVL around regex execution
+for thread/fiber-friendly matching.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/fast_regexp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Fast
+  class Regexp
+    VERSION = "0.4.0"
+  end
+end

data/lib/fast_regexp.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "fast_regexp/version"
+require_relative "fast_regexp/fast_regexp"
+
+# Ruby-side conveniences on top of the Rust extension. The native class only
+# exposes raw primitives (`_native_new`, `_native_match`, `_native_sub`,
+# `_native_gsub`); everything user-facing lives here so the API can grow
+# without touching FFI.
+module Fast
+  class Regexp
+    RUBY_FLAG_MAP = {
+      ::Regexp::IGNORECASE => "i",
+      ::Regexp::EXTENDED => "x",
+      ::Regexp::MULTILINE => "s" # Ruby's /m = dotall; in rust/regex that is (?s).
+    }.freeze
+
+    class << self
+      # Accept either a pattern string or an existing `::Regexp`. When given a
+      # Regexp the flags (`/i`, `/x`, `/m`) are translated into a leading
+      # inline group so the rust/regex engine sees them. Unsupported features
+      # (lookaround, backrefs) still raise from the engine with a clear
+      # message.
+      def new(pattern, **opts)
+        pattern = translate_regexp(pattern) if pattern.is_a?(::Regexp)
+        _native_new(pattern, **opts)
+      end
+
+      private
+
+      def translate_regexp(regexp)
+        flags = RUBY_FLAG_MAP.each_with_object(+"") do |(bit, char), acc|
+          acc << char if (regexp.options & bit) != 0
+        end
+        flags.empty? ? regexp.source : "(?#{flags})#{regexp.source}"
+      end
+    end
+
+    # Returns a `Fast::Regexp::MatchData` on hit, `nil` on miss — matching
+    # Ruby's `Regexp#match` shape so the old `[]`-truthy-but-empty trap is
+    # gone.
+    def match(haystack)
+      _native_match(coerce_string(haystack))
+    end
+
+    # Case-equality. Enables `case/when` and RSpec's
+    # `expect(str).to match(re)`.
+    def ===(other)
+      return false unless other.respond_to?(:to_str)
+      match?(other.to_str)
+    end
+
+    # Returns the byte offset of the first match, or nil. Matches the
+    # semantics of `Regexp#=~` except positions are in **bytes** (rust/regex
+    # is byte-based).
+    def =~(other)
+      return nil unless other.respond_to?(:to_str)
+      m = match(other.to_str)
+      m && m.byte_begin(0)
+    end
+
+    # `sub(haystack, replacement)` or `sub(haystack) { |m| ... }`.
+    #
+    # The string form uses rust/regex's native replacement template: `$1`,
+    # `${name}`, `$$` for a literal `$`. To pass a replacement string that
+    # contains `$` literally, pass `literal: true`.
+    def sub(haystack, replacement = nil, literal: false, &block)
+      haystack = coerce_string(haystack)
+      if block
+        raise ArgumentError, "wrong number of arguments (given 2, expected 1 with block)" if replacement
+        m = match(haystack)
+        return haystack.dup unless m
+        "#{m.pre_match}#{block.call(m)}#{m.post_match}"
+      else
+        raise ArgumentError, "wrong number of arguments (given 1, expected 2)" if replacement.nil?
+        _native_sub(haystack, coerce_string(replacement), literal)
+      end
+    end
+
+    # `gsub(haystack, replacement)` or `gsub(haystack) { |m| ... }`. See
+    # `#sub` for the template syntax.
+    def gsub(haystack, replacement = nil, literal: false, &block)
+      haystack = coerce_string(haystack)
+      if block
+        raise ArgumentError, "wrong number of arguments (given 2, expected 1 with block)" if replacement
+        gsub_with_block(haystack, &block)
+      else
+        raise ArgumentError, "wrong number of arguments (given 1, expected 2)" if replacement.nil?
+        _native_gsub(haystack, coerce_string(replacement), literal)
+      end
+    end
+
+    def inspect
+      "#<Fast::Regexp #{pattern.inspect}>"
+    end
+
+    alias_method :to_s, :pattern
+
+    private
+
+    def gsub_with_block(haystack)
+      matches = scan_matches(haystack)
+      return haystack.dup if matches.empty?
+
+      out = String.new(encoding: Encoding::UTF_8)
+      cursor = 0
+      matches.each do |m|
+        bs, be = m.byteoffset(0)
+        out << haystack.byteslice(cursor, bs - cursor) if bs > cursor
+        out << yield(m).to_s
+        cursor = be
+      end
+      out << haystack.byteslice(cursor, haystack.bytesize - cursor) if cursor < haystack.bytesize
+      out
+    end
+
+    def coerce_string(value)
+      return value if value.is_a?(String)
+      return value.to_str if value.respond_to?(:to_str)
+      raise TypeError, "no implicit conversion of #{value.class} into String"
+    end
+
+    class MatchData
+      include Enumerable
+
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def values_at(*indices)
+        indices.map { |i| self[i] }
+      end
+
+      def ==(other)
+        other.is_a?(MatchData) && to_a == other.to_a && string == other.string
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [to_a, string].hash
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: fast_regexp
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: x86_64-linux
+authors:
+- Eric Jacobs
+- Dmytro Horoshko
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-05-16 00:00:00.000000000 Z
+dependencies: []
+description: 'Ruby bindings to rust/regex with a Fast::Regexp API: MatchData, sub/gsub,
+  ===, =~, named captures, and GVL release for thread/fiber-friendly matching.'
+email:
+- eric@ebj.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/fast_regexp.rb
+- lib/fast_regexp/3.3/fast_regexp.so
+- lib/fast_regexp/3.4/fast_regexp.so
+- lib/fast_regexp/4.0/fast_regexp.so
+- lib/fast_regexp/version.rb
+homepage: https://github.com/jetpks/fast_regexp
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/jetpks/fast_regexp/issues
+  homepage_uri: https://github.com/jetpks/fast_regexp
+  source_code_uri: https://github.com/jetpks/fast_regexp
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Fast regex for Ruby, backed by rust/regex
+test_files: []