re2 2.23.0 → 2.27.0

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
@@ -131,11 +185,11 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil with an empty input and capture", :aggregate_failures do
+    it "returns an array of empty strings with an empty input and capture", :aggregate_failures do
       r = RE2::Regexp.new("()")
       scanner = r.scan("")
 
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
       expect(scanner.scan).to be_nil
     end
 
@@ -150,25 +204,34 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil if the pattern is an empty capturing group", :aggregate_failures do
+    it "returns an array of empty strings if the pattern is an empty capturing group", :aggregate_failures do
       r = RE2::Regexp.new("()")
       scanner = r.scan("Foo")
 
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to eq([""])
       expect(scanner.scan).to be_nil
     end
 
-    it "returns array of nils with multiple empty capturing groups", :aggregate_failures do
+    it "returns array of empty strings with multiple empty capturing groups", :aggregate_failures do
       r = RE2::Regexp.new("()()()")
       scanner = r.scan("Foo")
 
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
-      expect(scanner.scan).to eq([nil, nil, nil])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to eq(["", "", ""])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "distinguishes zero-length matches from unmatched groups", :aggregate_failures do
+      r = RE2::Regexp.new("()(a)?")
+      scanner = r.scan("b")
+
+      expect(scanner.scan).to eq(["", nil])
+      expect(scanner.scan).to eq(["", nil])
       expect(scanner.scan).to be_nil
     end
 
@@ -176,7 +239,53 @@ RSpec.describe RE2::Scanner do
       r = RE2::Regexp.new("()€")
       scanner = r.scan("€")
 
-      expect(scanner.scan).to eq([nil])
+      expect(scanner.scan).to eq([""])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 2-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("à")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 3-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u20AC")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 4-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u{1F600}")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by single bytes with zero-width matches on Latin-1 input", :aggregate_failures do
+      r = RE2::Regexp.new("", utf8: false)
+      scanner = r.scan("\xC3\xA0")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "handles truncated multi-byte sequences at the end of input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\xC3")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
       expect(scanner.scan).to be_nil
     end
 
@@ -211,6 +320,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 +385,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 +437,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
@@ -72,14 +84,12 @@ RSpec.describe RE2::Set do
       expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
     end
 
-    it "raises an error if called after #compile" do
+    it "raises a FrozenError if called after #compile" do
       set = RE2::Set.new(:unanchored, log_errors: false)
       set.add("abc")
       set.compile
 
-      silence_stderr do
-        expect { set.add("def") }.to raise_error(ArgumentError)
-      end
+      expect { set.add("def") }.to raise_error(FrozenError)
     end
 
     it "raises an error if given a pattern that can't be coerced to a String" do
@@ -93,6 +103,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 +118,33 @@ RSpec.describe RE2::Set do
 
       expect(set.compile).to be_truthy
     end
+
+    it "freezes the set on successful compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set).to be_frozen
+    end
+
+    it "is not frozen before compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+
+      expect(set).to_not be_frozen
+    end
+
+    it "cannot be re-initialized after compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect { set.send(:initialize) }.to raise_error(FrozenError)
+    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 +243,24 @@ 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
+
+    it "can be run concurrently" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.add("def")
+      set.add("ghi")
+      set.compile
+
+      threads = 10.times.map do
+        Thread.new { set.match("abcdefghi", exception: false) }
+      end
+
+      expect(threads.map(&:value)).to all(eq([0, 1, 2]))
+    end
   end
 
   describe "#size" do
@@ -228,6 +287,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 +311,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