re2 2.27.0 → 2.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac8a9eeb58a93e3f4241d2677a51a15016d543fd55a003e358f1d8442717c517
-  data.tar.gz: d505664cefe09a08d4c14f174791bc3f213cec515897943f12adc2867a91df6f
+  metadata.gz: dec6d6cc840ab3dd3c31626f4bfbcc1d4f55fe9d537d7e6196afe6b3e6a3a0ee
+  data.tar.gz: a06cd946502d973e2cb9f0003f22958dadc588a8b18079d4f0d660520ff93cd1
 SHA512:
-  metadata.gz: 31affec3aeee1a47021d3e96360b52c7dc5065d2abcbd748c35d305e6fffdd3b7a521f92bb6c97aaca67b265bb9df34867f18c5e00edf647bd8e609e093c29aa
-  data.tar.gz: 76654d86eea56b7e66102fc6780d16f94eaba95f0d2c605a46a1eece51c2158414d26edfdcfc3732b2301fe35a6fdbe8860336ce8efc1bd416d0830ee0a64e93
+  metadata.gz: d5ddc945b8c92f9c61c0c8e73974307b908c7da6bb535508733eccb8659f04005150c7d068b6689ef7b75c15c11f81703615a43e8fbfb0b28ddf6ecb593fb971
+  data.tar.gz: 6b889625aa01b8e53e5ac7b2d0b975b8406cc8013005ba3231086832bf5e8f65e40f321b75f426b54ee37c7de72877a161aeacd9ae0b99a2a5e7e3dac9b26b97

data/Gemfile

@@ -9,3 +9,8 @@ gem "rake", "> 12.3.2"
 group :memcheck, optional: true do
   gem "ruby_memcheck"
 end
+
+group :docs, optional: true do
+  gem "redcarpet"
+  gem "yard"
+end

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.27.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/extconf.rb

@@ -132,38 +132,14 @@ module RE2
 
     def build_extension
       $CFLAGS << " -Wall -Wextra -funroll-loops"
-      $CXXFLAGS << " -Wall -Wextra -funroll-loops"
+      $CXXFLAGS << " -Wall -Wextra -funroll-loops -std=c++17"
 
       # Pass -x c++ to force gcc to compile the test program
       # as C++ (as it will end in .c by default).
-      compile_options = +"-x c++"
+      compile_options = +"-x c++ -std=c++17"
 
       have_library("stdc++")
 
-      minimal_program = <<~SRC
-        #include <re2/re2.h>
-        int main() { return 0; }
-      SRC
-
-      re2_requires_version_flag = checking_for("re2 that requires explicit C++ version flag") do
-        !try_compile(minimal_program, compile_options)
-      end
-
-      if re2_requires_version_flag
-        # Recent versions of RE2 depend directly on Abseil, which requires a
-        # compiler with C++17 support.
-        abort "Cannot compile re2 with your compiler: recent versions require C++17 support." unless %w[c++20 c++17 c++11].any? do |std|
-          checking_for("re2 that compiles with #{std} standard") do
-            if try_compile(minimal_program, compile_options + " -std=#{std}")
-              compile_options << " -std=#{std}"
-              $CPPFLAGS << " -std=#{std}"
-
-              true
-            end
-          end
-        end
-      end
-
       # Determine which version of re2 the user has installed.
       # Revision d9f8806c004d added an `endpos` argument to the
       # generic Match() function.

data/ext/re2/re2.cc

@@ -42,6 +42,7 @@ typedef struct {
 
 typedef struct {
   RE2::Set *set;
+  bool compiled;
 } re2_set;
 
 struct nogvl_match_arg {
@@ -170,6 +171,13 @@ static void *nogvl_extract(void *ptr) {
   return nullptr;
 }
 
+static std::string group_name(VALUE key) {
+  VALUE str = SYMBOL_P(key) ? rb_sym2str(key) : key;
+  str = rb_str_conv_enc(str, rb_enc_get(str), rb_utf8_encoding());
+
+  return std::string(RSTRING_PTR(str), RSTRING_LEN(str));
+}
+
 VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cScanner, re2_cSet,
       re2_eSetMatchError, re2_eSetUnsupportedError, re2_eRegexpUnsupportedError;
 
@@ -412,9 +420,9 @@ static re2_scanner *unwrap_re2_scanner(VALUE self) {
  * in alphabetical order rather than definition order, as RE2 stores named
  * groups internally in a sorted map.
  *
- * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
- * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
- * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Array<String>] an array of names of named capturing groups
  * @example
@@ -427,9 +435,7 @@ static VALUE re2_regexp_names(const VALUE self) {
   VALUE names = rb_ary_new2(groups.size());
 
   for (const auto& group : groups) {
-    rb_ary_push(names,
-        encoded_str_new(group.first.data(), group.first.size(),
-          p->pattern->options().encoding()));
+    rb_ary_push(names, rb_utf8_str_new(group.first.data(), group.first.size()));
   }
 
   return names;
@@ -523,6 +529,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
 }
 
 static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+
   re2_scanner *self_c;
   re2_scanner *other_c = unwrap_re2_scanner(other);
 
@@ -646,20 +654,13 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
 
   if (RB_INTEGER_TYPE_P(idx)) {
     id = NUM2INT(idx);
-  } else if (SYMBOL_P(idx)) {
-    const auto& groups = p->pattern->NamedCapturingGroups();
-    auto search = groups.find(rb_id2name(SYM2ID(idx)));
-
-    if (search != groups.end()) {
-      id = search->second;
-    } else {
-      return nullptr;
-    }
   } else {
-    StringValue(idx);
+    if (!SYMBOL_P(idx)) {
+      StringValue(idx);
+    }
 
     const auto& groups = p->pattern->NamedCapturingGroups();
-    auto search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
+    auto search = groups.find(group_name(idx));
 
     if (search != groups.end()) {
       id = search->second;
@@ -712,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));
 }
 
 /*
@@ -737,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));
 }
 
 /*
@@ -829,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.
@@ -1004,11 +1084,8 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
   VALUE idx, rest;
   rb_scan_args(argc, argv, "11", &idx, &rest);
 
-  if (TYPE(idx) == T_STRING) {
-    return re2_matchdata_named_match(
-        std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self);
-  } else if (SYMBOL_P(idx)) {
-    return re2_matchdata_named_match(rb_id2name(SYM2ID(idx)), self);
+  if (TYPE(idx) == T_STRING || SYMBOL_P(idx)) {
+    return re2_matchdata_named_match(group_name(idx), self);
   } else if (!NIL_P(rest) || !RB_INTEGER_TYPE_P(idx) || NUM2INT(idx) < 0) {
     return rb_ary_aref(argc, argv, re2_matchdata_to_a(self));
   } else {
@@ -1122,6 +1199,7 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
  * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
  * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ * Capturing group names will always be returned in UTF-8.
  *
  * @return [Hash] a hash of capturing group names to submatches
  * @param [Array<Symbol>, nil] keys an array of `Symbol` capturing group names
@@ -1151,7 +1229,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   if (NIL_P(keys)) {
     for (const auto& group : groups) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern2(group.first.data(), group.first.size())),
+          rb_str_intern(rb_utf8_str_new(group.first.data(), group.first.size())),
           re2_matchdata_nth_match(group.second, self));
     }
   } else {
@@ -1161,8 +1239,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
       for (int i = 0; i < RARRAY_LEN(keys); ++i) {
         VALUE key = rb_ary_entry(keys, i);
         Check_Type(key, T_SYMBOL);
-        const char *name = rb_id2name(SYM2ID(key));
-        auto search = groups.find(name);
+        auto search = groups.find(group_name(key));
 
         if (search != groups.end()) {
           rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(search->second, self));
@@ -1182,6 +1259,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
  * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
  * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
  * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ * Capturing group names will always be returned in UTF-8.
  *
  * @overload named_captures
  *   Returns a hash with string keys.
@@ -1219,12 +1297,9 @@ static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE sel
   VALUE result = rb_hash_new();
 
   for (const auto& group : groups) {
-    VALUE key;
+    VALUE key = rb_utf8_str_new(group.first.data(), group.first.size());
     if (symbolize) {
-      key = ID2SYM(rb_intern2(group.first.data(), group.first.size()));
-    } else {
-      key = encoded_str_new(group.first.data(), group.first.size(),
-              p->pattern->options().encoding());
+      key = rb_str_intern(key);
     }
     rb_hash_aset(result, key, re2_matchdata_nth_match(group.second, self));
   }
@@ -1237,9 +1312,9 @@ static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE sel
  * alphabetical order rather than definition order, as RE2 stores named groups
  * internally in a sorted map.
  *
- * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
- * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
- * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Array<String>] an array of names of named capturing groups
  * @example
@@ -1276,12 +1351,8 @@ static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
   for (int i = 0; i < argc; ++i) {
     VALUE idx = argv[i];
 
-    if (TYPE(idx) == T_STRING) {
-      rb_ary_push(result, re2_matchdata_named_match(
-            std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self));
-    } else if (SYMBOL_P(idx)) {
-      rb_ary_push(result, re2_matchdata_named_match(
-            rb_id2name(SYM2ID(idx)), self));
+    if (TYPE(idx) == T_STRING || SYMBOL_P(idx)) {
+      rb_ary_push(result, re2_matchdata_named_match(group_name(idx), self));
     } else {
       rb_ary_push(result, re2_matchdata_nth_match(NUM2INT(idx), self));
     }
@@ -1291,6 +1362,8 @@ static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
 }
 
 static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+
   re2_matchdata *self_m;
   re2_matchdata *other_m = unwrap_re2_matchdata(other);
 
@@ -1376,24 +1449,17 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
-  rb_check_frozen(self);
-
-  if (p->pattern) {
-    delete p->pattern;
-    p->pattern = nullptr;
-  }
+  RE2::Options re2_options;
 
   if (RTEST(options)) {
-    RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
-
-    p->pattern = new(std::nothrow) RE2(
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), re2_options);
-  } else {
-    p->pattern = new(std::nothrow) RE2(
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)));
   }
 
+  rb_check_frozen(self);
+
+  p->pattern = new(std::nothrow) RE2(
+      re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), re2_options);
+
   if (p->pattern == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
@@ -1778,9 +1844,9 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
 /*
  * Returns a hash of names to capturing indices of groups.
  *
- * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
- * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
- * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Hash] a hash of names to capturing indices
  */
@@ -1791,8 +1857,7 @@ static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
 
   for (const auto& group : groups) {
     rb_hash_aset(capturing_groups,
-        encoded_str_new(group.first.data(), group.first.size(),
-          p->pattern->options().encoding()),
+        rb_utf8_str_new(group.first.data(), group.first.size()),
         INT2FIX(group.second));
   }
 
@@ -1818,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
@@ -1836,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
@@ -1869,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
@@ -1888,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);
@@ -2034,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);
 
@@ -2055,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);
 
@@ -2503,9 +2587,12 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
 
   rb_check_frozen(self);
 
+  /* Prevent re-initialisation: #match releases the GVL while holding a
+   * pointer to s->set, so replacing s->set from another thread would free
+   * the object out from under a concurrent match.
+   */
   if (s->set) {
-    delete s->set;
-    s->set = nullptr;
+    rb_raise(rb_eTypeError, "already initialized RE2::Set");
   }
 
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
@@ -2570,6 +2657,7 @@ static VALUE re2_set_compile(VALUE self) {
   bool compiled = s->set->Compile();
 
   if (compiled) {
+    s->compiled = true;
     rb_obj_freeze(self);
   }
 
@@ -2687,6 +2775,11 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
 
   if (raise_exception) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
+    /* RE2::Set::Match dereferences a null program after a failed Compile. */
+    if (!s->compiled) {
+      rb_raise(re2_eSetMatchError, "#match must not be called before #compile");
+    }
+
     RE2::Set::ErrorInfo e;
     nogvl_set_match_arg arg;
     arg.set = s->set;
@@ -2729,6 +2822,10 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
     rb_raise(re2_eSetUnsupportedError, "current version of RE2::Set::Match() does not output error information, :exception option can only be set to false");
 #endif
   } else {
+    if (!s->compiled) {
+      return rb_ary_new();
+    }
+
     nogvl_set_match_arg arg;
     arg.set = s->set;
     arg.text = re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str));
@@ -2801,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),
@@ -2867,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