re2 2.0.0-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 940680f362d9bb615771702ec8dfb7d3a90f006a41c0c3c81fbe1d32b2812545
+  data.tar.gz: cfde4c51519f1cf9df2326786249df7cbb9b3015da8dcf1e3d82cab804c127d2
+SHA512:
+  metadata.gz: 394bcdc5693fa48fbecde4560eb8f38bb5d7bd503aca1b569d4478aa5ba130babc3fd54b71373b1afc48fc5aeba9afd1b63de492e7e55e10b23193171ba026f1
+  data.tar.gz: 1a39127d22db58bd979046c6215aab9cfa05b0aa09991d26163967e79ec287edd1d6824266149ed83a9341cb18854714aefd7a55d8e8a309a68ef703bb66cd68

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "> 12.3.2"

data/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright (c) 2010-2014, Paul Mucur.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+  * Neither the name of Paul Mucur, nor the names of its contributors may be
+    used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,263 @@
+re2 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
+===
+
+A Ruby binding to [re2][], an "efficient, principled regular expression
+library".
+
+**Current version:** 2.0.0  
+**Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
+**Bundled re2 version:** libre2.11 (2023-09-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
+------------
+
+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.
+
+In v2.0 and later, precompiled native gems are available for Ruby 2.6 to 3.2
+on these platforms:
+
+- `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)
+
+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 Mac OS X, I
+recommend installing re2 with [Homebrew][] by running the following:
+
+    $ brew install re2
+
+If you are using Debian, you can install the [libre2-dev][] package like so:
+
+    $ sudo apt-get install libre2-dev
+
+Recent versions of re2 require a compiler with C++14 support such as
+[clang](http://clang.llvm.org/) 3.4 or [gcc](https://gcc.gnu.org/) 5.
+
+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.
+
+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:
+
+* `/usr/local`
+* `/opt/homebrew`
+* `/usr`
+
+Alternatively, you can set the `RE2_USE_SYSTEM_LIBRARIES` environment variable instead of passing `--enable-system-libraries` to the `gem` command.
+
+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.
+
+Documentation
+-------------
+
+Full documentation automatically generated from the latest version is
+available at <http://mudge.name/re2/>.
+
+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.
+
+Usage
+-----
+
+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:
+
+```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
+```
+
+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:
+
+```console
+> RE2('(\d+)')
+=> #<RE2::Regexp /(\d+)/>
+```
+
+Note the use of *single quotes* as double quotes will interpret `\d` as `d` as
+in the following example:
+
+```console
+> RE2("(\d+)")
+=> #<RE2::Regexp /(d+)/>
+```
+
+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"
+```
+
+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)):
+
+```ruby
+re = RE2('(\w+)')
+scanner = re.scan("It is a truth universally acknowledged")
+scanner.each do |match|
+  puts match
+end
+
+scanner.rewind
+
+enum = scanner.to_enum
+enum.next #=> ["It"]
+enum.next #=> ["is"]
+```
+
+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.
+
+```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]
+```
+
+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:
+
+```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!"
+end
+# My name is Alice and I am 42 years old
+
+
+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
+```
+
+Features
+--------
+
+* 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)`
+
+* 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)`)
+
+* Extracting matches by name (both with strings and symbols)
+
+* Checking for matches with `re2 =~ text`, `re2 === text` (for use in `case`
+  statements) and `re2 !~ text`
+
+* Incrementally scanning text with `re2.scan(text)`
+
+* Search a collection of patterns simultaneously with `RE2::Set`
+
+* Checking regular expression compilation with `re2.ok?`, `re2.error` and
+  `re2.error_arg`
+
+* Checking regular expression "cost" with `re2.program_size`
+
+* Checking the options for an expression with `re2.options` or individually
+  with `re2.case_sensitive?`
+
+* Performing a single string replacement with `pattern.replace(replacement,
+  original)`
+
+* Performing a global string replacement with
+  `pattern.replace_all(replacement, original)`
+
+* Escaping regular expressions with
+  [`RE2.escape(unquoted)`](https://github.com/google/re2/blob/2016-02-01/re2/re2.h#L418) and
+  `RE2.quote(unquoted)`
+
+* Pattern matching with `RE2::MatchData`
+
+Contributions
+-------------
+
+* Thanks to [Jason Woods](https://github.com/driskell) who contributed the
+  original implementations of `RE2::MatchData#begin` and `RE2::MatchData#end`;
+* Thanks to [Stefano Rivera](https://github.com/stefanor) who first contributed C++11 support;
+* Thanks to [Stan Hu](https://github.com/stanhu) for reporting a bug with empty patterns and `RE2::Regexp#scan`, contributing support for libre2.11 (2023-07-01) and for vendoring re2 and abseil and compiling native gems in 2.0;
+* Thanks to [Sebastian Reitenbach](https://github.com/buzzdeee) for reporting
+  the deprecation and removal of the `utf8` encoding option in re2;
+* Thanks to [Sergio Medina](https://github.com/serch) for reporting a bug when
+  using `RE2::Scanner#scan` with an invalid regular expression;
+* Thanks to [Pritam Baral](https://github.com/pritambaral) for contributed the
+  initial support for `RE2::Set`.
+
+Contact
+-------
+
+All issues and suggestions should go to [GitHub Issues](https://github.com/mudge/re2/issues).
+
+  [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
+

data/Rakefile

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+require 'rake_compiler_dock'
+require 'yaml'
+
+require_relative 'ext/re2/recipes'
+
+CLEAN.include FileList['**/*{.o,.so,.dylib,.bundle}'],
+              FileList['**/extconf.h'],
+              FileList['**/Makefile'],
+              FileList['pkg/']
+
+CLOBBER.include FileList['**/tmp'],
+                FileList['**/*.log'],
+                FileList['doc/**'],
+                FileList['tmp/']
+CLOBBER.add("ports/*").exclude(%r{ports/archives$})
+
+RE2_GEM_SPEC = Gem::Specification.load('re2.gemspec')
+
+task :prepare do
+  puts "Preparing project for gem building..."
+  recipes = load_recipes
+  recipes.each { |recipe| recipe.download }
+end
+
+task gem: :prepare
+
+Gem::PackageTask.new(RE2_GEM_SPEC) do |p|
+  p.need_zip = false
+  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_PLATFORMS = %w[
+  aarch64-linux
+  arm-linux
+  arm64-darwin
+  x64-mingw-ucrt
+  x64-mingw32
+  x86-linux
+  x86-mingw32
+  x86_64-darwin
+  x86_64-linux
+].freeze
+
+ENV['RUBY_CC_VERSION'] = CROSS_RUBY_VERSIONS
+
+Rake::ExtensionTask.new('re2', RE2_GEM_SPEC) do |e|
+  e.cross_compile = true
+  e.cross_config_options << '--enable-cross-build'
+  e.config_options << '--disable-system-libraries'
+  e.cross_platform = CROSS_RUBY_PLATFORMS
+  e.cross_compiling do |spec|
+    spec.files.reject! { |path| File.fnmatch?('ports/*', path) }
+    spec.dependencies.reject! { |dep| dep.name == 'mini_portile2' }
+  end
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace 'gem' do
+  def gem_builder(platform)
+    # use Task#invoke because the pkg/*gem task is defined at runtime
+    Rake::Task["native:#{platform}"].invoke
+    Rake::Task["pkg/#{RE2_GEM_SPEC.full_name}-#{Gem::Platform.new(platform)}.gem"].invoke
+  end
+
+  CROSS_RUBY_PLATFORMS.each do |platform|
+    # The Linux x86 image (ghcr.io/rake-compiler/rake-compiler-dock-image:1.3.0-mri-x86_64-linux)
+    # is based on CentOS 7 and has two versions of cmake installed:
+    # a 2.8 version in /usr/bin and a 3.25 in /usr/local/bin. The latter is needed by abseil.
+    cmake =
+      case platform
+      when 'x86_64-linux', 'x86-linux'
+        '/usr/local/bin/cmake'
+      else
+        'cmake'
+      end
+
+    desc "build native gem for #{platform} platform"
+    task platform do
+      RakeCompilerDock.sh <<~SCRIPT, platform: platform, verbose: true
+        gem install bundler --no-document &&
+        bundle &&
+        bundle exec rake gem:#{platform}:builder CMAKE=#{cmake}
+      SCRIPT
+    end
+
+    namespace platform do
+      desc "build native gem for #{platform} platform (guest container)"
+      task 'builder' do
+        gem_builder(platform)
+      end
+    end
+  end
+
+  desc 'build all native gems'
+  multitask 'native' => CROSS_RUBY_PLATFORMS
+end
+
+def add_file_to_gem(relative_source_path)
+  dest_path = File.join(gem_build_path, relative_source_path)
+  dest_dir = File.dirname(dest_path)
+
+  mkdir_p dest_dir unless Dir.exist?(dest_dir)
+  rm_f dest_path if File.exist?(dest_path)
+  safe_ln relative_source_path, dest_path
+
+  RE2_GEM_SPEC.files << relative_source_path
+end
+
+def gem_build_path
+  File.join 'pkg', RE2_GEM_SPEC.full_name
+end
+
+def add_vendored_libraries
+  dependencies = YAML.load_file(File.join(File.dirname(__FILE__), 'dependencies.yml'))
+  abseil_archive = File.join('ports', 'archives', "#{dependencies['abseil']['version']}.tar.gz")
+  libre2_archive = File.join('ports', 'archives', "re2-#{dependencies['libre2']['version']}.tar.gz")
+
+  add_file_to_gem(abseil_archive)
+  add_file_to_gem(libre2_archive)
+end
+
+task gem_build_path do
+  add_vendored_libraries
+end
+
+task default: [:compile, :spec]

data/dependencies.yml

@@ -0,0 +1,9 @@
+libre2:
+  version: "2023-09-01"
+  sha256: "5bb6875ae1cd1e9fedde98018c346db7260655f86fdb8837e3075103acd3649b"
+  # sha-256 hash provided in https://github.com/google/re2/releases/download/2023-09-01/re2-2023-09-01.tar.gz
+
+abseil:
+  version: "20230125.3"
+  sha256: 5366d7e7fa7ba0d915014d387b66d0d002c03236448e1ba9ef98122c13b35c36
+  # sha-256 hash provided in https://github.com/abseil/abseil-cpp/archive/refs/tags/20230125.3.tar.gz