re2 2.26.2 → 2.28.0

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.26.2"
+  VERSION = "2.28.0"
 end

data/re2.gemspec

@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
     "spec/re2/scanner_spec.rb"
   ]
   s.add_development_dependency("rake-compiler", "~> 1.3.1")
-  s.add_development_dependency("rake-compiler-dock", "~> 1.11.0")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.12.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.9") # keep version in sync with extconf.rb
 end

data/spec/re2/match_data_spec.rb

@@ -59,6 +59,15 @@ RSpec.describe RE2::MatchData do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      md = RE2::Regexp.new('(\d+)').match("123")
+      md.send(:initialize_copy, md)
+
+      expect(md.to_a).to eq(["123", "123"])
+    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
@@ -154,6 +163,24 @@ RSpec.describe RE2::MatchData do
       expect(md[:numbers]).to eq("123")
     end
 
+    it "allows access using a UTF-8 name and a UTF-8 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md[:café]).to eq("123")
+    end
+
+    it "allows access using a Latin-1 name and a Latin-1 pattern" do
+      re = RE2::Regexp.new('(?P<café>\d+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('bob 123')
+
+      expect(md["café".encode("ISO-8859-1")]).to eq("123")
+    end
+
     it "allows access by names and indices with mixed groups", :aggregate_failures do
       md = RE2::Regexp.new('(?P<name>\w+)(\s*)(?P<numbers>\d+)').match("bob 123")
 
@@ -199,6 +226,12 @@ RSpec.describe RE2::MatchData do
       expect(md[:name].encoding.name).to eq("ISO-8859-1")
     end
 
+    it "handles null bytes in symbol names" do
+      md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
+
+      expect(md[:"name\0b"]).to be_nil
+    end
+
     it "supports GC compaction" do
       md = RE2::Regexp.new('(wo{2})').match('woohoo' * 5)
       GC.compact
@@ -358,6 +391,24 @@ RSpec.describe RE2::MatchData do
       expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
     end
 
+    it "returns the offset of the start of a match by non-ASCII symbol name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin(:café)..-1]).to eq('foobar')
+    end
+
+    it "returns the offset of the start of a match by Latin-1 string name" do
+      re = RE2::Regexp.new('(?P<café>fo{2})'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('a foobar')
+
+      expect(md.string[md.begin("café".encode("ISO-8859-1"))..-1]).to eq('foobar')
+    end
+
     it "returns the offset of the start of a match by something that can be coerced to a String" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
 
@@ -822,12 +873,33 @@ RSpec.describe RE2::MatchData do
       expect(md.named_captures).to eq("empty" => "", "word" => "bob")
     end
 
+    it "returns UTF-8 names even for Latin-1 patterns" do
+      md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
+      key = md.named_captures.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    end
+
     it "returns symbol keys when symbolize_names: true" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
       expect(md.named_captures(symbolize_names: true)).to eq(numbers: "123", letters: "abc")
     end
 
+    it "returns garbage-collectable symbol keys when symbolize_names: true" do
+      md = RE2::Regexp.new('(?P<collectable_named_capture>\d+)').match('123')
+      key = md.named_captures(symbolize_names: true).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "correctly encodes non-ASCII capturing group names as symbols" do
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      expect(re.match('123').named_captures(symbolize_names: true)).to eq(café: "123")
+    end
+
     it "returns string keys when symbolize_names: false" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 
@@ -858,10 +930,10 @@ RSpec.describe RE2::MatchData do
       expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
-    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
       md = RE2::Regexp.new('(?P<numbers>\d+)', utf8: false).match('123')
 
-      expect(md.names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(md.names.first.encoding).to eq(Encoding::UTF_8)
     end
 
     it "raises an error when called on an uninitialized object" do
@@ -876,6 +948,22 @@ RSpec.describe RE2::MatchData do
       expect(md.deconstruct_keys(nil)).to eq(numbers: '123', letters: 'abc')
     end
 
+    it "returns garbage-collectable symbol keys if given nil" do
+      md = RE2::Regexp.new('(?P<collectable_deconstructed_key>\d+)').match('123')
+      key = md.deconstruct_keys(nil).keys.first
+
+      expect(ObjectSpace.each_object(Symbol)).to include(key)
+    end
+
+    it "returns UTF-8 named captures for a Latin-1 pattern if given nil" do
+      re = RE2::Regexp.new('(?P<café>\d+) (?P<letters>[a-zA-Z]+)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
+
+      md = re.match('123 abc')
+
+      expect(md.deconstruct_keys(nil)).to eq(café: '123', letters: 'abc')
+    end
+
     it "returns only named captures if given names" do
       md = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
 

data/spec/re2/regexp_spec.rb

@@ -39,6 +39,23 @@ 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
+
+    it "cannot be re-initialized while parsing options" do
+      re = described_class.allocate
+      options = Hash.new { |_, key| re.send(:initialize, 'bar') if key == :utf8 }
+
+      expect { re.send(:initialize, 'woo', options) }.to raise_error(FrozenError)
+    end
   end
 
   describe "#dup" do
@@ -70,6 +87,13 @@ RSpec.describe RE2::Regexp do
       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
@@ -83,6 +107,13 @@ RSpec.describe RE2::Regexp do
       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
@@ -769,6 +800,16 @@ RSpec.describe RE2::Regexp do
     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
@@ -794,6 +835,16 @@ RSpec.describe RE2::Regexp do
     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
@@ -826,6 +877,16 @@ RSpec.describe RE2::Regexp do
     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
@@ -915,6 +976,16 @@ RSpec.describe RE2::Regexp do
     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
@@ -984,6 +1055,13 @@ RSpec.describe RE2::Regexp do
       expect(RE2::Regexp.new('???', log_errors: false).named_capturing_groups).to be_empty
     end
 
+    it "returns names as UTF-8 even if the pattern is Latin-1" do
+      groups = RE2::Regexp.new('(?P<bob>a)', utf8: false).named_capturing_groups
+      key = groups.keys.first
+
+      expect(key.encoding).to eq(Encoding::UTF_8)
+    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
@@ -1007,15 +1085,17 @@ RSpec.describe RE2::Regexp do
     end
 
     it "returns UTF-8 strings if the pattern is UTF-8" do
-      names = RE2::Regexp.new('(?P<bob>a)').names
+      re = RE2::Regexp.new('(?P<café>\d+)', log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
 
-      expect(names.first.encoding).to eq(Encoding::UTF_8)
+      expect(re.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
+    it "returns UTF-8 strings if the pattern is not UTF-8" do
+      re = RE2::Regexp.new('(?P<café>a)'.encode("ISO-8859-1"), utf8: false, log_errors: false)
+      skip "Underlying RE2 does not support non-ASCII capturing group names" unless re.ok?
 
-      expect(names.first.encoding).to eq(Encoding::ISO_8859_1)
+      expect(re.names).to contain_exactly("café")
     end
 
     it "raises an error when called on an uninitialized object" do

data/spec/re2/scanner_spec.rb

@@ -106,6 +106,15 @@ RSpec.describe RE2::Scanner do
     end
   end
 
+  describe "#initialize_copy" do
+    it "is a no-op when the source is the same object" do
+      scanner = RE2::Regexp.new('(\w+)').scan("foo bar")
+      scanner.send(:initialize_copy, scanner)
+
+      expect(scanner.scan).to eq(["foo"])
+    end
+  end
+
   describe "#scan" do
     it "returns the next array of matches", :aggregate_failures do
       r = RE2::Regexp.new('(\w+)')

data/spec/re2/set_spec.rb

@@ -49,6 +49,13 @@ RSpec.describe RE2::Set do
         "anchor should be one of: :unanchored, :anchor_start, :anchor_both"
       )
     end
+
+    it "cannot be re-initialized before compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+
+      expect { set.send(:initialize) }.to raise_error(TypeError, /already initialized RE2::Set/)
+    end
   end
 
   describe "#dup" do
@@ -84,14 +91,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
@@ -121,6 +126,29 @@ 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
@@ -191,6 +219,30 @@ RSpec.describe RE2::Set do
       end
     end
 
+    it "raises an error if called after a failed #compile" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect { set.match("abc") }.to raise_error(RE2::Set::MatchError, "#match must not be called before #compile")
+      end
+    end
+
+    it "returns an empty array if called after a failed #compile when :exception is false" do
+      set = RE2::Set.new(:unanchored, max_mem: 1, log_errors: false)
+      set.add("a{1000}b{1000}c{1000}")
+
+      silence_stderr do
+        set.compile
+
+        expect(set.match("abc", exception: false)).to be_empty
+      end
+    end
+
     it "raises an error if :exception is true and RE2 does not support it" do
       skip "Underlying RE2::Set::Match outputs error information" if RE2::Set.match_raises_errors?
 
@@ -226,6 +278,20 @@ RSpec.describe RE2::Set do
     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

data/spec/re2_spec.rb

@@ -93,6 +93,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.replace("woo", "oo", 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.replace("one two", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)\s(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.replace("one two", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one"))
+    end
   end
 
   describe ".Replace" do
@@ -193,6 +213,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.global_replace("woo", "o", 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.global_replace("one two three four", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one four three"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)\s(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.global_replace("one two three four", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one four three"))
+    end
   end
 
   describe ".GlobalReplace" do
@@ -281,6 +321,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a rewrite that can't be converted to String" do
       expect { RE2.extract("woo", '(\w+)', 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)@(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.extract("alice@example", re, '\2-\1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("example-alice"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)@(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.extract("alice@example", re, '\2-\1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("example-alice"))
+    end
   end
 
   describe "#escape" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.26.2
+  version: 2.28.0
 platform: ruby
 authors:
 - Paul Mucur
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby bindings to RE2.
 test_files: