re2 2.15.0 → 2.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92d0c12dc899d22cf74c00bbda8f89f29665b32d10fcc9a8eb9ca01f671c62f5
-  data.tar.gz: 1aea6bbc6cc7168a5a16fbb52b244535ed422707f63ebac59c2a0d1ae81bfbaf
+  metadata.gz: 940bde937a78abda3052eb0957885f3f190310fcd16fd6408cab7796994bd008
+  data.tar.gz: a1847bd0e009e2e4a63395e9452b3ecf39d938922549cc2d8477a9398c1661b6
 SHA512:
-  metadata.gz: ff0c9014a05c741b9bc7f3b9961c9e36a97cc4e48f7546779a4ceca60ff225c84a3930acd7daf5d58225aa051b0d6ee475ce778c66ecd3f3643d522bd105b72b
-  data.tar.gz: ea0b6da27aa3e568821dc48a452fcd3e4e16600fe66e3964702d37c56e2f9247d16130e95a60c83684530633937b810539cf45d5c0f842f88d4ccc5b35dafa53
+  metadata.gz: 360dc102ebb6ee640bc4c45c8e17f0d22a5b2288c37c40e1288384275214b2c2d72c14ba490ee06472b2ecb9790fbfb5a9a3f7afc35df27aac516b3d4416e302
+  data.tar.gz: 02f43ce9a57cee1b1c3c068f3f66c12c029a0bc22b5af00d837fc1bb2fa5fb90e120dc9bf3287adb3f99302fd0f0dd32af5303fd0e7780f41961f2f7a8429ff5

data/README.md

@@ -6,8 +6,8 @@ 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.15.0  
-**Bundled RE2 version:** libre2.11 (2024-07-02)  
+**Current version:** 2.23.0  
+**Bundled RE2 version:** libre2.11 (2025-11-05)  
 
 ```ruby
 RE2('h.*o').full_match?("hello")    #=> true
@@ -224,12 +224,15 @@ the set. After all patterns have been added, the set can be compiled using
 and then
 [`RE2::Set#match`](https://mudge.name/re2/RE2/Set.html#match-instance_method)
 will return an array containing the indices of all the patterns that matched.
+[`RE2::Set#size`](https://mudge.name/re2/RE2/Set.html#size-instance_method)
+will return the number of patterns in the set.
 
 ```ruby
 set = RE2::Set.new
 set.add("abc")         #=> 0
 set.add("def")         #=> 1
 set.add("ghi")         #=> 2
+set.size               #=> 3
 set.compile            #=> true
 set.match("abcdefghi") #=> [0, 1, 2]
 set.match("ghidefabc") #=> [2, 1, 0]
@@ -257,39 +260,39 @@ RE2(non_latin1_pattern.encode("ISO-8859-1"), utf8: false).match(non_latin1_text.
 
 This gem requires the following to run:
 
-* [Ruby](https://www.ruby-lang.org/en/) 2.6 to 3.4
+* [Ruby](https://www.ruby-lang.org/en/) 3.1 to 4.0
 
 It supports the following RE2 ABI versions:
 
-* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2024-07-02)
+* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2025-11-05)
 
 ### Native gems
 
 Where possible, a pre-compiled native gem will be provided for the following platforms:
 
 * Linux
-    * `aarch64-linux`, `arm-linux`, `x86-linux` and `x86_64-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.29+, RubyGems 3.3.22+ and Bundler 2.3.21+)
+    * `aarch64-linux`, `arm-linux`, and `x86_64-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.29+, RubyGems 3.3.22+ and Bundler 2.3.21+)
     * [musl](https://musl.libc.org/)-based systems such as [Alpine](https://alpinelinux.org) are supported with Bundler 2.5.6+
-* macOS `x86_64-darwin` and `arm64-darwin`
-* Windows `x64-mingw32` and `x64-mingw-ucrt`
+* macOS 10.14+ `x86_64-darwin` and `arm64-darwin`
+* Windows 2022+ `x64-mingw-ucrt`
 
 ### Verifying the gems
 
 SHA256 checksums are included in the [release notes](https://github.com/mudge/re2/releases) for each version and can be checked with `sha256sum`, e.g.
 
 ```console
-$ gem fetch re2 -v 2.14.0
-Fetching re2-2.14.0-arm64-darwin.gem
-Downloaded re2-2.14.0-arm64-darwin
-$ sha256sum re2-2.14.0-arm64-darwin.gem
-3c922d54a44ac88499f6391bc2f9740559381deaf7f4e49eef5634cf32efc2ce  re2-2.14.0-arm64-darwin.gem
+$ gem fetch re2 -v 2.18.0
+Fetching re2-2.18.0-arm64-darwin.gem
+Downloaded re2-2.18.0-arm64-darwin
+$ sha256sum re2-2.18.0-arm64-darwin.gem
+953063f0491420163d3484ed256fe2ff616c777ec66ee20aa5ec1a1a1fc39ff5  re2-2.18.0-arm64-darwin.gem
 ```
 
 [GPG](https://www.gnupg.org/) signatures are attached to each release (the assets ending in `.sig`) and can be verified if you import [our signing key `0x39AC3530070E0F75`](https://mudge.name/39AC3530070E0F75.asc) (or fetch it from a public keyserver, e.g. `gpg --keyserver keyserver.ubuntu.com --recv-key 0x39AC3530070E0F75`):
 
 ```console
-$ gpg --verify re2-2.14.0-arm64-darwin.gem.sig re2-2.14.0-arm64-darwin.gem
-gpg: Signature made Fri  2 Aug 12:39:12 2024 BST
+$ gpg --verify re2-2.18.0-arm64-darwin.gem.sig re2-2.18.0-arm64-darwin.gem
+gpg: Signature made Sun  3 Aug 11:02:26 2025 BST
 gpg:                using RSA key 702609D9C790F45B577D7BEC39AC3530070E0F75
 gpg: Good signature from "Paul Mucur <mudge@mudge.name>" [unknown]
 gpg:                 aka "Paul Mucur <paul@ghostcassette.com>" [unknown]
@@ -328,8 +331,8 @@ You will need a full compiler toolchain for compiling Ruby C extensions (see
 Toolchain"](https://nokogiri.org/tutorials/installing_nokogiri.html#appendix-a-the-compiler-toolchain))
 plus the toolchain required for compiling the vendored version of RE2 and its
 dependency [Abseil][] which includes [CMake](https://cmake.org), a compiler
-with C++14 support such as [clang](http://clang.llvm.org/) 3.4 or
-[gcc](https://gcc.gnu.org/) 5 and a recent version of
+with C++17 support such as [clang](http://clang.llvm.org/) 5 or
+[gcc](https://gcc.gnu.org/) 8 and a recent version of
 [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/). On
 Windows, you'll also need pkgconf 2.1.0+ to avoid [`undefined reference`
 errors](https://github.com/pkgconf/pkgconf/issues/322) when attempting to
@@ -375,6 +378,8 @@ Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable i
   improvements in 2.4.0.
 * Thanks to [Manuel Jacob](https://github.com/manueljacob) for reporting a bug
   when passing strings with null bytes.
+* Thanks to [Maciej Gajewski](https://github.com/konieczkow) for helping
+  confirm issues with GC compaction and mutable strings.
 
 ## Contact
 

data/Rakefile

@@ -33,7 +33,7 @@ cross_platforms = %w[
   x86_64-linux-musl
 ].freeze
 
-ENV['RUBY_CC_VERSION'] = '3.4.1:3.3.5:3.2.6:3.1.6:3.0.7:2.7.8:2.6.10'
+RakeCompilerDock.set_ruby_cc_version("~> 3.1", "~> 4.0")
 
 Gem::PackageTask.new(re2_gemspec).define
 
@@ -70,8 +70,12 @@ namespace :gem do
     desc "Compile and build native gem for #{platform} platform"
     task platform do
       RakeCompilerDock.sh <<~SCRIPT, platform: platform, verbose: true
+        wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null &&
+        echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ focal main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null &&
+        sudo apt-get update &&
+        sudo apt-get install -y cmake=3.22.2-0kitware1ubuntu20.04.1 cmake-data=3.22.2-0kitware1ubuntu20.04.1 &&
         gem install bundler --no-document &&
-        bundle &&
+        bundle install &&
         bundle exec rake native:#{platform} pkg/#{re2_gemspec.full_name}-#{Gem::Platform.new(platform)}.gem PATH="/usr/local/bin:$PATH"
       SCRIPT
     end

data/dependencies.yml

@@ -1,7 +1,7 @@
 ---
 libre2:
-  version: '2024-07-02'
-  sha256: eb2df807c781601c14a260a507a5bb4509be1ee626024cb45acbd57cb9d4032b
+  version: '2025-11-05'
+  sha256: 87f6029d2f6de8aa023654240a03ada90e876ce9a4676e258dd01ea4c26ffd67
 abseil:
-  version: '20240722.0'
-  sha256: f50e5ac311a81382da7fa75b97310e4b9006474f9560ac46f54a9967f07d4ae3
+  version: '20250814.1'
+  sha256: 1692f77d1739bacf3f94337188b78583cf09bab7e420d2dc6c5605a4f86785a1

data/ext/re2/extconf.rb

@@ -103,6 +103,8 @@ module RE2
     def build_with_vendored_libraries
       message "Building re2 using packaged libraries.\n"
 
+      ENV["MACOSX_DEPLOYMENT_TARGET"] = "10.14"
+
       abseil_recipe, re2_recipe = load_recipes
 
       process_recipe(abseil_recipe) do |recipe|
@@ -129,10 +131,8 @@ module RE2
     end
 
     def build_extension
-      # Enable optional warnings but disable deprecated register warning for Ruby 2.6 support
       $CFLAGS << " -Wall -Wextra -funroll-loops"
       $CXXFLAGS << " -Wall -Wextra -funroll-loops"
-      $CPPFLAGS << " -Wno-register"
 
       # Pass -x c++ to force gcc to compile the test program
       # as C++ (as it will end in .c by default).
@@ -140,7 +140,6 @@ module RE2
 
       have_library("stdc++")
       have_header("stdint.h")
-      have_func("rb_gc_mark_movable") # introduced in Ruby 2.7
 
       minimal_program = <<~SRC
         #include <re2/re2.h>
@@ -152,13 +151,9 @@ module RE2
       end
 
       if re2_requires_version_flag
-        # Recent versions of re2 depend directly on abseil, which requires a
-        # compiler with C++14 support (see
-        # https://github.com/abseil/abseil-cpp/issues/1127 and
-        # https://github.com/abseil/abseil-cpp/issues/1431). However, the
-        # `std=c++14` flag doesn't appear to suffice; we need at least
-        # `std=c++17`.
-        abort "Cannot compile re2 with your compiler: recent versions require C++14 support." unless %w[c++20 c++17 c++11 c++0x].any? do |std|
+        # 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|
           checking_for("re2 that compiles with #{std} standard") do
             if try_compile(minimal_program, compile_options + " -std=#{std}")
               compile_options << " -std=#{std}"
@@ -217,6 +212,24 @@ module RE2
           $defs.push("-DHAVE_ERROR_INFO_ARGUMENT")
         end
       end
+
+      checking_for("RE2::Set::Size()") do
+        test_re2_set_size = <<~SRC
+          #include <re2/re2.h>
+          #include <re2/set.h>
+
+          int main() {
+            RE2::Set s(RE2::DefaultOptions, RE2::UNANCHORED);
+            s.Size();
+
+            return 0;
+          }
+        SRC
+
+        if try_compile(test_re2_set_size, compile_options)
+          $defs.push("-DHAVE_SET_SIZE")
+        end
+      end
     end
 
     def static_pkg_config(pc_file, pkg_config_paths)

data/ext/re2/re2.cc

@@ -125,27 +125,16 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
   }
 }
 
-/* For compatibility with Ruby < 2.7 */
-#ifdef HAVE_RB_GC_MARK_MOVABLE
-#define re2_compact_callback(x) (x),
-#else
-#define rb_gc_mark_movable(x) rb_gc_mark(x)
-#define re2_compact_callback(x)
-#endif
-
 static void re2_matchdata_mark(void *ptr) {
   re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
   rb_gc_mark_movable(m->regexp);
-  rb_gc_mark_movable(m->text);
+  rb_gc_mark(m->text);
 }
 
-#ifdef HAVE_RB_GC_MARK_MOVABLE
 static void re2_matchdata_compact(void *ptr) {
   re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
   m->regexp = rb_gc_location(m->regexp);
-  m->text = rb_gc_location(m->text);
 }
-#endif
 
 static void re2_matchdata_free(void *ptr) {
   re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
@@ -171,7 +160,7 @@ static const rb_data_type_t re2_matchdata_data_type = {
     re2_matchdata_mark,
     re2_matchdata_free,
     re2_matchdata_memsize,
-    re2_compact_callback(re2_matchdata_compact)
+    re2_matchdata_compact
   },
   0,
   0,
@@ -183,16 +172,13 @@ static const rb_data_type_t re2_matchdata_data_type = {
 static void re2_scanner_mark(void *ptr) {
   re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
   rb_gc_mark_movable(s->regexp);
-  rb_gc_mark_movable(s->text);
+  rb_gc_mark(s->text);
 }
 
-#ifdef HAVE_RB_GC_MARK_MOVABLE
 static void re2_scanner_compact(void *ptr) {
   re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
   s->regexp = rb_gc_location(s->regexp);
-  s->text = rb_gc_location(s->text);
 }
-#endif
 
 static void re2_scanner_free(void *ptr) {
   re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
@@ -218,7 +204,7 @@ static const rb_data_type_t re2_scanner_data_type = {
     re2_scanner_mark,
     re2_scanner_free,
     re2_scanner_memsize,
-    re2_compact_callback(re2_scanner_compact)
+    re2_scanner_compact
   },
   0,
   0,
@@ -290,10 +276,12 @@ static VALUE re2_matchdata_string(const VALUE self) {
 }
 
 /*
- * Returns the text supplied when incrementally matching with
+ * Returns a frozen copy of the text supplied when incrementally matching with
  * {RE2::Regexp#scan}.
  *
- * @return [String] the original string passed to {RE2::Regexp#scan}
+ * If the text was already a frozen string, returns the original.
+ *
+ * @return [String] a frozen string with the text passed to {RE2::Regexp#scan}
  * @example
  *   c = RE2::Regexp.new('(\d+)').scan("foo")
  *   c.string #=> "foo"
@@ -338,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;
@@ -424,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)));
@@ -693,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);
   }
 }
 
@@ -1433,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) {
@@ -1447,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) {
@@ -1477,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) {
@@ -1494,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) {
@@ -1527,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;
     }
   }
@@ -1626,10 +1619,14 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
-  c->input = new(std::nothrow) re2::StringPiece(
-      RSTRING_PTR(text), RSTRING_LEN(text));
   RB_OBJ_WRITE(scanner, &c->regexp, self);
-  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(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();
@@ -1925,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);
@@ -1962,6 +1957,26 @@ static VALUE re2_set_compile(VALUE self) {
   return BOOL2RUBY(s->set->Compile());
 }
 
+/*
+ * Returns the size of the {RE2::Set}.
+ *
+ * @return [Integer] the number of patterns in the set
+ * @example
+ *   set = RE2::Set.new
+ *   set.add("abc")
+ *   set.size #=> 1
+ */
+static VALUE re2_set_size(VALUE self) {
+#ifdef HAVE_SET_SIZE
+  re2_set *s;
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+
+  return INT2FIX(s->set->Size());
+#else
+  rb_raise(re2_eSetUnsupportedError, "current version of RE2::Set does not have Size method");
+#endif
+}
+
 /*
  * Returns whether the underlying RE2 version outputs error information from
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/set.h#L62-L65
@@ -1978,6 +1993,19 @@ static VALUE re2_set_match_raises_errors_p(VALUE) {
 #endif
 }
 
+/*
+ * Returns whether the underlying RE2 version has a Set::Size method.
+ *
+ * @return [Boolean] whether the underlying RE2 has a Set::Size method
+ */
+static VALUE re2_set_size_p(VALUE) {
+#ifdef HAVE_SET_SIZE
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
 /*
  * Matches the given text against patterns in the set, returning an array of
  * integer indices of the matching patterns if matched or an empty array if
@@ -2208,11 +2236,15 @@ extern "C" void Init_re2(void) {
 
   rb_define_singleton_method(re2_cSet, "match_raises_errors?",
       RUBY_METHOD_FUNC(re2_set_match_raises_errors_p), 0);
+  rb_define_singleton_method(re2_cSet, "size?",
+      RUBY_METHOD_FUNC(re2_set_size_p), 0);
   rb_define_method(re2_cSet, "initialize",
       RUBY_METHOD_FUNC(re2_set_initialize), -1);
   rb_define_method(re2_cSet, "add", RUBY_METHOD_FUNC(re2_set_add), 1);
   rb_define_method(re2_cSet, "compile", RUBY_METHOD_FUNC(re2_set_compile), 0);
   rb_define_method(re2_cSet, "match", RUBY_METHOD_FUNC(re2_set_match), -1);
+  rb_define_method(re2_cSet, "size", RUBY_METHOD_FUNC(re2_set_size), 0);
+  rb_define_method(re2_cSet, "length", RUBY_METHOD_FUNC(re2_set_size), 0);
 
   rb_define_module_function(re2_mRE2, "Replace",
       RUBY_METHOD_FUNC(re2_Replace), 3);

data/ext/re2/recipes.rb

@@ -9,7 +9,7 @@
 # Released under the BSD Licence, please see LICENSE.txt
 
 PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
-REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.7' # keep this version in sync with the one in the gemspec
+REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.9' # keep this version in sync with the one in the gemspec
 
 def load_recipes
   require 'yaml'
@@ -40,8 +40,8 @@ def build_recipe(name, version)
   MiniPortileCMake.new(name, version).tap do |recipe|
     recipe.target = File.join(PACKAGE_ROOT_DIR, 'ports')
     recipe.configure_options += [
-      # abseil needs a C++14 compiler
-      '-DCMAKE_CXX_STANDARD=14',
+      # abseil needs a C++17 compiler
+      '-DCMAKE_CXX_STANDARD=17',
       # needed for building the C extension shared library with -fPIC
       '-DCMAKE_POSITION_INDEPENDENT_CODE=ON',
       # ensures pkg-config and installed libraries will be in lib, not lib64

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.15.0"
+  VERSION = "2.23.0"
 end

data/re2.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/mudge/re2"
   s.extensions = ["ext/re2/extconf.rb"]
   s.license = "BSD-3-Clause"
-  s.required_ruby_version = ">= 2.6.0"
+  s.required_ruby_version = ">= 3.1.0"
   s.files = [
     "dependencies.yml",
     "ext/re2/extconf.rb",
@@ -40,8 +40,8 @@ Gem::Specification.new do |s|
     "spec/re2/set_spec.rb",
     "spec/re2/scanner_spec.rb"
   ]
-  s.add_development_dependency("rake-compiler", "~> 1.2.7")
-  s.add_development_dependency("rake-compiler-dock", "~> 1.8.0")
+  s.add_development_dependency("rake-compiler", "~> 1.3.1")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.11.0")
   s.add_development_dependency("rspec", "~> 3.2")
-  s.add_runtime_dependency("mini_portile2", "~> 2.8.7") # keep version in sync with extconf.rb
+  s.add_runtime_dependency("mini_portile2", "~> 2.8.9") # keep version in sync with extconf.rb
 end

data/spec/re2/match_data_spec.rb

@@ -133,6 +133,13 @@ RSpec.describe RE2::MatchData do
       expect(md["name"].encoding.name).to eq("ISO-8859-1")
       expect(md[:name].encoding.name).to eq("ISO-8859-1")
     end
+
+    it "supports GC compaction" do
+      md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
+      GC.compact
+
+      expect(md[1]).to eq("woo")
+    end
   end
 
   describe "#string" do
@@ -287,6 +294,13 @@ RSpec.describe RE2::MatchData do
 
       expect { md.begin(nil) }.to raise_error(TypeError)
     end
+
+    it "supports GC compaction" do
+      md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
+      GC.compact
+
+      expect(md.string[md.begin(0)..-1]).to eq('woohoo' * 5)
+    end
   end
 
   describe "#end" do
@@ -349,6 +363,13 @@ RSpec.describe RE2::MatchData do
 
       expect { md.end(nil) }.to raise_error(TypeError)
     end
+
+    it "supports GC compaction" do
+      md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
+      GC.compact
+
+      expect(md.string[0...md.end(0)]).to eq('woo')
+    end
   end
 
   describe "#deconstruct" do

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/scanner_spec.rb

@@ -11,7 +11,39 @@ RSpec.describe RE2::Scanner do
   end
 
   describe "#string" do
-    it "returns the original text for the scanner" do
+    it "returns the text for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to eq("It is a truth")
+    end
+
+    it "returns a frozen string" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to be_frozen
+    end
+
+    it "freezes unfrozen strings" do
+      re = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to be_frozen
+    end
+
+    it "copies unfrozen strings" do
+      re = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to_not equal(text)
+    end
+
+    it "does not copy the string if it was already frozen" do
       re = RE2::Regexp.new('(\w+)')
       text = "It is a truth"
       scanner = re.scan(text)
@@ -162,6 +194,23 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to eq(["world"])
       expect(scanner.scan).to be_nil
     end
+
+    it "supports GC compaction" do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("Hello world" * 2)
+      GC.compact
+
+      expect(scanner.scan).to eq(["Hello"])
+    end
+
+    it "works even if the original input is mutated" do
+      r = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth universally acknowledged"
+      scanner = r.scan(text)
+      text.upcase!
+
+      expect(scanner.scan).to eq(["It"])
+    end
   end
 
   it "is enumerable" do

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
@@ -204,6 +204,50 @@ RSpec.describe RE2::Set do
     end
   end
 
+  describe "#size" do
+    it "returns the number of patterns added to the set", :aggregate_failures do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      set = RE2::Set.new
+
+      expect(set.size).to eq(0)
+
+      set.add("abc")
+
+      expect(set.size).to eq(1)
+
+      set.add("def")
+
+      expect(set.size).to eq(2)
+    end
+
+    it "raises an error if RE2 does not support Set::Size" do
+      skip "Underlying RE2::Set has a Size method" if RE2::Set.size?
+
+      set = RE2::Set.new
+
+      expect { set.size }.to raise_error(RE2::Set::UnsupportedError)
+    end
+  end
+
+  describe "#length" do
+    it "is an alias for size" do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      set = RE2::Set.new
+
+      expect(set.length).to eq(0)
+
+      set.add("abc")
+
+      expect(set.length).to eq(1)
+
+      set.add("def")
+
+      expect(set.length).to eq(2)
+    end
+  end
+
   def silence_stderr
     original_stream = STDERR
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.15.0
+  version: 2.23.0
 platform: ruby
 authors:
 - Paul Mucur
 - Stan Hu
 bindir: bin
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.7
+        version: 1.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.7
+        version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: rake-compiler-dock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.8.7
+        version: 2.8.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.8.7
+        version: 2.8.9
 description: Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking
   regular expression engines like those used in PCRE, Perl, and Python".
 executables: []
@@ -88,8 +88,8 @@ files:
 - lib/re2/scanner.rb
 - lib/re2/string.rb
 - lib/re2/version.rb
-- ports/archives/20240722.0.tar.gz
-- ports/archives/re2-2024-07-02.tar.gz
+- ports/archives/20250814.1.tar.gz
+- ports/archives/re2-2025-11-05.tar.gz
 - re2.gemspec
 - spec/kernel_spec.rb
 - spec/re2/match_data_spec.rb
@@ -110,23 +110,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby bindings to RE2.
 test_files:
 - ".rspec"
-- spec/spec_helper.rb
-- spec/re2_spec.rb
 - spec/kernel_spec.rb
-- spec/re2/regexp_spec.rb
 - spec/re2/match_data_spec.rb
-- spec/re2/string_spec.rb
-- spec/re2/set_spec.rb
+- spec/re2/regexp_spec.rb
 - spec/re2/scanner_spec.rb
+- spec/re2/set_spec.rb
+- spec/re2/string_spec.rb
+- spec/re2_spec.rb
+- spec/spec_helper.rb