re2 2.0.0.beta1-x64-mingw-ucrt

data/ext/re2/recipes.rb

@@ -0,0 +1,43 @@
+PACKAGE_ROOT_DIR = File.expand_path('../..', __dir__)
+REQUIRED_MINI_PORTILE_VERSION = '~> 2.8.4' # 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=17',
+      # 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'))
+
+  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

data/lib/re2/scanner.rb

@@ -0,0 +1,15 @@
+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,85 @@
+# re2 (http://github.com/mudge/re2)
+# Ruby bindings to re2, an "efficient, principled regular expression library"
+#
+# Copyright (c) 2010-2014, Paul Mucur (http://mudge.name)
+# Released under the BSD Licence, please see LICENSE.txt
+
+require "re2"
+
+module RE2
+  module String
+
+    # Replaces the first occurrence +pattern+ with +rewrite+ and returns a new
+    # string.
+    #
+    # @see RE2.Replace
+    def re2_sub(*args)
+      RE2.Replace(self, *args)
+    end
+
+    # Replaces every occurrence of +pattern+ with +rewrite+ and return a new string.
+    #
+    # @see RE2.GlobalReplace
+    def re2_gsub(*args)
+      RE2.GlobalReplace(self, *args)
+    end
+
+    # Match the pattern and return either a boolean (if no submatches are required)
+    # or a {RE2::MatchData} instance.
+    #
+    # @return [Boolean, RE2::MatchData]
+    #
+    # @overload match(pattern)
+    #   Returns an {RE2::MatchData} containing the matching
+    #   pattern and all subpatterns resulting from looking for
+    #   +pattern+.
+    #
+    #   @param [String, RE2::Regexp] pattern the regular expression to match
+    #   @return [RE2::MatchData] the matches
+    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
+    #   @example
+    #     r = RE2::Regexp.new('w(o)(o)')
+    #     "woo".re2_match(r)             #=> #<RE2::MatchData "woo" 1:"o" 2:"o">
+    #
+    # @overload match(pattern, 0)
+    #   Returns either true or false indicating whether a
+    #   successful match was made.
+    #
+    #   @param [String, RE2::Regexp] pattern the regular expression to match
+    #   @return [Boolean] whether the match was successful
+    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
+    #   @example
+    #     r = RE2::Regexp.new('w(o)(o)')
+    #     "woo".re2_match(0) #=> true
+    #     "bob".re2_match(0) #=> false
+    #
+    # @overload match(pattern, number_of_matches)
+    #   See +match(pattern)+ but with a specific number of
+    #   matches returned (padded with nils if necessary).
+    #
+    #   @param [String, RE2::Regexp] pattern the regular expression to match
+    #   @param [Integer] number_of_matches the number of matches to return
+    #   @return [RE2::MatchData] the matches
+    #   @raise [NoMemoryError] if there was not enough memory to allocate the matches
+    #   @example
+    #     r = RE2::Regexp.new('w(o)(o)')
+    #     "woo".re2_match(r, 1) #=> #<RE2::MatchData "woo" 1:"o">
+    #     "woo".re2_match(r, 3) #=> #<RE2::MatchData "woo" 1:"o" 2:"o" 3:nil>
+    def re2_match(pattern, *args)
+      RE2::Regexp.new(pattern).match(self, *args)
+    end
+
+    # Escapes all potentially meaningful regexp characters.
+    # The returned string, used as a regular expression, will exactly match the
+    # original string.
+    #
+    # @return [String] the escaped string
+    # @example
+    #   "1.5-2.0?".escape    #=> "1\.5\-2\.0\?"
+    def re2_escape
+      RE2.QuoteMeta(self)
+    end
+
+    alias_method :re2_quote, :re2_escape
+  end
+end

data/lib/re2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RE2
+  VERSION = "2.0.0.beta1"
+end

data/lib/re2.rb

@@ -0,0 +1,14 @@
+# re2 (http://github.com/mudge/re2)
+# Ruby bindings to re2, an "efficient, principled regular expression library"
+#
+# Copyright (c) 2010-2014, Paul Mucur (http://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/scanner"
+require "re2/version"

data/re2.gemspec

@@ -0,0 +1,43 @@
+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, "an efficient, principled regular expression library".'
+  s.version = RE2::VERSION
+  s.authors = ["Paul Mucur"]
+  s.homepage = "https://github.com/mudge/re2"
+  s.extensions = ["ext/re2/extconf.rb"]
+  s.license = "BSD-3-Clause"
+  s.required_ruby_version = ">= 2.7.0"
+  s.files = [
+    ".rspec",
+    "dependencies.yml",
+    "ext/re2/extconf.rb",
+    "ext/re2/re2.cc",
+    "ext/re2/recipes.rb",
+    "Gemfile",
+    "lib/re2.rb",
+    "lib/re2/scanner.rb",
+    "lib/re2/string.rb",
+    "lib/re2/version.rb",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "re2.gemspec"
+  ]
+  s.test_files = [
+    "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.1"
+  s.add_development_dependency "rake-compiler-dock", "~> 1.3.0"
+  s.add_development_dependency("rspec", "~> 3.2")
+  s.add_runtime_dependency("mini_portile2", "~> 2.8.4") # keep version in sync with extconf.rb
+end

data/spec/kernel_spec.rb

@@ -0,0 +1,13 @@
+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).to be_a(RE2::Regexp)
+      expect(re).to_not be_case_sensitive
+    end
+  end
+end

data/spec/re2/match_data_spec.rb

@@ -0,0 +1,302 @@
+# encoding: utf-8
+RSpec.describe RE2::MatchData do
+  describe "#to_a" do
+    it "is populated with the match and capturing groups" do
+      a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
+      expect(a).to eq(["woo", "o", "o"])
+    end
+
+    it "populates optional capturing groups with nil if they are missing" do
+      a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
+      expect(a).to eq(["ab", nil, "a", "b"])
+    end
+  end
+
+  describe "#[]" do
+    it "accesses capturing groups by numerical index" do
+      md = RE2::Regexp.new('(\d)(\d{2})').match("123")
+      expect(md[1]).to eq("1")
+      expect(md[2]).to eq("23")
+    end
+
+    it "has the whole match as the 0th item" do
+      md = RE2::Regexp.new('(\d)(\d{2})').match("123")
+      expect(md[0]).to eq("123")
+    end
+
+    it "supports access by numerical ranges" do
+      md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
+      expect(md[1..3]).to eq(["123", "456", "789"])
+      expect(md[1...3]).to eq(["123", "456"])
+    end
+
+    it "supports slicing" do
+      md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
+      expect(md[1, 3]).to eq(["123", "456", "789"])
+      expect(md[1, 2]).to eq(["123", "456"])
+    end
+
+    it "returns nil if attempting to access non-existent capturing groups by index" do
+      md = RE2::Regexp.new('(\d+)').match('bob 123')
+      expect(md[2]).to be_nil
+      expect(md[3]).to be_nil
+    end
+
+    it "allows access by string names when there are named groups" do
+      md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
+      expect(md["numbers"]).to eq("123")
+    end
+
+    it "allows access by symbol names when there are named groups" do
+      md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
+      expect(md[:numbers]).to eq("123")
+    end
+
+    it "allows access by names and indices with mixed groups" do
+      md = RE2::Regexp.new('(?P<name>\w+)(\s*)(?P<numbers>\d+)').match("bob 123")
+      expect(md["name"]).to eq("bob")
+      expect(md[:name]).to eq("bob")
+      expect(md[2]).to eq(" ")
+      expect(md["numbers"]).to eq("123")
+      expect(md[:numbers]).to eq("123")
+    end
+
+    it "returns nil if no such named group exists" do
+      md = RE2::Regexp.new('(\d+)').match("bob 123")
+      expect(md["missing"]).to be_nil
+      expect(md[:missing]).to be_nil
+    end
+
+    it "raises an error if given an inappropriate index" do
+      md = RE2::Regexp.new('(\d+)').match("bob 123")
+      expect { md[nil] }.to raise_error(TypeError)
+    end
+
+    if String.method_defined?(:encoding)
+      it "returns UTF-8 encoded strings by default" do
+        md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
+        expect(md[0].encoding.name).to eq("UTF-8")
+        expect(md["name"].encoding.name).to eq("UTF-8")
+        expect(md[:name].encoding.name).to eq("UTF-8")
+      end
+
+      it "returns Latin 1 strings encoding when utf-8 is false" do
+        md = RE2::Regexp.new('(?P<name>\S+)', :utf8 => false).match('bob')
+        expect(md[0].encoding.name).to eq("ISO-8859-1")
+        expect(md["name"].encoding.name).to eq("ISO-8859-1")
+        expect(md[:name].encoding.name).to eq("ISO-8859-1")
+      end
+    end
+  end
+
+  describe "#string" do
+    it "returns the original string to match against" do
+      re = RE2::Regexp.new('(\D+)').match("bob")
+      expect(re.string).to eq("bob")
+    end
+
+    it "returns a copy, not the actual original" do
+      string = "bob"
+      re = RE2::Regexp.new('(\D+)').match(string)
+      expect(re.string).to_not equal(string)
+    end
+
+    it "returns a frozen string" do
+      re = RE2::Regexp.new('(\D+)').match("bob")
+      expect(re.string).to be_frozen
+    end
+  end
+
+  describe "#size" do
+    it "returns the number of capturing groups plus the matching string" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
+      expect(md.size).to eq(3)
+    end
+  end
+
+  describe "#length" do
+    it "returns the number of capturing groups plus the matching string" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
+      expect(md.length).to eq(3)
+    end
+  end
+
+  describe "#regexp" do
+    it "returns the original RE2::Regexp used" do
+      re = RE2::Regexp.new('(\d+)')
+      md = re.match("123")
+      expect(md.regexp).to equal(re)
+    end
+  end
+
+  describe "#inspect" do
+    it "returns a text representation of the object and indices" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
+    end
+
+    it "represents missing matches as nil" do
+      md = RE2::Regexp.new('(\d+) (\d+)?').match("1234 ")
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
+    end
+  end
+
+  describe "#to_s" do
+    it "returns the matching part of the original string" do
+      md = RE2::Regexp.new('(\d{2,5})').match("one two 23456")
+      expect(md.to_s).to eq("23456")
+    end
+  end
+
+  describe "#to_ary" do
+    it "allows the object to be expanded with an asterisk" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
+      m1, m2, m3 = *md
+      expect(m1).to eq("1234 56")
+      expect(m2).to eq("1234")
+      expect(m3).to eq("56")
+    end
+  end
+
+  describe "#begin" do
+    it "returns the offset of the start of a match by index" do
+      md = RE2::Regexp.new('(wo{2})').match('a woohoo')
+      expect(md.string[md.begin(0)..-1]).to eq('woohoo')
+    end
+
+    it "returns the offset of the start of a match by string name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      expect(md.string[md.begin('foo')..-1]).to eq('foobar')
+    end
+
+    it "returns the offset of the start of a match by symbol name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
+    end
+
+    it "returns the offset despite multibyte characters" do
+      md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
+      expect(md.string[md.begin(0)..-1]).to eq('Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(:foo)).to be_nil
+    end
+  end
+
+  describe "#end" do
+    it "returns the offset of the character following the end of a match" do
+      md = RE2::Regexp.new('(wo{2})').match('a woohoo')
+      expect(md.string[0...md.end(0)]).to eq('a woo')
+    end
+
+    it "returns the offset of a match by string name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      expect(md.string[0...md.end('foo')]).to eq('a foo')
+    end
+
+    it "returns the offset of a match by symbol name" do
+      md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
+      expect(md.string[0...md.end(:foo)]).to eq('a foo')
+    end
+
+    it "returns the offset despite multibyte characters" do
+      md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
+      expect(md.string[0...md.end(0)]).to eq('I ♥ Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(:foo)).to be_nil
+    end
+  end
+
+  describe "#deconstruct" do
+    it "returns all capturing groups" do
+      md = RE2::Regexp.new('w(o)(o)').match('woo')
+
+      expect(md.deconstruct).to eq(['o', 'o'])
+    end
+
+    it "includes optional capturing groups as nil" do
+      md = RE2::Regexp.new('w(.)(.)(.)?').match('woo')
+
+      expect(md.deconstruct).to eq(['o', 'o', nil])
+    end
+  end
+
+  describe "#deconstruct_keys" do
+    it "returns all named captures if given nil" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect(md.deconstruct_keys(nil)).to eq(:numbers => '123', :letters => 'abc')
+    end
+
+    it "returns only named captures if given names" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect(md.deconstruct_keys([:numbers])).to eq(:numbers => '123')
+    end
+
+    it "returns named captures up until an invalid name is given" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect(md.deconstruct_keys([:numbers, :punctuation])).to eq(:numbers => '123')
+    end
+
+    it "returns an empty hash if given more capture names than exist" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect(md.deconstruct_keys([:numbers, :letters, :punctuation])).to eq({})
+    end
+
+    it "returns an empty hash if there are no named capturing groups" do
+      md = RE2::Regexp.new('(\d+) ([a-zA-Z]+)').match('123 abc')
+
+      expect(md.deconstruct_keys(nil)).to eq({})
+    end
+
+    it "raises an error if given a non-array of keys" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect { md.deconstruct_keys(0) }.to raise_error(TypeError)
+    end
+
+    it "raises an error if given keys as non-symbols" do
+      md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+
+      expect { md.deconstruct_keys([0]) }.to raise_error(TypeError)
+    end
+  end
+end