re2 2.8.0-x86-linux → 2.10.0-x86-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa923a6d48f4ca3fee107a8da82b3a6aaaa5f186d63d5910e4b6d4651b12626
-  data.tar.gz: 86cfc0a4227e499a0cd65b81136463971c320906b044d1dd41d14a19ea81ca0f
+  metadata.gz: bef41f7ca80bdd0eb9d6c58a72f4777d73622f20d02caded21ca7bbe3f63e764
+  data.tar.gz: d51d46b1164f428e633d13872fbace662e6ed4d5fc9f186424f0f75ffcec672f
 SHA512:
-  metadata.gz: 2694d2d18548470808458d823d6c3b4b4c546643084b542f8c6415325cbfae7cfad774868d0c59840db2078c649c96d60ee1ecc14bd26fa9ab6b27091bf860c5
-  data.tar.gz: a3b51d050c13d275a7de0cf027a1201291899195f7a029620cc4b5d13821624d2c08f0c60d10e332cb8ebfdb9b6ad5c934da2f0d50f2a2b5da282d54a334c0bf
+  metadata.gz: 52464b70633e25d0802ad37d5bede02360d12190bf9450355a579aa59aa0b831d92b65a3b4c3590be09e3725f721a98ac8bdf6348c35909dfefe2e3e103e9fed
+  data.tar.gz: 6b027f7229427a216b01a5162723ec3abb92456d6edc2c7f2c4222aef8374a13efeded870906615b4d0d8a25e50d6b8cd1a43e0b9803e3d49703f643e49dac3b

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec

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.8.0  
-**Bundled RE2 version:** libre2.11 (2024-02-01)  
+**Current version:** 2.10.0  
+**Bundled RE2 version:** libre2.11 (2024-04-01)  
 
 ```ruby
 RE2('h.*o').full_match?("hello")    #=> true
@@ -261,7 +261,7 @@ This gem requires the following to run:
 
 It supports the following RE2 ABI versions:
 
-* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2024-02-01)
+* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2024-04-01)
 
 ### Native gems
 
@@ -279,18 +279,18 @@ Where possible, a pre-compiled native gem will be provided for the following pla
 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.7.0
-Fetching re2-2.7.0-arm64-darwin.gem
-Downloaded re2-2.7.0-arm64-darwin
-$ sha256sum re2-2.7.0-arm64-darwin.gem
-7d993f27a1afac4001c539a829e2af211ced62604930c90df32a307cf74cb4a4  re2-2.7.0-arm64-darwin.gem
+$ gem fetch re2 -v 2.9.0
+Fetching re2-2.9.0-arm64-darwin.gem
+Downloaded re2-2.9.0-arm64-darwin
+$ sha256sum re2-2.9.0-arm64-darwin.gem
+91dcc103257d7abb0ee832d673267cee48be7194883fed502b1407d2779c3499  re2-2.9.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.7.0-arm64-darwin.gem.sig re2-2.7.0-arm64-darwin.gem
-gpg: Signature made Sat 20 Jan 15:01:45 2024 GMT
+$ gpg --verify re2-2.9.0-arm64-darwin.gem.sig re2-2.9.0-arm64-darwin.gem
+gpg: Signature made Thu 29 Feb 14:00:55 2024 GMT
 gpg:                using RSA key 702609D9C790F45B577D7BEC39AC3530070E0F75
 gpg: Good signature from "Paul Mucur <mudge@mudge.name>" [unknown]
 gpg:                 aka "Paul Mucur <paul@ghostcassette.com>" [unknown]

data/dependencies.yml

@@ -1,7 +1,7 @@
 ---
 libre2:
-  version: '2024-02-01'
-  sha256: cd191a311b84fcf37310e5cd876845b4bf5aee76fdd755008eef3b6478ce07bb
+  version: '2024-04-01'
+  sha256: 3f6690c3393a613c3a0b566309cf04dc381d61470079b653afc47c67fb898198
 abseil:
-  version: '20240116.0'
-  sha256: 338420448b140f0dfd1a1ea3c3ce71b3bc172071f24f4d9a57d59b45037da440
+  version: '20240116.1'
+  sha256: 3c743204df78366ad2eaf236d6631d83f6bc928d1705dd0000b872e53b73dc6a

data/ext/re2/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and
@@ -9,370 +11,324 @@
 require 'mkmf'
 require_relative 'recipes'
 
-RE2_HELP_MESSAGE = <<~HELP
-  USAGE: ruby #{$0} [options]
+module RE2
+  class Extconf
+    def configure
+      configure_cross_compiler
 
-    Flags that are always valid:
+      if config_system_libraries?
+        build_with_system_libraries
+      else
+        build_with_vendored_libraries
+      end
 
-      --enable-system-libraries
-          Use system libraries instead of building and using the packaged libraries.
+      build_extension
 
-      --disable-system-libraries
-          Use the packaged libraries, and ignore the system libraries. This is the default.
+      create_makefile("re2")
+    end
 
+    def print_help
+      print(<<~TEXT)
+        USAGE: ruby #{$0} [options]
 
-    Flags only used when using system libraries:
+          Flags that are always valid:
 
-      Related to re2 library:
+            --enable-system-libraries
+                Use system libraries instead of building and using the packaged libraries.
 
-        --with-re2-dir=DIRECTORY
-            Look for re2 headers and library in DIRECTORY.
+            --disable-system-libraries
+                Use the packaged libraries, and ignore the system libraries. This is the default.
 
 
-    Flags only used when building and using the packaged libraries:
+          Flags only used when using system libraries:
 
-      --enable-cross-build
-          Enable cross-build mode. (You probably do not want to set this manually.)
+            Related to re2 library:
 
+              --with-re2-dir=DIRECTORY
+                  Look for re2 headers and library in DIRECTORY.
 
-    Environment variables used:
 
-      CC
-          Use this path to invoke the compiler instead of `RbConfig::CONFIG['CC']`
+          Flags only used when building and using the packaged libraries:
 
-      CPPFLAGS
-          If this string is accepted by the C preprocessor, add it to the flags passed to the C preprocessor
+            --enable-cross-build
+                Enable cross-build mode. (You probably do not want to set this manually.)
 
-      CFLAGS
-          If this string is accepted by the compiler, add it to the flags passed to the compiler
 
-      LDFLAGS
-          If this string is accepted by the linker, add it to the flags passed to the linker
+          Environment variables used:
 
-      LIBS
-          Add this string to the flags passed to the linker
-HELP
+            CC
+                Use this path to invoke the compiler instead of `RbConfig::CONFIG['CC']`
 
-#
-#  utility functions
-#
-def config_system_libraries?
-  enable_config("system-libraries", ENV.key?('RE2_USE_SYSTEM_LIBRARIES'))
-end
+            CPPFLAGS
+                If this string is accepted by the C preprocessor, add it to the flags passed to the C preprocessor
 
-def config_cross_build?
-  enable_config("cross-build")
-end
+            CFLAGS
+                If this string is accepted by the compiler, add it to the flags passed to the compiler
 
-def concat_flags(*args)
-  args.compact.join(" ")
-end
+            LDFLAGS
+                If this string is accepted by the linker, add it to the flags passed to the linker
 
-def do_help
-  print(RE2_HELP_MESSAGE)
-  exit!(0)
-end
+            LIBS
+                Add this string to the flags passed to the linker
+      TEXT
+    end
 
-def darwin?
-  RbConfig::CONFIG["target_os"].include?("darwin")
-end
+    private
 
-def windows?
-  RbConfig::CONFIG["target_os"].match?(/mingw|mswin/)
-end
+    def configure_cross_compiler
+      RbConfig::CONFIG["CC"] = RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"] if ENV["CC"]
+      RbConfig::CONFIG["CXX"] = RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"] if ENV["CXX"]
+    end
 
-def freebsd?
-  RbConfig::CONFIG["target_os"].include?("freebsd")
-end
+    def build_with_system_libraries
+      header_dirs = [
+        "/usr/local/include",
+        "/opt/homebrew/include",
+        "/usr/include"
+      ]
 
-def target_host
-  # We use 'host' to set compiler prefix for cross-compiling. Prefer host_alias over host. And
-  # prefer i686 (what external dev tools use) to i386 (what ruby's configure.ac emits).
-  host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
-  host.gsub(/i386/, "i686")
-end
+      lib_dirs = [
+        "/usr/local/lib",
+        "/opt/homebrew/lib",
+        "/usr/lib"
+      ]
 
-def target_arch
-  RbConfig::CONFIG['arch']
-end
+      dir_config("re2", header_dirs, lib_dirs)
 
-def with_temp_dir
-  Dir.mktmpdir do |temp_dir|
-    Dir.chdir(temp_dir) do
-      yield
+      unless have_library("re2")
+        abort "You must have re2 installed and specified with --with-re2-dir, please see https://github.com/google/re2/wiki/Install"
+      end
     end
-  end
-end
 
-#
-#  main
-#
-do_help if arg_config('--help')
+    def build_with_vendored_libraries
+      message "Building re2 using packaged libraries.\n"
 
-if ENV["CC"]
-  RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
-  RbConfig::CONFIG["CC"] = ENV["CC"]
-end
+      abseil_recipe, re2_recipe = load_recipes
 
-if ENV["CXX"]
-  RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"]
-  RbConfig::CONFIG["CXX"] = ENV["CXX"]
-end
+      process_recipe(abseil_recipe) do |recipe|
+        recipe.configure_options << '-DABSL_PROPAGATE_CXX_STD=ON'
+        # Workaround for https://github.com/abseil/abseil-cpp/issues/1510
+        recipe.configure_options << '-DCMAKE_CXX_FLAGS=-DABSL_FORCE_WAITER_MODE=4' if MiniPortile.windows?
+      end
 
-def build_extension(static_p = false)
-  # Enable optional warnings but disable deprecated register warning for Ruby 2.6 support
-  $CFLAGS << " -Wall -Wextra -funroll-loops"
-  $CPPFLAGS << " -Wno-register"
+      process_recipe(re2_recipe) do |recipe|
+        recipe.configure_options += [
+          # Specify Abseil's path so RE2 will prefer that over any system Abseil
+          "-DCMAKE_PREFIX_PATH=#{abseil_recipe.path}",
+          '-DCMAKE_CXX_FLAGS=-DNDEBUG'
+        ]
+      end
 
-  # Pass -x c++ to force gcc to compile the test program
-  # as C++ (as it will end in .c by default).
-  compile_options = "-x c++"
+      pc_file = File.join(re2_recipe.lib_path, 'pkgconfig', 're2.pc')
+      pkg_config_paths = [
+        File.join(abseil_recipe.lib_path, 'pkgconfig'),
+        File.join(re2_recipe.lib_path, 'pkgconfig')
+      ]
 
-  have_library("stdc++")
-  have_header("stdint.h")
-  have_func("rb_gc_mark_movable") # introduced in Ruby 2.7
+      static_pkg_config(pc_file, pkg_config_paths)
+    end
 
-  if !static_p and !have_library("re2")
-    abort "You must have re2 installed and specified with --with-re2-dir, please see https://github.com/google/re2/wiki/Install"
-  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"
 
-  minimal_program = <<SRC
-#include <re2/re2.h>
-int main() { return 0; }
-SRC
+      # Pass -x c++ to force gcc to compile the test program
+      # as C++ (as it will end in .c by default).
+      compile_options = +"-x c++"
 
-  re2_requires_version_flag = checking_for("re2 that requires explicit C++ version flag") do
-    !try_compile(minimal_program, compile_options)
-  end
+      have_library("stdc++")
+      have_header("stdint.h")
+      have_func("rb_gc_mark_movable") # introduced in Ruby 2.7
 
-  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|
-      checking_for("re2 that compiles with #{std} standard") do
-        if try_compile(minimal_program, compile_options + " -std=#{std}")
-          compile_options << " -std=#{std}"
-          $CPPFLAGS << " -std=#{std}"
-
-          true
+      minimal_program = <<~SRC
+        #include <re2/re2.h>
+        int main() { return 0; }
+      SRC
+
+      re2_requires_version_flag = checking_for("re2 that requires explicit C++ version flag") do
+        !try_compile(minimal_program, compile_options)
+      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|
+          checking_for("re2 that compiles with #{std} standard") do
+            if try_compile(minimal_program, compile_options + " -std=#{std}")
+              compile_options << " -std=#{std}"
+              $CPPFLAGS << " -std=#{std}"
+
+              true
+            end
+          end
         end
       end
-    end
-  end
 
-  # Determine which version of re2 the user has installed.
-  # Revision d9f8806c004d added an `endpos` argument to the
-  # generic Match() function.
-  #
-  # To test for this, try to compile a simple program that uses
-  # the newer form of Match() and set a flag if it is successful.
-  checking_for("RE2::Match() with endpos argument") do
-    test_re2_match_signature = <<SRC
-#include <re2/re2.h>
-
-int main() {
-  RE2 pattern("test");
-  re2::StringPiece *match;
-  pattern.Match("test", 0, 0, RE2::UNANCHORED, match, 0);
-
-  return 0;
-}
-SRC
-
-    if try_compile(test_re2_match_signature, compile_options)
-      $defs.push("-DHAVE_ENDPOS_ARGUMENT")
-    end
-  end
+      # Determine which version of re2 the user has installed.
+      # Revision d9f8806c004d added an `endpos` argument to the
+      # generic Match() function.
+      #
+      # To test for this, try to compile a simple program that uses
+      # the newer form of Match() and set a flag if it is successful.
+      checking_for("RE2::Match() with endpos argument") do
+        test_re2_match_signature = <<~SRC
+          #include <re2/re2.h>
+
+          int main() {
+            RE2 pattern("test");
+            re2::StringPiece *match;
+            pattern.Match("test", 0, 0, RE2::UNANCHORED, match, 0);
+
+            return 0;
+          }
+        SRC
+
+        if try_compile(test_re2_match_signature, compile_options)
+          $defs.push("-DHAVE_ENDPOS_ARGUMENT")
+        end
+      end
 
-  checking_for("RE2::Set::Match() with error information") do
-    test_re2_set_match_signature = <<SRC
-#include <vector>
-#include <re2/re2.h>
-#include <re2/set.h>
+      checking_for("RE2::Set::Match() with error information") do
+        test_re2_set_match_signature = <<~SRC
+          #include <vector>
+          #include <re2/re2.h>
+          #include <re2/set.h>
 
-int main() {
-  RE2::Set s(RE2::DefaultOptions, RE2::UNANCHORED);
-  s.Add("foo", NULL);
-  s.Compile();
+          int main() {
+            RE2::Set s(RE2::DefaultOptions, RE2::UNANCHORED);
+            s.Add("foo", NULL);
+            s.Compile();
 
-  std::vector<int> v;
-  RE2::Set::ErrorInfo ei;
-  s.Match("foo", &v, &ei);
+            std::vector<int> v;
+            RE2::Set::ErrorInfo ei;
+            s.Match("foo", &v, &ei);
 
-  return 0;
-}
-SRC
+            return 0;
+          }
+        SRC
 
-    if try_compile(test_re2_set_match_signature, compile_options)
-      $defs.push("-DHAVE_ERROR_INFO_ARGUMENT")
+        if try_compile(test_re2_set_match_signature, compile_options)
+          $defs.push("-DHAVE_ERROR_INFO_ARGUMENT")
+        end
+      end
     end
-  end
-end
 
-def process_recipe(recipe)
-  cross_build_p = config_cross_build?
-  message "Cross build is #{cross_build_p ? "enabled" : "disabled"}.\n"
+    def static_pkg_config(pc_file, pkg_config_paths)
+      ENV["PKG_CONFIG_PATH"] = [*pkg_config_paths, ENV["PKG_CONFIG_PATH"]].compact.join(File::PATH_SEPARATOR)
+
+      static_library_paths = minimal_pkg_config(pc_file, '--libs-only-L', '--static')
+        .shellsplit
+        .map { |flag| flag.delete_prefix('-L') }
 
-  recipe.host = target_host
-  # Ensure x64-mingw-ucrt and x64-mingw32 use different library paths since the host
-  # is the same (x86_64-w64-mingw32).
-  recipe.target = File.join(recipe.target, target_arch) if cross_build_p
+      $LIBPATH = static_library_paths | $LIBPATH
 
-  yield recipe
+      # Replace all -l flags that can be found in one of the static library
+      # paths with the absolute path instead.
+      minimal_pkg_config(pc_file, '--libs-only-l', '--static')
+        .shellsplit
+        .each do |flag|
+          lib = "lib#{flag.delete_prefix('-l')}.#{$LIBEXT}"
 
-  checkpoint = "#{recipe.target}/#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
-  name = recipe.name
-  version = recipe.version
+          if (static_lib_path = static_library_paths.find { |path| File.exist?(File.join(path, lib)) })
+            $libs << ' ' << File.join(static_lib_path, lib).shellescape
+          else
+            $libs << ' ' << flag.shellescape
+          end
+        end
 
-  if File.exist?(checkpoint)
-    message("Building re2 with a packaged version of #{name}-#{version}.\n")
-  else
-    message(<<~EOM)
-        ---------- IMPORTANT NOTICE ----------
-        Building re2 with a packaged version of #{name}-#{version}.
-        Configuration options: #{recipe.configure_options.shelljoin}
-      EOM
+      append_ldflags(minimal_pkg_config(pc_file, '--libs-only-other', '--static'))
 
-    unless recipe.patch_files.empty?
-      message("The following patches are being applied:\n")
+      incflags = minimal_pkg_config(pc_file, '--cflags-only-I')
+      $INCFLAGS = [incflags, $INCFLAGS].join(" ").strip
 
-      recipe.patch_files.each do |patch|
-        message("  - %s\n" % File.basename(patch))
-      end
+      cflags = minimal_pkg_config(pc_file, '--cflags-only-other')
+      $CFLAGS = [$CFLAGS, cflags].join(" ").strip
+      $CXXFLAGS = [$CXXFLAGS, cflags].join(" ").strip
     end
 
-    # Use a temporary base directory to reduce filename lengths since
-    # Windows can hit a limit of 250 characters (CMAKE_OBJECT_PATH_MAX).
-    with_temp_dir { recipe.cook }
+    def process_recipe(recipe)
+      cross_build_p = config_cross_build?
+      message "Cross build is #{cross_build_p ? "enabled" : "disabled"}.\n"
 
-    FileUtils.touch(checkpoint)
-  end
-
-  recipe.activate
-end
+      recipe.host = target_host
+      # Ensure x64-mingw-ucrt and x64-mingw32 use different library paths since the host
+      # is the same (x86_64-w64-mingw32).
+      recipe.target = File.join(recipe.target, target_arch) if cross_build_p
 
-def build_with_system_libraries
-  header_dirs = [
-    "/usr/local/include",
-    "/opt/homebrew/include",
-    "/usr/include"
-  ]
+      yield recipe
 
-  lib_dirs = [
-    "/usr/local/lib",
-    "/opt/homebrew/lib",
-    "/usr/lib"
-  ]
+      checkpoint = "#{recipe.target}/#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
+      name = recipe.name
+      version = recipe.version
 
-  dir_config("re2", header_dirs, lib_dirs)
+      if File.exist?(checkpoint)
+        message("Building re2 with a packaged version of #{name}-#{version}.\n")
+      else
+        message(<<~EOM)
+            ---------- IMPORTANT NOTICE ----------
+            Building re2 with a packaged version of #{name}-#{version}.
+            Configuration options: #{recipe.configure_options.shelljoin}
+          EOM
 
-  build_extension
-end
+        # Use a temporary base directory to reduce filename lengths since
+        # Windows can hit a limit of 250 characters (CMAKE_OBJECT_PATH_MAX).
+        Dir.mktmpdir { |dir| Dir.chdir(dir) { recipe.cook } }
 
-def libflag_to_filename(ldflag)
-  case ldflag
-  when /\A-l(.+)/
-    "lib#{Regexp.last_match(1)}.#{$LIBEXT}"
-  end
-end
+        FileUtils.touch(checkpoint)
+      end
+    end
 
-# This method does a number of things to ensure the final shared library
-# is compiled statically with the vendored libraries:
-#
-# 1. For -L<path> flags, ensure that any `ports` paths are prioritized just
-#    in case there are installed libraries that might take precedence.
-# 2. For -l<lib> flags, convert the library to the static library with a
-#    full path and substitute the absolute static library.  For example,
-#    -lre2 maps to /path/to/ports/<arch>/libre2/<version>/lib/libre2.a.
-#
-# This is needed because when building the extension, Ruby appears to
-# insert `-L#{RbConfig::CONFIG['exec_prefix']}/lib` first. If libre2 is
-# in installed in that location then the extension will link against the
-# system library instead of the vendored library.
-def add_flag(arg, lib_paths)
-  case arg
-  when /\A-L(.+)\z/
-    # Prioritize ports' directories
-    lib_dir = Regexp.last_match(1)
-    $LIBPATH =
-      if lib_dir.start_with?(PACKAGE_ROOT_DIR + "/")
-        [lib_dir] | $LIBPATH
+    # See MiniPortile2's minimal_pkg_config:
+    # https://github.com/flavorjones/mini_portile/blob/52fb0bc41c89a10f1ac7b5abcf0157e059194374/lib/mini_portile2/mini_portile.rb#L760-L783
+    # and Ruby's pkg_config:
+    # https://github.com/ruby/ruby/blob/c505bb0ca0fd61c7ae931d26451f11122a2644e9/lib/mkmf.rb#L1916-L2004
+    def minimal_pkg_config(pc_file, *options)
+      if ($PKGCONFIG ||=
+          (pkgconfig = MakeMakefile.with_config("pkg-config") {MakeMakefile.config_string("PKG_CONFIG") || "pkg-config"}) &&
+          MakeMakefile.find_executable0(pkgconfig) && pkgconfig)
+        pkgconfig = $PKGCONFIG
       else
-        $LIBPATH | [lib_dir]
+        raise RuntimeError, "pkg-config is not found"
       end
-  when /\A-l./
-    filename = libflag_to_filename(arg)
-
-    added = false
-    lib_paths.each do |path|
-      static_lib = File.join(path, filename)
 
-      next unless File.exist?(static_lib)
+      response = xpopen([pkgconfig, *options, pc_file], err: %i[child out], &:read)
+      raise RuntimeError, response unless $?.success?
 
-      $LDFLAGS << " " << static_lib
-      added = true
-      break
+      response.strip
     end
 
-    append_ldflags(arg.shellescape) unless added
-  else
-    append_ldflags(arg.shellescape)
-  end
-end
-
-def add_static_ldflags(flags, lib_paths)
-  flags.strip.shellsplit.each { |flag| add_flag(flag, lib_paths) }
-end
-
-def build_with_vendored_libraries
-  message "Building re2 using packaged libraries.\n"
+    def config_system_libraries?
+      enable_config("system-libraries", ENV.key?('RE2_USE_SYSTEM_LIBRARIES'))
+    end
 
-  abseil_recipe, re2_recipe = load_recipes
+    def config_cross_build?
+      enable_config("cross-build")
+    end
 
-  process_recipe(abseil_recipe) do |recipe|
-    recipe.configure_options += ['-DABSL_PROPAGATE_CXX_STD=ON', '-DCMAKE_CXX_VISIBILITY_PRESET=hidden']
-    # Workaround for https://github.com/abseil/abseil-cpp/issues/1510
-    recipe.configure_options += ['-DCMAKE_CXX_FLAGS=-DABSL_FORCE_WAITER_MODE=4'] if windows?
-  end
+    # We use 'host' to set compiler prefix for cross-compiling. Prefer host_alias over host. And
+    # prefer i686 (what external dev tools use) to i386 (what ruby's configure.ac emits).
+    def target_host
+      host = RbConfig::CONFIG["host_alias"].empty? ? RbConfig::CONFIG["host"] : RbConfig::CONFIG["host_alias"]
+      host.gsub(/i386/, "i686")
+    end
 
-  process_recipe(re2_recipe) do |recipe|
-    recipe.configure_options += ["-DCMAKE_PREFIX_PATH=#{abseil_recipe.path}", '-DCMAKE_CXX_FLAGS=-DNDEBUG',
-                                 '-DCMAKE_CXX_VISIBILITY_PRESET=hidden']
+    def target_arch
+      RbConfig::CONFIG['arch']
+    end
   end
-
-  dir_config("re2", File.join(re2_recipe.path, 'include'), File.join(re2_recipe.path, 'lib'))
-  dir_config("abseil", File.join(abseil_recipe.path, 'include'), File.join(abseil_recipe.path, 'lib'))
-
-  pkg_config_paths = [
-    "#{abseil_recipe.path}/lib/pkgconfig",
-    "#{re2_recipe.path}/lib/pkgconfig"
-  ].join(File::PATH_SEPARATOR)
-
-  pkg_config_paths = "#{ENV['PKG_CONFIG_PATH']}#{File::PATH_SEPARATOR}#{pkg_config_paths}" if ENV['PKG_CONFIG_PATH']
-
-  ENV['PKG_CONFIG_PATH'] = pkg_config_paths
-  pc_file = File.join(re2_recipe.path, 'lib', 'pkgconfig', 're2.pc')
-
-  raise 'Please install the `pkg-config` utility!' unless find_executable('pkg-config')
-
-  # See https://bugs.ruby-lang.org/issues/18490, broken in Ruby 3.1 but fixed in Ruby 3.2.
-  flags = xpopen(['pkg-config', '--libs', '--static', pc_file], err: %i[child out], &:read)
-
-  raise 'Unable to run pkg-config --libs --static' unless $?.success?
-
-  lib_paths = [File.join(abseil_recipe.path, 'lib'), File.join(re2_recipe.path, 'lib')]
-  add_static_ldflags(flags, lib_paths)
-  build_extension(true)
 end
 
-if config_system_libraries?
-  build_with_system_libraries
-else
-  build_with_vendored_libraries
+extconf = RE2::Extconf.new
+
+if arg_config('--help')
+  extconf.print_help
+  exit!(true)
 end
 
-create_makefile("re2")
+extconf.configure

data/ext/re2/recipes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and
@@ -9,26 +11,6 @@
 PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
 REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.5' # keep this version in sync with the one in the gemspec
 
-def build_recipe(name, version)
-  require 'rubygems'
-  gem('mini_portile2', REQUIRED_MINI_PORTILE_VERSION) # gemspec is not respected at install time
-  require 'mini_portile2'
-
-  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',
-      # 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
-      '-DCMAKE_INSTALL_LIBDIR=lib'
-    ]
-
-    yield recipe
-  end
-end
-
 def load_recipes
   require 'yaml'
   dependencies = YAML.load_file(File.join(PACKAGE_ROOT_DIR, 'dependencies.yml'))
@@ -49,3 +31,24 @@ def load_recipes
 
   [abseil_recipe, re2_recipe]
 end
+
+def build_recipe(name, version)
+  require 'rubygems'
+  gem('mini_portile2', REQUIRED_MINI_PORTILE_VERSION) # gemspec is not respected at install time
+  require 'mini_portile2'
+
+  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',
+      # 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
+      '-DCMAKE_INSTALL_LIBDIR=lib',
+      '-DCMAKE_CXX_VISIBILITY_PRESET=hidden'
+    ]
+
+    yield recipe
+  end
+end

data/lib/re2/regexp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and

data/lib/re2/scanner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and

data/lib/re2/string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.8.0"
+  VERSION = "2.10.0"
 end

data/lib/re2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # re2 (https://github.com/mudge/re2)
 # Ruby bindings to RE2, a "fast, safe, thread-friendly alternative to
 # backtracking regular expression engines like those used in PCRE, Perl, and

data/re2.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/re2/version'
 
 Gem::Specification.new do |s|

data/spec/kernel_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Kernel do
   describe ".RE2" do
     it "returns an RE2::Regexp instance given a pattern" do

data/spec/re2/match_data_spec.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'objspace'
 
 RSpec.describe RE2::MatchData do
@@ -142,7 +143,7 @@ RSpec.describe RE2::MatchData do
     end
 
     it "returns a copy, not the actual original" do
-      string = "bob"
+      string = +"bob"
       re = RE2::Regexp.new('(\D+)').match(string)
 
       expect(re.string).to_not equal(string)
@@ -155,7 +156,7 @@ RSpec.describe RE2::MatchData do
     end
 
     it "does not copy the string if it was already frozen" do
-      string = "bob".freeze
+      string = "bob"
       re = RE2::Regexp.new('(\D+)').match(string)
 
       expect(re.string).to equal(string)

data/spec/re2/regexp_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe RE2::Regexp do
   describe "#initialize" do
     it "returns an instance given only a pattern" do

data/spec/re2/scanner_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe RE2::Scanner do
   describe "#regexp" do

data/spec/re2/set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe RE2::Set do
   describe "#initialize" do
     it "returns an instance given no args" do

data/spec/re2/string_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "re2/string"
 
 class String

data/spec/re2_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe RE2 do
   describe ".Replace" do
     it "only replaces the first occurrence of the pattern" do

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "re2"
 
 # To test passing objects that can be coerced to a String.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.10.0
 platform: x86-linux
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-31 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler