re2 2.4.3-arm-linux → 2.6.0-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 605ea0ab2ff1b3ab2f5d34c2f305acb5727ebba46eaa08354656aebf2f07b47d
-  data.tar.gz: 303e367f9cf140b2657f4e4cc8defa3942db8d6a0a140977e80a17fd6609d14c
+  metadata.gz: 75fd241317d5b71585653e0cfbd355dbc7a121e9aa5b930d3501c26fa02d6a4e
+  data.tar.gz: 74f249cbf03ca05344b53206277eff97030c5d4432a4358745ab50fa252eaab9
 SHA512:
-  metadata.gz: 727d9012282272fa94b7e7ba3fe06c92ad3210cc951bc4567743ca2a734c5285d12c34b04aaf9199fabbeec10977e5dc81e1a487bbccc16895b06e470de2114f
-  data.tar.gz: 074bdf4ac7ff5c65d62b78f3e139842c08e5616e30cf51f77662fdb28ec75859f31fdc2660dfb6ebb55db59c912f40d4a7297ad81c91b7d226ed77d28498e54a
+  metadata.gz: 3e44a97ad5614ddb5a5a321530b2b2cdcfd0dd330b92277adfb69dfb477e87c5e338394304c94e298bb78f2bf5f8710650dfa37d296e1c71b0d22746f10a92d5
+  data.tar.gz: 0435e54961edd7a0ca238ad79e4512714d79c2af4f1f4a061f6e82d47b36e5e58e13881159df35eb5becdd3a74a90dcfb315304b46de0c9f0836a7ce8bf7de22

data/README.md

@@ -1,205 +1,246 @@
-re2 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
-===
+# re2 - safer regular expressions in Ruby
 
 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  
+[![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
+
+**Current version:** 2.6.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)
+    * [Verifying the gems](#verifying-the-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?
+
+While [recent
+versions](https://www.ruby-lang.org/en/news/2022/12/25/ruby-3-2-0-released/) of
+Ruby have improved defences against [regular expression denial of service
+(ReDoS) attacks](https://en.wikipedia.org/wiki/ReDoS), it is still possible for
+users to craft malicious patterns that take a long time to process by using
+syntactic features such as [back-references, lookaheads and possessive
+quantifiers](https://bugs.ruby-lang.org/issues/19104#note-3). RE2 aims to
+eliminate ReDoS by design:
+
+> **_Safety is RE2's raison d'être._**
+>
+> 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#partial_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:
+`RE2::MatchData` supports retrieving submatches by numeric index or by name if present in the regular expression:
 
-```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"
+```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 +250,106 @@ 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"))
+```
+
+## Requirements
+
+This gem requires the following to run:
+
+* [Ruby](https://www.ruby-lang.org/en/) 2.6 to 3.3
+
+It supports the following RE2 ABI versions:
+
+* libre2.0 (prior to release 2020-03-02) to libre2.11 (2023-07-01 to 2023-11-01)
+
+### Native gems
+
+Where possible, a pre-compiled native gem will be provided for the following platforms:
+
+* Linux
+    * `aarch64-linux` and `arm-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.29+)
+    * `x86-linux` and `x86_64-linux` (requires [glibc](https://www.gnu.org/software/libc/) 2.17+)
+    * [musl](https://musl.libc.org/)-based systems such as [Alpine](https://alpinelinux.org) are supported as long as a [glibc-compatible library is installed](https://wiki.alpinelinux.org/wiki/Running_glibc_programs)
+* macOS `x86_64-darwin` and `arm64-darwin`
+* Windows `x64-mingw32` and `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.5.0
+Fetching re2-2.5.0-arm64-darwin.gem
+Downloaded re2-2.5.0-arm64-darwin
+$ sha256sum re2-2.5.0-arm64-darwin.gem
+4b20c4539a12787102b22012e678968af23f87e35f88843744835bd13ac9f6bc  re2-2.5.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.5.0-arm64-darwin.gem.sig re2-2.5.0-arm64-darwin.gem
+gpg: Signature made Fri 15 Dec 2023 12:58:58 GMT
+gpg:                using RSA key 702609D9C790F45B577D7BEC39AC3530070E0F75
+gpg: Good signature from "Paul Mucur <mudge@mudge.name>" [unknown]
+gpg:                 aka "Paul Mucur <paul@ghostcassette.com>" [unknown]
+gpg: WARNING: This key is not certified with a trusted signature!
+gpg:          There is no indication that the signature belongs to the owner.
+Primary key fingerprint: 7026 09D9 C790 F45B 577D  7BEC 39AC 3530 070E 0F75
 ```
 
-Features
---------
+The fingerprint should be as shown above or you can independently verify it with the ones shown in the footer of https://mudge.name.
 
-* 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)`
+### Installing the `ruby` platform gem
 
-* 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)`)
+> [!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.
 
-* Extracting matches by name (both with strings and symbols)
+If you wish to compile the gem, you will need to explicitly install the `ruby` platform gem:
 
-* Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case`
-  statements) and `re2 !~ text`
+```ruby
+# In your Gemfile with Bundler 2.3.18+
+gem "re2", force_ruby_platform: true
 
-* Incrementally scanning text with `re2.scan(text)`
+# With Bundler 2.1+
+bundle config set force_ruby_platform true
 
-* Search a collection of patterns simultaneously with `RE2::Set`
+# With older versions of Bundler
+bundle config force_ruby_platform true
 
-* Checking regular expression compilation with `re2.ok?`, `re2.error` and
-  `re2.error_arg`
+# Without Bundler
+gem install re2 --platform=ruby
+```
 
-* Checking regular expression "cost" with `re2.program_size`
+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.
 
-* Checking the options for an expression with `re2.options` or individually
-  with `re2.case_sensitive?`
+### Using system libraries
 
-* Performing a single string replacement with `pattern.replace(replacement,
-  original)`
+If you already have RE2 installed, you can instruct the gem not to use its own vendored version:
 
-* Performing a global string replacement with
-  `pattern.replace_all(replacement, original)`
+```ruby
+gem install re2 --platform=ruby -- --enable-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 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
+```
+
+Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable instead of passing `--enable-system-libraries` to the `gem` command.
 
-* Pattern matching with `RE2::MatchData`
 
-Contributions
--------------
+## Thanks
 
 * Thanks to [Jason Woods](https://github.com/driskell) who contributed the
   original implementations of `RE2::MatchData#begin` and `RE2::MatchData#end`.
@@ -278,30 +374,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/Rakefile

@@ -33,7 +33,7 @@ Gem::PackageTask.new(RE2_GEM_SPEC) do |p|
   p.need_tar = false
 end
 
-CROSS_RUBY_VERSIONS = %w[3.2.0 3.1.0 3.0.0 2.7.0 2.6.0].join(':')
+CROSS_RUBY_VERSIONS = %w[3.3.0 3.2.0 3.1.0 3.0.0 2.7.0 2.6.0].join(':')
 CROSS_RUBY_PLATFORMS = %w[
   aarch64-linux
   arm-linux