re2 2.4.3-x86_64-linux → 2.5.0-x86_64-linux

data/ext/re2/recipes.rb

@@ -1,3 +1,11 @@
+# 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.5' # keep this version in sync with the one in the gemspec
 

data/lib/re2/regexp.rb

@@ -0,0 +1,69 @@
+# 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

@@ -1,3 +1,11 @@
+# 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

data/lib/re2/string.rb

@@ -1,81 +1,31 @@
-# 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-2014, Paul Mucur (http://mudge.name)
+# Copyright (c) 2010, Paul Mucur (https://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
+    # @deprecated Use {RE2.Replace} instead.
     def re2_sub(*args)
       RE2.Replace(self, *args)
     end
 
-    # Replaces every occurrence of +pattern+ with +rewrite+ and return a new string.
-    #
-    # @see RE2.GlobalReplace
+    # @deprecated Use {RE2.GlobalReplace} instead.
     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>
+    # @deprecated Use {RE2::Regexp#match} instead.
     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\?"
+    # @deprecated Use {RE2.QuoteMeta} instead.
     def re2_escape
       RE2.QuoteMeta(self)
     end

data/lib/re2/version.rb

@@ -1,5 +1,13 @@
 # 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.4.3"
+  VERSION = "2.5.0"
 end

data/lib/re2.rb

@@ -1,8 +1,11 @@
-# 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-2014, Paul Mucur (http://mudge.name)
+# 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"
@@ -10,5 +13,6 @@ rescue LoadError
   require 're2.so'
 end
 
+require "re2/regexp"
 require "re2/scanner"
 require "re2/version"

data/re2.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
     "ext/re2/recipes.rb",
     "Gemfile",
     "lib/re2.rb",
+    "lib/re2/regexp.rb",
     "lib/re2/scanner.rb",
     "lib/re2/string.rb",
     "lib/re2/version.rb",

data/spec/kernel_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Kernel do
     end
 
     it "returns an RE2::Regexp instance given a pattern and options" do
-      re = RE2('w(o)(o)', :case_sensitive => false)
+      re = RE2('w(o)(o)', case_sensitive: false)
 
       expect(re).not_to be_case_sensitive
     end
@@ -15,7 +15,7 @@ RSpec.describe Kernel do
     end
 
     it "allows invalid patterns to be created" do
-      re = RE2('???', :log_errors => false)
+      re = RE2('???', log_errors: false)
 
       expect(re).to be_a(RE2::Regexp)
     end

data/spec/re2/match_data_spec.rb

@@ -12,11 +12,13 @@ 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
 
@@ -27,15 +29,16 @@ RSpec.describe RE2::MatchData do
     end
 
     it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
-      a = RE2::Regexp.new('w(o)(o)', :utf8 => false).match('woo').to_a
+      a = RE2::Regexp.new('w(o)(o)', utf8: false).match('woo').to_a
 
       expect(a.map(&:encoding)).to all eq(Encoding::ISO_8859_1)
     end
   end
 
   describe "#[]" do
-    it "accesses capturing groups by numerical index" do
+    it "accesses capturing groups by numerical index", :aggregate_failures do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
+
       expect(md[1]).to eq("1")
       expect(md[2]).to eq("23")
     end
@@ -47,46 +50,53 @@ RSpec.describe RE2::MatchData do
     end
 
     it "returns a ISO-8859-1 string by numerical index if the pattern is not UTF-8" do
-      md = RE2::Regexp.new('(\d)(\d{2})', :utf8 => false).match("123")
+      md = RE2::Regexp.new('(\d)(\d{2})', utf8: false).match("123")
 
       expect(md[1].encoding).to eq(Encoding::ISO_8859_1)
     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
+    it "supports access by numerical ranges", :aggregate_failures 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
+    it "supports slicing", :aggregate_failures 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
+    it "returns nil if attempting to access non-existent capturing groups by index", :aggregate_failures 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
+    it "allows access by names and indices with mixed groups", :aggregate_failures 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(" ")
@@ -94,54 +104,60 @@ RSpec.describe RE2::MatchData do
       expect(md[:numbers]).to eq("123")
     end
 
-    it "returns nil if no such named group exists" do
+    it "returns nil if no such named group exists", :aggregate_failures 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 UTF-8 encoded strings by default", :aggregate_failures do
+      md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
 
-      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
+      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", :aggregate_failures 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
 
   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
 
     it "does not copy the string if it was already frozen" do
       string = "bob".freeze
       re = RE2::Regexp.new('(\D+)').match(string)
+
       expect(re.string).to equal(string)
     end
   end
@@ -149,6 +165,7 @@ RSpec.describe RE2::MatchData do
   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
@@ -156,6 +173,7 @@ RSpec.describe RE2::MatchData do
   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
@@ -164,6 +182,7 @@ RSpec.describe RE2::MatchData 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
@@ -171,11 +190,13 @@ RSpec.describe RE2::MatchData do
   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
@@ -183,14 +204,16 @@ RSpec.describe RE2::MatchData do
   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
+    it "allows the object to be expanded with an asterisk", :aggregate_failures 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")
@@ -200,41 +223,49 @@ RSpec.describe RE2::MatchData do
   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
@@ -242,41 +273,49 @@ RSpec.describe RE2::MatchData do
   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
@@ -299,19 +338,19 @@ RSpec.describe RE2::MatchData 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')
+      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')
+      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')
+      expect(md.deconstruct_keys([:numbers, :punctuation])).to eq(numbers: '123')
     end
 
     it "returns an empty hash if given more capture names than exist" do