re2 2.0.0.beta2-aarch64-linux → 2.1.0-aarch64-linux

data/re2.gemspec

@@ -2,8 +2,8 @@ require_relative 'lib/re2/version'
 
 Gem::Specification.new do |s|
   s.name = "re2"
-  s.summary = "Ruby bindings to re2."
-  s.description = 'Ruby bindings to re2, "an efficient, principled regular expression library".'
+  s.summary = "Ruby bindings to RE2."
+  s.description = 'Ruby bindings to RE2, "a fast, safe, thread-friendly alternative to backtracking regular expression engines like those used in PCRE, Perl, and Python".'
   s.version = RE2::VERSION
   s.authors = ["Paul Mucur", "Stan Hu"]
   s.homepage = "https://github.com/mudge/re2"
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     "lib/re2/string.rb",
     "lib/re2/version.rb",
     "LICENSE.txt",
+    "LICENSE-DEPENDENCIES.txt",
     "README.md",
     "Rakefile",
     "re2.gemspec"
@@ -36,8 +37,8 @@ Gem::Specification.new do |s|
     "spec/re2/set_spec.rb",
     "spec/re2/scanner_spec.rb"
   ]
-  s.add_development_dependency "rake-compiler", "~> 1.2.1"
-  s.add_development_dependency "rake-compiler-dock", "~> 1.3.0"
+  s.add_development_dependency("rake-compiler", "~> 1.2.1")
+  s.add_development_dependency("rake-compiler-dock", "~> 1.3.0")
   s.add_development_dependency("rspec", "~> 3.2")
   s.add_runtime_dependency("mini_portile2", "~> 2.8.4") # keep version in sync with extconf.rb
 end

data/spec/kernel_spec.rb

@@ -1,13 +1,13 @@
 RSpec.describe Kernel do
-  describe "#RE2" do
+  describe ".RE2" do
     it "returns an RE2::Regexp instance given a pattern" do
       expect(RE2('w(o)(o)')).to be_a(RE2::Regexp)
     end
 
     it "returns an RE2::Regexp instance given a pattern and options" do
       re = RE2('w(o)(o)', :case_sensitive => false)
-      expect(re).to be_a(RE2::Regexp)
-      expect(re).to_not be_case_sensitive
+
+      expect(re).not_to be_case_sensitive
     end
   end
 end

data/spec/re2/match_data_spec.rb

@@ -10,6 +10,18 @@ RSpec.describe RE2::MatchData do
       a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
       expect(a).to eq(["ab", nil, "a", "b"])
     end
+
+    it "returns UTF-8 strings if the pattern is UTF-8" do
+      a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
+
+      expect(a.map(&:encoding)).to all eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 strings if the pattern is not UTF-8" do
+      a = RE2::Regexp.new('w(o)(o)', :utf8 => false).match('woo').to_a
+
+      expect(a.map(&:encoding)).to all eq(Encoding::ISO_8859_1)
+    end
   end
 
   describe "#[]" do
@@ -19,6 +31,18 @@ RSpec.describe RE2::MatchData do
       expect(md[2]).to eq("23")
     end
 
+    it "returns a UTF-8 string by numerical index if the pattern is UTF-8" do
+      md = RE2::Regexp.new('(\d)(\d{2})').match("123")
+
+      expect(md[1].encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns a ISO-8859-1 string by numerical index if the pattern is not UTF-8" do
+      md = RE2::Regexp.new('(\d)(\d{2})', :utf8 => false).match("123")
+
+      expect(md[1].encoding).to eq(Encoding::ISO_8859_1)
+    end
+
     it "has the whole match as the 0th item" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
       expect(md[0]).to eq("123")

data/spec/re2/regexp_spec.rb

@@ -287,6 +287,12 @@ RSpec.describe RE2::Regexp do
       expect(re.match("My age is 99", 0)).to eq(false)
     end
 
+    it "returns only true or false if the pattern has no capturing groups" do
+      re = RE2::Regexp.new('My name is')
+
+      expect(re.match('My name is Robert Paulson')).to eq(true)
+    end
+
     it "raises an exception when given nil" do
       expect { re.match(nil) }.to raise_error(TypeError)
     end

data/spec/re2/scanner_spec.rb

@@ -21,9 +21,10 @@ RSpec.describe RE2::Scanner do
   end
 
   describe "#scan" do
-    it "returns the next array of matches" do
+    it "returns the next array of matches", :aggregate_failures do
       r = RE2::Regexp.new('(\w+)')
       scanner = r.scan("It is a truth universally acknowledged")
+
       expect(scanner.scan).to eq(["It"])
       expect(scanner.scan).to eq(["is"])
       expect(scanner.scan).to eq(["a"])
@@ -33,41 +34,73 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
+    it "returns UTF-8 matches if the pattern is UTF-8" do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan("It")
+      matches = scanner.scan
+
+      expect(matches.first.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns ISO-8859-1 matches if the pattern is not UTF-8" do
+      r = RE2::Regexp.new('(\w+)', :utf8 => false)
+      scanner = r.scan("It")
+      matches = scanner.scan
+
+      expect(matches.first.encoding).to eq(Encoding::ISO_8859_1)
+    end
+
+    it "returns multiple capturing groups at a time", :aggregate_failures do
+      r = RE2::Regexp.new('(\w+) (\w+)')
+      scanner = r.scan("It is a truth universally acknowledged")
+
+      expect(scanner.scan).to eq(["It", "is"])
+      expect(scanner.scan).to eq(["a", "truth"])
+      expect(scanner.scan).to eq(["universally", "acknowledged"])
+      expect(scanner.scan).to be_nil
+    end
+
     it "returns an empty array if there are no capturing groups" do
       r = RE2::Regexp.new('\w+')
       scanner = r.scan("Foo bar")
+
       expect(scanner.scan).to eq([])
     end
 
     it "returns nil if there is no match" do
       r = RE2::Regexp.new('\d+')
       scanner = r.scan("Foo bar")
+
       expect(scanner.scan).to be_nil
     end
 
     it "returns nil if the regexp is invalid" do
       r = RE2::Regexp.new('???', :log_errors => false)
       scanner = r.scan("Foo bar")
+
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an empty array if the input is empty" do
+    it "returns an empty array if the input is empty", :aggregate_failures do
       r = RE2::Regexp.new("")
       scanner = r.scan("")
+
       expect(scanner.scan).to eq([])
       expect(scanner.scan).to be_nil
     end
 
-    it "returns an array of nil with an empty input and capture" do
+    it "returns an array of nil 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 be_nil
     end
 
-    it "returns an empty array for every match if the pattern is empty" do
+    it "returns an empty array for every match if the pattern is empty", :aggregate_failures do
       r = RE2::Regexp.new("")
       scanner = r.scan("Foo")
+
       expect(scanner.scan).to eq([])
       expect(scanner.scan).to eq([])
       expect(scanner.scan).to eq([])
@@ -75,9 +108,10 @@ 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" do
+    it "returns an array of nil 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])
@@ -85,9 +119,10 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "returns array of nils with multiple empty capturing groups" do
+    it "returns array of nils 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])
@@ -95,17 +130,34 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
-    it "supports empty groups with multibyte characters" do
+    it "supports empty groups with multibyte characters", :aggregate_failures do
       r = RE2::Regexp.new("()€")
       scanner = r.scan("€")
+
       expect(scanner.scan).to eq([nil])
       expect(scanner.scan).to be_nil
     end
+
+    it "raises a Type Error if given input that can't be coerced to a String" do
+      r = RE2::Regexp.new('(\w+)')
+
+      expect { r.scan(0) }.to raise_error(TypeError)
+    end
+
+    it "accepts input that can be coerced to a String", :aggregate_failures do
+      r = RE2::Regexp.new('(\w+)')
+      scanner = r.scan(StringLike.new("Hello world"))
+
+      expect(scanner.scan).to eq(["Hello"])
+      expect(scanner.scan).to eq(["world"])
+      expect(scanner.scan).to be_nil
+    end
   end
 
   it "is enumerable" do
     r = RE2::Regexp.new('(\d)')
     scanner = r.scan("There are 1 some 2 numbers 3")
+
     expect(scanner).to be_a(Enumerable)
   end
 
@@ -113,12 +165,8 @@ RSpec.describe RE2::Scanner do
     it "yields each match" do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("There are 1 some 2 numbers 3")
-      matches = []
-      scanner.each do |match|
-        matches << match
-      end
 
-      expect(matches).to eq([["1"], ["2"], ["3"]])
+      expect { |b| scanner.each(&b) }.to yield_successive_args(["1"], ["2"], ["3"])
     end
 
     it "returns an enumerator when not given a block" do
@@ -135,22 +183,28 @@ RSpec.describe RE2::Scanner do
   end
 
   describe "#rewind" do
-    it "resets any consumption" do
+    it "resets any consumption", :aggregate_failures do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("There are 1 some 2 numbers 3")
+
       expect(scanner.to_enum.first).to eq(["1"])
       expect(scanner.to_enum.first).to eq(["2"])
+
       scanner.rewind
+
       expect(scanner.to_enum.first).to eq(["1"])
     end
 
-    it "resets the eof? check" do
+    it "resets the eof? check", :aggregate_failures do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("1")
       scanner.scan
-      expect(scanner.eof?).to be_truthy
+
+      expect(scanner).to be_eof
+
       scanner.rewind
-      expect(scanner.eof?).to be_falsey
+
+      expect(scanner).not_to be_eof
     end
   end
 
@@ -159,7 +213,7 @@ RSpec.describe RE2::Scanner do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("1 2 3")
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns true if the input has been consumed" do
@@ -167,7 +221,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("1")
       scanner.scan
 
-      expect(scanner.eof?).to be_truthy
+      expect(scanner).to be_eof
     end
 
     it "returns false if no match is made" do
@@ -175,14 +229,14 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("a")
       scanner.scan
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns false with an empty input that has not been scanned" do
       r = RE2::Regexp.new("")
       scanner = r.scan("")
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns false with an empty input that has not been matched" do
@@ -190,7 +244,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("")
       scanner.scan
 
-      expect(scanner.eof?).to be_falsey
+      expect(scanner).not_to be_eof
     end
 
     it "returns true with an empty input that has been matched" do
@@ -198,7 +252,7 @@ RSpec.describe RE2::Scanner do
       scanner = r.scan("")
       scanner.scan
 
-      expect(scanner.eof?).to be_truthy
+      expect(scanner).to be_eof
     end
   end
 end

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.1.0
 platform: aarch64-linux
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-10 00:00:00.000000000 Z
+date: 2023-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -53,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: []
@@ -61,6 +62,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - Gemfile
+- LICENSE-DEPENDENCIES.txt
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -104,14 +106,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
       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