re2 0.7.0 → 1.3.0

data/spec/re2/scanner_spec.rb

@@ -1,12 +1,12 @@
-require "spec_helper"
+# encoding: utf-8
 
-describe RE2::Scanner do
+RSpec.describe RE2::Scanner do
   describe "#regexp" do
     it "returns the original pattern for the scanner" do
       re = RE2::Regexp.new('(\w+)')
       scanner = re.scan("It is a truth")
 
-      scanner.regexp.must_be_same_as(re)
+      expect(scanner.regexp).to equal(re)
     end
   end
 
@@ -16,7 +16,7 @@ describe RE2::Scanner do
       text = "It is a truth"
       scanner = re.scan(text)
 
-      scanner.string.must_be_same_as(text)
+      expect(scanner.string).to equal(text)
     end
   end
 
@@ -24,32 +24,83 @@ describe RE2::Scanner do
     it "returns the next array of matches" do
       r = RE2::Regexp.new('(\w+)')
       scanner = r.scan("It is a truth universally acknowledged")
-      scanner.scan.must_equal(["It"])
-      scanner.scan.must_equal(["is"])
-      scanner.scan.must_equal(["a"])
-      scanner.scan.must_equal(["truth"])
-      scanner.scan.must_equal(["universally"])
-      scanner.scan.must_equal(["acknowledged"])
-      scanner.scan.must_be_nil
+      expect(scanner.scan).to eq(["It"])
+      expect(scanner.scan).to eq(["is"])
+      expect(scanner.scan).to eq(["a"])
+      expect(scanner.scan).to eq(["truth"])
+      expect(scanner.scan).to eq(["universally"])
+      expect(scanner.scan).to eq(["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")
-      scanner.scan.must_equal([])
+      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")
-      scanner.scan.must_be_nil
+      expect(scanner.scan).to be_nil
+    end
+
+    it "returns an empty array if the input is empty" 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
+      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
+      r = RE2::Regexp.new("")
+      scanner = r.scan("Foo")
+      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 an array of nil if the pattern is an empty capturing group" 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 be_nil
+    end
+
+    it "returns array of nils with multiple empty capturing groups" 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 be_nil
+    end
+
+    it "supports empty groups with multibyte characters" do
+      r = RE2::Regexp.new("()€")
+      scanner = r.scan("€")
+      expect(scanner.scan).to eq([nil])
+      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")
-    scanner.must_be_kind_of(Enumerable)
+    expect(scanner).to be_a(Enumerable)
   end
 
   describe "#each" do
@@ -61,7 +112,7 @@ describe RE2::Scanner do
         matches << match
       end
 
-      matches.must_equal([["1"], ["2"], ["3"]])
+      expect(matches).to eq([["1"], ["2"], ["3"]])
     end
 
     it "returns an enumerator when not given a block" do
@@ -70,9 +121,9 @@ describe RE2::Scanner do
 
       # Prior to Ruby 1.9, Enumerator was within Enumerable.
       if defined?(Enumerator)
-        scanner.each.must_be_kind_of(Enumerator)
+        expect(scanner.each).to be_a(Enumerator)
       elsif defined?(Enumerable::Enumerator)
-        scanner.each.must_be_kind_of(Enumerable::Enumerator)
+        expect(scanner.each).to be_a(Enumerable::Enumerator)
       end
     end
   end
@@ -81,10 +132,67 @@ describe RE2::Scanner do
     it "resets any consumption" do
       r = RE2::Regexp.new('(\d)')
       scanner = r.scan("There are 1 some 2 numbers 3")
-      scanner.to_enum.first.must_equal(["1"])
-      scanner.to_enum.first.must_equal(["2"])
+      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
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+      expect(scanner.eof?).to be_truthy
       scanner.rewind
-      scanner.to_enum.first.must_equal(["1"])
+      expect(scanner.eof?).to be_falsey
+    end
+  end
+
+  describe "#eof?" do
+    it "returns false if the input has not been consumed" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1 2 3")
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns true if the input has been consumed" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("1")
+      scanner.scan
+
+      expect(scanner.eof?).to be_truthy
+    end
+
+    it "returns false if no match is made" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("a")
+      scanner.scan
+
+      expect(scanner.eof?).to be_falsey
+    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
+    end
+
+    it "returns false with an empty input that has not been matched" do
+      r = RE2::Regexp.new('(\d)')
+      scanner = r.scan("")
+      scanner.scan
+
+      expect(scanner.eof?).to be_falsey
+    end
+
+    it "returns true with an empty input that has been matched" do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("")
+      scanner.scan
+
+      expect(scanner.eof?).to be_truthy
     end
   end
 end

data/spec/re2/string_spec.rb

@@ -1,57 +1,56 @@
-require "spec_helper"
 require "re2/string"
 
 class String
   include RE2::String
 end
 
-describe RE2::String do
+RSpec.describe RE2::String do
   describe "#re2_sub" do
     it "delegates to RE2.Replace to perform replacement" do
-      "My name is Robert Paulson".re2_sub('Robert', 'Crobert').must_equal("My name is Crobert Paulson")
+      expect("My name is Robert Paulson".re2_sub('Robert', 'Crobert')).to eq("My name is Crobert Paulson")
     end
 
     it "doesn't perform an in-place replacement" do
       string = "My name is Robert Paulson"
-      string.re2_sub('Robert', 'Crobert').wont_be_same_as(string)
+      expect(string.re2_sub('Robert', 'Crobert')).to_not equal(string)
     end
   end
 
   describe "#re2_gsub" do
     it "delegates to RE2.GlobalReplace to perform replacement" do
-      "My name is Robert Paulson".re2_gsub('a', 'e').must_equal("My neme is Robert Peulson")
+      expect("My name is Robert Paulson".re2_gsub('a', 'e')).to eq("My neme is Robert Peulson")
     end
 
     it "doesn't perform an in-place replacement" do
       string = "My name is Robert Paulson"
-      string.re2_gsub('a', 'e').wont_be_same_as(string)
+      expect(string.re2_gsub('a', 'e')).to_not equal(string)
     end
   end
 
   describe "#re2_match" do
     it "delegates to RE2::Regexp#match to perform matches" do
       md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)')
-      md.must_be_instance_of(RE2::MatchData)
-      md[0].must_equal("My name is Robert Paulson")
-      md[1].must_equal("Robert")
-      md[2].must_equal("Paulson")
+      expect(md).to be_a(RE2::MatchData)
+      expect(md[0]).to eq("My name is Robert Paulson")
+      expect(md[1]).to eq("Robert")
+      expect(md[2]).to eq("Paulson")
     end
 
     it "supports limiting the number of matches" do
       md = "My name is Robert Paulson".re2_match('My name is (\S+) (\S+)', 0)
-      md.must_equal(true)
+      expect(md).to eq(true)
     end
   end
 
   describe "#re2_escape" do
     it "escapes the string for use in regular expressions" do
-      "1.5-2.0?".re2_escape.must_equal('1\.5\-2\.0\?')
+      expect("1.5-2.0?".re2_escape).to eq('1\.5\-2\.0\?')
     end
   end
 
   describe "#re2_quote" do
     it "escapes the string for use in regular expressions" do
-      "1.5-2.0?".re2_quote.must_equal('1\.5\-2\.0\?')
+      expect("1.5-2.0?".re2_quote).to eq('1\.5\-2\.0\?')
     end
   end
 end

data/spec/re2_spec.rb

@@ -1,79 +1,75 @@
-require "spec_helper"
-
-describe RE2 do
+RSpec.describe RE2 do
   describe "#Replace" do
     it "only replaces the first occurrence of the pattern" do
-      RE2.Replace("woo", "o", "a").must_equal("wao")
+      expect(RE2.Replace("woo", "o", "a")).to eq("wao")
     end
 
     it "performs replacement based on regular expressions" do
-      RE2.Replace("woo", "o+", "e").must_equal("we")
+      expect(RE2.Replace("woo", "o+", "e")).to eq("we")
     end
 
     it "supports flags in patterns" do
-      RE2.Replace("Good morning", "(?i)gOOD MORNING", "hi").must_equal("hi")
+      expect(RE2.Replace("Good morning", "(?i)gOOD MORNING", "hi")).to eq("hi")
     end
 
     it "does not perform replacements in-place" do
       name = "Robert"
       replacement = RE2.Replace(name, "R", "Cr")
-      replacement.must_equal("Crobert")
-      name.wont_be_same_as(replacement)
+      expect(name).to_not equal(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
       re = RE2::Regexp.new('wo{2}')
-      RE2.Replace("woo", re, "miaow").must_equal("miaow")
+      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)
-      RE2.Replace("Good morning", re, "hi").must_equal("hi")
+      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")
-        original.encoding.must_equal(replacement.encoding)
+        expect(original.encoding).to eq(replacement.encoding)
       end
     end
   end
 
   describe "#GlobalReplace" do
     it "replaces every occurrence of a pattern" do
-      RE2.GlobalReplace("woo", "o", "a").must_equal("waa")
+      expect(RE2.GlobalReplace("woo", "o", "a")).to eq("waa")
     end
 
     it "performs replacement based on regular expressions" do
-      RE2.GlobalReplace("woohoo", "o+", "e").must_equal("wehe")
+      expect(RE2.GlobalReplace("woohoo", "o+", "e")).to eq("wehe")
     end
 
     it "supports flags in patterns" do
-      RE2.GlobalReplace("Robert", "(?i)r", "w").must_equal("wobewt")
+      expect(RE2.GlobalReplace("Robert", "(?i)r", "w")).to eq("wobewt")
     end
 
     it "does not perform replacement in-place" do
       name = "Robert"
       replacement = RE2.GlobalReplace(name, "(?i)R", "w")
-      replacement.must_equal("wobewt")
-      name.wont_be_same_as(replacement)
+      expect(name).to_not equal(replacement)
     end
 
     it "supports passing an RE2::Regexp as the pattern" do
       re = RE2::Regexp.new('wo{2,}')
-      RE2.GlobalReplace("woowooo", re, "miaow").must_equal("miaowmiaow")
+      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)
-      RE2.GlobalReplace("Good morning Good morning", re, "hi").must_equal("hi hi")
+      expect(RE2.GlobalReplace("Good morning Good morning", re, "hi")).to eq("hi hi")
     end
   end
 
   describe "#QuoteMeta" do
     it "escapes a string so it can be used as a regular expression" do
-      RE2.QuoteMeta("1.5-2.0?").must_equal('1\.5\-2\.0\?')
+      expect(RE2.QuoteMeta("1.5-2.0?")).to eq('1\.5\-2\.0\?')
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,19 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require "re2"
-require "minitest/autorun"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.default_formatter = 'doc' if config.files_to_run.one?
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Paul Mucur
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-01-25 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -25,21 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '3.2'
 description: Ruby bindings to re2, "an efficient, principled regular expression library".
-email: ruby.re2@librelist.com
+email:
 executables: []
 extensions:
 - ext/re2/extconf.rb
@@ -60,11 +60,11 @@ files:
 - spec/re2/string_spec.rb
 - spec/re2_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/mudge/re2
+homepage: https://github.com/mudge/re2
 licenses:
-- BSD
+- BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -79,9 +79,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Ruby bindings to re2.
 test_files:
@@ -92,4 +91,3 @@ test_files:
 - spec/re2/match_data_spec.rb
 - spec/re2/string_spec.rb
 - spec/re2/scanner_spec.rb
-has_rdoc: