re2 2.0.0.beta1-arm64-darwin → 2.1.0-arm64-darwin

data/spec/re2/set_spec.rb

@@ -67,11 +67,17 @@ RSpec.describe RE2::Set do
       end
     end
 
-    it "raises an error if given a non-string pattern" do
+    it "raises an error if given a pattern that can't be coerced to a String" do
       set = RE2::Set.new(:unanchored, :log_errors => false)
 
       expect { set.add(0) }.to raise_error(TypeError)
     end
+
+    it "accepts a pattern that can be coerced to a String" do
+      set = RE2::Set.new
+
+      expect(set.add(StringLike.new("abc"))).to eq(0)
+    end
   end
 
   describe "#compile" do
@@ -96,6 +102,24 @@ RSpec.describe RE2::Set do
       expect(set.match("abcdefghi", :exception => false)).to eq([0, 1, 2])
     end
 
+    it "returns an empty array if there is no match" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match("def", :exception => false)).to be_empty
+    end
+
+    it "returns an empty array if there is no match when :exception is true" do
+      skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
+
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match("def")).to be_empty
+    end
+
     it "raises an error if called before #compile by default" do
       skip "Underlying RE2::Set::Match does not output error information" unless RE2::Set.match_raises_errors?
 
@@ -139,6 +163,22 @@ RSpec.describe RE2::Set do
 
       expect { set.match("", 0) }.to raise_error(TypeError)
     end
+
+    it "raises a Type Error if given input that can't be coerced to a String" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect { set.match(0, :exception => false) }.to raise_error(TypeError)
+    end
+
+    it "accepts input if it can be coerced to a String" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set.match(StringLike.new("abcdef"), :exception => false)).to contain_exactly(0)
+    end
   end
 
   def silence_stderr

data/spec/re2/string_spec.rb

@@ -12,7 +12,8 @@ RSpec.describe RE2::String do
 
     it "doesn't perform an in-place replacement" do
       string = "My name is Robert Paulson"
-      expect(string.re2_sub('Robert', 'Crobert')).to_not equal(string)
+
+      expect(string.re2_sub('Robert', 'Crobert')).not_to equal(string)
     end
   end
 
@@ -23,13 +24,15 @@ RSpec.describe RE2::String do
 
     it "doesn't perform an in-place replacement" do
       string = "My name is Robert Paulson"
-      expect(string.re2_gsub('a', 'e')).to_not equal(string)
+
+      expect(string.re2_gsub('a', 'e')).not_to equal(string)
     end
   end
 
   describe "#re2_match" do
-    it "delegates to RE2::Regexp#match to perform matches" do
+    it "delegates to RE2::Regexp#match to perform matches", :aggregate_failures do
       md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)')
+
       expect(md).to be_a(RE2::MatchData)
       expect(md[0]).to eq("My name is Robert Paulson")
       expect(md[1]).to eq("Robert")
@@ -38,6 +41,7 @@ RSpec.describe RE2::String do
 
     it "supports limiting the number of matches" do
       md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)', 0)
+
       expect(md).to eq(true)
     end
   end

data/spec/re2_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe RE2 do
-  describe "#Replace" do
+  describe ".Replace" do
     it "only replaces the first occurrence of the pattern" do
       expect(RE2.Replace("woo", "o", "a")).to eq("wao")
     end
@@ -15,29 +15,68 @@ RSpec.describe RE2 do
     it "does not perform replacements in-place" do
       name = "Robert"
       replacement = RE2.Replace(name, "R", "Cr")
-      expect(name).to_not equal(replacement)
+
+      expect(name).not_to equal(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
       re = RE2::Regexp.new('wo{2}')
+
       expect(RE2.Replace("woo", re, "miaow")).to eq("miaow")
     end
 
     it "respects any passed RE2::Regexp's flags" do
       re = RE2::Regexp.new('gOOD MORNING', :case_sensitive => false)
+
       expect(RE2.Replace("Good morning", re, "hi")).to eq("hi")
     end
 
-    if String.method_defined?(:encoding)
-      it "preserves the original string's encoding" do
-        original = "Foo"
-        replacement = RE2.Replace(original, "oo", "ah")
-        expect(original.encoding).to eq(replacement.encoding)
-      end
+    it "supports passing something that can be coerced to a String as input" do
+      expect(RE2.Replace(StringLike.new("woo"), "oo", "ah")).to eq("wah")
+    end
+
+    it "supports passing something that can be coerced to a String as a pattern" do
+      expect(RE2.Replace("woo", StringLike.new("oo"), "ah")).to eq("wah")
+    end
+
+    it "supports passing something that can be coerced to a String as a replacement" do
+      expect(RE2.Replace("woo", "oo", StringLike.new("ah"))).to eq("wah")
+    end
+
+    it "returns UTF-8 strings if the pattern is UTF-8" do
+      original = "Foo".encode("ISO-8859-1")
+      replacement = RE2.Replace(original, "oo", "ah")
+
+      expect(replacement.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+      original = "Foo"
+      replacement = RE2.Replace(original, RE2("oo", :utf8 => false), "ah")
+
+      expect(replacement.encoding).to eq(Encoding::ISO_8859_1)
+    end
+
+    it "returns UTF-8 strings when given a String pattern" do
+      replacement = RE2.Replace("Foo", "oo".encode("ISO-8859-1"), "ah")
+
+      expect(replacement.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "raises a Type Error for input that can't be converted to String" do
+      expect { RE2.Replace(0, "oo", "ah") }.to raise_error(TypeError)
+    end
+
+    it "raises a Type Error for a non-RE2::Regexp pattern that can't be converted to String" do
+      expect { RE2.Replace("woo", 0, "ah") }.to raise_error(TypeError)
+    end
+
+    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
   end
 
-  describe "#GlobalReplace" do
+  describe ".GlobalReplace" do
     it "replaces every occurrence of a pattern" do
       expect(RE2.GlobalReplace("woo", "o", "a")).to eq("waa")
     end
@@ -53,23 +92,78 @@ RSpec.describe RE2 do
     it "does not perform replacement in-place" do
       name = "Robert"
       replacement = RE2.GlobalReplace(name, "(?i)R", "w")
-      expect(name).to_not equal(replacement)
+
+      expect(name).not_to equal(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
       re = RE2::Regexp.new('wo{2,}')
+
       expect(RE2.GlobalReplace("woowooo", re, "miaow")).to eq("miaowmiaow")
     end
 
     it "respects any passed RE2::Regexp's flags" do
       re = RE2::Regexp.new('gOOD MORNING', :case_sensitive => false)
+
       expect(RE2.GlobalReplace("Good morning Good morning", re, "hi")).to eq("hi hi")
     end
+
+    it "supports passing something that can be coerced to a String as input" do
+      expect(RE2.GlobalReplace(StringLike.new("woo"), "o", "a")).to eq("waa")
+    end
+
+    it "supports passing something that can be coerced to a String as a pattern" do
+      expect(RE2.GlobalReplace("woo", StringLike.new("o"), "a")).to eq("waa")
+    end
+
+    it "supports passing something that can be coerced to a String as a replacement" do
+      expect(RE2.GlobalReplace("woo", "o", StringLike.new("a"))).to eq("waa")
+    end
+
+    it "returns UTF-8 strings if the pattern is UTF-8" do
+      original = "Foo".encode("ISO-8859-1")
+      replacement = RE2.GlobalReplace(original, "oo", "ah")
+
+      expect(replacement.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+      original = "Foo"
+      replacement = RE2.GlobalReplace(original, RE2("oo", :utf8 => false), "ah")
+
+      expect(replacement.encoding).to eq(Encoding::ISO_8859_1)
+    end
+
+    it "returns UTF-8 strings when given a String pattern" do
+      replacement = RE2.GlobalReplace("Foo", "oo".encode("ISO-8859-1"), "ah")
+
+      expect(replacement.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "raises a Type Error for input that can't be converted to String" do
+      expect { RE2.GlobalReplace(0, "o", "a") }.to raise_error(TypeError)
+    end
+
+    it "raises a Type Error for a non-RE2::Regexp pattern that can't be converted to String" do
+      expect { RE2.GlobalReplace("woo", 0, "a") }.to raise_error(TypeError)
+    end
+
+    it "raises a Type Error for a replacement that can't be converted to String" do
+      expect { RE2.GlobalReplace("woo", "o", 0) }.to raise_error(TypeError)
+    end
   end
 
   describe "#QuoteMeta" do
     it "escapes a string so it can be used as a regular expression" do
       expect(RE2.QuoteMeta("1.5-2.0?")).to eq('1\.5\-2\.0\?')
     end
+
+    it "raises a Type Error for input that can't be converted to String" do
+      expect { RE2.QuoteMeta(0) }.to raise_error(TypeError)
+    end
+
+    it "supports passing something that can be coerced to a String as input" do
+      expect(RE2.QuoteMeta(StringLike.new("1.5"))).to eq('1\.5')
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,15 @@
 require "re2"
 
+# To test passing objects that can be coerced to a String.
+class StringLike
+  attr_reader :str
+  alias_method :to_str, :str
+
+  def initialize(str)
+    @str = str
+  end
+end
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.1.0
 platform: arm64-darwin
 authors:
 - Paul Mucur
+- Stan Hu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2023-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -52,7 +53,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-description: Ruby bindings to re2, "an efficient, principled regular expression library".
+description: Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking
+  regular expression engines like those used in PCRE, Perl, and Python".
 email: 
 executables: []
 extensions: []
@@ -60,6 +62,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - Gemfile
+- LICENSE-DEPENDENCIES.txt
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -67,6 +70,7 @@ files:
 - ext/re2/extconf.rb
 - ext/re2/re2.cc
 - ext/re2/recipes.rb
+- lib/2.6/re2.bundle
 - lib/2.7/re2.bundle
 - lib/3.0/re2.bundle
 - lib/3.1/re2.bundle
@@ -96,20 +100,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '2.6'
   - - "<"
     - !ruby/object:Gem::Version
       version: 3.3.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
-summary: Ruby bindings to re2.
+summary: Ruby bindings to RE2.
 test_files:
 - spec/spec_helper.rb
 - spec/re2_spec.rb