re2 0.7.0 → 1.3.0

data/spec/kernel_spec.rb

@@ -1,15 +1,13 @@
-require "spec_helper"
-
-describe Kernel do
+RSpec.describe Kernel do
   describe "#RE2" do
     it "returns an RE2::Regexp instance given a pattern" do
-      RE2('w(o)(o)').must_be_instance_of(RE2::Regexp)
+      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)
-      re.must_be_instance_of(RE2::Regexp)
-      re.wont_be(:case_sensitive?)
+      expect(re).to be_a(RE2::Regexp)
+      expect(re).to_not be_case_sensitive
     end
   end
 end

data/spec/re2/match_data_spec.rb

@@ -1,94 +1,90 @@
 # encoding: utf-8
-
-require "spec_helper"
-
-describe RE2::MatchData do
-
+RSpec.describe RE2::MatchData do
   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
-      a.must_equal(["woo", "o", "o"])
+      expect(a).to eq(["woo", "o", "o"])
     end
 
     it "populates optional capturing groups with nil if they are missing" do
       a = RE2::Regexp.new('(\d?)(a)(b)').match('ab').to_a
-      a.must_equal(["ab", nil, "a", "b"])
+      expect(a).to eq(["ab", nil, "a", "b"])
     end
   end
 
   describe "#[]" do
     it "accesses capturing groups by numerical index" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
-      md[1].must_equal("1")
-      md[2].must_equal("23")
+      expect(md[1]).to eq("1")
+      expect(md[2]).to eq("23")
     end
 
     it "has the whole match as the 0th item" do
       md = RE2::Regexp.new('(\d)(\d{2})').match("123")
-      md[0].must_equal("123")
+      expect(md[0]).to eq("123")
     end
 
     it "supports access by numerical ranges" do
       md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
-      md[1..3].must_equal(["123", "456", "789"])
-      md[1...3].must_equal(["123", "456"])
+      expect(md[1..3]).to eq(["123", "456", "789"])
+      expect(md[1...3]).to eq(["123", "456"])
     end
 
     it "supports slicing" do
       md = RE2::Regexp.new('(\d+) (\d+) (\d+)').match("123 456 789")
-      md[1, 3].must_equal(["123", "456", "789"])
-      md[1, 2].must_equal(["123", "456"])
+      expect(md[1, 3]).to eq(["123", "456", "789"])
+      expect(md[1, 2]).to eq(["123", "456"])
     end
 
     it "returns nil if attempting to access non-existent capturing groups by index" do
       md = RE2::Regexp.new('(\d+)').match('bob 123')
-      md[2].must_be_nil
-      md[3].must_be_nil
+      expect(md[2]).to be_nil
+      expect(md[3]).to be_nil
     end
 
     it "allows access by string names when there are named groups" do
       md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
-      md["numbers"].must_equal("123")
+      expect(md["numbers"]).to eq("123")
     end
 
     it "allows access by symbol names when there are named groups" do
       md = RE2::Regexp.new('(?P<numbers>\d+)').match('bob 123')
-      md[:numbers].must_equal("123")
+      expect(md[:numbers]).to eq("123")
     end
 
     it "allows access by names and indices with mixed groups" do
       md = RE2::Regexp.new('(?P<name>\w+)(\s*)(?P<numbers>\d+)').match("bob 123")
-      md["name"].must_equal("bob")
-      md[:name].must_equal("bob")
-      md[2].must_equal(" ")
-      md["numbers"].must_equal("123")
-      md[:numbers].must_equal("123")
+      expect(md["name"]).to eq("bob")
+      expect(md[:name]).to eq("bob")
+      expect(md[2]).to eq(" ")
+      expect(md["numbers"]).to eq("123")
+      expect(md[:numbers]).to eq("123")
     end
 
     it "returns nil if no such named group exists" do
       md = RE2::Regexp.new('(\d+)').match("bob 123")
-      md["missing"].must_be_nil
-      md[:missing].must_be_nil
+      expect(md["missing"]).to be_nil
+      expect(md[:missing]).to be_nil
     end
 
     it "raises an error if given an inappropriate index" do
       md = RE2::Regexp.new('(\d+)').match("bob 123")
-      lambda { md[nil] }.must_raise(TypeError)
+      expect { md[nil] }.to raise_error(TypeError)
     end
 
     if String.method_defined?(:encoding)
       it "returns UTF-8 encoded strings by default" do
         md = RE2::Regexp.new('(?P<name>\S+)').match("bob")
-        md[0].encoding.name.must_equal("UTF-8")
-        md["name"].encoding.name.must_equal("UTF-8")
-        md[:name].encoding.name.must_equal("UTF-8")
+        expect(md[0].encoding.name).to eq("UTF-8")
+        expect(md["name"].encoding.name).to eq("UTF-8")
+        expect(md[:name].encoding.name).to eq("UTF-8")
       end
 
       it "returns Latin 1 strings encoding when utf-8 is false" do
         md = RE2::Regexp.new('(?P<name>\S+)', :utf8 => false).match('bob')
-        md[0].encoding.name.must_equal("ISO-8859-1")
-        md["name"].encoding.name.must_equal("ISO-8859-1")
-        md[:name].encoding.name.must_equal("ISO-8859-1")
+        expect(md[0].encoding.name).to eq("ISO-8859-1")
+        expect(md["name"].encoding.name).to eq("ISO-8859-1")
+        expect(md[:name].encoding.name).to eq("ISO-8859-1")
       end
     end
   end
@@ -96,32 +92,32 @@ describe RE2::MatchData do
   describe "#string" do
     it "returns the original string to match against" do
       re = RE2::Regexp.new('(\D+)').match("bob")
-      re.string.must_equal("bob")
+      expect(re.string).to eq("bob")
     end
 
     it "returns a copy, not the actual original" do
       string = "bob"
       re = RE2::Regexp.new('(\D+)').match(string)
-      re.string.wont_be_same_as(string)
+      expect(re.string).to_not equal(string)
     end
 
     it "returns a frozen string" do
       re = RE2::Regexp.new('(\D+)').match("bob")
-      re.string.must_be(:frozen?)
+      expect(re.string).to be_frozen
     end
   end
 
   describe "#size" do
     it "returns the number of capturing groups plus the matching string" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.size.must_equal(3)
+      expect(md.size).to eq(3)
     end
   end
 
   describe "#length" do
     it "returns the number of capturing groups plus the matching string" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.length.must_equal(3)
+      expect(md.length).to eq(3)
     end
   end
 
@@ -129,26 +125,26 @@ describe RE2::MatchData do
     it "returns the original RE2::Regexp used" do
       re = RE2::Regexp.new('(\d+)')
       md = re.match("123")
-      md.regexp.must_be_same_as(re)
+      expect(md.regexp).to equal(re)
     end
   end
 
   describe "#inspect" do
     it "returns a text representation of the object and indices" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
-      md.inspect.must_equal('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 56" 1:"1234" 2:"56">')
     end
 
     it "represents missing matches as nil" do
       md = RE2::Regexp.new('(\d+) (\d+)?').match("1234 ")
-      md.inspect.must_equal('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
+      expect(md.inspect).to eq('#<RE2::MatchData "1234 " 1:"1234" 2:nil>')
     end
   end
 
   describe "#to_s" do
     it "returns the matching part of the original string" do
       md = RE2::Regexp.new('(\d{2,5})').match("one two 23456")
-      md.to_s.must_equal("23456")
+      expect(md.to_s).to eq("23456")
     end
   end
 
@@ -156,53 +152,93 @@ describe RE2::MatchData do
     it "allows the object to be expanded with an asterisk" do
       md = RE2::Regexp.new('(\d+) (\d+)').match("1234 56")
       m1, m2, m3 = *md
-      m1.must_equal("1234 56")
-      m2.must_equal("1234")
-      m3.must_equal("56")
+      expect(m1).to eq("1234 56")
+      expect(m2).to eq("1234")
+      expect(m3).to eq("56")
     end
   end
 
   describe "#begin" do
     it "returns the offset of the start of a match by index" do
       md = RE2::Regexp.new('(wo{2})').match('a woohoo')
-      md.string[md.begin(0)..-1].must_equal('woohoo')
+      expect(md.string[md.begin(0)..-1]).to eq('woohoo')
     end
 
     it "returns the offset of the start of a match by string name" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
-      md.string[md.begin('foo')..-1].must_equal('foobar')
+      expect(md.string[md.begin('foo')..-1]).to eq('foobar')
     end
 
     it "returns the offset of the start of a match by symbol name" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
-      md.string[md.begin(:foo)..-1].must_equal('foobar')
+      expect(md.string[md.begin(:foo)..-1]).to eq('foobar')
     end
 
     it "returns the offset despite multibyte characters" do
       md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
-      md.string[md.begin(0)..-1].must_equal('Ruby')
+      expect(md.string[md.begin(0)..-1]).to eq('Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.begin(:foo)).to be_nil
     end
   end
 
   describe "#end" do
     it "returns the offset of the character following the end of a match" do
       md = RE2::Regexp.new('(wo{2})').match('a woohoo')
-      md.string[0...md.end(0)].must_equal('a woo')
+      expect(md.string[0...md.end(0)]).to eq('a woo')
     end
 
     it "returns the offset of a match by string name" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
-      md.string[0...md.end('foo')].must_equal('a foo')
+      expect(md.string[0...md.end('foo')]).to eq('a foo')
     end
 
     it "returns the offset of a match by symbol name" do
       md = RE2::Regexp.new('(?P<foo>fo{2})').match('a foobar')
-      md.string[0...md.end(:foo)].must_equal('a foo')
+      expect(md.string[0...md.end(:foo)]).to eq('a foo')
     end
 
     it "returns the offset despite multibyte characters" do
       md = RE2::Regexp.new('(Ruby)').match('I ♥ Ruby')
-      md.string[0...md.end(0)].must_equal('I ♥ Ruby')
+      expect(md.string[0...md.end(0)]).to eq('I ♥ Ruby')
+    end
+
+    it "returns nil for non-existent numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(10)).to be_nil
+    end
+
+    it "returns nil for negative numerical matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(-4)).to be_nil
+    end
+
+    it "returns nil for non-existent named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end('foo')).to be_nil
+    end
+
+    it "returns nil for non-existent symbol named matches" do
+      md = RE2::Regexp.new('(\d)').match('123')
+      expect(md.end(:foo)).to be_nil
     end
   end
 end

data/spec/re2/regexp_spec.rb

@@ -1,253 +1,251 @@
-require "spec_helper"
-
-describe RE2::Regexp do
+RSpec.describe RE2::Regexp do
   describe "#initialize" do
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.new('woo')
-      re.must_be_instance_of(RE2::Regexp)
+      expect(re).to be_a(RE2::Regexp)
     end
 
     it "returns an instance given a pattern and options" do
       re = RE2::Regexp.new('woo', :case_sensitive => false)
-      re.must_be_instance_of(RE2::Regexp)
+      expect(re).to be_a(RE2::Regexp)
     end
 
     it "raises an error if given an inappropriate type" do
-      lambda { RE2::Regexp.new(nil) }.must_raise(TypeError)
+      expect { RE2::Regexp.new(nil) }.to raise_error(TypeError)
     end
   end
 
   describe "#compile" do
     it "returns an instance given only a pattern" do
       re = RE2::Regexp.compile('woo')
-      re.must_be_instance_of(RE2::Regexp)
+      expect(re).to be_a(RE2::Regexp)
     end
 
     it "returns an instance given a pattern and options" do
       re = RE2::Regexp.compile('woo', :case_sensitive => false)
-      re.must_be_instance_of(RE2::Regexp)
+      expect(re).to be_a(RE2::Regexp)
     end
   end
 
   describe "#options" do
     it "returns a hash of options" do
       options = RE2::Regexp.new('woo').options
-      options.must_be_instance_of(Hash)
+      expect(options).to be_a(Hash)
     end
 
     it "is populated with default options when nothing has been set" do
       options = RE2::Regexp.new('woo').options
-      assert options[:utf8]
-      refute options[:posix_syntax]
-      refute options[:longest_match]
-      assert [:log_errors]
-      refute options[:literal]
-      refute options[:never_nl]
-      assert options[:case_sensitive]
-      refute options[:perl_classes]
-      refute options[:word_boundary]
-      refute options[:one_line]
+      expect(options).to include(:utf8 => true,
+                                 :posix_syntax => false,
+                                 :longest_match => false,
+                                 :log_errors => true,
+                                 :literal => false,
+                                 :never_nl => false,
+                                 :case_sensitive => true,
+                                 :perl_classes => false,
+                                 :word_boundary => false,
+                                 :one_line => false)
     end
 
     it "is populated with overridden options when specified" do
       options = RE2::Regexp.new('woo', :case_sensitive => false).options
-      refute options[:case_sensitive]
+      expect(options[:case_sensitive]).to eq(false)
     end
   end
 
   describe "#error" do
     it "returns nil if there is no error" do
       error = RE2::Regexp.new('woo').error
-      error.must_be_nil
+      expect(error).to be_nil
     end
 
     # Use log_errors => false to suppress RE2's logging to STDERR.
     it "contains the error string if there is an error" do
       error = RE2::Regexp.new('wo(o', :log_errors => false).error
-      error.must_equal("missing ): wo(o")
+      expect(error).to eq("missing ): wo(o")
     end
   end
 
   describe "#error_arg" do
     it "returns nil if there is no error" do
       error_arg = RE2::Regexp.new('woo').error_arg
-      error_arg.must_be_nil
+      expect(error_arg).to be_nil
     end
 
     it "returns the offending portin of the regexp if there is an error" do
       error_arg = RE2::Regexp.new('wo(o', :log_errors => false).error_arg
-      error_arg.must_equal("wo(o")
+      expect(error_arg).to eq("wo(o")
     end
   end
 
   describe "#program_size" do
     it "returns a numeric value" do
       program_size = RE2::Regexp.new('w(o)(o)').program_size
-      program_size.must_be_instance_of(Fixnum)
+      expect(program_size).to be_a(Fixnum)
     end
   end
 
   describe "#to_str" do
     it "returns the original pattern" do
       string = RE2::Regexp.new('w(o)(o)').to_str
-      string.must_equal("w(o)(o)")
+      expect(string).to eq("w(o)(o)")
     end
   end
 
   describe "#pattern" do
     it "returns the original pattern" do
       pattern = RE2::Regexp.new('w(o)(o)').pattern
-      pattern.must_equal("w(o)(o)")
+      expect(pattern).to eq("w(o)(o)")
     end
   end
 
   describe "#inspect" do
     it "shows the class name and original pattern" do
       string = RE2::Regexp.new('w(o)(o)').inspect
-      string.must_equal("#<RE2::Regexp /w(o)(o)/>")
+      expect(string).to eq("#<RE2::Regexp /w(o)(o)/>")
     end
   end
 
   describe "#utf8?" do
     it "returns true by default" do
-      RE2::Regexp.new('woo').must_be(:utf8?)
+      expect(RE2::Regexp.new('woo')).to be_utf8
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :utf8 => false)
-      re.wont_be(:utf8?)
+      expect(re).to_not be_utf8
     end
   end
 
   describe "#posix_syntax?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:posix_syntax?)
+      expect(RE2::Regexp.new('woo')).to_not be_posix_syntax
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :posix_syntax => true)
-      re.must_be(:posix_syntax?)
+      expect(re).to be_posix_syntax
     end
   end
 
   describe "#literal?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:literal?)
+      expect(RE2::Regexp.new('woo')).to_not be_literal
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :literal => true)
-      re.must_be(:literal?)
+      expect(re).to be_literal
     end
   end
 
   describe "#never_nl?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:never_nl?)
+      expect(RE2::Regexp.new('woo')).to_not be_never_nl
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :never_nl => true)
-      re.must_be(:never_nl?)
+      expect(re).to be_never_nl
     end
   end
 
   describe "#case_sensitive?" do
     it "returns true by default" do
-      RE2::Regexp.new('woo').must_be(:case_sensitive?)
+      expect(RE2::Regexp.new('woo')).to be_case_sensitive
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :case_sensitive => false)
-      re.wont_be(:case_sensitive?)
+      expect(re).to_not be_case_sensitive
     end
   end
 
   describe "#case_insensitive?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:case_insensitive?)
+      expect(RE2::Regexp.new('woo')).to_not be_case_insensitive
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :case_sensitive => false)
-      re.must_be(:case_insensitive?)
+      expect(re).to be_case_insensitive
     end
   end
 
   describe "#casefold?" do
     it "returns true by default" do
-      RE2::Regexp.new('woo').wont_be(:casefold?)
+      expect(RE2::Regexp.new('woo')).to_not be_casefold
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :case_sensitive => false)
-      re.must_be(:casefold?)
+      expect(re).to be_casefold
     end
   end
 
   describe "#longest_match?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:casefold?)
+      expect(RE2::Regexp.new('woo')).to_not be_casefold
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :longest_match => true)
-      re.must_be(:longest_match?)
+      expect(re).to be_longest_match
     end
   end
 
   describe "#log_errors?" do
     it "returns true by default" do
-      RE2::Regexp.new('woo').must_be(:log_errors?)
+      expect(RE2::Regexp.new('woo')).to be_log_errors
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :log_errors => false)
-      re.wont_be(:log_errors?)
+      expect(re).to_not be_log_errors
     end
   end
 
   describe "#perl_classes?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:perl_classes?)
+      expect(RE2::Regexp.new('woo')).to_not be_perl_classes
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :perl_classes => true)
-      re.must_be(:perl_classes?)
+      expect(re).to be_perl_classes
     end
   end
 
   describe "#word_boundary?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:word_boundary?)
+      expect(RE2::Regexp.new('woo')).to_not be_word_boundary
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :word_boundary => true)
-      re.must_be(:word_boundary?)
+      expect(re).to be_word_boundary
     end
   end
 
   describe "#one_line?" do
     it "returns false by default" do
-      RE2::Regexp.new('woo').wont_be(:one_line?)
+      expect(RE2::Regexp.new('woo')).to_not be_one_line
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :one_line => true)
-      re.must_be(:one_line?)
+      expect(re).to be_one_line
     end
   end
 
   describe "#max_mem" do
     it "returns the default max memory" do
-      RE2::Regexp.new('woo').max_mem.must_equal(8388608)
+      expect(RE2::Regexp.new('woo').max_mem).to eq(8388608)
     end
 
     it "can be overridden on initialization" do
       re = RE2::Regexp.new('woo', :max_mem => 1024)
-      re.max_mem.must_equal(1024)
+      expect(re.max_mem).to eq(1024)
     end
   end
 
@@ -256,43 +254,43 @@ describe RE2::Regexp do
 
     it "returns match data given only text" do
       md = re.match("My name is Robert Paulson")
-      md.must_be_instance_of(RE2::MatchData)
+      expect(md).to be_a(RE2::MatchData)
     end
 
     it "returns nil if there is no match for the given text" do
-      re.match("My age is 99").must_be_nil
+      expect(re.match("My age is 99")).to be_nil
     end
 
     it "returns only true or false if no matches are requested" do
-      re.match("My name is Robert Paulson", 0).must_equal(true)
-      re.match("My age is 99", 0).must_equal(false)
+      expect(re.match("My name is Robert Paulson", 0)).to eq(true)
+      expect(re.match("My age is 99", 0)).to eq(false)
     end
 
     it "raises an exception when given nil" do
-      lambda { re.match(nil) }.must_raise(TypeError)
+      expect { re.match(nil) }.to raise_error(TypeError)
     end
 
     it "raises an exception when given an inappropriate number of matches" do
-      lambda { re.match("My name is Robert Paulson", {}) }.must_raise(TypeError)
+      expect { re.match("My name is Robert Paulson", {}) }.to raise_error(TypeError)
     end
 
     describe "with a specific number of matches under the total in the pattern" do
       subject { re.match("My name is Robert Paulson", 1) }
 
       it "returns a match data object" do
-        subject.must_be_instance_of(RE2::MatchData)
+        expect(subject).to be_a(RE2::MatchData)
       end
 
       it "has the whole match and only the specified number of matches" do
-        subject.size.must_equal(2)
+        expect(subject.size).to eq(2)
       end
 
       it "populates any specified matches" do
-        subject[1].must_equal("Robert")
+        expect(subject[1]).to eq("Robert")
       end
 
       it "does not populate any matches that weren't included" do
-        subject[2].must_be_nil
+        expect(subject[2]).to be_nil
       end
     end
 
@@ -300,23 +298,23 @@ describe RE2::Regexp do
       subject { re.match("My name is Robert Paulson", 5) }
 
       it "returns a match data object" do
-        subject.must_be_instance_of(RE2::MatchData)
+        expect(subject).to be_a(RE2::MatchData)
       end
 
       it "has the whole match the specified number of matches" do
-        subject.size.must_equal(6)
+        expect(subject.size).to eq(6)
       end
 
       it "populates any specified matches" do
-        subject[1].must_equal("Robert")
-        subject[2].must_equal("Paulson")
+        expect(subject[1]).to eq("Robert")
+        expect(subject[2]).to eq("Paulson")
       end
 
       it "pads the remaining matches with nil" do
-        subject[3].must_be_nil
-        subject[4].must_be_nil
-        subject[5].must_be_nil
-        subject[6].must_be_nil
+        expect(subject[3]).to be_nil
+        expect(subject[4]).to be_nil
+        expect(subject[5]).to be_nil
+        expect(subject[6]).to be_nil
       end
     end
   end
@@ -324,83 +322,83 @@ describe RE2::Regexp do
   describe "#match?" do
     it "returns only true or false if no matches are requested" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
-      re.match?("My name is Robert Paulson").must_equal(true)
-      re.match?("My age is 99").must_equal(false)
+      expect(re.match?("My name is Robert Paulson")).to eq(true)
+      expect(re.match?("My age is 99")).to eq(false)
     end
   end
 
   describe "#=~" do
     it "returns only true or false if no matches are requested" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
-      (re =~ "My name is Robert Paulson").must_equal(true)
-      (re =~ "My age is 99").must_equal(false)
+      expect(re =~ "My name is Robert Paulson").to eq(true)
+      expect(re =~ "My age is 99").to eq(false)
     end
   end
 
   describe "#!~" do
     it "returns only true or false if no matches are requested" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
-      (re !~ "My name is Robert Paulson").must_equal(false)
-      (re !~ "My age is 99").must_equal(true)
+      expect(re !~ "My name is Robert Paulson").to eq(false)
+      expect(re !~ "My age is 99").to eq(true)
     end
   end
 
   describe "#===" do
     it "returns only true or false if no matches are requested" do
       re = RE2::Regexp.new('My name is (\S+) (\S+)')
-      (re === "My name is Robert Paulson").must_equal(true)
-      (re === "My age is 99").must_equal(false)
+      expect(re === "My name is Robert Paulson").to eq(true)
+      expect(re === "My age is 99").to eq(false)
     end
   end
 
   describe "#ok?" do
     it "returns true for valid regexps" do
-      RE2::Regexp.new('woo').must_be(:ok?)
-      RE2::Regexp.new('wo(o)').must_be(:ok?)
-      RE2::Regexp.new('((\d)\w+){3,}').must_be(:ok?)
+      expect(RE2::Regexp.new('woo')).to be_ok
+      expect(RE2::Regexp.new('wo(o)')).to be_ok
+      expect(RE2::Regexp.new('((\d)\w+){3,}')).to be_ok
     end
 
     it "returns false for invalid regexps" do
-      RE2::Regexp.new('wo(o', :log_errors => false).wont_be(:ok?)
-      RE2::Regexp.new('wo[o', :log_errors => false).wont_be(:ok?)
-      RE2::Regexp.new('*', :log_errors => false).wont_be(:ok?)
+      expect(RE2::Regexp.new('wo(o', :log_errors => false)).to_not be_ok
+      expect(RE2::Regexp.new('wo[o', :log_errors => false)).to_not be_ok
+      expect(RE2::Regexp.new('*', :log_errors => false)).to_not be_ok
     end
   end
 
   describe "#escape" do
     it "transforms a string into a regexp" do
-      RE2::Regexp.escape("1.5-2.0?").must_equal('1\.5\-2\.0\?')
+      expect(RE2::Regexp.escape("1.5-2.0?")).to eq('1\.5\-2\.0\?')
     end
   end
 
   describe "#quote" do
     it "transforms a string into a regexp" do
-      RE2::Regexp.quote("1.5-2.0?").must_equal('1\.5\-2\.0\?')
+      expect(RE2::Regexp.quote("1.5-2.0?")).to eq('1\.5\-2\.0\?')
     end
   end
 
   describe "#number_of_capturing_groups" do
     it "returns the number of groups in a regexp" do
-      RE2::Regexp.new('(a)(b)(c)').number_of_capturing_groups.must_equal(3)
-      RE2::Regexp.new('abc').number_of_capturing_groups.must_equal(0)
-      RE2::Regexp.new('a((b)c)').number_of_capturing_groups.must_equal(2)
+      expect(RE2::Regexp.new('(a)(b)(c)').number_of_capturing_groups).to eq(3)
+      expect(RE2::Regexp.new('abc').number_of_capturing_groups).to eq(0)
+      expect(RE2::Regexp.new('a((b)c)').number_of_capturing_groups).to eq(2)
     end
   end
 
   describe "#named_capturing_groups" do
     it "returns a hash of names to indices" do
-      RE2::Regexp.new('(?P<bob>a)').named_capturing_groups.must_be_instance_of(Hash)
+      expect(RE2::Regexp.new('(?P<bob>a)').named_capturing_groups).to be_a(Hash)
     end
 
     it "maps names to indices with only one group" do
       groups = RE2::Regexp.new('(?P<bob>a)').named_capturing_groups
-      groups["bob"].must_equal(1)
+      expect(groups["bob"]).to eq(1)
     end
 
     it "maps names to indices with several groups" do
       groups = RE2::Regexp.new('(?P<bob>a)(o)(?P<rob>e)').named_capturing_groups
-      groups["bob"].must_equal(1)
-      groups["rob"].must_equal(3)
+      expect(groups["bob"]).to eq(1)
+      expect(groups["rob"]).to eq(3)
     end
   end
 
@@ -409,7 +407,7 @@ describe RE2::Regexp do
       r = RE2::Regexp.new('(\w+)')
       scanner = r.scan("It is a truth universally acknowledged")
 
-      scanner.must_be_instance_of(RE2::Scanner)
+      expect(scanner).to be_a(RE2::Scanner)
     end
   end
 end