re2 2.9.0 → 2.27.0

data/spec/re2/scanner_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe RE2::Scanner do
   describe "#regexp" do
@@ -8,16 +8,102 @@ 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
-    it "returns the original text for the scanner" do
+    it "returns the text for the scanner" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to eq("It is a truth")
+    end
+
+    it "returns a frozen string" do
+      re = RE2::Regexp.new('(\w+)')
+      text = "It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to be_frozen
+    end
+
+    it "freezes unfrozen strings" do
+      re = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to be_frozen
+    end
+
+    it "copies unfrozen strings" do
+      re = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth"
+      scanner = re.scan(text)
+
+      expect(scanner.string).to_not equal(text)
+    end
+
+    it "does not copy the string if it was already frozen" do
       re = RE2::Regexp.new('(\w+)')
       text = "It is a truth"
       scanner = re.scan(text)
 
       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
@@ -99,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
 
@@ -118,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
 
@@ -144,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
 
@@ -162,6 +303,27 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to eq(["world"])
       expect(scanner.scan).to be_nil
     end
+
+    it "supports GC compaction" do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("Hello world" * 2)
+      GC.compact
+
+      expect(scanner.scan).to eq(["Hello"])
+    end
+
+    it "works even if the original input is mutated" do
+      r = RE2::Regexp.new('(\w+)')
+      text = +"It is a truth universally acknowledged"
+      scanner = r.scan(text)
+      text.upcase!
+
+      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
@@ -223,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
@@ -271,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe RE2::Set do
   describe "#initialize" do
     it "returns an instance given no args" do
@@ -49,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
@@ -64,20 +78,18 @@ RSpec.describe RE2::Set do
       expect { set.add("???") }.to raise_error(ArgumentError, /str rejected by RE2::Set->Add\(\)/)
     end
 
-    it "truncates error messages to 100 characters" do
+    it "includes the full error message" do
       set = RE2::Set.new(:unanchored, log_errors: false)
 
-      expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
+      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
@@ -91,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
@@ -102,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
@@ -200,6 +243,80 @@ 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
+    it "returns the number of patterns added to the set", :aggregate_failures do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      set = RE2::Set.new
+
+      expect(set.size).to eq(0)
+
+      set.add("abc")
+
+      expect(set.size).to eq(1)
+
+      set.add("def")
+
+      expect(set.size).to eq(2)
+    end
+
+    it "raises an error if RE2 does not support Set::Size" do
+      skip "Underlying RE2::Set has a Size method" if RE2::Set.size?
+
+      set = RE2::Set.new
+
+      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
+    it "is an alias for size" do
+      skip "Underlying RE2::Set has no Size method" unless RE2::Set.size?
+
+      set = RE2::Set.new
+
+      expect(set.length).to eq(0)
+
+      set.add("abc")
+
+      expect(set.length).to eq(1)
+
+      set.add("def")
+
+      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

data/spec/re2/string_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "re2/string"
 
 class String