re2 2.15.0.rc1-x86-linux-musl

data/ext/re2/recipes.rb

@@ -0,0 +1,54 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
+REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.7' # keep this version in sync with the one in the gemspec
+
+def load_recipes
+  require 'yaml'
+  dependencies = YAML.load_file(File.join(PACKAGE_ROOT_DIR, 'dependencies.yml'))
+
+  abseil_recipe = build_recipe('abseil', dependencies['abseil']['version']) do |recipe|
+    recipe.files = [{
+      url: "https://github.com/abseil/abseil-cpp/archive/refs/tags/#{recipe.version}.tar.gz",
+      sha256: dependencies['abseil']['sha256']
+    }]
+  end
+
+  re2_recipe = build_recipe('libre2', dependencies['libre2']['version']) do |recipe|
+    recipe.files = [{
+      url: "https://github.com/google/re2/releases/download/#{recipe.version}/re2-#{recipe.version}.tar.gz",
+      sha256: dependencies['libre2']['sha256']
+    }]
+  end
+
+  [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

@@ -0,0 +1,72 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
+module RE2
+  class Regexp
+    # Match the pattern against any substring of the given `text` and return a
+    # {RE2::MatchData} instance with the specified number of submatches
+    # (defaults to the total number of capturing groups) or a boolean (if no
+    # submatches are required).
+    #
+    # The number of submatches has a significant impact on performance: requesting
+    # one submatch is much faster than requesting more than one and requesting
+    # zero submatches is faster still.
+    #
+    # @param [String] text the text to search
+    # @param [Hash] options the options with which to perform the match
+    # @option options [Integer] :submatches how many submatches to extract (0
+    #   is fastest), defaults to the total number of capturing groups
+    # @return [RE2::MatchData, nil] if extracting any submatches
+    # @return [Boolean] if not extracting any submatches
+    # @raise [ArgumentError] if given a negative number of submatches
+    # @raise [NoMemoryError] if there was not enough memory to allocate the
+    #   matches
+    # @raise [TypeError] if given non-numeric submatches or non-hash options
+    # @example
+    #   r = RE2::Regexp.new('w(o)(o)')
+    #   r.partial_match('woot')                #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+    #   r.partial_match('nope')                #=> nil
+    #   r.partial_match('woot', submatches: 1) #=> #<RE2::MatchData "woo" 1:"o">
+    #   r.partial_match('woot', submatches: 0) #=> true
+    def partial_match(text, options = {})
+      match(text, Hash(options).merge(anchor: :unanchored))
+    end
+
+    # Match the pattern against the given `text` exactly and return a
+    # {RE2::MatchData} instance with the specified number of submatches
+    # (defaults to the total number of capturing groups) or a boolean (if no
+    # submatches are required).
+    #
+    # The number of submatches has a significant impact on performance: requesting
+    # one submatch is much faster than requesting more than one and requesting
+    # zero submatches is faster still.
+    #
+    # @param [String] text the text to search
+    # @param [Hash] options the options with which to perform the match
+    # @option options [Integer] :submatches how many submatches to extract (0
+    #   is fastest), defaults to the total number of capturing groups
+    # @return [RE2::MatchData, nil] if extracting any submatches
+    # @return [Boolean] if not extracting any submatches
+    # @raise [ArgumentError] if given a negative number of submatches
+    # @raise [NoMemoryError] if there was not enough memory to allocate the
+    #   matches
+    # @raise [TypeError] if given non-numeric submatches or non-hash options
+    # @example
+    #   r = RE2::Regexp.new('w(o)(o)')
+    #   r.full_match('woo')                #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+    #   r.full_match('woot')               #=> nil
+    #   r.full_match('woo', submatches: 1) #=> #<RE2::MatchData "woo" 1:"o">
+    #   r.full_match('woo', submatches: 0) #=> true
+    def full_match(text, options = {})
+      match(text, Hash(options).merge(anchor: :anchor_both))
+    end
+  end
+end

data/lib/re2/scanner.rb

@@ -0,0 +1,26 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
+module RE2
+  class Scanner
+    include Enumerable
+
+    def each
+      if block_given?
+        while matches = scan
+          yield matches
+        end
+      else
+        to_enum(:each)
+      end
+    end
+  end
+end

data/lib/re2/string.rb

@@ -0,0 +1,38 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+require "re2"
+
+module RE2
+  # @deprecated Use methods on {RE2} and {RE2::Regexp} instead.
+  module String
+    # @deprecated Use {RE2.Replace} instead.
+    def re2_sub(*args)
+      RE2.Replace(self, *args)
+    end
+
+    # @deprecated Use {RE2.GlobalReplace} instead.
+    def re2_gsub(*args)
+      RE2.GlobalReplace(self, *args)
+    end
+
+    # @deprecated Use {RE2::Regexp#match} instead.
+    def re2_match(pattern, *args)
+      RE2::Regexp.new(pattern).match(self, *args)
+    end
+
+    # @deprecated Use {RE2.QuoteMeta} instead.
+    def re2_escape
+      RE2.QuoteMeta(self)
+    end
+
+    alias_method :re2_quote, :re2_escape
+  end
+end

data/lib/re2/version.rb

@@ -0,0 +1,14 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+
+module RE2
+  VERSION = "2.15.0.rc1"
+end

data/lib/re2.rb

@@ -0,0 +1,20 @@
+# 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
+# Python".
+#
+# Copyright (c) 2010, Paul Mucur (https://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+begin
+  ::RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "#{Regexp.last_match(1)}/re2.so"
+rescue LoadError
+  require 're2.so'
+end
+
+require "re2/regexp"
+require "re2/scanner"
+require "re2/version"

data/re2.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/re2/version'
+
+Gem::Specification.new do |s|
+  s.name = "re2"
+  s.summary = "Ruby bindings to RE2."
+  s.description = 'Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking regular expression engines like those used in PCRE, Perl, and Python".'
+  s.version = RE2::VERSION
+  s.authors = ["Paul Mucur", "Stan Hu"]
+  s.homepage = "https://github.com/mudge/re2"
+  s.extensions = ["ext/re2/extconf.rb"]
+  s.license = "BSD-3-Clause"
+  s.required_ruby_version = ">= 3.1.0"
+  s.files = [
+    "dependencies.yml",
+    "ext/re2/extconf.rb",
+    "ext/re2/re2.cc",
+    "ext/re2/recipes.rb",
+    "Gemfile",
+    "lib/re2.rb",
+    "lib/re2/regexp.rb",
+    "lib/re2/scanner.rb",
+    "lib/re2/string.rb",
+    "lib/re2/version.rb",
+    "LICENSE.txt",
+    "LICENSE-DEPENDENCIES.txt",
+    "README.md",
+    "Rakefile",
+    "re2.gemspec"
+  ]
+  s.test_files = [
+    ".rspec",
+    "spec/spec_helper.rb",
+    "spec/re2_spec.rb",
+    "spec/kernel_spec.rb",
+    "spec/re2/regexp_spec.rb",
+    "spec/re2/match_data_spec.rb",
+    "spec/re2/string_spec.rb",
+    "spec/re2/set_spec.rb",
+    "spec/re2/scanner_spec.rb"
+  ]
+  s.add_development_dependency("rake-compiler", "~> 1.2.7")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.7.0.rc1")
+  s.add_development_dependency("rspec", "~> 3.2")
+  s.add_runtime_dependency("mini_portile2", "~> 2.8.7") # keep version in sync with extconf.rb
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Kernel do
+  describe ".RE2" do
+    it "returns an RE2::Regexp instance given a pattern" do
+      expect(RE2('w(o)(o)')).to be_a(RE2::Regexp)
+    end
+
+    it "returns an RE2::Regexp instance given a pattern and options" do
+      re = RE2('w(o)(o)', case_sensitive: false)
+
+      expect(re).not_to be_case_sensitive
+    end
+
+    it "accepts patterns containing null bytes" do
+      re = RE2("a\0b")
+
+      expect(re.pattern).to eq("a\0b")
+    end
+
+    it "raises an error if given an inappropriate type" do
+      expect { RE2(nil) }.to raise_error(TypeError)
+    end
+
+    it "allows invalid patterns to be created" do
+      re = RE2('???', log_errors: false)
+
+      expect(re).to be_a(RE2::Regexp)
+    end
+
+    it "supports passing something that can be coerced to a String as input" do
+      re = RE2(StringLike.new('w(o)(o)'))
+
+      expect(re).to be_a(RE2::Regexp)
+    end
+  end
+end