re2 2.26.1-x86_64-linux-gnu → 2.26.2-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f26a7c50adf99ee96e8af8cf72c2807df885f3aea35a56ac56962327b6151cce
-  data.tar.gz: 8823d9b232988ec6026e30b4930284a0deed495cbf7fd7c8c2fab09c0244004c
+  metadata.gz: cebd541e73b7d04ed10265c89a3c0ef8f52989a11ff8065d7bded9caba0a887f
+  data.tar.gz: c023f43cf0c7782b496f22811cd079f4a72da624b98c48f1049a62ca8345781e
 SHA512:
-  metadata.gz: 8423cd1e0bfb54c2e7d211c5f9b667cbd3025163adbbb42575e545ef5bbef4e437c955f107bdeb30a0a988e65374c3b601bcaa542716b9a649f0fdd803fc78c3
-  data.tar.gz: 55b2b7aa364e94aa1a0e25a344707643974b435d82c8a04a73ac261aa99f3c2b350cd9dd01627e5a21c0b81c5412d5a833ecb7e138bc08a085a5ed87a574e352
+  metadata.gz: 0e75a3f78b09dbff07b53b9566382bd03227efecb246065451c9b30063c053c2d48cfd6a42ac44746a5a182aafc563cd2879094193acdb467f4400e7c12af308
+  data.tar.gz: 17755302c984c920b3510463a91e2d7d7280d7f49e5180662a52e46400751a0f3aa4a67625c7e5147df2f6d0b1f8fea69c3d795f6d70d13b5e6d88e15ce44d03

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

data/ext/re2/re2.cc

@@ -403,6 +403,7 @@ static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
 
   if (self_c->input) {
     delete self_c->input;
+    self_c->input = nullptr;
   }
 
   RB_OBJ_WRITE(self, &self_c->regexp, other_c->regexp);
@@ -481,9 +482,27 @@ static VALUE re2_scanner_scan(VALUE self) {
     /* Check whether we've exhausted the input yet. */
     c->eof = new_input_size == 0;
 
-    /* If the match didn't advance the input, we need to do this ourselves. */
+    /* If the match didn't advance the input, we need to do this ourselves,
+     * advancing by a whole character to avoid splitting multi-byte characters.
+     *
+     * The lookup table approach is taken from RE2's own Python extension: the
+     * high 4 bits of a UTF-8 lead byte determine the character's byte length.
+     *
+     * See https://github.com/google/re2/blob/972a15cedd008d846f1a39b2e88ce48d7f166cbd/python/_re2.cc#L46-L48
+     */
     if (!input_advanced && new_input_size > 0) {
-      c->input->remove_prefix(1);
+      size_t char_size = 1;
+
+      if (p->pattern->options().encoding() == RE2::Options::EncodingUTF8) {
+        char_size = "\1\1\1\1\1\1\1\1\1\1\1\1\2\2\3\4"
+            [((*c->input)[0] & 0xFF) >> 4];
+
+        if (char_size > new_input_size) {
+          char_size = new_input_size;
+        }
+      }
+
+      c->input->remove_prefix(char_size);
     }
 
     return result;
@@ -1152,6 +1171,7 @@ static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
 
   if (self_m->matches) {
     delete[] self_m->matches;
+    self_m->matches = nullptr;
   }
 
   self_m->number_of_matches = other_m->number_of_matches;
@@ -1231,6 +1251,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   if (p->pattern) {
     delete p->pattern;
+    p->pattern = nullptr;
   }
 
   if (RTEST(options)) {
@@ -1259,6 +1280,7 @@ static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
 
   if (self_p->pattern) {
     delete self_p->pattern;
+    self_p->pattern = nullptr;
   }
 
   self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
@@ -1822,6 +1844,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     rb_raise(rb_eArgError, "startpos should be <= endpos");
   }
 
+#ifndef HAVE_ENDPOS_ARGUMENT
+  /* Old RE2's Match() takes int startpos. Reject values that would overflow. */
+  if (startpos > INT_MAX) {
+    rb_raise(rb_eRangeError, "startpos should be <= %d", INT_MAX);
+  }
+#endif
+
   if (n == 0) {
 #ifdef HAVE_ENDPOS_ARGUMENT
     bool matched = p->pattern->Match(
@@ -1997,29 +2026,32 @@ static VALUE re2_regexp_match_has_endpos_argument_p(VALUE) {
  */
 static VALUE re2_replace(VALUE, VALUE str, VALUE pattern,
     VALUE rewrite) {
-  /* Ensure rewrite is a string. */
-  StringValue(rewrite);
+  re2_pattern *p = nullptr;
 
-  re2_pattern *p;
+  /* Coerce all arguments before any C++ allocations so that any Ruby
+   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+   */
+  StringValue(str);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
+    StringValue(pattern);
+  }
+  StringValue(rewrite);
 
   /* Take a copy of str so it can be modified in-place by
    * RE2::Replace.
    */
-  StringValue(str);
   std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
   /* Do the replacement. */
-  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    p = unwrap_re2_regexp(pattern);
+  if (p) {
     RE2::Replace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    /* Ensure pattern is a string. */
-    StringValue(pattern);
-
     RE2::Replace(&str_as_string,
         re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
@@ -2050,28 +2082,32 @@ static VALUE re2_replace(VALUE, VALUE str, VALUE pattern,
  */
 static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
                                VALUE rewrite) {
-  /* Ensure rewrite is a string. */
+  re2_pattern *p = nullptr;
+
+  /* Coerce all arguments before any C++ allocations so that any Ruby
+   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+   */
+  StringValue(str);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
+    StringValue(pattern);
+  }
   StringValue(rewrite);
 
   /* Take a copy of str so it can be modified in-place by
    * RE2::GlobalReplace.
    */
-  re2_pattern *p;
-  StringValue(str);
   std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
   /* Do the replacement. */
-  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    p = unwrap_re2_regexp(pattern);
+  if (p) {
     RE2::GlobalReplace(&str_as_string, *p->pattern,
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    /* Ensure pattern is a string. */
-    StringValue(pattern);
-
     RE2::GlobalReplace(&str_as_string,
         re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
         re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
@@ -2104,16 +2140,23 @@ static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
  */
 static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
     VALUE rewrite) {
-  /* Ensure rewrite and text are strings. */
-  StringValue(rewrite);
+  re2_pattern *p = nullptr;
+
+  /* Coerce all arguments before any C++ allocations so that any Ruby
+   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+   */
   StringValue(text);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
+    StringValue(pattern);
+  }
+  StringValue(rewrite);
 
-  re2_pattern *p;
   std::string out;
   bool extracted;
 
-  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    p = unwrap_re2_regexp(pattern);
+  if (p) {
     extracted = RE2::Extract(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
         *p->pattern,
@@ -2127,9 +2170,6 @@ static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
       return Qnil;
     }
   } else {
-    /* Ensure pattern is a string. */
-    StringValue(pattern);
-
     extracted = RE2::Extract(
         re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
         RE2(re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern))),
@@ -2294,6 +2334,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
 
   if (s->set) {
     delete s->set;
+    s->set = nullptr;
   }
 
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);

data/lib/re2/version.rb

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

data/spec/re2/regexp_spec.rb

@@ -757,6 +757,15 @@ RSpec.describe RE2::Regexp do
       expect(re.match("one two three", nil)).to be_a(RE2::MatchData)
     end
 
+    it "raises an error when startpos exceeds INT_MAX on old RE2 ABI" do
+      skip "Underlying RE2::Match does not take int startpos" if 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("test", start_pos: 2_147_483_648) }.to raise_error(RangeError, /startpos should be <=/)
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.match("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end

data/spec/re2/scanner_spec.rb

@@ -243,6 +243,52 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
+    it "advances by whole characters with zero-width matches on 2-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("à")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 3-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u20AC")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 4-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u{1F600}")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by single bytes with zero-width matches on Latin-1 input", :aggregate_failures do
+      r = RE2::Regexp.new("", utf8: false)
+      scanner = r.scan("\xC3\xA0")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "handles truncated multi-byte sequences at the end of input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\xC3")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
     it "raises a Type Error if given input that can't be coerced to a String" do
       r = RE2::Regexp.new('(\w+)')
 

data/spec/re2_spec.rb

@@ -86,6 +86,10 @@ RSpec.describe RE2 do
       expect { RE2.replace("woo", 0, "ah") }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.replace("a" * 128, 0, "ah") }.to raise_error(TypeError)
+    end
+
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.replace("woo", "oo", 0) }.to raise_error(TypeError)
     end
@@ -182,6 +186,10 @@ RSpec.describe RE2 do
       expect { RE2.global_replace("woo", 0, "a") }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.global_replace("a" * 128, 0, "a") }.to raise_error(TypeError)
+    end
+
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.global_replace("woo", "o", 0) }.to raise_error(TypeError)
     end
@@ -266,6 +274,10 @@ RSpec.describe RE2 do
       expect { RE2.extract("woo", 0, '\1') }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.extract("a" * 128, 0, '\1') }.to raise_error(TypeError)
+    end
+
     it "raises a Type Error for a rewrite that can't be converted to String" do
       expect { RE2.extract("woo", '(\w+)', 0) }.to raise_error(TypeError)
     end

metadata

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