re2 2.27.0-arm-linux-gnu → 2.28.0-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 645eab3b4e65e9324ce7c21fb194003d47e49218bc14ea9a33a971d128b8426d
-  data.tar.gz: f1459959f76efa60581508fd0b1f8360afb4ccfaf8a651d076a4b67cbd334659
+  metadata.gz: 140f6962d695db89ed1410372669691144d1c71e31c49873504bcb68291ce986
+  data.tar.gz: 91120b25899a2db5f6b5e31c65a940710a9614123e9fac4c029f5ee42ed6863e
 SHA512:
-  metadata.gz: 55cc7f7cf8a3ac43c7dfc64040a1f9f137bf04d040b99bcbc4039be358c6b6d6176239164747d8b8ad7be1a1af2a38ba82870bf00965caf2a76af7609a78aefb
-  data.tar.gz: 753a84156ac0cea64cf30e579baf613d691dd04bfd1f092ecbc5e5ad5308ecba601c360c97c4f42b5ddf0f5983b9555d09393f46564dc2e1cb5a0b81f2d401fa
+  metadata.gz: 31498cbb945d8595590a63d93d3031f67de273e95fc976dfcd227e43fc619c93a6c8403d5e1eafded51559f7e985282836dab6072cc6056249a7d830c515565a
+  data.tar.gz: 53981ca65527f73169d63361022736afd5d301b6b7e1e3a4cd90463f176481a57efdab1e00428449e4296a67bde72f11c4b50fd77abf6990a21731144ff4b342

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.28.0  
 **Bundled RE2 version:** libre2.11 (2025-11-05)  
 
 ```ruby

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;
@@ -1004,11 +1005,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 +1120,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 +1150,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 +1160,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 +1180,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 +1218,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 +1233,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 +1272,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 +1283,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 +1370,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 +1765,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 +1778,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));
   }
 
@@ -2503,9 +2489,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 +2559,7 @@ static VALUE re2_set_compile(VALUE self) {
   bool compiled = s->set->Compile();
 
   if (compiled) {
+    s->compiled = true;
     rb_obj_freeze(self);
   }
 
@@ -2687,6 +2677,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 +2724,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));

data/lib/re2/version.rb

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

data/re2.gemspec

@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
     "spec/re2/scanner_spec.rb"
   ]
   s.add_development_dependency("rake-compiler", "~> 1.3.1")
-  s.add_development_dependency("rake-compiler-dock", "~> 1.11.0")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.12.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.9") # keep version in sync with extconf.rb
 end

data/spec/re2/match_data_spec.rb

@@ -59,6 +59,15 @@ RSpec.describe RE2::MatchData do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      md = RE2::Regexp.new('(\d+)').match("123")
+      md.send(:initialize_copy, md)
+
+      expect(md.to_a).to eq(["123", "123"])
+    end
+  end
+
   describe "#to_a" do
     it "is populated with the match and capturing groups" do
       a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
@@ -154,6 +163,24 @@ RSpec.describe RE2::MatchData do
       expect(md[:numbers]).to eq("123")
     end
 
+    it "allows access using a UTF-8 name and a UTF-8 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md[:café]).to eq("123")
+    end
+
+    it "allows access using a Latin-1 name and a Latin-1 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md["café".encode("ISO-8859-1")]).to eq("123")
+    end
+
     it "allows access by names and indices with mixed groups", :aggregate_failures do
       md = RE2::Regexp.new('(?P<name>\w+)(\s*)(?P<numbers>\d+)').match("bob 123")
 
@@ -199,6 +226,12 @@ RSpec.describe RE2::MatchData do
       expect(md[:name].encoding.name).to eq("ISO-8859-1")
     end
 
+    it "handles null bytes in symbol names" do
+      md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
+
+      expect(md[:"name\0b"]).to be_nil
+    end
+
     it "supports GC compaction" do
       md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
       GC.compact
@@ -358,6 +391,24 @@ RSpec.describe RE2::MatchData do
       expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
     end
 
+    it "returns the offset of the start of a match by non-ASCII symbol name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin(:café)..-1]).to eq('foobar')
+    end
+
+    it "returns the offset of the start of a match by Latin-1 string name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin("café".encode("ISO-8859-1"))..-1]).to eq('foobar')
+    end
+
     it "returns the offset of the start of a match by something that can be coerced to a String" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
 
@@ -822,12 +873,33 @@ RSpec.describe RE2::MatchData do
       expect(md.named_captures).to eq("empty" => "", "word" => "bob")
     end
 
+    it "returns UTF-8 names even for Latin-1 patterns" do
+      md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
+      key = md.named_captures.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    end
+
     it "returns symbol keys when symbolize_names: true" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
       expect(md.named_captures(symbolize_names: true)).to eq(numbers: "123", letters: "abc")
     end
 
+    it "returns garbage-collectable symbol keys when symbolize_names: true" do
+      md = RE2::Regexp.new('(?P<collectable_named_capture>\d+)').match('123')
+      key = md.named_captures(symbolize_names: true).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "correctly encodes non-ASCII capturing group names as symbols" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      expect(re.match('123').named_captures(symbolize_names: true)).to eq(café: "123")
+    end
+
     it "returns string keys when symbolize_names: false" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
@@ -858,10 +930,10 @@ RSpec.describe RE2::MatchData do
       expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
-    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
       md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
 
-      expect(md.names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -876,6 +948,22 @@ RSpec.describe RE2::MatchData do
       expect(md.deconstruct_keys(nil)).to eq(numbers: '123', letters: 'abc')
     end
 
+    it "returns garbage-collectable symbol keys if given nil" do
+      md = RE2::Regexp.new('(?P<collectable_deconstructed_key>\d+)').match('123')
+      key = md.deconstruct_keys(nil).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "returns UTF-8 named captures for a Latin-1 pattern if given nil" do
+      re = RE2::Regexp.new('(?P<café>\d+) (?P<letters>[a-zA-Z]+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('123 abc')
+
+      expect(md.deconstruct_keys(nil)).to eq(café: '123', letters: 'abc')
+    end
+
     it "returns only named captures if given names" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 

data/spec/re2/regexp_spec.rb

@@ -49,6 +49,13 @@ RSpec.describe RE2::Regexp do
 
       expect { re.send(:initialize, 'bar') }.to raise_error(FrozenError)
     end
+
+    it "cannot be re-initialized while parsing options" do
+      re = described_class.allocate
+      options = Hash.new { |_, key| re.send(:initialize, 'bar') if key == :utf8 }
+
+      expect { re.send(:initialize, 'woo', options) }.to raise_error(FrozenError)
+    end
   end
 
   describe "#dup" do
@@ -1048,6 +1055,13 @@ RSpec.describe RE2::Regexp do
       expect(RE2::Regexp.new('???', log_errors: false).named_capturing_groups).to be_empty
     end
 
+    it "returns names as UTF-8 even if the pattern is Latin-1" do
+      groups = RE2::Regexp.new('(?P<bob>a)', utf8: false).named_capturing_groups
+      key = groups.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.named_capturing_groups }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
@@ -1071,15 +1085,17 @@ RSpec.describe RE2::Regexp do
     end
 
     it "returns UTF-8 strings if the pattern is UTF-8" do
-      names = RE2::Regexp.new('(?P<bob>a)').names
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
 
-      expect(names.first.encoding).to eq(Encoding::UTF_8)
+      expect(re.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
-    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
-      names = RE2::Regexp.new('(?P<bob>a)', utf8: false).names
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
+      re = RE2::Regexp.new('(?P<café>a)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
 
-      expect(names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(re.names).to contain_exactly("café")
     end
 
     it "raises an error when called on an uninitialized object" do

data/spec/re2/scanner_spec.rb

@@ -106,6 +106,15 @@ RSpec.describe RE2::Scanner do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar")
+      scanner.send(:initialize_copy, scanner)
+
+      expect(scanner.scan).to eq(["foo"])
+    end
+  end
+
   describe "#scan" do
     it "returns the next array of matches", :aggregate_failures do
       r = RE2::Regexp.new('(\w+)')

data/spec/re2/set_spec.rb

@@ -49,6 +49,13 @@ RSpec.describe RE2::Set do
         "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
       )
     end
+
+    it "cannot be re-initialized before compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+
+      expect { set.send(:initialize) }.to raise_error(TypeError, /already initialized RE2::Set/)
+    end
   end
 
   describe "#dup" do
@@ -212,6 +219,30 @@ RSpec.describe RE2::Set do
       end
     end
 
+    it "raises an error if called after a failed #compile" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect { set.match("abc") }.to raise_error(RE2::Set::MatchError, "#match must not be called before #compile")
+      end
+    end
+
+    it "returns an empty array if called after a failed #compile when :exception is false" do
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect(set.match("abc", exception: false)).to be_empty
+      end
+    end
+
     it "raises an error if :exception is true and RE2 does not support it" do
       skip "Underlying RE2::Set::Match outputs error information" if RE2::Set.match_raises_errors?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.27.0
+  version: 2.28.0
 platform: arm-linux-gnu
 authors:
 - Paul Mucur
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Ruby bindings to RE2.
 test_files: