re2 2.4.3-aarch64-linux → 2.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31bc284bb7f3f24ad0fe291ece346eafb484863ecf0f30d4ec799ba844e059ad
-  data.tar.gz: 29199e8a8d0c2165d17ecce3c39343d5228e3bd817616dc7cd576abbc454b1f5
+  metadata.gz: 63dead02fd50e66e67c4a3dcffaafae264842980bc13fe7ea26664de2c58cf5f
+  data.tar.gz: 4eb055c939db8088f671cdb87a7b1e43936f5985cfa98280a78f550efe80a8e4
 SHA512:
-  metadata.gz: 3e02625f399fda1f48e34f8d34c6d17319c520e515123a6044e739a2146c3ddd42caa93478fae1750291c6a57f35b701d4b6edb71383be72f0dc44c00deb8595
-  data.tar.gz: 4700f794748edb1f1062eccfad6b05f5e6bfbb728449a1d34b4c0a5c4a7b90c11b9c47db3b7b67bbc339c0f9e552a8ef9447eed6fdd3a19ec7efe3e561bccb45
+  metadata.gz: 825ad2cc8b322a046b263a5a491f2f2fc58a9b0a1f894f2ec95884e978a392d88afd467a093aff732d9f057c4d98c90eb4da98fdb9c639d28550d89add9f492a
+  data.tar.gz: f36a361482d3b9b4ebd6308a112ec9d9f1daede0599218551292b95f42bb58919afa3da180941d38738113ebfe86a0470d831f1ae89db6e1ca57440dd8b2542a

data/README.md

@@ -1,205 +1,232 @@
-re2 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
-===
+# re2 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
 
 Ruby bindings to [RE2][], a "fast, safe, thread-friendly alternative to
 backtracking regular expression engines like those used in PCRE, Perl, and
 Python".
 
-**Current version:** 2.4.3  
-**Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
+**Current version:** 2.5.0  
 **Bundled RE2 version:** libre2.11 (2023-11-01)  
-**Supported RE2 versions:** libre2.0 (< 2020-03-02), libre2.1 (2020-03-02), libre2.6 (2020-03-03), libre2.7 (2020-05-01), libre2.8 (2020-07-06), libre2.9 (2020-11-01), libre2.10 (2022-12-01), libre2.11 (2023-07-01)
 
-Installation
-------------
+```ruby
+RE2('h.*o').full_match?("hello")    #=> true
+RE2('e').full_match?("hello")       #=> false
+RE2('h.*o').partial_match?("hello") #=> true
+RE2('e').partial_match?("hello")    #=> true
+RE2('(\w+):(\d+)').full_match("ruby:1234")
+#=> #<RE2::MatchData "ruby:1234" 1:"ruby" 2:"1234">
+```
 
-The gem comes bundled with a version of [RE2][] and will compile itself (and
-any dependencies) on install. As compilation can take a while, precompiled
-native gems are available for Linux, Windows and macOS.
+## Table of Contents
+
+* [Why RE2?](#why-re2)
+* [Usage](#usage)
+    * [Compiling regular expressions](#compiling-regular-expressions)
+    * [Matching interface](#matching-interface)
+    * [Submatch extraction](#submatch-extraction)
+    * [Scanning text incrementally](#scanning-text-incrementally)
+    * [Searching simultaneously](#searching-simultaneously)
+    * [Encoding](#encoding)
+* [Requirements](#requirements)
+    * [Native gems](#native-gems)
+    * [Installing the `ruby` platform gem](#installing-the-ruby-platform-gem)
+    * [Using system libraries](#using-system-libraries)
+* [Thanks](#thanks)
+* [Contact](#contact)
+* [License](#license)
+    * [Dependencies](#dependencies)
+
+## Why RE2?
+
+> RE2 was designed and implemented with an explicit goal of being able to
+> handle regular expressions from untrusted users without risk. One of its
+> primary guarantees is that the match time is linear in the length of the
+> input string. It was also written with production concerns in mind: the
+> parser, the compiler and the execution engines limit their memory usage by
+> working within a configurable budget – failing gracefully when exhausted –
+> and they avoid stack overflow by eschewing recursion.
+
+— [Why RE2?](https://github.com/google/re2/wiki/WhyRE2)
+
+## Usage
+
+Install re2 as a dependency:
 
-In v2.0 and later, precompiled native gems are available for Ruby 2.6 to 3.2
-on these platforms:
+```ruby
+# In your Gemfile
+gem "re2"
 
-- `aarch64-linux` (requires: glibc >= 2.29)
-- `arm-linux` (requires: glibc >= 2.29)
-- `arm64-darwin`
-- `x64-mingw32` / `x64-mingw-ucrt`
-- `x86-linux` (requires: glibc >= 2.17)
-- `x86_64-darwin`
-- `x86_64-linux` (requires: glibc >= 2.17)
+# Or without Bundler
+gem install re2
+```
 
-If you wish to opt out of using the bundled libraries, you will need RE2
-installed as well as a C++ compiler such as [gcc][] (on Debian and Ubuntu, this
-is provided by the [build-essential][] package). If you are using macOS, I
-recommend installing RE2 with [Homebrew][] by running the following:
+Include in your code:
 
-    $ brew install re2
+```ruby
+require "re2"
+```
 
-If you are using Debian, you can install the [libre2-dev][] package like so:
+Full API documentation automatically generated from the latest version is
+available at https://mudge.name/re2/.
 
-    $ sudo apt-get install libre2-dev
+While re2 uses the same naming scheme as Ruby's built-in regular expression
+library (with [`Regexp`](https://mudge.name/re2/RE2/Regexp.html) and
+[`MatchData`](https://mudge.name/re2/RE2/MatchData.html)), its API is slightly
+different:
 
-Recent versions of RE2 require [CMake](https://cmake.org) and a compiler with
-C++14 support such as [clang](http://clang.llvm.org/) 3.4 or
-[gcc](https://gcc.gnu.org/) 5.
+### Compiling regular expressions
 
-If you are using a packaged Ruby distribution, make sure you also have the
-Ruby header files installed such as those provided by the [ruby-dev][] package
-on Debian and Ubuntu.
+> [!WARNING]
+> RE2's regular expression syntax differs from PCRE and Ruby's built-in
+> [`Regexp`](https://docs.ruby-lang.org/en/3.2/Regexp.html) library, see the
+> [official syntax page](https://github.com/google/re2/wiki/Syntax) for more
+> details.
 
-You can then install the library via RubyGems with `gem install re2 --platform=ruby --
---enable-system-libraries` or `gem install re2 --platform=ruby -- --enable-system-libraries
---with-re2-dir=/path/to/re2/prefix` if RE2 is not installed in any of the
-following default locations:
+The core class is [`RE2::Regexp`](https://mudge.name/re2/RE2/Regexp.html) which
+takes a regular expression as a string and compiles it internally into an `RE2`
+object. A global function `RE2` is available to concisely compile a new
+`RE2::Regexp`:
 
-* `/usr/local`
-* `/opt/homebrew`
-* `/usr`
+```ruby
+re = RE2('(\w+):(\d+)')
+#=> #<RE2::Regexp /(\w+):(\d+)/>
+re.ok? #=> true
 
-Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable instead of passing `--enable-system-libraries` to the `gem` command.
+re = RE2('abc)def')
+re.ok?   #=> false
+re.error #=> "missing ): abc(def"
+```
 
-If you're using Bundler, you can use the
-[`force_ruby_platform`](https://bundler.io/v2.3/man/gemfile.5.html#FORCE_RUBY_PLATFORM)
-option in your Gemfile.
+> [!TIP]
+> Note the use of *single quotes* when passing the regular expression as
+> a string to `RE2` so that the backslashes aren't interpreted as escapes.
 
-Documentation
--------------
+When compiling a regular expression, an optional second argument can be used to change RE2's default options, e.g. stop logging syntax and execution errors to stderr with `log_errors`:
 
-Full documentation automatically generated from the latest version is
-available at <http://mudge.name/re2/>.
+```ruby
+RE2('abc)def', log_errors: false)
+```
 
-Note that RE2's regular expression syntax differs from PCRE and Ruby's
-built-in [`Regexp`][Regexp] library, see the [official syntax page][] for more
-details.
+See the API documentation for [`RE2::Regexp#initialize`](https://mudge.name/re2/RE2/Regexp.html#initialize-instance_method) for all the available options.
 
-Usage
------
+### Matching interface
 
-While re2 uses the same naming scheme as Ruby's built-in regular expression
-library (with [`Regexp`](http://mudge.name/re2/RE2/Regexp.html) and
-[`MatchData`](http://mudge.name/re2/RE2/MatchData.html)), its API is slightly
-different:
+There are two main methods for matching: [`RE2::Regexp#full_match?`](https://mudge.name/re2/RE2/Regexp.html#full_match%3F-instance_method) requires the regular expression to match the entire input text, and [`RE2::Regexp#partial_match?`](https://mudge.name/re2/RE2/Regexp.html#match%3F-instance_method) looks for a match for a substring of the input text, returning a boolean to indicate whether a match was successful or not.
 
-```console
-$ irb -rubygems
-> require 're2'
-> r = RE2::Regexp.new('w(\d)(\d+)')
-=> #<RE2::Regexp /w(\d)(\d+)/>
-> m = r.match("w1234")
-=> #<RE2::MatchData "w1234" 1:"1" 2:"234">
-> m[1]
-=> "1"
-> m.string
-=> "w1234"
-> m.begin(1)
-=> 1
-> m.end(1)
-=> 2
-> r =~ "w1234"
-=> true
-> r !~ "bob"
-=> true
-> r.match("bob")
-=> nil
+```ruby
+RE2('h.*o').full_match?("hello")    #=> true
+RE2('e').full_match?("hello")       #=> false
+
+RE2('h.*o').partial_match?("hello") #=> true
+RE2('e').partial_match?("hello")    #=> true
 ```
 
-As
-[`RE2::Regexp.new`](http://mudge.name/re2/RE2/Regexp.html#initialize-instance_method)
-(or `RE2::Regexp.compile`) can be quite verbose, a helper method has been
-defined against `Kernel` so you can use a shorter version to create regular
-expressions:
+### Submatch extraction
 
-```console
-> RE2('(\d+)')
-=> #<RE2::Regexp /(\d+)/>
-```
+> [!TIP]
+> Only extract the number of submatches you need as performance is improved
+> with fewer submatches (with the best performance when avoiding submatch
+> extraction altogether).
 
-Note the use of *single quotes* as double quotes will interpret `\d` as `d` as
-in the following example:
+Both matching methods have a second form that can extract submatches as [`RE2::MatchData`](https://mudge.name/re2/RE2/MatchData.html) objects: [`RE2::Regexp#full_match`](https://mudge.name/re2/RE2/Regexp.html#full_match-instance_method) and [`RE2::Regexp#partial_match`](https://mudge.name/re2/RE2/Regexp.html#partial_match-instance_method).
 
-```console
-> RE2("(\d+)")
-=> #<RE2::Regexp /(d+)/>
+```ruby
+m = RE2('(\w+):(\d+)').full_match("ruby:1234")
+#=> #<RE2::MatchData "ruby:1234" 1:"ruby" 2:"1234">
+
+m[0] #=> "ruby:1234"
+m[1] #=> "ruby"
+m[2] #=> "1234"
+
+m = RE2('(\w+):(\d+)').full_match("r")
+#=> nil
 ```
 
-As of 0.3.0, you can use named groups:
-
-```console
-> r = RE2::Regexp.new('(?P<name>\w+) (?P<age>\d+)')
-=> #<RE2::Regexp /(?P<name>\w+) (?P<age>\d+)/>
-> m = r.match("Bob 40")
-=> #<RE2::MatchData "Bob 40" 1:"Bob" 2:"40">
-> m[:name]
-=> "Bob"
-> m["age"]
-=> "40"
+`RE2::MatchData` supports retrieving submatches by numeric index or by name if present in the regular expression:
+
+```ruby
+m = RE2('(?P<word>\w+):(?P<number>\d+)').full_match("ruby:1234")
+#=> #<RE2::MatchData "ruby:1234" 1:"ruby" 2:"1234">
+
+m["word"]   #=> "ruby"
+m["number"] #=> "1234"
 ```
 
-As of 0.6.0, you can use `RE2::Regexp#scan` to incrementally scan text for
-matches (similar in purpose to Ruby's
-[`String#scan`](http://ruby-doc.org/core-2.0.0/String.html#method-i-scan)).
-Calling `scan` will return an `RE2::Scanner` which is
-[enumerable](http://ruby-doc.org/core-2.0.0/Enumerable.html) meaning you can
-use `each` to iterate through the matches (and even use
-[`Enumerator::Lazy`](http://ruby-doc.org/core-2.0/Enumerator/Lazy.html)):
+They can also be used with Ruby's [pattern matching](https://docs.ruby-lang.org/en/3.2/syntax/pattern_matching_rdoc.html):
 
 ```ruby
-re = RE2('(\w+)')
-scanner = re.scan("It is a truth universally acknowledged")
-scanner.each do |match|
-  puts match
+case RE2('(\w+):(\d+)').full_match("ruby:1234")
+in [word, number]
+  puts "Word: #{word}, Number: #{number}"
+else
+  puts "No match"
 end
+# Word: ruby, Number: 1234
 
-scanner.rewind
-
-enum = scanner.to_enum
-enum.next #=> ["It"]
-enum.next #=> ["is"]
+case RE2('(?P<word>\w+):(?P<number>\d+)').full_match("ruby:1234")
+in word:, number:
+  puts "Word: #{word}, Number: #{number}"
+else
+  puts "No match"
+end
+# Word: ruby, Number: 1234
 ```
 
-As of 1.5.0, you can use `RE2::Set` to match multiple patterns against a
-string. Calling `RE2::Set#add` with a pattern will return an integer index of
-the pattern. After all patterns have been added, the set can be compiled using
-`RE2::Set#compile`, and then `RE2::Set#match` will return an `Array<Integer>`
-containing the indices of all the patterns that matched.
+By default, both `full_match` and `partial_match` will extract all submatches into the `RE2::MatchData` based on the number of capturing groups in the regular expression. This can be changed by passing an optional second argument when matching:
 
 ```ruby
-set = RE2::Set.new
-set.add("abc") #=> 0
-set.add("def") #=> 1
-set.add("ghi") #=> 2
-set.compile #=> true
-set.match("abcdefghi") #=> [0, 1, 2]
-set.match("ghidefabc") #=> [2, 1, 0]
+m = RE2('(\w+):(\d+)').full_match("ruby:1234", submatches: 1)
+=> #<RE2::MatchData "ruby:1234" 1:"ruby">
 ```
 
-As of 1.6.0, you can use [Ruby's pattern matching](https://docs.ruby-lang.org/en/3.0/syntax/pattern_matching_rdoc.html) against `RE2::MatchData` with both array patterns and hash patterns:
+> [!WARNING]
+> If the regular expression has no capturing groups or you pass `submatches:
+> 0`, the matching method will behave like its `full_match?` or
+> `partial_match?` form and only return `true` or `false` rather than
+> `RE2::MatchData`.
+
+### Scanning text incrementally
+
+If you want to repeatedly match regular expressions from the start of some input text, you can use [`RE2::Regexp#scan`](https://mudge.name/re2/RE2/Regexp.html#scan-instance_method) to return an `Enumerable` [`RE2::Scanner`](https://mudge.name/re2/RE2/Scanner.html) object which will lazily consume matches as you iterate over it:
 
 ```ruby
-case RE2('(\w+) (\d+)').match("Alice 42")
-in [name, age]
-  puts "My name is #{name} and I am #{age} years old"
-else
-  puts "No match!"
+scanner = RE2('(\w+)').scan(" one two three 4")
+scanner.each do |match|
+  puts match.inspect
 end
-# My name is Alice and I am 42 years old
+# ["one"]
+# ["two"]
+# ["three"]
+# ["4"]
+```
 
+### Searching simultaneously
 
-case RE2('(?P<name>\w+) (?P<age>\d+)').match("Alice 42")
-in {name:, age:}
-  puts "My name is #{name} and I am #{age} years old"
-else
-  puts "No match!"
-end
-# My name is Alice and I am 42 years old
+[`RE2::Set`](https://mudge.name/re2/RE2/Set.html) represents a collection of
+regular expressions that can be searched for simultaneously. Calling
+[`RE2::Set#add`](https://mudge.name/re2/RE2/Set.html#add-instance_method) with
+a regular expression will return the integer index at which it is stored within
+the set. After all patterns have been added, the set can be compiled using
+[`RE2::Set#compile`](https://mudge.name/re2/RE2/Set.html#compile-instance_method),
+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.
+
+```ruby
+set = RE2::Set.new
+set.add("abc")         #=> 0
+set.add("def")         #=> 1
+set.add("ghi")         #=> 2
+set.compile            #=> true
+set.match("abcdefghi") #=> [0, 1, 2]
+set.match("ghidefabc") #=> [2, 1, 0]
 ```
 
-Encoding
---------
+### Encoding
 
-Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
-returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
-`RE2::Regexp` is set to false (any other encoding's behaviour is undefined).
+> [!WARNING]
+> Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+> returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+> `RE2::Regexp` is set to `false` (any other encoding's behaviour is undefined).
 
 For backward compatibility: re2 won't automatically convert string inputs to
 the right encoding so this is the responsibility of the caller, e.g.
@@ -209,51 +236,77 @@ the right encoding so this is the responsibility of the caller, e.g.
 RE2(non_utf8_pattern.encode("UTF-8")).match(non_utf8_text.encode("UTF-8"))
 
 # If the :utf8 option is false, RE2 will process patterns and text as ISO-8859-1
-RE2(non_latin1_pattern.encode("ISO-8859-1"), :utf8 => false).match(non_latin1_text.encode("ISO-8859-1"))
+RE2(non_latin1_pattern.encode("ISO-8859-1"), utf8: false).match(non_latin1_text.encode("ISO-8859-1"))
 ```
 
-Features
---------
+## Requirements
 
-* Pre-compiling regular expressions with
-  [`RE2::Regexp.new(re)`](https://github.com/google/re2/blob/2016-02-01/re2/re2.h#L100),
-  `RE2::Regexp.compile(re)` or `RE2(re)` (including specifying options, e.g.
-  `RE2::Regexp.new("pattern", :case_sensitive => false)`
+This gem requires the following to run:
 
-* Extracting matches with `re2.match(text)` (and an exact number of matches
-  with `re2.match(text, number_of_matches)` such as `re2.match("123-234", 2)`)
+* [Ruby](https://www.ruby-lang.org/en/) 2.6 to 3.3
 
-* Extracting matches by name (both with strings and symbols)
+It supports the following RE2 ABI versions:
 
-* Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case`
-  statements) and `re2 !~ text`
+* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2023-11-01)
 
-* Incrementally scanning text with `re2.scan(text)`
+### Native gems
 
-* Search a collection of patterns simultaneously with `RE2::Set`
+Where possible, a pre-compiled native gem will be provided for the following platforms:
 
-* Checking regular expression compilation with `re2.ok?`, `re2.error` and
-  `re2.error_arg`
+* Linux `aarch64-linux` and `arm-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.29+)
+* Linux `x86-linux` and `x86_64-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.17+) including [musl](https://musl.libc.org/)-based systems such as [Alpine](https://alpinelinux.org)
+* macOS `x86_64-darwin` and `arm64-darwin`
+* Windows `x64-mingw32` and `x64-mingw-ucrt`
 
-* Checking regular expression "cost" with `re2.program_size`
+### Installing the `ruby` platform gem
 
-* Checking the options for an expression with `re2.options` or individually
-  with `re2.case_sensitive?`
+> [!WARNING]
+> We strongly recommend using the native gems where possible to avoid the need
+> for compiling the C++ extension and its dependencies which will take longer
+> and be less reliable.
 
-* Performing a single string replacement with `pattern.replace(replacement,
-  original)`
+If you wish to compile the gem, you will need to explicitly install the `ruby` platform gem:
 
-* Performing a global string replacement with
-  `pattern.replace_all(replacement, original)`
+```ruby
+# In your Gemfile with Bundler 2.3.18+
+gem "re2", force_ruby_platform: true
+
+# With Bundler 2.1+
+bundle config set force_ruby_platform true
+
+# With older versions of Bundler
+bundle config force_ruby_platform true
+
+# Without Bundler
+gem install re2 --platform=ruby
+```
+
+You will need a full compiler toolchain for compiling Ruby C extensions (see
+[Nokogiri's "The Compiler
+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) and a compiler with C++14 support such as
+[clang](http://clang.llvm.org/) 3.4 or [gcc](https://gcc.gnu.org/) 5. 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
+compile Abseil.
+
+### Using system libraries
 
-* Escaping regular expressions with
-  [`RE2.escape(unquoted)`](https://github.com/google/re2/blob/2016-02-01/re2/re2.h#L418) and
-  `RE2.quote(unquoted)`
+If you already have RE2 installed, you can instruct the gem not to use its own vendored version:
 
-* Pattern matching with `RE2::MatchData`
+```ruby
+gem install re2 --platform=ruby -- --enable-system-libraries
+
+# If RE2 is not installed in /usr/local, /usr, or /opt/homebrew:
+gem install re2 --platform=ruby -- --enable-system-libraries --with-re2-dir=/path/to/re2/prefix
+```
 
-Contributions
--------------
+Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable instead of passing `--enable-system-libraries` to the `gem` command.
+
+
+## Thanks
 
 * Thanks to [Jason Woods](https://github.com/driskell) who contributed the
   original implementations of `RE2::MatchData#begin` and `RE2::MatchData#end`.
@@ -278,30 +331,21 @@ Contributions
   switch to Ruby's `TypedData` API and the resulting garbage collection
   improvements in 2.4.0.
 
-Contact
--------
+## Contact
 
 All issues and suggestions should go to [GitHub Issues](https://github.com/mudge/re2/issues).
 
-License
--------
+## License
 
 This library is licensed under the BSD 3-Clause License, see `LICENSE.txt`.
 
-Dependencies
-------------
+Copyright © 2010, Paul Mucur.
+
+### Dependencies
 
 The source code of [RE2][] is distributed in the `ruby` platform gem. This code is licensed under the BSD 3-Clause License, see `LICENSE-DEPENDENCIES.txt`.
 
 The source code of [Abseil][] is distributed in the `ruby` platform gem. This code is licensed under the Apache License 2.0, see `LICENSE-DEPENDENCIES.txt`.
 
   [RE2]: https://github.com/google/re2
-  [gcc]: http://gcc.gnu.org/
-  [ruby-dev]: http://packages.debian.org/ruby-dev
-  [build-essential]: http://packages.debian.org/build-essential
-  [Regexp]: http://ruby-doc.org/core/classes/Regexp.html
-  [MatchData]: http://ruby-doc.org/core/classes/MatchData.html
-  [Homebrew]: http://mxcl.github.com/homebrew
-  [libre2-dev]: http://packages.debian.org/search?keywords=libre2-dev
-  [official syntax page]: https://github.com/google/re2/wiki/Syntax
   [Abseil]: https://abseil.io

data/ext/re2/extconf.rb

@@ -1,7 +1,9 @@
-# re2 (http://github.com/mudge/re2)
-# Ruby bindings to re2, an "efficient, principled regular expression library"
+# 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
+# Python".
 #
-# Copyright (c) 2010-2012, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
 # Released under the BSD Licence, please see LICENSE.txt
 
 require 'mkmf'
@@ -271,65 +273,6 @@ def build_with_system_libraries
   build_extension
 end
 
-# pkgconf v1.9.3 on Windows incorrectly sorts the output of `pkg-config
-# --libs --static`, resulting in build failures: https://github.com/pkgconf/pkgconf/issues/268.
-# To work around the issue, store the correct order of abseil flags here and add them manually
-# for Windows.
-#
-# Note that `-ldbghelp` is incorrectly added before `-labsl_symbolize` in abseil:
-# https://github.com/abseil/abseil-cpp/issues/1497
-ABSL_LDFLAGS = %w[
-  -labsl_flags
-  -labsl_flags_internal
-  -labsl_flags_marshalling
-  -labsl_flags_reflection
-  -labsl_flags_private_handle_accessor
-  -labsl_flags_commandlineflag
-  -labsl_flags_commandlineflag_internal
-  -labsl_flags_config
-  -labsl_flags_program_name
-  -labsl_cord
-  -labsl_cordz_info
-  -labsl_cord_internal
-  -labsl_cordz_functions
-  -labsl_cordz_handle
-  -labsl_crc_cord_state
-  -labsl_crc32c
-  -labsl_crc_internal
-  -labsl_crc_cpu_detect
-  -labsl_raw_hash_set
-  -labsl_hash
-  -labsl_city
-  -labsl_bad_variant_access
-  -labsl_low_level_hash
-  -labsl_hashtablez_sampler
-  -labsl_exponential_biased
-  -labsl_bad_optional_access
-  -labsl_str_format_internal
-  -labsl_synchronization
-  -labsl_graphcycles_internal
-  -labsl_kernel_timeout_internal
-  -labsl_stacktrace
-  -labsl_symbolize
-  -ldbghelp
-  -labsl_debugging_internal
-  -labsl_demangle_internal
-  -labsl_malloc_internal
-  -labsl_time
-  -labsl_civil_time
-  -labsl_strings
-  -labsl_string_view
-  -labsl_strings_internal
-  -labsl_base
-  -ladvapi32
-  -labsl_spinlock_wait
-  -labsl_int128
-  -labsl_throw_delegate
-  -labsl_raw_logging_internal
-  -labsl_log_severity
-  -labsl_time_zone
-].freeze
-
 def libflag_to_filename(ldflag)
   case ldflag
   when /\A-l(.+)/
@@ -382,14 +325,7 @@ def add_flag(arg, lib_paths)
 end
 
 def add_static_ldflags(flags, lib_paths)
-  static_flags = flags.strip.shellsplit
-
-  if MiniPortile.windows?
-    static_flags.each { |flag| add_flag(flag, lib_paths) unless ABSL_LDFLAGS.include?(flag) }
-    ABSL_LDFLAGS.each { |flag| add_flag(flag, lib_paths) }
-  else
-    static_flags.each { |flag| add_flag(flag, lib_paths) }
-  end
+  flags.strip.shellsplit.each { |flag| add_flag(flag, lib_paths) }
 end
 
 def build_with_vendored_libraries