re2 2.26.0-x86_64-linux-gnu → 2.26.1-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c487be8dde24ba47698605128ab9a836beab4cafd37996e102c50826a32055ee
-  data.tar.gz: d24f390a439bb16f90e04f8dbf2a89d617007cbd6a5f54f7f3469519e7cedaa1
+  metadata.gz: f26a7c50adf99ee96e8af8cf72c2807df885f3aea35a56ac56962327b6151cce
+  data.tar.gz: 8823d9b232988ec6026e30b4930284a0deed495cbf7fd7c8c2fab09c0244004c
 SHA512:
-  metadata.gz: 2eed385c1284ffbd65a744c7c59c9b3e6376c8d268b33998b37078ffacddc8ddcb8031ec57a8a2f32db39f079dee20390df2eaf65596d2c86f72c7b7c6a1c750
-  data.tar.gz: efe3b8cca6408cd273dd627e15fd3472cc4f1626187bdec616c9953ac597011cd04895bf86a688bd3ed53a2db7d6ab6986979ab5f796f3652f1d373b67cdf2cb
+  metadata.gz: 8423cd1e0bfb54c2e7d211c5f9b667cbd3025163adbbb42575e545ef5bbef4e437c955f107bdeb30a0a988e65374c3b601bcaa542716b9a649f0fdd803fc78c3
+  data.tar.gz: 55b2b7aa364e94aa1a0e25a344707643974b435d82c8a04a73ac261aa99f3c2b350cd9dd01627e5a21c0b81c5412d5a833ecb7e138bc08a085a5ed87a574e352

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.1  
 **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");
   }
@@ -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].data() == NULL) {
+      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->data() != NULL) {
+    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->data() == NULL) {
+  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->data() == NULL) {
+  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->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 +786,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 +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->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 +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.26.0"
+  VERSION = "2.26.1"
 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)')
 

metadata

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