re2 2.27.0-x86_64-linux-gnu → 2.29.0-x86_64-linux-gnu

data/lib/re2/regexp.rb

@@ -68,5 +68,48 @@ module RE2
     def full_match(text, options = {})
       match(text, Hash(options).merge(anchor: :anchor_both))
     end
+
+    # Match the pattern against any substring of the given `text`, returning
+    # `false` if it is not a `String`, `Symbol`, or object responding to
+    # `to_str` so that an {RE2::Regexp} can be used in a `case` statement like
+    # Ruby's own `Regexp#===`.
+    #
+    # @param [Object] text the text to search; anything other than a `String`,
+    #   `Symbol`, or object responding to `to_str` returns `false`
+    # @return [Boolean] whether the match was successful
+    # @example
+    #   case "bob 123"
+    #   when RE2::Regexp.new('\d+')
+    #     "numbers"
+    #   end
+    def ===(text)
+      text = text.to_s if text.is_a?(Symbol)
+      text = ::String.try_convert(text)
+      return false unless text
+
+      match?(text)
+    end
+
+    # Return whether this regular expression has the same pattern and options
+    # as another {RE2::Regexp}.
+    #
+    # @param [Object] other the object to compare against
+    # @return [Boolean] whether the two regular expressions are equal
+    # @example
+    #   RE2::Regexp.new('abc') == RE2::Regexp.new('abc')                        #=> true
+    #   RE2::Regexp.new('abc') == RE2::Regexp.new('abc', case_sensitive: false) #=> false
+    def ==(other)
+      other.is_a?(RE2::Regexp) && source == other.source && options == other.options
+    end
+
+    alias_method :eql?, :==
+
+    # Return a hash based on the pattern and options so that equal
+    # {RE2::Regexp}s can be used as Hash keys.
+    #
+    # @return [Integer] the hash of the regular expression
+    def hash
+      [source, options].hash
+    end
   end
 end

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.27.0"
+  VERSION = "2.29.0"
 end

data/lib/re2.rb

@@ -16,5 +16,6 @@ rescue LoadError
 end
 
 require "re2/regexp"
+require "re2/match_data"
 require "re2/scanner"
 require "re2/version"

data/re2.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
     "Gemfile",
     "lib/re2.rb",
     "lib/re2/regexp.rb",
+    "lib/re2/match_data.rb",
     "lib/re2/scanner.rb",
     "lib/re2/string.rb",
     "lib/re2/version.rb",
@@ -41,7 +42,7 @@ Gem::Specification.new do |s|
     "spec/re2/scanner_spec.rb"
   ]
   s.add_development_dependency("rake-compiler", "~> 1.3.1")
-  s.add_development_dependency("rake-compiler-dock", "~> 1.11.0")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.12.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.9") # keep version in sync with extconf.rb
 end

data/spec/re2/match_data_spec.rb

@@ -59,6 +59,15 @@ RSpec.describe RE2::MatchData do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      md = RE2::Regexp.new('(\d+)').match("123")
+      md.send(:initialize_copy, md)
+
+      expect(md.to_a).to eq(["123", "123"])
+    end
+  end
+
   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
@@ -154,6 +163,24 @@ RSpec.describe RE2::MatchData do
       expect(md[:numbers]).to eq("123")
     end
 
+    it "allows access using a UTF-8 name and a UTF-8 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md[:café]).to eq("123")
+    end
+
+    it "allows access using a Latin-1 name and a Latin-1 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md["café".encode("ISO-8859-1")]).to eq("123")
+    end
+
     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")
 
@@ -199,6 +226,12 @@ RSpec.describe RE2::MatchData do
       expect(md[:name].encoding.name).to eq("ISO-8859-1")
     end
 
+    it "handles null bytes in symbol names" do
+      md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
+
+      expect(md[:"name\0b"]).to be_nil
+    end
+
     it "supports GC compaction" do
       md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
       GC.compact
@@ -358,6 +391,24 @@ RSpec.describe RE2::MatchData do
       expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
     end
 
+    it "returns the offset of the start of a match by non-ASCII symbol name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin(:café)..-1]).to eq('foobar')
+    end
+
+    it "returns the offset of the start of a match by Latin-1 string name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin("café".encode("ISO-8859-1"))..-1]).to eq('foobar')
+    end
+
     it "returns the offset of the start of a match by something that can be coerced to a String" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
 
@@ -581,6 +632,108 @@ RSpec.describe RE2::MatchData do
     end
   end
 
+  describe "#bytebegin" do
+    it "returns the byte offset of the start of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin(0)).to eq(6)
+    end
+
+    it "returns the byte offset of the start of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<word>Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin("word")).to eq(6)
+    end
+
+    it "returns the byte offset of the start of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<word>Ruby)').match("I ♥ Ruby")
+
+      expect(md.bytebegin(:word)).to eq(6)
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.bytebegin(1)).to be_nil
+    end
+
+    it "returns nil for a nonexistent submatch" do
+      md = RE2::Regexp.new('(a)').match("a")
+
+      expect(md.bytebegin(5)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.bytebegin(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#byteend" do
+    it "returns the byte offset after the end of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.byteend(0)).to eq(10)
+    end
+
+    it "returns the byte offset after the end of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteend("heart")).to eq(5)
+    end
+
+    it "returns the byte offset after the end of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteend(:heart)).to eq(5)
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.byteend(1)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.byteend(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#byteoffset" do
+    it "returns the byte offsets of a match by index" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.byteoffset(0)).to eq([6, 10])
+    end
+
+    it "returns the byte offsets of a submatch by string name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteoffset("heart")).to eq([2, 5])
+    end
+
+    it "returns the byte offsets of a submatch by symbol name" do
+      md = RE2::Regexp.new('(?P<heart>♥)').match("I ♥ Ruby")
+
+      expect(md.byteoffset(:heart)).to eq([2, 5])
+    end
+
+    it "can be used to slice the original string by bytes" do
+      md = RE2::Regexp.new('(Ruby)').match("I ♥ Ruby")
+
+      expect(md.string.byteslice(*md.byteoffset(1))).to eq("Ruby")
+    end
+
+    it "returns nil for an unmatched submatch" do
+      md = RE2::Regexp.new('a(b)?').match("ac")
+
+      expect(md.byteoffset(1)).to be_nil
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.byteoffset(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
   describe "#offset" do
     it "returns the offset of a match by index" do
       md = RE2::Regexp.new('ob (\d+)').match("bob 123")
@@ -822,12 +975,33 @@ RSpec.describe RE2::MatchData do
       expect(md.named_captures).to eq("empty" => "", "word" => "bob")
     end
 
+    it "returns UTF-8 names even for Latin-1 patterns" do
+      md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
+      key = md.named_captures.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    end
+
     it "returns symbol keys when symbolize_names: true" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
       expect(md.named_captures(symbolize_names: true)).to eq(numbers: "123", letters: "abc")
     end
 
+    it "returns garbage-collectable symbol keys when symbolize_names: true" do
+      md = RE2::Regexp.new('(?P<collectable_named_capture>\d+)').match('123')
+      key = md.named_captures(symbolize_names: true).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "correctly encodes non-ASCII capturing group names as symbols" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      expect(re.match('123').named_captures(symbolize_names: true)).to eq(café: "123")
+    end
+
     it "returns string keys when symbolize_names: false" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
@@ -858,10 +1032,10 @@ RSpec.describe RE2::MatchData do
       expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
-    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
       md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
 
-      expect(md.names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -876,6 +1050,22 @@ RSpec.describe RE2::MatchData do
       expect(md.deconstruct_keys(nil)).to eq(numbers: '123', letters: 'abc')
     end
 
+    it "returns garbage-collectable symbol keys if given nil" do
+      md = RE2::Regexp.new('(?P<collectable_deconstructed_key>\d+)').match('123')
+      key = md.deconstruct_keys(nil).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "returns UTF-8 named captures for a Latin-1 pattern if given nil" do
+      re = RE2::Regexp.new('(?P<café>\d+) (?P<letters>[a-zA-Z]+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('123 abc')
+
+      expect(md.deconstruct_keys(nil)).to eq(café: '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')
 
@@ -922,4 +1112,95 @@ RSpec.describe RE2::MatchData do
       expect { described_class.allocate.deconstruct_keys(nil) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
     end
   end
+
+  describe "#==" do
+    it "returns true for matches with the same regexp, text, and offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eq(re.match("abc 123"))
+    end
+
+    it "returns true for matches against equal but distinct regexps" do
+      md = RE2::Regexp.new('(\d+)').match("abc 123")
+
+      expect(md).to eq(RE2::Regexp.new('(\d+)').match("abc 123"))
+    end
+
+    it "returns true for matches against a copy of the text" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eq(re.match("abc 123".dup))
+    end
+
+    it "returns true for matches with unmatched optional groups" do
+      re = RE2::Regexp.new('a(b)?')
+
+      expect(re.match("ac")).to eq(re.match("ac"))
+    end
+
+    it "returns false for matches against different text" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).not_to eq(re.match("abc 456"))
+    end
+
+    it "returns false for the same captures at different offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("123 abc")).not_to eq(re.match("abc 123"))
+    end
+
+    it "returns false for matches against regexps with different options" do
+      md = RE2::Regexp.new('(abc)').match("abc")
+
+      expect(md).not_to eq(RE2::Regexp.new('(abc)', case_sensitive: false).match("abc"))
+    end
+
+    it "returns false for matches with a different number of submatches" do
+      re = RE2::Regexp.new('(a)(b)')
+
+      expect(re.match("ab")).not_to eq(re.match("ab", submatches: 1))
+    end
+
+    it "returns false for a non-MatchData" do
+      expect(RE2::Regexp.new('(a)').match("a")).not_to eq("a")
+    end
+
+    it "is aliased to eql?" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123")).to eql(re.match("abc 123"))
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate == RE2::Regexp.new('(a)').match("a") }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#hash" do
+    it "is the same for equal matches" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("abc 123").hash).to eq(re.match("abc 123").hash)
+    end
+
+    it "differs for matches at different offsets" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match("123 abc").hash).not_to eq(re.match("abc 123").hash)
+    end
+
+    it "allows matches to be used as Hash keys" do
+      re = RE2::Regexp.new('(\d+)')
+      hash = { re.match("abc 123") => :found }
+
+      expect(hash[re.match("abc 123")]).to eq(:found)
+    end
+
+    it "allows matches to be deduplicated" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect([re.match("abc 123"), re.match("abc 123")].uniq.size).to eq(1)
+    end
+  end
 end