re2 2.25.0 → 2.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 477c8a61880d0b90859d119d21612ccaa439fd6e7a5d06946b5044a6520b2fab
-  data.tar.gz: '0973c566418525946e61a99d1d317bd708a52dc395053064261c6d581ebb797c'
+  metadata.gz: 32598d3c71b90c6646ca084271c0c3cc07a4b0a0d5ca60e9e50f5007fd335adc
+  data.tar.gz: 4415cd8091165f5ed1a9361f92dc1f8d1ee7db86c905c2987331d404a50b6a3c
 SHA512:
-  metadata.gz: 9e18ab14bd16e37917b988483dd432b7469da78113c1f67dcaefaf5102771c635dfde842779b6b325ffd857d0203acc9c32cd88c5f1cb7017fdf05f93f89adf1
-  data.tar.gz: 20081d9a25c5789a2c585b0c33049c8431ab0f5abc29b2bc0c4e4baa6a1bc6b3da24fd609fe7f05e65a4d5eb4759c20ba3c481f31bc85c25d3cbf2f8efb56d18
+  metadata.gz: 26cc651d02984bfb0bdf2b3ca2d9dff1e4a32710c589cf186cf04a05cfcf82048a1994624ed5cec47a28b81c768844e8a9eaa5f2a3aa35621c50928f0a1ee151
+  data.tar.gz: 55b85a59ab0f4c6a59f07dad5ae109ddd1134b763d2b857c3cb071847962665ba71052cb1f9095982ae5975eaacab130dd1cf64ef7fe061bb721ed14ecc833a2

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

data/Rakefile

@@ -24,10 +24,6 @@ cross_platforms = %w[
   arm-linux-musl
   arm64-darwin
   x64-mingw-ucrt
-  x64-mingw32
-  x86-linux-gnu
-  x86-linux-musl
-  x86-mingw32
   x86_64-darwin
   x86_64-linux-gnu
   x86_64-linux-musl

data/ext/re2/extconf.rb

@@ -139,7 +139,6 @@ module RE2
       compile_options = +"-x c++"
 
       have_library("stdc++")
-      have_header("stdint.h")
 
       minimal_program = <<~SRC
         #include <re2/re2.h>
@@ -153,7 +152,7 @@ module RE2
       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 c++0x].any? do |std|
+        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}"
@@ -268,8 +267,8 @@ module RE2
       message "Cross build is #{cross_build_p ? "enabled" : "disabled"}.\n"
 
       recipe.host = target_host
-      # Ensure x64-mingw-ucrt and x64-mingw32 use different library paths since the host
-      # is the same (x86_64-w64-mingw32).
+      # Ensure x64-mingw-ucrt uses different library paths since the host is
+      # the same (x86_64-w64-mingw32).
       recipe.target = File.join(recipe.target, target_arch) if cross_build_p
 
       yield recipe

data/ext/re2/re2.cc

@@ -8,7 +8,7 @@
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
-#include <stdint.h>
+#include <cstdint>
 
 #include <map>
 #include <sstream>
@@ -296,12 +296,12 @@ static re2_scanner *unwrap_re2_scanner(VALUE self) {
 static VALUE re2_regexp_names(const VALUE self) {
   re2_pattern *p = unwrap_re2_regexp(self);
 
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE names = rb_ary_new2(groups.size());
 
-  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+  for (const auto& group : groups) {
     rb_ary_push(names,
-        encoded_str_new(it->first.data(), it->first.size(),
+        encoded_str_new(group.first.data(), group.first.size(),
           p->pattern->options().encoding()));
   }
 
@@ -385,7 +385,7 @@ static VALUE re2_scanner_rewind(VALUE self) {
   delete c->input;
   c->input = new(std::nothrow) re2::StringPiece(
       RSTRING_PTR(c->text), RSTRING_LEN(c->text));
-  if (c->input == 0) {
+  if (c->input == nullptr) {
     rb_raise(rb_eNoMemError,
              "not enough memory to allocate StringPiece for input");
   }
@@ -412,12 +412,12 @@ static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
 
   if (other_c->input) {
     self_c->input = new(std::nothrow) re2::StringPiece(*other_c->input);
-    if (self_c->input == 0) {
+    if (self_c->input == nullptr) {
       rb_raise(rb_eNoMemError,
                "not enough memory to allocate StringPiece for input");
     }
   } else {
-    self_c->input = NULL;
+    self_c->input = nullptr;
   }
 
   return self;
@@ -469,7 +469,7 @@ static VALUE re2_scanner_scan(VALUE self) {
     VALUE result = rb_ary_new2(c->number_of_capturing_groups);
 
     for (int i = 0; i < c->number_of_capturing_groups; ++i) {
-      if (matches[i].empty()) {
+      if (matches[i].data() == nullptr) {
         rb_ary_push(result, Qnil);
       } else {
         rb_ary_push(result, encoded_str_new(matches[i].data(),
@@ -501,36 +501,36 @@ 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 std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-    std::map<std::string, int>::const_iterator search = groups.find(rb_id2name(SYM2ID(idx)));
+    const auto& groups = p->pattern->NamedCapturingGroups();
+    auto search = groups.find(rb_id2name(SYM2ID(idx)));
 
     if (search != groups.end()) {
       id = search->second;
     } else {
-      return NULL;
+      return nullptr;
     }
   } else {
     StringValue(idx);
 
-    const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-    std::map<std::string, int>::const_iterator search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
+    const auto& groups = p->pattern->NamedCapturingGroups();
+    auto search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
 
     if (search != groups.end()) {
       id = search->second;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
 
   if (id >= 0 && id < m->number_of_matches) {
     re2::StringPiece *match = &m->matches[id];
 
-    if (!match->empty()) {
+    if (match->data() != nullptr) {
       return match;
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /*
@@ -564,7 +564,7 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
   re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   } else {
     long offset = match->data() - RSTRING_PTR(m->text);
@@ -589,7 +589,7 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   } else {
     long offset = (match->data() - RSTRING_PTR(m->text)) + match->size();
@@ -615,7 +615,7 @@ static VALUE re2_matchdata_pre_match(const VALUE self) {
   re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   re2::StringPiece *match = &m->matches[0];
-  if (match->empty()) {
+  if (match->data() == nullptr) {
     return Qnil;
   }
 
@@ -642,7 +642,7 @@ static VALUE re2_matchdata_post_match(const VALUE self) {
   re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   re2::StringPiece *match = &m->matches[0];
-  if (match->empty()) {
+  if (match->data() == nullptr) {
     return Qnil;
   }
 
@@ -669,7 +669,7 @@ static VALUE re2_matchdata_offset(const VALUE self, VALUE n) {
   re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   }
 
@@ -700,7 +700,7 @@ static VALUE re2_matchdata_match_length(const VALUE self, VALUE n) {
   re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   }
 
@@ -766,7 +766,7 @@ static VALUE re2_matchdata_to_a(const VALUE self) {
   for (int i = 0; i < m->number_of_matches; ++i) {
     re2::StringPiece *match = &m->matches[i];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -786,7 +786,7 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
   } else {
     re2::StringPiece *match = &m->matches[nth];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       return Qnil;
     } else {
       return encoded_str_new(match->data(), match->size(),
@@ -799,8 +799,8 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
   re2_matchdata *m = unwrap_re2_matchdata(self);
   re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-  std::map<std::string, int>::const_iterator search = groups.find(name);
+  const auto& groups = p->pattern->NamedCapturingGroups();
+  auto search = groups.find(name);
 
   if (search != groups.end()) {
     return re2_matchdata_nth_match(search->second, self);
@@ -955,7 +955,7 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
   for (int i = 1; i < m->number_of_matches; ++i) {
     re2::StringPiece *match = &m->matches[i];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -999,14 +999,14 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   re2_matchdata *m = unwrap_re2_matchdata(self);
   re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
   if (NIL_P(keys)) {
-    for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+    for (const auto& group : groups) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern2(it->first.data(), it->first.size())),
-          re2_matchdata_nth_match(it->second, self));
+          ID2SYM(rb_intern2(group.first.data(), group.first.size())),
+          re2_matchdata_nth_match(group.second, self));
     }
   } else {
     Check_Type(keys, T_ARRAY);
@@ -1016,7 +1016,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
         VALUE key = rb_ary_entry(keys, i);
         Check_Type(key, T_SYMBOL);
         const char *name = rb_id2name(SYM2ID(key));
-        std::map<std::string, int>::const_iterator search = groups.find(name);
+        auto search = groups.find(name);
 
         if (search != groups.end()) {
           rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(search->second, self));
@@ -1069,18 +1069,18 @@ static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE sel
   re2_matchdata *m = unwrap_re2_matchdata(self);
   re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE result = rb_hash_new();
 
-  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+  for (const auto& group : groups) {
     VALUE key;
     if (symbolize) {
-      key = ID2SYM(rb_intern2(it->first.data(), it->first.size()));
+      key = ID2SYM(rb_intern2(group.first.data(), group.first.size()));
     } else {
-      key = encoded_str_new(it->first.data(), it->first.size(),
+      key = encoded_str_new(group.first.data(), group.first.size(),
               p->pattern->options().encoding());
     }
-    rb_hash_aset(result, key, re2_matchdata_nth_match(it->second, self));
+    rb_hash_aset(result, key, re2_matchdata_nth_match(group.second, self));
   }
 
   return result;
@@ -1160,7 +1160,7 @@ static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
 
   if (other_m->matches) {
     self_m->matches = new(std::nothrow) re2::StringPiece[other_m->number_of_matches];
-    if (self_m->matches == 0) {
+    if (self_m->matches == nullptr) {
       rb_raise(rb_eNoMemError,
                "not enough memory to allocate StringPiece for matches");
     }
@@ -1168,7 +1168,7 @@ static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
       self_m->matches[i] = other_m->matches[i];
     }
   } else {
-    self_m->matches = NULL;
+    self_m->matches = nullptr;
   }
 
   return self;
@@ -1244,7 +1244,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
         re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)));
   }
 
-  if (p->pattern == 0) {
+  if (p->pattern == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
@@ -1263,7 +1263,7 @@ static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
 
   self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
                                           other_p->pattern->options());
-  if (self_p->pattern == 0) {
+  if (self_p->pattern == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
@@ -1629,14 +1629,14 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
  */
 static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
   re2_pattern *p = unwrap_re2_regexp(self);
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
-  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+  for (const auto& group : groups) {
     rb_hash_aset(capturing_groups,
-        encoded_str_new(it->first.data(), it->first.size(),
+        encoded_str_new(group.first.data(), group.first.size(),
           p->pattern->options().encoding()),
-        INT2FIX(it->second));
+        INT2FIX(group.second));
   }
 
   return capturing_groups;
@@ -1737,8 +1737,8 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   p = unwrap_re2_regexp(self);
 
   int n;
-  int startpos = 0;
-  int endpos = RSTRING_LEN(text);
+  size_t startpos = 0;
+  size_t endpos = RSTRING_LEN(text);
   RE2::Anchor anchor = RE2::UNANCHORED;
 
   if (RTEST(options)) {
@@ -1756,11 +1756,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
       VALUE endpos_option = rb_hash_aref(options, ID2SYM(id_endpos));
       if (!NIL_P(endpos_option)) {
 #ifdef HAVE_ENDPOS_ARGUMENT
-        endpos = NUM2INT(endpos_option);
+        ssize_t endpos_value = NUM2SSIZET(endpos_option);
 
-        if (endpos < 0) {
+        if (endpos_value < 0) {
           rb_raise(rb_eArgError, "endpos should be >= 0");
         }
+
+        endpos = static_cast<size_t>(endpos_value);
 #else
         rb_raise(re2_eRegexpUnsupportedError, "current version of RE2::Match() does not support endpos argument");
 #endif
@@ -1799,11 +1801,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
       VALUE startpos_option = rb_hash_aref(options, ID2SYM(id_startpos));
       if (!NIL_P(startpos_option)) {
-        startpos = NUM2INT(startpos_option);
+        ssize_t startpos_value = NUM2SSIZET(startpos_option);
 
-        if (startpos < 0) {
+        if (startpos_value < 0) {
           rb_raise(rb_eArgError, "startpos should be >= 0");
         }
+
+        startpos = static_cast<size_t>(startpos_value);
       }
     }
   } else {
@@ -1838,7 +1842,7 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     n += 1;
 
     re2::StringPiece *matches = new(std::nothrow) re2::StringPiece[n];
-    if (matches == 0) {
+    if (matches == nullptr) {
       rb_raise(rb_eNoMemError,
                "not enough memory to allocate StringPieces for matches");
     }
@@ -1935,7 +1939,7 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   RB_OBJ_WRITE(scanner, &c->text, rb_str_new_frozen(text));
   c->input = new(std::nothrow) re2::StringPiece(
       RSTRING_PTR(c->text), RSTRING_LEN(c->text));
-  if (c->input == 0) {
+  if (c->input == nullptr) {
     rb_raise(rb_eNoMemError,
              "not enough memory to allocate StringPiece for input");
   }
@@ -2293,7 +2297,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
   }
 
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
-  if (s->set == 0) {
+  if (s->set == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Set object");
   }
 
@@ -2480,8 +2484,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
           rb_raise(re2_eSetMatchError, "Unknown RE2::Set::ErrorKind: %d", e.kind);
       }
     } else {
-      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
-        rb_ary_push(result, INT2FIX(v[i]));
+      for (int index : v) {
+        rb_ary_push(result, INT2FIX(index));
       }
     }
 
@@ -2495,8 +2499,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
     VALUE result = rb_ary_new2(v.size());
 
     if (matched) {
-      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
-        rb_ary_push(result, INT2FIX(v[i]));
+      for (int index : v) {
+        rb_ary_push(result, INT2FIX(index));
       }
     }
 

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.25.0"
+  VERSION = "2.26.1"
 end

data/spec/re2/match_data_spec.rb

@@ -66,10 +66,16 @@ RSpec.describe RE2::MatchData do
       expect(a).to eq(["woo", "o", "o"])
     end
 
-    it "populates optional capturing groups with nil if they are missing" do
+    it "populates optional capturing groups with empty strings if they match zero characters" do
       a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
 
-      expect(a).to eq(["ab", nil, "a", "b"])
+      expect(a).to eq(["ab", "", "a", "b"])
+    end
+
+    it "distinguishes between zero-length matches and unmatched groups" do
+      a = RE2::Regexp.new('()(a)?').match('b').to_a
+
+      expect(a).to eq(["", "", nil])
     end
 
     it "returns UTF-8 strings if the pattern is UTF-8" do
@@ -158,6 +164,12 @@ RSpec.describe RE2::MatchData do
       expect(md[:numbers]).to eq("123")
     end
 
+    it "returns an empty string for a zero-length capturing group" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md[1]).to eq("")
+    end
+
     it "returns nil if no such named group exists", :aggregate_failures do
       md = RE2::Regexp.new('(\d+)').match("bob 123")
 
@@ -281,6 +293,12 @@ RSpec.describe RE2::MatchData do
       expect(md.inspect).to eq('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
     end
 
+    it "represents zero-length capturing groups as empty strings" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.inspect).to eq('#<RE2::MatchData "" 1:"">')
+    end
+
     it "supports matches with null bytes" do
       md = RE2::Regexp.new("(\\w\0\\w) (\\w\0\\w)").match("a\0b c\0d")
 
@@ -299,6 +317,12 @@ RSpec.describe RE2::MatchData do
       expect(md.to_s).to eq("23456")
     end
 
+    it "returns an empty string for a zero-length match" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.to_s).to eq("")
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.to_s }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
@@ -346,6 +370,12 @@ RSpec.describe RE2::MatchData do
       expect(md.string[md.begin(0)..-1]).to eq('Ruby')
     end
 
+    it "returns the offset for a zero-length capturing group" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.begin(1)).to eq(0)
+    end
+
     it "returns nil for non-existent numerical matches" do
       md = RE2::Regexp.new('(\d)').match('123')
 
@@ -419,6 +449,12 @@ RSpec.describe RE2::MatchData do
       expect(md.string[0...md.end(0)]).to eq('I ♥ Ruby')
     end
 
+    it "returns the offset for a zero-length capturing group" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.end(1)).to eq(0)
+    end
+
     it "returns nil for non-existent numerical matches" do
       md = RE2::Regexp.new('(\d)').match('123')
 
@@ -492,6 +528,12 @@ RSpec.describe RE2::MatchData do
       expect(md.pre_match.encoding).to eq(Encoding::ISO_8859_1)
     end
 
+    it "returns the text before a zero-length match" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.pre_match).to eq("")
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.pre_match }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
@@ -528,6 +570,12 @@ RSpec.describe RE2::MatchData do
       expect(md.post_match.encoding).to eq(Encoding::ISO_8859_1)
     end
 
+    it "returns the text after a zero-length match" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.post_match).to eq("bob")
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.post_match }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
@@ -564,6 +612,12 @@ RSpec.describe RE2::MatchData do
       expect(md.offset(0)).to eq([4, 8])
     end
 
+    it "returns identical offsets for a zero-length capturing group" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.offset(1)).to eq([0, 0])
+    end
+
     it "returns nil for non-existent numerical matches" do
       md = RE2::Regexp.new('(\d)').match("123")
 
@@ -618,6 +672,12 @@ RSpec.describe RE2::MatchData do
       expect(md.match_length(0)).to eq(6)
     end
 
+    it "returns zero for a zero-length capturing group" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.match_length(1)).to eq(0)
+    end
+
     it "returns nil for non-existent numerical matches" do
       md = RE2::Regexp.new('(\d)').match("123")
 
@@ -672,6 +732,12 @@ RSpec.describe RE2::MatchData do
       expect(md.values_at(:a, :z)).to eq(["123", nil])
     end
 
+    it "returns an empty string for a zero-length capturing group" do
+      md = RE2::Regexp.new('()(b)').match("bob")
+
+      expect(md.values_at(1, 2)).to eq(["", "b"])
+    end
+
     it "returns the full match when given index 0" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("123 456")
 
@@ -702,6 +768,12 @@ RSpec.describe RE2::MatchData do
       expect(md.deconstruct).to eq(['o', 'o', nil])
     end
 
+    it "includes zero-length capturing groups as empty strings" do
+      md = RE2::Regexp.new('()').match("bob")
+
+      expect(md.deconstruct).to eq([""])
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.deconstruct }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
@@ -744,6 +816,12 @@ RSpec.describe RE2::MatchData do
       expect(md.named_captures).to eq("a" => "123", "b" => nil)
     end
 
+    it "returns an empty string for a zero-length named capturing group" do
+      md = RE2::Regexp.new('(?P<empty>)(?P<word>\w+)').match("bob")
+
+      expect(md.named_captures).to eq("empty" => "", "word" => "bob")
+    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')
 
@@ -822,6 +900,12 @@ RSpec.describe RE2::MatchData do
       expect(md.deconstruct_keys(nil)).to eq({})
     end
 
+    it "returns an empty string for a zero-length named capturing group" do
+      md = RE2::Regexp.new('(?P<empty>)(?P<word>\w+)').match("bob")
+
+      expect(md.deconstruct_keys(nil)).to eq(empty: "", word: "bob")
+    end
+
     it "raises an error if given a non-array of keys" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 

data/spec/re2/regexp_spec.rb

@@ -590,6 +590,24 @@ RSpec.describe RE2::Regexp do
       expect { re.match("one two three", endpos: 3) }.to raise_error(RE2::Regexp::UnsupportedError)
     end
 
+    it "does not truncate startpos to 32 bits" do
+      skip "Underlying RE2::Match does not have endpos argument" unless RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect(re.match("one two three", startpos: 2_147_483_648, endpos: 2_147_483_649)).to be_nil
+    end
+
+    it "does not truncate endpos to 32 bits" do
+      skip "Underlying RE2::Match does not have endpos argument" unless RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect(re.match("one two three", endpos: 2_147_483_648)).to be_nil
+    end
+
     it "does not anchor matches by default when extracting submatches" do
       re = RE2::Regexp.new('(two)')
 

data/spec/re2/scanner_spec.rb

@@ -185,11 +185,11 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil with an empty input and capture", :aggregate_failures do
+    it "returns an array of empty strings with an empty input and capture", :aggregate_failures do
       r = RE2::Regexp.new("()")
       scanner = r.scan("")
 
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
       expect(scanner.scan).to be_nil
     end
 
@@ -204,25 +204,34 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil if the pattern is an empty capturing group", :aggregate_failures do
+    it "returns an array of empty strings if the pattern is an empty capturing group", :aggregate_failures do
       r = RE2::Regexp.new("()")
       scanner = r.scan("Foo")
 
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
       expect(scanner.scan).to be_nil
     end
 
-    it "returns array of nils with multiple empty capturing groups", :aggregate_failures do
+    it "returns array of empty strings with multiple empty capturing groups", :aggregate_failures do
       r = RE2::Regexp.new("()()()")
       scanner = r.scan("Foo")
 
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "distinguishes zero-length matches from unmatched groups", :aggregate_failures do
+      r = RE2::Regexp.new("()(a)?")
+      scanner = r.scan("b")
+
+      expect(scanner.scan).to eq(["", nil])
+      expect(scanner.scan).to eq(["", nil])
       expect(scanner.scan).to be_nil
     end
 
@@ -230,7 +239,7 @@ RSpec.describe RE2::Scanner do
       r = RE2::Regexp.new("()€")
       scanner = r.scan("€")
 
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
       expect(scanner.scan).to be_nil
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.25.0
+  version: 2.26.1
 platform: ruby
 authors:
 - Paul Mucur