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

data/spec/re2/regexp_spec.rb

@@ -49,6 +49,13 @@ RSpec.describe RE2::Regexp do
 
       expect { re.send(:initialize, 'bar') }.to raise_error(FrozenError)
     end
+
+    it "cannot be re-initialized while parsing options" do
+      re = described_class.allocate
+      options = Hash.new { |_, key| re.send(:initialize, 'bar') if key == :utf8 }
+
+      expect { re.send(:initialize, 'woo', options) }.to raise_error(FrozenError)
+    end
   end
 
   describe "#dup" do
@@ -234,24 +241,6 @@ RSpec.describe RE2::Regexp do
     end
   end
 
-  describe "#to_str" do
-    it "returns the original pattern" do
-      string = RE2::Regexp.new('w(o)(o)').to_str
-
-      expect(string).to eq("w(o)(o)")
-    end
-
-    it "returns the pattern even if invalid" do
-      string = RE2::Regexp.new('???', log_errors: false).to_str
-
-      expect(string).to eq("???")
-    end
-
-    it "raises an error when called on an uninitialized object" do
-      expect { described_class.allocate.to_str }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
-    end
-  end
-
   describe "#pattern" do
     it "returns the original pattern" do
       pattern = RE2::Regexp.new('w(o)(o)').pattern
@@ -508,6 +497,18 @@ RSpec.describe RE2::Regexp do
       expect(re.match("My name is Alice Bloggs")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "supports matching against text containing null bytes" do
       re = RE2::Regexp.new("a\0b")
 
@@ -529,7 +530,7 @@ RSpec.describe RE2::Regexp do
     it "raises an exception when given text that cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\w+) (\w+)')
 
-      expect { re.match(nil) }.to raise_error(TypeError)
+      expect { re.match(0) }.to raise_error(TypeError)
     end
 
     it "returns nil with an invalid pattern" do
@@ -819,6 +820,18 @@ RSpec.describe RE2::Regexp do
       expect(re.match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re.match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -861,6 +874,18 @@ RSpec.describe RE2::Regexp do
       expect(re.partial_match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.partial_match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re.partial_match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -903,6 +928,18 @@ RSpec.describe RE2::Regexp do
       expect(re =~ "My name is Alice Bloggs").to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re =~ nil).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re =~ :abc123).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -914,6 +951,52 @@ RSpec.describe RE2::Regexp do
     end
   end
 
+  describe "#==" do
+    it "returns true for regexps with the same pattern and options" do
+      expect(RE2::Regexp.new('a(b)', case_sensitive: false)).to eq(RE2::Regexp.new('a(b)', case_sensitive: false))
+    end
+
+    it "returns false for regexps with different patterns" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq(RE2::Regexp.new('a(c)'))
+    end
+
+    it "returns false for regexps with different options" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq(RE2::Regexp.new('a(b)', case_sensitive: false))
+    end
+
+    it "returns false for a String with the same pattern" do
+      expect(RE2::Regexp.new('a(b)')).not_to eq('a(b)')
+    end
+
+    it "is aliased to eql?" do
+      expect(RE2::Regexp.new('a(b)')).to eql(RE2::Regexp.new('a(b)'))
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate == RE2::Regexp.new('a') }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+  end
+
+  describe "#hash" do
+    it "is the same for equal regexps" do
+      expect(RE2::Regexp.new('a(b)').hash).to eq(RE2::Regexp.new('a(b)').hash)
+    end
+
+    it "differs for regexps with different options" do
+      expect(RE2::Regexp.new('a(b)').hash).not_to eq(RE2::Regexp.new('a(b)', case_sensitive: false).hash)
+    end
+
+    it "allows regexps to be used as Hash keys" do
+      hash = { RE2::Regexp.new('a(b)') => :found }
+
+      expect(hash[RE2::Regexp.new('a(b)')]).to eq(:found)
+    end
+
+    it "allows regexps to be deduplicated" do
+      expect([RE2::Regexp.new('a'), RE2::Regexp.new('a')].uniq.size).to eq(1)
+    end
+  end
+
   describe "#===" do
     it "returns only true or false even if there are capturing groups", :aggregate_failures do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
@@ -928,10 +1011,31 @@ RSpec.describe RE2::Regexp do
       expect(re === "My name is Alice Bloggs").to eq(false)
     end
 
-    it "raises an exception if text cannot be coerced to a string" do
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\d+')
+
+      expect(re === :abc123).to eq(true)
+    end
+
+    it "returns false if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
-      expect { re === 0 }.to raise_error(TypeError)
+      expect(re === 0).to eq(false)
+    end
+
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re === nil).to eq(false)
+    end
+
+    it "can be used in a case statement" do
+      result = case 123
+               when RE2::Regexp.new('\d+') then :matched
+               else :not_matched
+               end
+
+      expect(result).to eq(:not_matched)
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -960,6 +1064,18 @@ RSpec.describe RE2::Regexp do
       expect(re.full_match?("My name is Alice Bloggs")).to eq(false)
     end
 
+    it "returns false for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.full_match?(nil)).to eq(false)
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('\w+')
+
+      expect(re.full_match?(:abc123)).to eq(true)
+    end
+
     it "raises an exception if text cannot be coerced to a string" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
 
@@ -1048,6 +1164,13 @@ RSpec.describe RE2::Regexp do
       expect(RE2::Regexp.new('???', log_errors: false).named_capturing_groups).to be_empty
     end
 
+    it "returns names as UTF-8 even if the pattern is Latin-1" do
+      groups = RE2::Regexp.new('(?P<bob>a)', utf8: false).named_capturing_groups
+      key = groups.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.named_capturing_groups }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
@@ -1071,15 +1194,17 @@ RSpec.describe RE2::Regexp do
     end
 
     it "returns UTF-8 strings if the pattern is UTF-8" do
-      names = RE2::Regexp.new('(?P<bob>a)').names
+      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(names.first.encoding).to eq(Encoding::UTF_8)
+      expect(re.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
-    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
-      names = RE2::Regexp.new('(?P<bob>a)', utf8: false).names
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
+      re = RE2::Regexp.new('(?P<café>a)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
 
-      expect(names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(re.names).to contain_exactly("café")
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -1143,6 +1268,18 @@ RSpec.describe RE2::Regexp do
       expect(r.partial_match("foo bar")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.partial_match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\d+)')
+
+      expect(re.partial_match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "can set the number of submatches to extract", :aggregate_failures do
       r = RE2::Regexp.new('f(o+)(a+)')
       m = r.partial_match("fooaa bar", submatches: 1)
@@ -1203,6 +1340,18 @@ RSpec.describe RE2::Regexp do
       expect(r.full_match("foo")).to eq(true)
     end
 
+    it "returns nil for nil" do
+      re = RE2::Regexp.new('.*')
+
+      expect(re.full_match(nil)).to be_nil
+    end
+
+    it "matches against symbols" do
+      re = RE2::Regexp.new('(\w+)')
+
+      expect(re.full_match(:abc123)).to be_a(RE2::MatchData)
+    end
+
     it "can set the number of submatches to extract", :aggregate_failures do
       r = RE2::Regexp.new('f(o+)(a+)')
       m = r.full_match("fooaa", submatches: 1)

data/spec/re2/scanner_spec.rb

@@ -106,6 +106,15 @@ RSpec.describe RE2::Scanner do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar")
+      scanner.send(:initialize_copy, scanner)
+
+      expect(scanner.scan).to eq(["foo"])
+    end
+  end
+
   describe "#scan" do
     it "returns the next array of matches", :aggregate_failures do
       r = RE2::Regexp.new('(\w+)')

data/spec/re2/set_spec.rb

@@ -49,6 +49,13 @@ RSpec.describe RE2::Set do
         "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
       )
     end
+
+    it "cannot be re-initialized before compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+
+      expect { set.send(:initialize) }.to raise_error(TypeError, /already initialized RE2::Set/)
+    end
   end
 
   describe "#dup" do
@@ -212,6 +219,30 @@ RSpec.describe RE2::Set do
       end
     end
 
+    it "raises an error if called after a failed #compile" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect { set.match("abc") }.to raise_error(RE2::Set::MatchError, "#match must not be called before #compile")
+      end
+    end
+
+    it "returns an empty array if called after a failed #compile when :exception is false" do
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect(set.match("abc", exception: false)).to be_empty
+      end
+    end
+
     it "raises an error if :exception is true and RE2 does not support it" do
       skip "Underlying RE2::Set::Match outputs error information" if RE2::Set.match_raises_errors?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.27.0
+  version: 2.29.0
 platform: x86_64-linux-gnu
 authors:
 - Paul Mucur
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -74,6 +74,7 @@ files:
 - lib/3.4/re2.so
 - lib/4.0/re2.so
 - lib/re2.rb
+- lib/re2/match_data.rb
 - lib/re2/regexp.rb
 - lib/re2/scanner.rb
 - lib/re2/string.rb
@@ -108,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Ruby bindings to RE2.
 test_files: