re2 2.23.0-arm-linux-gnu → 2.24.0-arm-linux-gnu

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.23.0"
+  VERSION = "2.24.0"
 end

data/spec/re2/match_data_spec.rb

@@ -10,6 +10,55 @@ RSpec.describe RE2::MatchData do
     expect(ObjectSpace.memsize_of(matches1)).to be < ObjectSpace.memsize_of(matches2)
   end
 
+  describe "#dup" do
+    it "returns a copy of the match data" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("123 456")
+      copy = md.dup
+
+      expect(copy.to_a).to eq(["123 456", "123", "456"])
+    end
+
+    it "returns a different object" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("123 456")
+      copy = md.dup
+
+      expect(copy).to_not equal(md)
+    end
+
+    it "preserves the original string" do
+      str = "bob 123"
+      md = RE2::Regexp.new('(\d+)').match(str)
+      copy = md.dup
+
+      expect(copy.string).to equal(str)
+    end
+
+    it "preserves the original regexp" do
+      re = RE2::Regexp.new('(\d+)')
+      md = re.match("123")
+      copy = md.dup
+
+      expect(copy.regexp).to equal(re)
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.dup }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
+  end
+
+  describe "#clone" do
+    it "returns a copy of the match data" do
+      md = RE2::Regexp.new('(\d+) (\d+)').match("123 456")
+      copy = md.clone
+
+      expect(copy.to_a).to eq(["123 456", "123", "456"])
+    end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.clone }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    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
@@ -34,6 +83,10 @@ RSpec.describe RE2::MatchData do
 
       expect(a.map(&:encoding)).to all eq(Encoding::ISO_8859_1)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.to_a }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#[]" do
@@ -140,6 +193,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md[1]).to eq("woo")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate[0] }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#string" do
@@ -168,6 +225,10 @@ RSpec.describe RE2::MatchData do
 
       expect(re.string).to equal(string)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.string }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#size" do
@@ -176,6 +237,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.size).to eq(3)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.size }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#length" do
@@ -184,6 +249,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.length).to eq(3)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.length }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#regexp" do
@@ -193,6 +262,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.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::MatchData/)
+    end
   end
 
   describe "#inspect" do
@@ -213,6 +286,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.inspect).to eq("#<RE2::MatchData \"a\0b c\0d\" 1:\"a\0b\" 2:\"c\0d\">")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.inspect }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#to_s" do
@@ -221,6 +298,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.to_s).to eq("23456")
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.to_s }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#to_ary" do
@@ -301,6 +382,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.string[md.begin(0)..-1]).to eq('woohoo' * 5)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.begin(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#end" do
@@ -370,6 +455,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.string[0...md.end(0)]).to eq('woo')
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.end(0) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#deconstruct" do
@@ -384,6 +473,10 @@ RSpec.describe RE2::MatchData do
 
       expect(md.deconstruct).to eq(['o', 'o', nil])
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.deconstruct }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 
   describe "#deconstruct_keys" do
@@ -428,5 +521,9 @@ RSpec.describe RE2::MatchData do
 
       expect { md.deconstruct_keys([0]) }.to raise_error(TypeError)
     end
+
+    it "raises an error when called on an uninitialized object" do
+      expect { described_class.allocate.deconstruct_keys(nil) }.to raise_error(TypeError, /uninitialized RE2::MatchData/)
+    end
   end
 end

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
@@ -612,6 +739,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 +764,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 +796,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 +828,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 +853,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 +885,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 +903,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 +931,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 +957,10 @@ 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 "#scan" do
@@ -813,6 +976,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 +1035,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 +1095,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