re2 2.26.0-aarch64-linux-gnu → 2.26.2-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ad7f334824a616b2e39a28633fb597b5d2e79b47c27a8dee1283a4d7482ee5e
-  data.tar.gz: 9ffb6aadda033107deb3fbfda3313b031cad65e7d478464bae1406fe2919f8bd
+  metadata.gz: b40f4cfd1c562498a0249b43c03cffb2a22525184f4ed51f1c498c2f8ab17954
+  data.tar.gz: ed9df3b2b2085afb91e3cd418ce38f7e7513c96c6381e05a40089c975f0256ea
 SHA512:
-  metadata.gz: c5f4a9d037c6de275a4e95c70e3ef55861a40d086507095c3484fd35f3fe97894098723edef3d12e4576da8a90907a78f09d1b536e173182f4cdbce6a216934a
-  data.tar.gz: bf858ffe8ade2e2e03d77a81531d566a41ae762fc654984d0584c76848079aae84e8ac2a65d92915228014dcb0ed70666b1041a4b5f65c68d48f0e2e6ea78b1d
+  metadata.gz: b6205ed6870d1459dbb2384cd2e563ed59d0176ce74c3c7ad8c68d33c16f8a1e637de69eb571069de7a47dadd6d095a52e23508455b89f259438792536a0b513
+  data.tar.gz: 26b825f7a5d4026f40dfc6909838ca5d32ed3750009508bf7eb131659db1599bdc6cdb7564f08d54caeb0d98a7e0acb610840cdd8491e94d44b4fec18634a80c

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

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");
   }
@@ -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);
@@ -412,12 +413,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 +470,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].data() == NULL) {
+      if (matches[i].data() == nullptr) {
         rb_ary_push(result, Qnil);
       } else {
         rb_ary_push(result, encoded_str_new(matches[i].data(),
@@ -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;
@@ -501,36 +520,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->data() != NULL) {
+    if (match->data() != nullptr) {
       return match;
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /*
@@ -564,7 +583,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 +608,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 +634,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->data() == NULL) {
+  if (match->data() == nullptr) {
     return Qnil;
   }
 
@@ -642,7 +661,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->data() == NULL) {
+  if (match->data() == nullptr) {
     return Qnil;
   }
 
@@ -669,7 +688,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 +719,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 +785,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->data() == NULL) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -786,7 +805,7 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
   } else {
     re2::StringPiece *match = &m->matches[nth];
 
-    if (match->data() == NULL) {
+    if (match->data() == nullptr) {
       return Qnil;
     } else {
       return encoded_str_new(match->data(), match->size(),
@@ -799,8 +818,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 +974,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->data() == NULL) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -999,14 +1018,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 +1035,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 +1088,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;
@@ -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;
@@ -1160,7 +1180,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 +1188,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;
@@ -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)) {
@@ -1244,7 +1265,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");
   }
 
@@ -1259,11 +1280,12 @@ 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(),
                                           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 +1651,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 +1759,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 +1778,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 +1823,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 {
@@ -1818,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(
@@ -1838,7 +1871,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 +1968,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");
   }
@@ -1993,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)));
@@ -2046,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)));
@@ -2100,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,
@@ -2123,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))),
@@ -2290,10 +2334,11 @@ 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);
-  if (s->set == 0) {
+  if (s->set == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Set object");
   }
 
@@ -2480,8 +2525,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 +2540,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.26.0"
+  VERSION = "2.26.2"
 end

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)')
 
@@ -739,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.0
+  version: 2.26.2
 platform: aarch64-linux-gnu
 authors:
 - Paul Mucur