re2 2.25.0 → 2.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 477c8a61880d0b90859d119d21612ccaa439fd6e7a5d06946b5044a6520b2fab
-  data.tar.gz: '0973c566418525946e61a99d1d317bd708a52dc395053064261c6d581ebb797c'
+  metadata.gz: e424609ac6f07a3b9ad8ebaa3dacdae7b2f9ef421f450ee83d5b1e11d1088423
+  data.tar.gz: 8a650664e82ace10809cc4f65af1f40177b3b70bdc92f495a7b79db65859ead2
 SHA512:
-  metadata.gz: 9e18ab14bd16e37917b988483dd432b7469da78113c1f67dcaefaf5102771c635dfde842779b6b325ffd857d0203acc9c32cd88c5f1cb7017fdf05f93f89adf1
-  data.tar.gz: 20081d9a25c5789a2c585b0c33049c8431ab0f5abc29b2bc0c4e4baa6a1bc6b3da24fd609fe7f05e65a4d5eb4759c20ba3c481f31bc85c25d3cbf2f8efb56d18
+  metadata.gz: 676b8efebf7d2c7f7d8a4cdd984ce4050d798ce9198010364cd6b0c9cf02e25276699fcefbe3c1a387ef74f1ee9fae97a18364df60370ca76aeab6f9a15d9fee
+  data.tar.gz: e0595b1d2bc13e0b40e880fe78090a1ac2780a2c7a6a2e8d0a456af3c18dc6aac70ae7b81cb6cac4f1f6cde223a099e6f31f27d1c0b173250851a7d2f9677dab

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.0  
 **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

@@ -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() == NULL) {
         rb_ary_push(result, Qnil);
       } else {
         rb_ary_push(result, encoded_str_new(matches[i].data(),
@@ -525,7 +525,7 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
   if (id >= 0 && id < m->number_of_matches) {
     re2::StringPiece *match = &m->matches[id];
 
-    if (!match->empty()) {
+    if (match->data() != NULL) {
       return match;
     }
   }
@@ -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() == NULL) {
     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() == NULL) {
     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() == NULL) {
       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() == NULL) {
       return Qnil;
     } else {
       return encoded_str_new(match->data(), match->size(),
@@ -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() == NULL) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.25.0"
+  VERSION = "2.26.0"
 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/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.0
 platform: ruby
 authors:
 - Paul Mucur