re2 2.9.0 → 2.27.0

data/spec/re2/regexp_spec.rb

@@ -1,4 +1,10 @@
+# frozen_string_literal: true
+
+require "rbconfig/sizeof"
+
 RSpec.describe RE2::Regexp do
+  INT_MAX = 2**(RbConfig::SIZEOF.fetch("int") * 8 - 1) - 1
+
   describe "#initialize" do
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.new('woo')
@@ -33,6 +39,77 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_a(RE2::Regexp)
     end
+
+    it "returns a frozen object" do
+      expect(RE2::Regexp.new('woo')).to be_frozen
+    end
+
+    it "cannot be re-initialized" do
+      re = RE2::Regexp.new('woo')
+
+      expect { re.send(:initialize, 'bar') }.to raise_error(FrozenError)
+    end
+  end
+
+  describe "#dup" do
+    it "returns a copy with the same pattern" do
+      re = described_class.new('(\d+)')
+      copy = re.dup
+
+      expect(copy.to_s).to eq('(\d+)')
+    end
+
+    it "returns a different object" do
+      re = described_class.new('(\d+)')
+      copy = re.dup
+
+      expect(copy).to_not equal(re)
+    end
+
+    it "returns a valid copy" do
+      re = described_class.new('(\d+)')
+      copy = re.dup
+
+      expect(copy.ok?).to eq(true)
+    end
+
+    it "copies options from the original" do
+      re = described_class.new('(\d+)', case_sensitive: false)
+      copy = re.dup
+
+      expect(copy).to_not be_case_sensitive
+    end
+
+    it "returns a frozen copy" do
+      re = described_class.new('(\d+)')
+      copy = re.dup
+
+      expect(copy).to be_frozen
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.dup }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+  end
+
+  describe "#clone" do
+    it "returns a copy with the same pattern" do
+      re = described_class.new('woo')
+      copy = re.clone
+
+      expect(copy.to_s).to eq('woo')
+    end
+
+    it "returns a frozen copy" do
+      re = described_class.new('woo')
+      copy = re.clone
+
+      expect(copy).to be_frozen
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.clone }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe ".compile" do
@@ -96,6 +173,10 @@ RSpec.describe RE2::Regexp do
 
       expect(options).to include(case_sensitive: false)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.options }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#error" do
@@ -111,6 +192,10 @@ RSpec.describe RE2::Regexp do
 
       expect(error).to eq("missing ): wo(o")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.error }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#error_arg" do
@@ -125,6 +210,10 @@ RSpec.describe RE2::Regexp do
 
       expect(error_arg).to eq("wo(o")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.error_arg }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#program_size" do
@@ -139,6 +228,10 @@ RSpec.describe RE2::Regexp do
 
       expect(program_size).to eq(-1)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.program_size }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#to_str" do
@@ -153,6 +246,10 @@ RSpec.describe RE2::Regexp do
 
       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
@@ -167,6 +264,10 @@ RSpec.describe RE2::Regexp do
 
       expect(pattern).to eq("???")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.pattern }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#inspect" do
@@ -181,6 +282,10 @@ RSpec.describe RE2::Regexp do
 
       expect(string.encoding).to eq(Encoding::ISO_8859_1)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.inspect }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#utf8?" do
@@ -193,6 +298,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to_not be_utf8
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.utf8? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#posix_syntax?" do
@@ -205,6 +314,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_posix_syntax
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.posix_syntax? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#literal?" do
@@ -217,6 +330,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_literal
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.literal? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#never_nl?" do
@@ -229,6 +346,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_never_nl
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.never_nl? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#case_sensitive?" do
@@ -240,6 +361,10 @@ RSpec.describe RE2::Regexp do
       re = RE2::Regexp.new('woo', case_sensitive: false)
       expect(re).to_not be_case_sensitive
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.case_sensitive? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#case_insensitive?" do
@@ -252,6 +377,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_case_insensitive
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.case_insensitive? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#casefold?" do
@@ -264,6 +393,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_casefold
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.casefold? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#longest_match?" do
@@ -276,6 +409,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_longest_match
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.longest_match? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#log_errors?" do
@@ -288,6 +425,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to_not be_log_errors
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.log_errors? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#perl_classes?" do
@@ -300,6 +441,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_perl_classes
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.perl_classes? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#word_boundary?" do
@@ -312,6 +457,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_word_boundary
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.word_boundary? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#one_line?" do
@@ -324,6 +473,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_one_line
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.one_line? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#max_mem" do
@@ -336,6 +489,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re.max_mem).to eq(1024)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.max_mem }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#match" do
@@ -457,6 +614,24 @@ RSpec.describe RE2::Regexp do
       expect { re.match("one two three", endpos: 3) }.to raise_error(RE2::Regexp::UnsupportedError)
     end
 
+    it "does not truncate startpos to 32 bits" do
+      skip "Underlying RE2::Match does not have endpos argument" unless RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect(re.match("one two three", startpos: 2_147_483_648, endpos: 2_147_483_649)).to be_nil
+    end
+
+    it "does not truncate endpos to 32 bits" do
+      skip "Underlying RE2::Match does not have endpos argument" unless RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect(re.match("one two three", endpos: 2_147_483_648)).to be_nil
+    end
+
     it "does not anchor matches by default when extracting submatches" do
       re = RE2::Regexp.new('(two)')
 
@@ -564,6 +739,12 @@ RSpec.describe RE2::Regexp do
       expect { re.match("one two three", submatches: :invalid) }.to raise_error(TypeError)
     end
 
+    it "raises an exception when given too large a number of submatches" do
+      re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
+
+      expect { re.match("one two three", submatches: INT_MAX) }.to raise_error(RangeError, "number of matches should be < #{INT_MAX}")
+    end
+
     it "defaults to extracting all submatches when given nil", :aggregate_failures do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
       md = re.match("one two three", submatches: nil)
@@ -582,6 +763,12 @@ RSpec.describe RE2::Regexp do
       expect(md[3]).to be_nil
     end
 
+    it "raises an exception if given too large a number of submatches instead of options" do
+      re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
+
+      expect { re.match("one two three", INT_MAX) }.to raise_error(RangeError, "number of matches should be < #{INT_MAX}")
+    end
+
     it "raises an exception when given invalid options" do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
 
@@ -593,6 +780,29 @@ RSpec.describe RE2::Regexp do
 
       expect(re.match("one two three", nil)).to be_a(RE2::MatchData)
     end
+
+    it "raises an error when startpos exceeds INT_MAX on old RE2 ABI" do
+      skip "Underlying RE2::Match does not take int startpos" if RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect { re.match("test", start_pos: 2_147_483_648) }.to raise_error(RangeError, /startpos should be <=/)
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.match("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { re.match("one two").values_at(1, 2) }
+      end
+
+      expect(threads.map(&:value)).to all(eq(["one", "two"]))
+    end
   end
 
   describe "#match?" do
@@ -614,6 +824,20 @@ RSpec.describe RE2::Regexp do
 
       expect { re.match?(0) }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { re.match?("one two") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#partial_match?" do
@@ -642,6 +866,20 @@ RSpec.describe RE2::Regexp do
 
       expect { re.partial_match?(0) }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.partial_match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\d+)')
+
+      threads = 10.times.map do
+        Thread.new { re.partial_match?("alice 123") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#=~" do
@@ -670,6 +908,10 @@ RSpec.describe RE2::Regexp do
 
       expect { re =~ 0 }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate =~ "test" }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#===" do
@@ -691,6 +933,10 @@ RSpec.describe RE2::Regexp do
 
       expect { re === 0 }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate === "test" }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#full_match?" do
@@ -719,6 +965,20 @@ RSpec.describe RE2::Regexp do
 
       expect { re.full_match?(0) }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.full_match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+) (\d+)')
+
+      threads = 10.times.map do
+        Thread.new { re.full_match?("alice 123") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#ok?" do
@@ -733,6 +993,10 @@ RSpec.describe RE2::Regexp do
       expect(RE2::Regexp.new('wo[o', log_errors: false)).to_not be_ok
       expect(RE2::Regexp.new('*', log_errors: false)).to_not be_ok
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.ok? }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe ".escape" do
@@ -757,6 +1021,10 @@ RSpec.describe RE2::Regexp do
     it "returns -1 for an invalid pattern" do
       expect(RE2::Regexp.new('???', log_errors: false).number_of_capturing_groups).to eq(-1)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.number_of_capturing_groups }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#named_capturing_groups" do
@@ -779,6 +1047,68 @@ RSpec.describe RE2::Regexp do
     it "returns an empty hash for an invalid regexp" do
       expect(RE2::Regexp.new('???', log_errors: false).named_capturing_groups).to be_empty
     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
+  end
+
+  describe "#names" do
+    it "returns an array of names of named capturing groups" do
+      expect(RE2::Regexp.new('(?P<bob>a)(?P<rob>b)').names).to eq(["bob", "rob"])
+    end
+
+    it "returns an empty array if there are no named capturing groups" do
+      expect(RE2::Regexp.new('(a)(b)').names).to be_empty
+    end
+
+    it "returns an empty array for a pattern with no capturing groups" do
+      expect(RE2::Regexp.new('ab').names).to be_empty
+    end
+
+    it "returns an empty array for an invalid regexp" do
+      expect(RE2::Regexp.new('???', log_errors: false).names).to be_empty
+    end
+
+    it "returns UTF-8 strings if the pattern is UTF-8" do
+      names = RE2::Regexp.new('(?P<bob>a)').names
+
+      expect(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
+
+      expect(names.first.encoding).to eq(Encoding::ISO_8859_1)
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.names }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
+  end
+
+  describe "#named_captures" do
+    it "returns a hash of names to indices" do
+      expect(RE2::Regexp.new('(?P<bob>a)').named_captures).to eq("bob" => 1)
+    end
+
+    it "maps names to indices with several groups" do
+      groups = RE2::Regexp.new('(?P<bob>a)(o)(?P<rob>e)').named_captures
+
+      expect(groups).to eq("bob" => 1, "rob" => 3)
+    end
+
+    it "returns an empty hash for a pattern with no named groups" do
+      expect(RE2::Regexp.new('(a)(b)').named_captures).to be_empty
+    end
+
+    it "returns an empty hash for an invalid regexp" do
+      expect(RE2::Regexp.new('???', log_errors: false).named_captures).to be_empty
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.named_captures }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#scan" do
@@ -794,6 +1124,10 @@ RSpec.describe RE2::Regexp do
 
       expect { r.scan(nil) }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.scan("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#partial_match" do
@@ -849,6 +1183,10 @@ RSpec.describe RE2::Regexp do
 
       expect(r.partial_match('ruby:1234', anchor: :anchor_both)).to be_a(RE2::MatchData)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.partial_match('test') }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 
   describe "#full_match" do
@@ -905,5 +1243,9 @@ RSpec.describe RE2::Regexp do
 
       expect(r.full_match('ruby:1234', anchor: :unanchored)).to be_nil
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.full_match('test') }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
+    end
   end
 end