re2 2.21.0-arm-linux-gnu → 2.22.0-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbdd9a1a46ac6e196b2bbf90e31684c9559f87d9ab4febad73a5f4cf34c9ed77
-  data.tar.gz: 44e9874ed9f6e4454d5707144553d1abd79be711fdfcea9727bb2480179d9924
+  metadata.gz: 83f94d7b94283ab5cd0b89ee9b0e3749aa3b7757fe6520b8c680d6ef11584a6b
+  data.tar.gz: 878457fb7ab4cbd81d5d4953637581b248ce1e0c8a576905ac96da3945c6cf05
 SHA512:
-  metadata.gz: 283e6f9ae2614b8ac86d0dda2fcb8b3f24f52ea4a0bfd1a0abfef467a5aed358408adc8718ae35357c885b39e8e197a39129556d9e07bc69c1d9ff19b05a2ecf
-  data.tar.gz: 6b98326df023569622d7906f1a4b7e83a2a8c0038413aaad6cc9ea2f1200f6340adb927313818c600bbe84ebcae3a7d2819cc7d773e9c82a9458993c00aad437
+  metadata.gz: 3955f1d2eba7052e5c6c94f54314212a8756c2c3f8a2f034c3b9c61d40193d2918bc5c83c68025fbbdb178ab40dd19b38102c9b042687f5ecca37e5c4138fe0a
+  data.tar.gz: a97b2d4b5a02b9844b8201bbe3d7f2da60534cf84b616f761357257042bb1cb6db5169f0aeb8214e8c538fc4dd100b2de1c1a5ba92e406794b49b22de52c6e49

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

data/ext/re2/re2.cc

@@ -326,6 +326,11 @@ 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) {
+    rb_raise(rb_eNoMemError,
+             "not enough memory to allocate StringPiece for input");
+  }
+
   c->eof = false;
 
   return self;
@@ -412,8 +417,8 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
 
   int id;
 
-  if (FIXNUM_P(idx)) {
-    id = FIX2INT(idx);
+  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)));
@@ -681,10 +686,10 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
         std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self);
   } else if (SYMBOL_P(idx)) {
     return re2_matchdata_named_match(rb_id2name(SYM2ID(idx)), self);
-  } else if (!NIL_P(rest) || !FIXNUM_P(idx) || FIX2INT(idx) < 0) {
+  } 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 {
-    return re2_matchdata_nth_match(FIX2INT(idx), self);
+    return re2_matchdata_nth_match(NUM2INT(idx), self);
   }
 }
 
@@ -1421,7 +1426,7 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   RE2::Anchor anchor = RE2::UNANCHORED;
 
   if (RTEST(options)) {
-    if (FIXNUM_P(options)) {
+    if (RB_INTEGER_TYPE_P(options)) {
       n = NUM2INT(options);
 
       if (n < 0) {
@@ -1435,8 +1440,6 @@ 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
-        Check_Type(endpos_option, T_FIXNUM);
-
         endpos = NUM2INT(endpos_option);
 
         if (endpos < 0) {
@@ -1465,8 +1468,6 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
       VALUE submatches_option = rb_hash_aref(options, ID2SYM(id_submatches));
       if (!NIL_P(submatches_option)) {
-        Check_Type(submatches_option, T_FIXNUM);
-
         n = NUM2INT(submatches_option);
 
         if (n < 0) {
@@ -1482,8 +1483,6 @@ 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)) {
-        Check_Type(startpos_option, T_FIXNUM);
-
         startpos = NUM2INT(startpos_option);
 
         if (startpos < 0) {
@@ -1515,37 +1514,43 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 #endif
     return BOOL2RUBY(matched);
   } else {
+    if (n == INT_MAX) {
+      rb_raise(rb_eRangeError, "number of matches should be < %d", INT_MAX);
+    }
+
     /* Because match returns the whole match as well. */
     n += 1;
 
-    VALUE matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
-    TypedData_Get_Struct(matchdata, re2_matchdata, &re2_matchdata_data_type, m);
-    m->matches = new(std::nothrow) re2::StringPiece[n];
-    RB_OBJ_WRITE(matchdata, &m->regexp, self);
-    if (!RTEST(rb_obj_frozen_p(text))) {
-      text = rb_str_freeze(rb_str_dup(text));
-    }
-    RB_OBJ_WRITE(matchdata, &m->text, text);
-
-    if (m->matches == 0) {
+    re2::StringPiece *matches = new(std::nothrow) re2::StringPiece[n];
+    if (matches == 0) {
       rb_raise(rb_eNoMemError,
                "not enough memory to allocate StringPieces for matches");
     }
 
-    m->number_of_matches = n;
+    text = rb_str_new_frozen(text);
 
 #ifdef HAVE_ENDPOS_ARGUMENT
     bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(m->text), RSTRING_LEN(m->text)),
-        startpos, endpos, anchor, m->matches, n);
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        startpos, endpos, anchor, matches, n);
 #else
     bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(m->text), RSTRING_LEN(m->text)),
-        startpos, anchor, m->matches, n);
+        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
+        startpos, anchor, matches, n);
 #endif
     if (matched) {
+      VALUE matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
+      TypedData_Get_Struct(matchdata, re2_matchdata, &re2_matchdata_data_type, m);
+
+      RB_OBJ_WRITE(matchdata, &m->regexp, self);
+      RB_OBJ_WRITE(matchdata, &m->text, text);
+      m->matches = matches;
+      m->number_of_matches = n;
+
       return matchdata;
     } else {
+      delete[] matches;
+
       return Qnil;
     }
   }
@@ -1615,12 +1620,13 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
   RB_OBJ_WRITE(scanner, &c->regexp, self);
-  if (!RTEST(rb_obj_frozen_p(text))) {
-    text = rb_str_freeze(rb_str_dup(text));
-  }
-  RB_OBJ_WRITE(scanner, &c->text, text);
+  RB_OBJ_WRITE(scanner, &c->text, rb_str_new_frozen(text));
   c->input = new(std::nothrow) re2::StringPiece(
-      RSTRING_PTR(text), RSTRING_LEN(text));
+      RSTRING_PTR(c->text), RSTRING_LEN(c->text));
+  if (c->input == 0) {
+    rb_raise(rb_eNoMemError,
+             "not enough memory to allocate StringPiece for input");
+  }
 
   if (p->pattern->ok()) {
     c->number_of_capturing_groups = p->pattern->NumberOfCapturingGroups();
@@ -1916,21 +1922,19 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
   re2_set *s;
   TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
 
-  /* To prevent the memory of the err string leaking when we call rb_raise,
-   * take a copy of it and let it go out of scope.
-   */
-  char msg[100];
   int index;
+  VALUE msg;
 
   {
     std::string err;
     index = s->set->Add(
         re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), &err);
-    strlcpy(msg, err.c_str(), sizeof(msg));
+    msg = rb_str_new(err.data(), err.size());
   }
 
   if (index < 0) {
-    rb_raise(rb_eArgError, "str rejected by RE2::Set->Add(): %s", msg);
+    rb_raise(rb_eArgError,
+             "str rejected by RE2::Set->Add(): %s", RSTRING_PTR(msg));
   }
 
   return INT2FIX(index);

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.21.0"
+  VERSION = "2.22.0"
 end

data/spec/re2/regexp_spec.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require "rbconfig/sizeof"
+
 RSpec.describe RE2::Regexp do
+  INT_MAX = 2**(RbConfig::SIZEOF.fetch("int") * 8 - 1) - 1
+
   describe "#initialize" do
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.new('woo')
@@ -566,6 +570,12 @@ RSpec.describe RE2::Regexp do
       expect { re.match("one two three", submatches: :invalid) }.to raise_error(TypeError)
     end
 
+    it "raises an exception when given too large a number of submatches" do
+      re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
+
+      expect { re.match("one two three", submatches: INT_MAX) }.to raise_error(RangeError, "number of matches should be < #{INT_MAX}")
+    end
+
     it "defaults to extracting all submatches when given nil", :aggregate_failures do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
       md = re.match("one two three", submatches: nil)
@@ -584,6 +594,13 @@ RSpec.describe RE2::Regexp do
       expect(md[3]).to be_nil
     end
 
+    it "raises an exception if given too large a number of submatches instead of options" do
+      re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
+      md = re.match("one two three", 2)
+
+      expect { re.match("one two three", INT_MAX) }.to raise_error(RangeError, "number of matches should be < #{INT_MAX}")
+    end
+
     it "raises an exception when given invalid options" do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
 

data/spec/re2/set_spec.rb

@@ -66,10 +66,10 @@ RSpec.describe RE2::Set do
       expect { set.add("???") }.to raise_error(ArgumentError, /str rejected by RE2::Set->Add\(\)/)
     end
 
-    it "truncates error messages to 100 characters" do
+    it "includes the full error message" do
       set = RE2::Set.new(:unanchored, log_errors: false)
 
-      expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
+      expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
     end
 
     it "raises an error if called after #compile" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.21.0
+  version: 2.22.0
 platform: arm-linux-gnu
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-11-10 00:00:00.000000000 Z
+date: 2025-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler