re2 2.28.0-x86_64-linux-gnu → 2.29.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d149dfbab5aa104c93f829e99962f35922b6bdf123b6535ea95f925a052a9465
-  data.tar.gz: dc26acf96cf4278134831e270bbdb0dbb93da8b840afc95f7416ccd56fe3281e
+  metadata.gz: c820ef6767846d99c2f7a45e0bbcfdfd5e4d87a135492a435d4c0c3abd04afe1
+  data.tar.gz: 41234ec0a65da25ea8ed64576945aa38e4a07c3c1e984f34909b66e2a30455eb
 SHA512:
-  metadata.gz: 2249126b7e4af253c810aa8fbf9940f83ca5e37230935598073ed8b5da9fe53843615a8dec86ce3819b80c03f7a543fef54854780932e2bd10d1fc88dc3ab4cd
-  data.tar.gz: 33440763d865e3d29b10e41bd0115b88a9d1d51c60f6e7c00b86606ca4fcc670ad04f387633376db22054c4b03beda07bea4294af6a5e4f662d5390ee338d579
+  metadata.gz: 1fdb0292918640afd131cf0363ec00b91268882f143037b012e7e65c2f9a6829f2a5c91ac21f91720b99d8175ea4e2e6e29cdcc6981300b9908d085bb11d23b8
+  data.tar.gz: 93fd57162da06b2820d509327cbd1b27b13c0cb21bb5d796a5c1982caa195fa86654a0dd4fadbf03138871fcb048f921b2b1b5cebd89f7affb53f61a5c5b28e3

data/README.md

@@ -6,7 +6,7 @@ Python".
 
 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
 
-**Current version:** 2.28.0  
+**Current version:** 2.29.0  
 **Bundled RE2 version:** libre2.11 (2025-11-05)  
 
 ```ruby
@@ -232,6 +232,14 @@ m.offset(1)       #=> [4, 7]
 m.match_length(1) #=> 3
 ```
 
+As RE2 works in bytes, the [`byteoffset`](https://mudge.name/re2/RE2/MatchData.html#byteoffset-instance_method), [`bytebegin`](https://mudge.name/re2/RE2/MatchData.html#bytebegin-instance_method) and [`byteend`](https://mudge.name/re2/RE2/MatchData.html#byteend-instance_method) of a match are cheaper to retrieve than their character equivalents:
+
+```ruby
+m = RE2::Regexp.new('(Ruby)').partial_match("I ♥ Ruby")
+m.offset(1)     #=> [4, 8]
+m.byteoffset(1) #=> [6, 10]
+```
+
 `RE2::MatchData` objects can also be used with Ruby's [pattern matching](https://docs.ruby-lang.org/en/3.2/syntax/pattern_matching_rdoc.html):
 
 ```ruby
@@ -483,6 +491,8 @@ Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable i
   when passing strings with null bytes.
 * Thanks to [Maciej Gajewski](https://github.com/konieczkow) for helping
   confirm issues with GC compaction and mutable strings.
+* Thanks to [Konstantin Haase](https://github.com/rkh) for reporting that
+  `RE2::Regexp` shouldn't implement `to_str`.
 
 ## Contact
 

data/ext/re2/re2.cc

@@ -713,11 +713,11 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == nullptr) {
     return Qnil;
-  } else {
-    long offset = match->data() - RSTRING_PTR(m->text);
-
-    return LONG2NUM(rb_str_sublen(m->text, offset));
   }
+
+  long offset = match->data() - RSTRING_PTR(m->text);
+
+  return LONG2NUM(rb_str_sublen(m->text, offset));
 }
 
 /*
@@ -738,11 +738,11 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == nullptr) {
     return Qnil;
-  } else {
-    long offset = (match->data() - RSTRING_PTR(m->text)) + match->size();
-
-    return LONG2NUM(rb_str_sublen(m->text, offset));
   }
+
+  long offset = (match->data() - RSTRING_PTR(m->text)) + match->size();
+
+  return LONG2NUM(rb_str_sublen(m->text, offset));
 }
 
 /*
@@ -830,6 +830,85 @@ static VALUE re2_matchdata_offset(const VALUE self, VALUE n) {
   return array;
 }
 
+/*
+ * Returns the byte offset of the start of the nth element of the
+ * {RE2::MatchData}, like Ruby's `MatchData#bytebegin`. This is cheaper than
+ * {RE2::MatchData#begin} as it does not need to count characters.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the submatch
+ * @return [Integer, nil] the byte offset of the start of the match or `nil` if
+ *   there is no such submatch
+ * @example
+ *   m = RE2::Regexp.new('(Ruby)').partial_match("I ♥ Ruby")
+ *   m.bytebegin(0) #=> 6
+ *   m.begin(0)     #=> 4
+ */
+static VALUE re2_matchdata_bytebegin(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == nullptr) {
+    return Qnil;
+  }
+
+  return LONG2NUM(match->data() - RSTRING_PTR(m->text));
+}
+
+/*
+ * Returns the byte offset of the byte following the end of the nth element of
+ * the {RE2::MatchData}, like Ruby's `MatchData#byteend`. This is cheaper than
+ * {RE2::MatchData#end} as it does not need to count characters.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Integer, nil] the byte offset of the byte following the end of the
+ *   match or `nil` if there is no such match
+ * @example
+ *   m = RE2::Regexp.new('(Ruby)').partial_match("I ♥ Ruby")
+ *   m.byteend(0) #=> 10
+ *   m.end(0)     #=> 8
+ */
+static VALUE re2_matchdata_byteend(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == nullptr) {
+    return Qnil;
+  }
+
+  return LONG2NUM((match->data() - RSTRING_PTR(m->text)) + match->size());
+}
+
+/*
+ * Returns a two-element array containing the beginning and ending byte
+ * offsets of the nth match, like Ruby's `MatchData#byteoffset`. This is
+ * cheaper than {RE2::MatchData#offset} as it does not need to count
+ * characters.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Array<Integer>, nil] a two-element array with the beginning and
+ *   ending byte offsets of the match or `nil` if there is no such match
+ * @example
+ *   m = RE2::Regexp.new('(Ruby)').partial_match("I ♥ Ruby")
+ *   m.byteoffset(0) #=> [6, 10]
+ *   m.offset(0)     #=> [4, 8]
+ */
+static VALUE re2_matchdata_byteoffset(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == nullptr) {
+    return Qnil;
+  }
+
+  long start = match->data() - RSTRING_PTR(m->text);
+
+  VALUE array = rb_ary_new2(2);
+  rb_ary_push(array, LONG2NUM(start));
+  rb_ary_push(array, LONG2NUM(start + match->size()));
+
+  return array;
+}
+
 /*
  * Returns the length of the nth match in characters. This is equivalent to
  * `m[n].length` but without allocating a new string.
@@ -1804,7 +1883,7 @@ static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
  *   Returns either `true` or `false` indicating whether a successful match was
  *   made if the pattern contains no capturing groups.
  *
- *   @param [String] text the text to search
+ *   @param [String, Symbol, nil] text the text to search; `nil` returns `nil`
  *   @return [RE2::MatchData, nil] if the pattern contains capturing groups
  *   @return [Boolean] if the pattern does not contain capturing groups
  *   @raise [NoMemoryError] if there was not enough memory to allocate the submatches
@@ -1822,7 +1901,7 @@ static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
  *   specific number of submatches to extract (padded with `nil`s if
  *   necessary).
  *
- *   @param [String] text the text to search
+ *   @param [String, Symbol, nil] text the text to search; `nil` returns `nil`
  *   @param [Hash] options the options with which to perform the match
  *   @option options [Integer] :startpos (0) offset at which to start matching
  *   @option options [Integer] :endpos offset at which to stop matching, defaults to the text length
@@ -1855,7 +1934,7 @@ static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
  *   @deprecated Legacy syntax for matching against `text` with a specific
  *     number of submatches to extract. Use `match(text, submatches: n)` instead.
  *
- *   @param [String] text the text to search
+ *   @param [String, Symbol, nil] text the text to search; `nil` returns `nil`
  *   @param [Integer] submatches the number of submatches to extract
  *   @return [RE2::MatchData, nil] if extracting any submatches
  *   @return [Boolean] if not extracting any submatches
@@ -1874,6 +1953,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
   rb_scan_args(argc, argv, "11", &text, &options);
 
+  if (NIL_P(text)) {
+    return Qnil;
+  }
+  if (SYMBOL_P(text)) {
+    text = rb_sym2str(text);
+  }
+
   /* Coerce and freeze text to prevent mutation. */
   StringValue(text);
   text = rb_str_new_frozen(text);
@@ -2020,11 +2106,17 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L413-L427
  * `PartialMatch`}.
  *
- * @param [String] text the text to search
+ * @param [String, Symbol, nil] text the text to search; `nil` returns `false`
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
+  if (NIL_P(text)) {
+    return Qfalse;
+  }
+  if (SYMBOL_P(text)) {
+    text = rb_sym2str(text);
+  }
   StringValue(text);
   text = rb_str_new_frozen(text);
 
@@ -2041,11 +2133,17 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L376-L411
  * `FullMatch`}.
  *
- * @param [String] text the text to search
+ * @param [String, Symbol, nil] text the text to search; `nil` returns `false`
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
+  if (NIL_P(text)) {
+    return Qfalse;
+  }
+  if (SYMBOL_P(text)) {
+    text = rb_sym2str(text);
+  }
   StringValue(text);
   text = rb_str_new_frozen(text);
 
@@ -2800,6 +2898,12 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_post_match), 0);
   rb_define_method(re2_cMatchData, "offset",
       RUBY_METHOD_FUNC(re2_matchdata_offset), 1);
+  rb_define_method(re2_cMatchData, "bytebegin",
+      RUBY_METHOD_FUNC(re2_matchdata_bytebegin), 1);
+  rb_define_method(re2_cMatchData, "byteend",
+      RUBY_METHOD_FUNC(re2_matchdata_byteend), 1);
+  rb_define_method(re2_cMatchData, "byteoffset",
+      RUBY_METHOD_FUNC(re2_matchdata_byteoffset), 1);
   rb_define_method(re2_cMatchData, "match_length",
       RUBY_METHOD_FUNC(re2_matchdata_match_length), 1);
   rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref),
@@ -2866,14 +2970,11 @@ extern "C" void Init_re2(void) {
   rb_define_method(re2_cRegexp, "partial_match?",
       RUBY_METHOD_FUNC(re2_regexp_match_p), 1);
   rb_define_method(re2_cRegexp, "=~", RUBY_METHOD_FUNC(re2_regexp_match_p), 1);
-  rb_define_method(re2_cRegexp, "===", RUBY_METHOD_FUNC(re2_regexp_match_p), 1);
   rb_define_method(re2_cRegexp, "full_match?",
       RUBY_METHOD_FUNC(re2_regexp_full_match_p), 1);
   rb_define_method(re2_cRegexp, "scan",
       RUBY_METHOD_FUNC(re2_regexp_scan), 1);
   rb_define_method(re2_cRegexp, "to_s", RUBY_METHOD_FUNC(re2_regexp_to_s), 0);
-  rb_define_method(re2_cRegexp, "to_str", RUBY_METHOD_FUNC(re2_regexp_to_s),
-      0);
   rb_define_method(re2_cRegexp, "pattern", RUBY_METHOD_FUNC(re2_regexp_to_s),
       0);
   rb_define_method(re2_cRegexp, "source", RUBY_METHOD_FUNC(re2_regexp_to_s),

data/lib/re2/match_data.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# re2 (https://github.com/mudge/re2)
+# Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
+# backtracking regular expression engines like those used in PCRE, Perl, and
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
+module RE2
+  class MatchData
+    # Return whether this match has the same regular expression, text, and
+    # submatch offsets as another {RE2::MatchData}, like Ruby's own
+    # `MatchData#==`.
+    #
+    # @param [Object] other the object to compare against
+    # @return [Boolean] whether the two matches are equal
+    # @example
+    #   re = RE2::Regexp.new('(\d+)')
+    #   re.match("abc 123") == re.match("abc 123") #=> true
+    #   re.match("abc 123") == re.match("123 abc") #=> false
+    def ==(other)
+      other.is_a?(RE2::MatchData) &&
+        regexp == other.regexp &&
+        string == other.string &&
+        byteoffsets == other.byteoffsets
+    end
+
+    alias_method :eql?, :==
+
+    # Return a hash based on the regular expression, text, and submatch offsets
+    # so that equal {RE2::MatchData}s can be used as Hash keys.
+    #
+    # @return [Integer] the hash of the match
+    def hash
+      [regexp, string, byteoffsets].hash
+    end
+
+    protected
+
+    def byteoffsets
+      Array.new(size) { |i| byteoffset(i) }
+    end
+  end
+end

data/lib/re2/regexp.rb

@@ -68,5 +68,48 @@ module RE2
     def full_match(text, options = {})
       match(text, Hash(options).merge(anchor: :anchor_both))
     end
+
+    # Match the pattern against any substring of the given `text`, returning
+    # `false` if it is not a `String`, `Symbol`, or object responding to
+    # `to_str` so that an {RE2::Regexp} can be used in a `case` statement like
+    # Ruby's own `Regexp#===`.
+    #
+    # @param [Object] text the text to search; anything other than a `String`,
+    #   `Symbol`, or object responding to `to_str` returns `false`
+    # @return [Boolean] whether the match was successful
+    # @example
+    #   case "bob 123"
+    #   when RE2::Regexp.new('\d+')
+    #     "numbers"
+    #   end
+    def ===(text)
+      text = text.to_s if text.is_a?(Symbol)
+      text = ::String.try_convert(text)
+      return false unless text
+
+      match?(text)
+    end
+
+    # Return whether this regular expression has the same pattern and options
+    # as another {RE2::Regexp}.
+    #
+    # @param [Object] other the object to compare against
+    # @return [Boolean] whether the two regular expressions are equal
+    # @example
+    #   RE2::Regexp.new('abc') == RE2::Regexp.new('abc')                        #=> true
+    #   RE2::Regexp.new('abc') == RE2::Regexp.new('abc', case_sensitive: false) #=> false
+    def ==(other)
+      other.is_a?(RE2::Regexp) && source == other.source && options == other.options
+    end
+
+    alias_method :eql?, :==
+
+    # Return a hash based on the pattern and options so that equal
+    # {RE2::Regexp}s can be used as Hash keys.
+    #
+    # @return [Integer] the hash of the regular expression
+    def hash
+      [source, options].hash
+    end
   end
 end

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.28.0"
+  VERSION = "2.29.0"
 end

data/lib/re2.rb

@@ -16,5 +16,6 @@ rescue LoadError
 end
 
 require "re2/regexp"
+require "re2/match_data"
 require "re2/scanner"
 require "re2/version"

data/re2.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
     "Gemfile",
     "lib/re2.rb",
     "lib/re2/regexp.rb",
+    "lib/re2/match_data.rb",
     "lib/re2/scanner.rb",
     "lib/re2/string.rb",
     "lib/re2/version.rb",

data/spec/re2/match_data_spec.rb

@@ -632,6 +632,108 @@ RSpec.describe RE2::MatchData do
     end
   end
 
+  describe "#bytebegin" do
+    it "returns the byte offset of the start of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin(0)).to eq(6)
+    end
+
+    it "returns the byte offset of the start of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<word>Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin("word")).to eq(6)
+    end
+
+    it "returns the byte offset of the start of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<word>Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin(:word)).to eq(6)
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.bytebegin(1)).to be_nil
+    end
+
+    it "returns nil for a nonexistent submatch" do
+      md = RE2::Regexp.new('(a)').match("a")
+
+      expect(md.bytebegin(5)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.bytebegin(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#byteend" do
+    it "returns the byte offset after the end of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.byteend(0)).to eq(10)
+    end
+
+    it "returns the byte offset after the end of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteend("heart")).to eq(5)
+    end
+
+    it "returns the byte offset after the end of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteend(:heart)).to eq(5)
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.byteend(1)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.byteend(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#byteoffset" do
+    it "returns the byte offsets of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.byteoffset(0)).to eq([6, 10])
+    end
+
+    it "returns the byte offsets of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteoffset("heart")).to eq([2, 5])
+    end
+
+    it "returns the byte offsets of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteoffset(:heart)).to eq([2, 5])
+    end
+
+    it "can be used to slice the original string by bytes" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.string.byteslice(*md.byteoffset(1))).to eq("Ruby")
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.byteoffset(1)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.byteoffset(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
   describe "#offset" do
     it "returns the offset of a match by index" do
       md = RE2::Regexp.new('ob (\d+)').match("bob 123")
@@ -1010,4 +1112,95 @@ RSpec.describe RE2::MatchData do
       expect { described_class.allocate.deconstruct_keys(nil) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
   end
+
+  describe "#==" do
+    it "returns true for matches with the same regexp, text, and offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eq(re.match("abc 123"))
+    end
+
+    it "returns true for matches against equal but distinct regexps" do
+      md = RE2::Regexp.new('(\d+)').match("abc 123")
+
+      expect(md).to eq(RE2::Regexp.new('(\d+)').match("abc 123"))
+    end
+
+    it "returns true for matches against a copy of the text" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eq(re.match("abc 123".dup))
+    end
+
+    it "returns true for matches with unmatched optional groups" do
+      re = RE2::Regexp.new('a(b)?')
+
+      expect(re.match("ac")).to eq(re.match("ac"))
+    end
+
+    it "returns false for matches against different text" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).not_to eq(re.match("abc 456"))
+    end
+
+    it "returns false for the same captures at different offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("123 abc")).not_to eq(re.match("abc 123"))
+    end
+
+    it "returns false for matches against regexps with different options" do
+      md = RE2::Regexp.new('(abc)').match("abc")
+
+      expect(md).not_to eq(RE2::Regexp.new('(abc)', case_sensitive: false).match("abc"))
+    end
+
+    it "returns false for matches with a different number of submatches" do
+      re = RE2::Regexp.new('(a)(b)')
+
+      expect(re.match("ab")).not_to eq(re.match("ab", submatches: 1))
+    end
+
+    it "returns false for a non-MatchData" do
+      expect(RE2::Regexp.new('(a)').match("a")).not_to eq("a")
+    end
+
+    it "is aliased to eql?" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eql(re.match("abc 123"))
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate == RE2::Regexp.new('(a)').match("a") }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#hash" do
+    it "is the same for equal matches" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123").hash).to eq(re.match("abc 123").hash)
+    end
+
+    it "differs for matches at different offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("123 abc").hash).not_to eq(re.match("abc 123").hash)
+    end
+
+    it "allows matches to be used as Hash keys" do
+      re = RE2::Regexp.new('(\d+)')
+      hash = { re.match("abc 123") => :found }
+
+      expect(hash[re.match("abc 123")]).to eq(:found)
+    end
+
+    it "allows matches to be deduplicated" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect([re.match("abc 123"), re.match("abc 123")].uniq.size).to eq(1)
+    end
+  end
 end

data/spec/re2/regexp_spec.rb

@@ -241,24 +241,6 @@ RSpec.describe RE2::Regexp do
     end
   end
 
-  describe "#to_str" do
-    it "returns the original pattern" do
-      string = RE2::Regexp.new('w(o)(o)').to_str
-
-      expect(string).to eq("w(o)(o)")
-    end
-
-    it "returns the pattern even if invalid" do
-      string = RE2::Regexp.new('???', log_errors: false).to_str
-
-      expect(string).to eq("???")
-    end
-
-    it "raises an error when called on an uninitialized object" do
-      expect { described_class.allocate.to_str }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
-    end
-  end
-
   describe "#pattern" do
     it "returns the original pattern" do
       pattern = RE2::Regexp.new('w(o)(o)').pattern
@@ -515,6 +497,18 @@ RSpec.describe RE2::Regexp do
       expect(re.match("My name is Alice Bloggs")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "supports matching against text containing null bytes" do
       re = RE2::Regexp.new("a\0b")
 
@@ -536,7 +530,7 @@ RSpec.describe RE2::Regexp do
     it "raises an exception when given text that cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\w+) (\w+)')
 
-      expect { re.match(nil) }.to raise_error(TypeError)
+      expect { re.match(0) }.to raise_error(TypeError)
     end
 
     it "returns nil with an invalid pattern" do
@@ -826,6 +820,18 @@ RSpec.describe RE2::Regexp do
       expect(re.match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re.match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -868,6 +874,18 @@ RSpec.describe RE2::Regexp do
       expect(re.partial_match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.partial_match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re.partial_match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -910,6 +928,18 @@ RSpec.describe RE2::Regexp do
       expect(re =~ "My name is Alice Bloggs").to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re =~ nil).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re =~ :abc123).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -921,6 +951,52 @@ RSpec.describe RE2::Regexp do
     end
   end
 
+  describe "#==" do
+    it "returns true for regexps with the same pattern and options" do
+      expect(RE2::Regexp.new('a(b)', case_sensitive: false)).to eq(RE2::Regexp.new('a(b)', case_sensitive: false))
+    end
+
+    it "returns false for regexps with different patterns" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq(RE2::Regexp.new('a(c)'))
+    end
+
+    it "returns false for regexps with different options" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq(RE2::Regexp.new('a(b)', case_sensitive: false))
+    end
+
+    it "returns false for a String with the same pattern" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq('a(b)')
+    end
+
+    it "is aliased to eql?" do
+      expect(RE2::Regexp.new('a(b)')).to eql(RE2::Regexp.new('a(b)'))
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate == RE2::Regexp.new('a') }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+  end
+
+  describe "#hash" do
+    it "is the same for equal regexps" do
+      expect(RE2::Regexp.new('a(b)').hash).to eq(RE2::Regexp.new('a(b)').hash)
+    end
+
+    it "differs for regexps with different options" do
+      expect(RE2::Regexp.new('a(b)').hash).not_to eq(RE2::Regexp.new('a(b)', case_sensitive: false).hash)
+    end
+
+    it "allows regexps to be used as Hash keys" do
+      hash = { RE2::Regexp.new('a(b)') => :found }
+
+      expect(hash[RE2::Regexp.new('a(b)')]).to eq(:found)
+    end
+
+    it "allows regexps to be deduplicated" do
+      expect([RE2::Regexp.new('a'), RE2::Regexp.new('a')].uniq.size).to eq(1)
+    end
+  end
+
   describe "#===" do
     it "returns only true or false even if there are capturing groups", :aggregate_failures do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
@@ -935,10 +1011,31 @@ RSpec.describe RE2::Regexp do
       expect(re === "My name is Alice Bloggs").to eq(false)
     end
 
-    it "raises an exception if text cannot be coerced to a string" do
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re === :abc123).to eq(true)
+    end
+
+    it "returns false if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
-      expect { re === 0 }.to raise_error(TypeError)
+      expect(re === 0).to eq(false)
+    end
+
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re === nil).to eq(false)
+    end
+
+    it "can be used in a case statement" do
+      result = case 123
+               when RE2::Regexp.new('\d+') then :matched
+               else :not_matched
+               end
+
+      expect(result).to eq(:not_matched)
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -967,6 +1064,18 @@ RSpec.describe RE2::Regexp do
       expect(re.full_match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.full_match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\w+')
+
+      expect(re.full_match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -1159,6 +1268,18 @@ RSpec.describe RE2::Regexp do
       expect(r.partial_match("foo bar")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.partial_match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.partial_match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "can set the number of submatches to extract", :aggregate_failures do
       r = RE2::Regexp.new('f(o+)(a+)')
       m = r.partial_match("fooaa bar", submatches: 1)
@@ -1219,6 +1340,18 @@ RSpec.describe RE2::Regexp do
       expect(r.full_match("foo")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.full_match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\w+)')
+
+      expect(re.full_match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "can set the number of submatches to extract", :aggregate_failures do
       r = RE2::Regexp.new('f(o+)(a+)')
       m = r.full_match("fooaa", submatches: 1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.28.0
+  version: 2.29.0
 platform: x86_64-linux-gnu
 authors:
 - Paul Mucur
@@ -74,6 +74,7 @@ files:
 - lib/3.4/re2.so
 - lib/4.0/re2.so
 - lib/re2.rb
+- lib/re2/match_data.rb
 - lib/re2/regexp.rb
 - lib/re2/scanner.rb
 - lib/re2/string.rb