re2 2.23.0-aarch64-linux-gnu → 2.25.0-aarch64-linux-gnu

data/spec/re2/regexp_spec.rb

@@ -41,6 +41,53 @@ RSpec.describe RE2::Regexp do
     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 "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 "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
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.compile('woo')
@@ -102,6 +149,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
@@ -117,6 +168,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
@@ -131,6 +186,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
@@ -145,6 +204,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
@@ -159,6 +222,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
@@ -173,6 +240,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
@@ -187,6 +258,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
@@ -199,6 +274,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
@@ -211,6 +290,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
@@ -223,6 +306,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
@@ -235,6 +322,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
@@ -246,6 +337,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
@@ -258,6 +353,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
@@ -270,6 +369,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
@@ -282,6 +385,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
@@ -294,6 +401,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
@@ -306,6 +417,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
@@ -318,6 +433,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
@@ -330,6 +449,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
@@ -342,6 +465,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
@@ -596,7 +723,6 @@ RSpec.describe RE2::Regexp do
 
     it "raises an exception if given too large a number of submatches instead of options" do
       re = RE2::Regexp.new('(\w+) (\w+) (\w+)')
-      md = re.match("one two three", 2)
 
       expect { re.match("one two three", INT_MAX) }.to raise_error(RangeError, "number of matches should be < #{INT_MAX}")
     end
@@ -612,6 +738,10 @@ RSpec.describe RE2::Regexp do
 
       expect(re.match("one two three", nil)).to be_a(RE2::MatchData)
     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
   end
 
   describe "#match?" do
@@ -633,6 +763,10 @@ 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
   end
 
   describe "#partial_match?" do
@@ -661,6 +795,10 @@ 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
   end
 
   describe "#=~" do
@@ -689,6 +827,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
@@ -710,6 +852,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
@@ -738,6 +884,10 @@ 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
   end
 
   describe "#ok?" do
@@ -752,6 +902,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
@@ -776,6 +930,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
@@ -798,6 +956,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
@@ -813,6 +1033,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
@@ -868,6 +1092,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
@@ -924,5 +1152,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

data/spec/re2/scanner_spec.rb

@@ -8,6 +8,56 @@ RSpec.describe RE2::Scanner do
 
       expect(scanner.regexp).to equal(re)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.regexp }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
+  end
+
+  describe "#dup" do
+    it "returns a usable copy of the scanner at the same position" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar baz")
+      scanner.scan
+
+      copy = scanner.dup
+
+      expect(copy.scan).to eq(["bar"])
+    end
+
+    it "creates an independent copy" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar baz")
+      scanner.scan
+
+      copy = scanner.dup
+      copy.scan
+
+      expect(scanner.scan).to eq(["bar"])
+    end
+
+    it "copies the EOF state of the scanner" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo")
+      scanner.scan
+      scanner.scan
+
+      copy = scanner.dup
+
+      expect(copy).to be_eof
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.dup }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
+  end
+
+  describe "#clone" do
+    it "returns a usable copy of the scanner at the same position" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar baz")
+      scanner.scan
+
+      copy = scanner.clone
+
+      expect(copy.scan).to eq(["bar"])
+    end
   end
 
   describe "#string" do
@@ -50,6 +100,10 @@ RSpec.describe RE2::Scanner do
 
       expect(scanner.string).to equal(text)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.string }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
   end
 
   describe "#scan" do
@@ -211,6 +265,10 @@ RSpec.describe RE2::Scanner do
 
       expect(scanner.scan).to eq(["It"])
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.scan }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
   end
 
   it "is enumerable" do
@@ -272,6 +330,10 @@ RSpec.describe RE2::Scanner do
 
       expect(scanner).not_to be_eof
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.rewind }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
   end
 
   describe "#eof?" do
@@ -320,5 +382,9 @@ RSpec.describe RE2::Scanner do
 
       expect(scanner).to be_eof
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.eof? }.to raise_error(TypeError, /uninitialized RE2::Scanner/)
+    end
   end
 end

data/spec/re2/set_spec.rb

@@ -51,6 +51,18 @@ RSpec.describe RE2::Set do
     end
   end
 
+  describe "#dup" do
+    it "raises a TypeError" do
+      expect { described_class.new.dup }.to raise_error(TypeError, /cannot copy RE2::Set/)
+    end
+  end
+
+  describe "#clone" do
+    it "raises a TypeError" do
+      expect { described_class.new.clone }.to raise_error(TypeError, /cannot copy RE2::Set/)
+    end
+  end
+
   describe "#add" do
     it "allows multiple patterns to be added", :aggregate_failures do
       set = RE2::Set.new
@@ -93,6 +105,10 @@ RSpec.describe RE2::Set do
 
       expect(set.add(StringLike.new("abc"))).to eq(0)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.add("foo") }.to raise_error(TypeError, /uninitialized RE2::Set/)
+    end
   end
 
   describe "#compile" do
@@ -104,6 +120,10 @@ RSpec.describe RE2::Set do
 
       expect(set.compile).to be_truthy
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.compile }.to raise_error(TypeError, /uninitialized RE2::Set/)
+    end
   end
 
   describe "#match" do
@@ -202,6 +222,10 @@ RSpec.describe RE2::Set do
 
       expect(set.match(StringLike.new("abcdef"), exception: false)).to contain_exactly(0)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.match("foo") }.to raise_error(TypeError, /uninitialized RE2::Set/)
+    end
   end
 
   describe "#size" do
@@ -228,6 +252,12 @@ RSpec.describe RE2::Set do
 
       expect { set.size }.to raise_error(RE2::Set::UnsupportedError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      expect { described_class.allocate.size }.to raise_error(TypeError, /uninitialized RE2::Set/)
+    end
   end
 
   describe "#length" do
@@ -246,6 +276,12 @@ RSpec.describe RE2::Set do
 
       expect(set.length).to eq(2)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      expect { described_class.allocate.length }.to raise_error(TypeError, /uninitialized RE2::Set/)
+    end
   end
 
   def silence_stderr