update rspec syntax from should to expect via transpec

spec/colors_spec.rb

@@ -30,14 +30,14 @@ describe "AwesomePrint" do
 
       it "colorizes tty processes by default" do
         stub_tty!
-        @arr.ai(:multiline => false).should == COLORIZED
+        expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
       end
 
       it "colorizes processes with ENV['ANSICON'] by default" do
         begin
           stub_tty!
           term, ENV['ANSICON'] = ENV['ANSICON'], "1"
-          @arr.ai(:multiline => false).should == COLORIZED
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
         ensure
           ENV['ANSICON'] = term
         end
@@ -47,7 +47,7 @@ describe "AwesomePrint" do
         begin
           stub_tty!
           term, ENV['TERM'] = ENV['TERM'], "dumb"
-          @arr.ai(:multiline => false).should == PLAIN
+          expect(@arr.ai(:multiline => false)).to eq(PLAIN)
         ensure
           ENV['TERM'] = term
         end
@@ -56,7 +56,7 @@ describe "AwesomePrint" do
       it "does not colorize subprocesses by default" do
         begin
           stub_tty! false
-          @arr.ai(:multiline => false).should == PLAIN
+          expect(@arr.ai(:multiline => false)).to eq(PLAIN)
         ensure
           stub_tty!
         end
@@ -70,14 +70,14 @@ describe "AwesomePrint" do
       
       it "still colorizes tty processes" do
         stub_tty!
-        @arr.ai(:multiline => false).should == COLORIZED
+        expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
       end
 
       it "colorizes processes with ENV['ANSICON'] set to 0" do
         begin
           stub_tty!
           term, ENV['ANSICON'] = ENV['ANSICON'], "1"
-          @arr.ai(:multiline => false).should == COLORIZED
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
         ensure
           ENV['ANSICON'] = term
         end
@@ -87,7 +87,7 @@ describe "AwesomePrint" do
         begin
           stub_tty!
           term, ENV['TERM'] = ENV['TERM'], "dumb"
-          @arr.ai(:multiline => false).should == COLORIZED
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
         ensure
           ENV['TERM'] = term
         end
@@ -96,7 +96,7 @@ describe "AwesomePrint" do
       it "colorizes subprocess" do
         begin
           stub_tty! false
-          @arr.ai(:multiline => false).should == COLORIZED
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
         ensure
           stub_tty!
         end

spec/core_ext/logger_spec.rb

@@ -11,8 +11,8 @@ describe "AwesomePrint logging extensions" do
 
   describe "ap method" do
     it "should awesome_inspect the given object" do
-      object = mock
+      object = double
-      object.should_receive(:ai)
+      expect(object).to receive(:ai)
       @logger.ap object
     end
     
@@ -22,18 +22,18 @@ describe "AwesomePrint logging extensions" do
       end
       
       it "should fallback to the default :debug log level" do
-        @logger.should_receive(:debug)
+        expect(@logger).to receive(:debug)
         @logger.ap(nil)
       end
 
       it "should use the global user default if no level passed" do
         AwesomePrint.defaults = { :log_level => :info }
-        @logger.should_receive(:info)
+        expect(@logger).to receive(:info)
         @logger.ap(nil)
       end
 
       it "should use the passed in level" do
-        @logger.should_receive(:warn)
+        expect(@logger).to receive(:warn)
         @logger.ap(nil, :warn)
       end
     end

spec/core_ext/string_spec.rb

@@ -3,18 +3,18 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe "String extensions" do
   [ :gray, :red, :green, :yellow, :blue, :purple, :cyan, :white ].each_with_index do |color, i|
     it "should have #{color} color" do
-      color.to_s.send(color).should == "\e[1;#{30+i}m#{color}\e[0m"
+      expect(color.to_s.send(color)).to eq("\e[1;#{30+i}m#{color}\e[0m")
     end
 
     it "should have #{color}ish color" do
-      color.to_s.send(:"#{color}ish").should == "\e[0;#{30+i}m#{color}\e[0m"
+      expect(color.to_s.send(:"#{color}ish")).to eq("\e[0;#{30+i}m#{color}\e[0m")
     end
   end
 
   it "should have black and pale colors" do
-    "black".send(:black).should == "black".send(:grayish)
+    expect("black".send(:black)).to eq("black".send(:grayish))
-    "pale".send(:pale).should  == "pale".send(:whiteish)
+    expect("pale".send(:pale)).to  eq("pale".send(:whiteish))
-    "pale".send(:pale).should == "\e[0;37mpale\e[0m"
+    expect("pale".send(:pale)).to eq("\e[0;37mpale\e[0m")
-    "whiteish".send(:whiteish).should == "\e[0;37mwhiteish\e[0m"
+    expect("whiteish".send(:whiteish)).to eq("\e[0;37mwhiteish\e[0m")
   end
 end

spec/ext/action_view_spec.rb

@@ -11,12 +11,12 @@ begin
     
     it "uses HTML and adds 'debug_dump' class to plain <pre> tag" do
       markup = rand
-      @view.ap(markup, :plain => true).should == %Q|<pre class="debug_dump">#{markup}</pre>|
+      expect(@view.ap(markup, :plain => true)).to eq(%Q|<pre class="debug_dump">#{markup}</pre>|)
     end
 
     it "uses HTML and adds 'debug_dump' class to colorized <pre> tag" do
       markup = ' &<hello>'
-      @view.ap(markup).should == '<pre class="debug_dump"><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>'
+      expect(@view.ap(markup)).to eq('<pre class="debug_dump"><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>')
     end
   end
 

spec/ext/active_record_spec.rb

@@ -79,7 +79,7 @@ EOS
           else
             str.sub!('?', '1992-10-10 12:30:00 UTC')
           end
-          out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+          expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
         end
 
         it "display multiple records" do
@@ -109,7 +109,7 @@ EOS
             str.sub!('??', '1992-10-10 12:30:00 UTC')
             str.sub!('?!', '2003-05-26 14:15:00 UTC')
           end
-          out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+          expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
         end
       end
 
@@ -203,7 +203,7 @@ EOS
 EOS
           end
           str.sub!('?', '1992-10-10 12:30:00')
-          out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+          expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
         end
 
         it "display multiple records" do
@@ -355,7 +355,7 @@ EOS
           end
           str.sub!('?', '1992-10-10 12:30:00')
           str.sub!('?', '2003-05-26 14:15:00')
-          out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+          expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
         end
       end
 
@@ -366,7 +366,7 @@ EOS
         end
 
         it "should print the class" do
-          @ap.send(:awesome, User).should == <<-EOS.strip
+          expect(@ap.send(:awesome, User)).to eq <<-EOS.strip
 class User < ActiveRecord::Base {
             :id => :integer,
           :name => :string,
@@ -378,7 +378,7 @@ EOS
         end
 
         it "should print the class for non-direct subclasses of ActiveRecord::Base" do
-          @ap.send(:awesome, SubUser).should == <<-EOS.strip
+          expect(@ap.send(:awesome, SubUser)).to eq <<-EOS.strip
 class SubUser < User {
             :id => :integer,
           :name => :string,
@@ -390,7 +390,7 @@ EOS
         end
 
         it "should print ActiveRecord::Base objects (ex. ancestors)" do
-          lambda { @ap.send(:awesome, User.ancestors) }.should_not raise_error
+          expect { @ap.send(:awesome, User.ancestors) }.not_to raise_error
         end
       end
 
@@ -405,22 +405,22 @@ EOS
 
           if ActiveRecord::VERSION::STRING >= "3.2"
             if RUBY_VERSION >= "1.9"
-              out.should =~ /\sfirst\(\*args,\s&block\)\s+Class \(ActiveRecord::Querying\)/
+              expect(out).to match(/\sfirst\(\*args,\s&block\)\s+Class \(ActiveRecord::Querying\)/)
             else
-              out.should =~ /\sfirst\(\*arg1\)\s+Class \(ActiveRecord::Querying\)/
+              expect(out).to match(/\sfirst\(\*arg1\)\s+Class \(ActiveRecord::Querying\)/)
             end
           else
-            out.should =~ /\sfirst\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/
+            expect(out).to match(/\sfirst\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/)
           end
 
           out = @ap.send(:awesome, User.methods.grep(/primary_key/))
-          out.should =~ /\sprimary_key\(.*?\)\s+User/
+          expect(out).to match(/\sprimary_key\(.*?\)\s+User/)
 
           out = @ap.send(:awesome, User.methods.grep(/validate/))
           if ActiveRecord::VERSION::MAJOR < 3
-            out.should =~ /\svalidate\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/
+            expect(out).to match(/\svalidate\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/)
           else
-            out.should =~ /\svalidate\(\*arg.*?\)\s+Class \(ActiveModel::Validations::ClassMethods\)/
+            expect(out).to match(/\svalidate\(\*arg.*?\)\s+Class \(ActiveModel::Validations::ClassMethods\)/)
           end
         end
       end

spec/ext/active_support_spec.rb

@@ -13,20 +13,20 @@ begin
     it "should format ActiveSupport::TimeWithZone as regular Time" do
       Time.zone = 'Eastern Time (US & Canada)'
       time = Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone
-      @ap.send(:awesome, time).should == "\e[0;32mSat, 10 Feb 2007 15:30:45 EST -05:00\e[0m"
+      expect(@ap.send(:awesome, time)).to eq("\e[0;32mSat, 10 Feb 2007 15:30:45 EST -05:00\e[0m")
     end
 
     it "should format HashWithIndifferentAccess as regular Hash" do
       hash = HashWithIndifferentAccess.new({ :hello => "world" })
-      @ap.send(:awesome, hash).should == "{\n    \"hello\"\e[0;37m => \e[0m\e[0;33m\"world\"\e[0m\n}"
+      expect(@ap.send(:awesome, hash)).to eq("{\n    \"hello\"\e[0;37m => \e[0m\e[0;33m\"world\"\e[0m\n}")
     end
 
     # ActiveSupport sticks in instance variables to the date object. Make sure
     # we ignore that and format Date instance as regular date.
     it "should formate Date object as date" do
       date = Date.new(2003, 5, 26)
-      date.ai(:plain => true).should == "Mon, 26 May 2003"
+      expect(date.ai(:plain => true)).to eq("Mon, 26 May 2003")
-      date.ai.should == "\e[0;32mMon, 26 May 2003\e[0m"
+      expect(date.ai).to eq("\e[0;32mMon, 26 May 2003\e[0m")
     end
   end
 

spec/ext/mongo_mapper_spec.rb

@@ -45,11 +45,11 @@ begin
 >
 EOS
         out.gsub!(/0x([a-f\d]+)/, "0x01234567")
-        out.should == str
+        expect(out).to eq(str)
       end
 
       it "should print the class" do
-        @ap.send(:awesome, MongoUser).should == <<-EOS.strip
+        expect(@ap.send(:awesome, MongoUser)).to eq <<-EOS.strip
 class MongoUser < Object {
            "_id" => :object_id,
     "first_name" => :string,
@@ -64,7 +64,7 @@ EOS
           key :last_attribute
         end
 
-        @ap.send(:awesome, Chamelion).should == <<-EOS.strip
+        expect(@ap.send(:awesome, Chamelion)).to eq <<-EOS.strip
 class Chamelion < Object {
                "_id" => :object_id,
     "last_attribute" => :undefined
@@ -96,7 +96,7 @@ EOS
 
       describe "with show associations turned off (default)" do
         it "should render the class as normal" do
-          @ap.send(:awesome, Parent).should == <<-EOS.strip
+          expect(@ap.send(:awesome, Parent)).to eq <<-EOS.strip
 class Parent < Object {
      "_id" => :object_id,
     "name" => :undefined
@@ -115,7 +115,7 @@ EOS
 EOS
           out.gsub!(/'([\w]+){23}'/, "'4d9183739a546f6806000001'")
           out.gsub!(/0x([a-f\d]+)/, "0x01234567")
-          out.should == str
+          expect(out).to eq(str)
         end
       end
 
@@ -125,7 +125,7 @@ EOS
         end
 
         it "should render the class with associations shown" do
-          @ap.send(:awesome, Parent).should == <<-EOS.strip
+          expect(@ap.send(:awesome, Parent)).to eq <<-EOS.strip
 class Parent < Object {
         "_id" => :object_id,
        "name" => :undefined,
@@ -148,7 +148,7 @@ EOS
 EOS
           out.gsub!(/'([\w]+){23}'/, "'4d9183739a546f6806000001'")
           out.gsub!(/0x([a-f\d]+)/, "0x01234567")
-          out.should == str
+          expect(out).to eq(str)
         end
       end
 
@@ -178,7 +178,7 @@ EOS
 EOS
           out.gsub!(/'([\w]+){23}'/, "'4d9183739a546f6806000001'")
           out.gsub!(/0x([a-f\d]+)/, "0x01234567")
-          out.should == str
+          expect(out).to eq(str)
         end
       end
     end

spec/ext/mongoid_spec.rb

@@ -42,12 +42,12 @@ EOS
       else
         out.gsub!(/Id\('[^']+/, "Id('424242424242424242424242")
       end
-      out.should == str
+      expect(out).to eq(str)
     end
 
     it "should print the class" do
       moped_or_not = defined?(::Moped) ? 'moped/' : ''
-      @ap.send(:awesome, MongoUser).should == <<-EOS.strip
+      expect(@ap.send(:awesome, MongoUser)).to eq <<-EOS.strip
 class MongoUser < Object {
            :_id => :"#{moped_or_not}bson/object_id",
          :_type => :string,
@@ -65,7 +65,7 @@ EOS
 
       moped_or_not = defined?(::Moped) ? 'moped/' : ''
       last_attribute = defined?(::Moped) ? 'object' : '"mongoid/fields/serializable/object"'
-      @ap.send(:awesome, Chamelion).should == <<-EOS.strip
+      expect(@ap.send(:awesome, Chamelion)).to eq <<-EOS.strip
 class Chamelion < Object {
                :_id => :"#{moped_or_not}bson/object_id",
              :_type => :string,

spec/ext/nokogiri_spec.rb

@@ -11,7 +11,7 @@ begin
 
     it "should colorize tags" do
       xml = Nokogiri::XML('<html><body><h1></h1></body></html>')
-      xml.ai.should ==  <<-EOS
+      expect(xml.ai).to eq  <<-EOS
 <?xml version=\"1.0\"?>\e[1;32m
 \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
   \e[0m<\e[1;36mbody\e[0m>\e[1;32m
@@ -23,7 +23,7 @@ EOS
 
     it "should colorize contents" do
       xml = Nokogiri::XML('<html><body><h1>Hello</h1></body></html>')
-      xml.ai.should ==  <<-EOS
+      expect(xml.ai).to eq  <<-EOS
 <?xml version=\"1.0\"?>\e[1;32m
 \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
   \e[0m<\e[1;36mbody\e[0m>\e[1;32m
@@ -35,7 +35,7 @@ EOS
 
     it "should colorize class and id" do
       xml = Nokogiri::XML('<html><body><h1><span id="hello" class="world"></span></h1></body></html>')
-      xml.ai.should ==  <<-EOS
+      expect(xml.ai).to eq  <<-EOS
 <?xml version=\"1.0\"?>\e[1;32m
 \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
   \e[0m<\e[1;36mbody\e[0m>\e[1;32m

spec/ext/ripple_spec.rb

@@ -29,7 +29,7 @@ begin
       user = RippleUser.new :_id => "12345", :first_name => "Al", :last_name => "Capone"
       out = @ap.send :awesome, user
 
-      out.should == <<-EOS.strip
+      expect(out).to eq <<-EOS.strip
 #<RippleUser:12345> {
            :_id => "12345",
     :first_name => "Al",
@@ -39,7 +39,7 @@ EOS
     end
 
     it "should print the class" do
-      @ap.send(:awesome, RippleUser).should == <<-EOS.strip
+      expect(@ap.send(:awesome, RippleUser)).to eq <<-EOS.strip
 class RippleUser < Object {
            :_id => :string,
          :_type => :string,

spec/formats_spec.rb

@@ -14,11 +14,11 @@ describe "AwesomePrint" do
     end
 
     it "empty array" do
-      [].ai.should == "[]"
+      expect([].ai).to eq("[]")
     end
 
     it "plain multiline" do
-      @arr.ai(:plain => true).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -35,7 +35,7 @@ EOS
       end
 
     it "plain multiline without index" do
-      @arr.ai(:plain => true, :index => false).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :index => false)).to eq <<-EOS.strip
 [
     1,
     :two,
@@ -52,7 +52,7 @@ EOS
       end
 
     it "plain multiline indented" do
-      @arr.ai(:plain => true, :indent => 2).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :indent => 2)).to eq <<-EOS.strip
 [
   [0] 1,
   [1] :two,
@@ -69,7 +69,7 @@ EOS
     end
 
     it "plain multiline indented without index" do
-      @arr.ai(:plain => true, :indent => 2, :index => false).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :indent => 2, :index => false)).to eq <<-EOS.strip
 [
   1,
   :two,
@@ -86,11 +86,11 @@ EOS
     end
 
     it "plain single line" do
-      @arr.ai(:plain => true, :multiline => false).should == '[ 1, :two, "three", [ nil, [ true, false ] ] ]'
+      expect(@arr.ai(:plain => true, :multiline => false)).to eq('[ 1, :two, "three", [ nil, [ true, false ] ] ]')
     end
 
     it "colored multiline (default)" do
-      @arr.ai.should == <<-EOS.strip
+      expect(@arr.ai).to eq <<-EOS.strip
 [
     \e[1;37m[0] \e[0m\e[1;34m1\e[0m,
     \e[1;37m[1] \e[0m\e[0;36m:two\e[0m,
@@ -107,7 +107,7 @@ EOS
       end
 
     it "colored multiline indented" do
-      @arr.ai(:indent => 8).should == <<-EOS.strip
+      expect(@arr.ai(:indent => 8)).to eq <<-EOS.strip
 [
         \e[1;37m[0] \e[0m\e[1;34m1\e[0m,
         \e[1;37m[1] \e[0m\e[0;36m:two\e[0m,
@@ -124,7 +124,7 @@ EOS
     end
 
     it "colored single line" do
-      @arr.ai(:multiline => false).should == "[ \e[1;34m1\e[0m, \e[0;36m:two\e[0m, \e[0;33m\"three\"\e[0m, [ \e[1;31mnil\e[0m, [ \e[1;32mtrue\e[0m, \e[1;31mfalse\e[0m ] ] ]"
+      expect(@arr.ai(:multiline => false)).to eq("[ \e[1;34m1\e[0m, \e[0;36m:two\e[0m, \e[0;33m\"three\"\e[0m, [ \e[1;31mnil\e[0m, [ \e[1;32mtrue\e[0m, \e[1;31mfalse\e[0m ] ] ]")
     end
   end
 
@@ -136,7 +136,7 @@ EOS
     end
 
     it "plain multiline" do
-      @arr.ai(:plain => true).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] 2,
@@ -146,7 +146,7 @@ EOS
     end
 
     it "plain multiline without index" do
-      @arr.ai(:plain => true, :index => false).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :index => false)).to eq <<-EOS.strip
 [
     1,
     2,
@@ -156,7 +156,7 @@ EOS
     end
 
     it "plain single line" do
-      @arr.ai(:plain => true, :multiline => false).should == "[ 1, 2, [...] ]"
+      expect(@arr.ai(:plain => true, :multiline => false)).to eq("[ 1, 2, [...] ]")
     end
   end
 
@@ -167,7 +167,7 @@ EOS
     end
 
     it "plain limited output large" do
-      @arr.ai(:plain => true, :limit => true).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :limit => true)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -182,7 +182,7 @@ EOS
 
     it "plain limited output small" do
       @arr = @arr[0..3]
-      @arr.ai(:plain => true, :limit => true).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :limit => true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] 2,
@@ -193,7 +193,7 @@ EOS
     end
 
     it "plain limited output with 10 lines" do
-      @arr.ai(:plain => true, :limit => 10).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :limit => 10)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -210,7 +210,7 @@ EOS
     end
 
     it "plain limited output with 11 lines" do
-      @arr.ai(:plain => true, :limit => 11).should == <<-EOS.strip
+      expect(@arr.ai(:plain => true, :limit => 11)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -235,7 +235,7 @@ EOS
     end
 
     it "plain limited output" do
-      @hash.ai(:sort_keys => true, :plain => true, :limit => true).should == <<-EOS.strip
+      expect(@hash.ai(:sort_keys => true, :plain => true, :limit => true)).to eq <<-EOS.strip
 {
     "a" => :a,
     "b" => :b,
@@ -256,11 +256,11 @@ EOS
     end
     
     it "empty hash" do
-      {}.ai.should == "{}"
+      expect({}.ai).to eq("{}")
     end
     
     it "plain multiline" do
-      @hash.ai(:plain => true).should == <<-EOS.strip
+      expect(@hash.ai(:plain => true)).to eq <<-EOS.strip
 {
     1 => {
         :sym => {
@@ -276,7 +276,7 @@ EOS
     end
 
     it "plain multiline indented" do
-      @hash.ai(:plain => true, :indent => 1).should == <<-EOS.strip
+      expect(@hash.ai(:plain => true, :indent => 1)).to eq <<-EOS.strip
 {
  1 => {
   :sym => {
@@ -292,11 +292,11 @@ EOS
     end
 
     it "plain single line" do
-      @hash.ai(:plain => true, :multiline => false).should == '{ 1 => { :sym => { "str" => { [ 1, 2, 3 ] => { { :k => :v } => Hash < Object } } } } }'
+      expect(@hash.ai(:plain => true, :multiline => false)).to eq('{ 1 => { :sym => { "str" => { [ 1, 2, 3 ] => { { :k => :v } => Hash < Object } } } } }')
     end
 
     it "colored multiline (default)" do
-      @hash.ai.should == <<-EOS.strip
+      expect(@hash.ai).to eq <<-EOS.strip
 {
     1\e[0;37m => \e[0m{
         :sym\e[0;37m => \e[0m{
@@ -312,7 +312,7 @@ EOS
     end
 
     it "colored multiline indented" do
-      @hash.ai(:indent => 2).should == <<-EOS.strip
+      expect(@hash.ai(:indent => 2)).to eq <<-EOS.strip
 {
   1\e[0;37m => \e[0m{
     :sym\e[0;37m => \e[0m{
@@ -328,7 +328,7 @@ EOS
     end
 
     it "colored single line" do
-      @hash.ai(:multiline => false).should == "{ 1\e[0;37m => \e[0m{ :sym\e[0;37m => \e[0m{ \"str\"\e[0;37m => \e[0m{ [ 1, 2, 3 ]\e[0;37m => \e[0m{ { :k => :v }\e[0;37m => \e[0m\e[1;33mHash < Object\e[0m } } } } }"
+      expect(@hash.ai(:multiline => false)).to eq("{ 1\e[0;37m => \e[0m{ :sym\e[0;37m => \e[0m{ \"str\"\e[0;37m => \e[0m{ [ 1, 2, 3 ]\e[0;37m => \e[0m{ { :k => :v }\e[0;37m => \e[0m\e[1;33mHash < Object\e[0m } } } } }")
     end
 
   end
@@ -341,7 +341,7 @@ EOS
     end
 
     it "plain multiline" do
-      @hash.ai(:plain => true).should == <<-EOS.strip
+      expect(@hash.ai(:plain => true)).to eq <<-EOS.strip
 {
     :a => {...}
 }
@@ -349,7 +349,7 @@ EOS
     end
 
     it "plain single line" do
-      @hash.ai(:plain => true, :multiline => false).should == '{ :a => {...} }'
+      expect(@hash.ai(:plain => true, :multiline => false)).to eq('{ :a => {...} }')
     end
   end
 
@@ -362,13 +362,13 @@ EOS
     it "plain multiline" do
       out = @hash.ai(:plain => true)
       if RUBY_VERSION.to_f < 1.9 # Order of @hash keys is not guaranteed.
-        out.should =~ /^\{[^\}]+\}/m
+        expect(out).to match(/^\{[^\}]+\}/m)
-        out.should =~ /        "b" => "b",?/
+        expect(out).to match(/        "b" => "b",?/)
-        out.should =~ /         :a => "a",?/
+        expect(out).to match(/         :a => "a",?/)
-        out.should =~ /         :z => "z",?/
+        expect(out).to match(/         :z => "z",?/)
-        out.should =~ /    "alpha" => "alpha",?$/
+        expect(out).to match(/    "alpha" => "alpha",?$/)
       else
-        out.should == <<-EOS.strip
+        expect(out).to eq <<-EOS.strip
 {
         "b" => "b",
          :a => "a",
@@ -380,7 +380,7 @@ EOS
     end
     
     it "plain multiline with sorted keys" do
-      @hash.ai(:plain => true, :sort_keys => true).should == <<-EOS.strip
+      expect(@hash.ai(:plain => true, :sort_keys => true)).to eq <<-EOS.strip
 {
          :a => "a",
     "alpha" => "alpha",
@@ -401,7 +401,7 @@ EOS
     it "hash keys must be left aligned" do
       hash = { [0, 0, 255] => :yellow, :red => "rgb(255, 0, 0)", "magenta" => "rgb(255, 0, 255)" }
       out = hash.ai(:plain => true, :indent => -4, :sort_keys => true)
-      out.should == <<-EOS.strip
+      expect(out).to eq <<-EOS.strip
 {
     [ 0, 0, 255 ] => :yellow,
     "magenta"     => "rgb(255, 0, 255)",
@@ -413,7 +413,7 @@ EOS
     it "nested hash keys should be indented (array of hashes)" do
       arr = [ { :a => 1, :bb => 22, :ccc => 333}, { 1 => :a, 22 => :bb, 333 => :ccc} ]
       out = arr.ai(:plain => true, :indent => -4, :sort_keys => true)
-      out.should == <<-EOS.strip
+      expect(out).to eq <<-EOS.strip
 [
     [0] {
         :a   => 1,
@@ -432,7 +432,7 @@ EOS
     it "nested hash keys should be indented (hash of hashes)" do
       arr = { :first => { :a => 1, :bb => 22, :ccc => 333}, :second => { 1 => :a, 22 => :bb, 333 => :ccc} }
       out = arr.ai(:plain => true, :indent => -4, :sort_keys => true)
-      out.should == <<-EOS.strip
+      expect(out).to eq <<-EOS.strip
 {
     :first  => {
         :a   => 1,
@@ -452,11 +452,11 @@ EOS
   #------------------------------------------------------------------------------
   describe "Class" do
     it "shoud show superclass (plain)" do
-      self.class.ai(:plain => true).should == "#{self.class} < #{self.class.superclass}"
+      expect(self.class.ai(:plain => true)).to eq("#{self.class} < #{self.class.superclass}")
     end
 
     it "shoud show superclass (color)" do
-      self.class.ai.should == "#{self.class} < #{self.class.superclass}".yellow
+      expect(self.class.ai).to eq("#{self.class} < #{self.class.superclass}".yellow)
     end
   end
 
@@ -464,7 +464,7 @@ EOS
   describe "File" do
     it "should display a file (plain)" do
       File.open(__FILE__, "r") do |f|
-        f.ai(:plain => true).should == "#{f.inspect}\n" << `ls -alF #{f.path}`.chop
+        expect(f.ai(:plain => true)).to eq("#{f.inspect}\n" << `ls -alF #{f.path}`.chop)
       end
     end
   end
@@ -473,7 +473,7 @@ EOS
   describe "Dir" do
     it "should display a direcory (plain)" do
       Dir.open(File.dirname(__FILE__)) do |d|
-        d.ai(:plain => true).should == "#{d.inspect}\n" << `ls -alF #{d.path}`.chop
+        expect(d.ai(:plain => true)).to eq("#{d.inspect}\n" << `ls -alF #{d.path}`.chop)
       end
     end
   end
@@ -482,7 +482,7 @@ EOS
   describe "BigDecimal and Rational" do
     it "should present BigDecimal object with arbitrary precision" do
       big = BigDecimal("201020102010201020102010201020102010.4")
-      big.ai(:plain => true).should == "201020102010201020102010201020102010.4"
+      expect(big.ai(:plain => true)).to eq("201020102010201020102010201020102010.4")
     end
 
     it "should present Rational object with arbitrary precision" do
@@ -494,9 +494,9 @@ EOS
       # http://www.ruby-forum.com/topic/189397
       #
       if RUBY_VERSION < "1.9"
-        out.should == "100510051005100510051005100510051005"
+        expect(out).to eq("100510051005100510051005100510051005")
       else
-        out.should == "100510051005100510051005100510051005/1"
+        expect(out).to eq("100510051005100510051005100510051005/1")
       end
     end
   end
@@ -507,8 +507,8 @@ EOS
       ap = AwesomePrint::Inspector.new
       ap.send(:merge_options!, { :color => { :array => :black }, :indent => 0 })
       options = ap.instance_variable_get("@options")
-      options[:color][:array].should == :black
+      expect(options[:color][:array]).to eq(:black)
-      options[:indent].should == 0
+      expect(options[:indent]).to eq(0)
     end
   end
 
@@ -520,40 +520,40 @@ EOS
     end
 
     it "empty set" do
-      Set.new.ai.should == [].ai
+      expect(Set.new.ai).to eq([].ai)
     end
 
     if RUBY_VERSION > "1.9"
       it "plain multiline" do
-        @set.ai(:plain => true).should == @arr.ai(:plain => true)
+        expect(@set.ai(:plain => true)).to eq(@arr.ai(:plain => true))
       end
 
       it "plain multiline indented" do
-        @set.ai(:plain => true, :indent => 1).should == @arr.ai(:plain => true, :indent => 1)
+        expect(@set.ai(:plain => true, :indent => 1)).to eq(@arr.ai(:plain => true, :indent => 1))
       end
 
       it "plain single line" do
-        @set.ai(:plain => true, :multiline => false).should == @arr.ai(:plain => true, :multiline => false)
+        expect(@set.ai(:plain => true, :multiline => false)).to eq(@arr.ai(:plain => true, :multiline => false))
       end
 
       it "colored multiline (default)" do
-        @set.ai.should == @arr.ai
+        expect(@set.ai).to eq(@arr.ai)
       end
     else # Prior to Ruby 1.9 the order of set values is unpredicatble.
       it "plain multiline" do
-        @set.sort_by{ |x| x.to_s }.ai(:plain => true).should == @arr.sort_by{ |x| x.to_s }.ai(:plain => true)
+        expect(@set.sort_by{ |x| x.to_s }.ai(:plain => true)).to eq(@arr.sort_by{ |x| x.to_s }.ai(:plain => true))
       end
 
       it "plain multiline indented" do
-        @set.sort_by{ |x| x.to_s }.ai(:plain => true, :indent => 1).should == @arr.sort_by{ |x| x.to_s }.ai(:plain => true, :indent => 1)
+        expect(@set.sort_by{ |x| x.to_s }.ai(:plain => true, :indent => 1)).to eq(@arr.sort_by{ |x| x.to_s }.ai(:plain => true, :indent => 1))
       end
 
       it "plain single line" do
-        @set.sort_by{ |x| x.to_s }.ai(:plain => true, :multiline => false).should == @arr.sort_by{ |x| x.to_s }.ai(:plain => true, :multiline => false)
+        expect(@set.sort_by{ |x| x.to_s }.ai(:plain => true, :multiline => false)).to eq(@arr.sort_by{ |x| x.to_s }.ai(:plain => true, :multiline => false))
       end
 
       it "colored multiline (default)" do
-        @set.sort_by{ |x| x.to_s }.ai.should == @arr.sort_by{ |x| x.to_s }.ai
+        expect(@set.sort_by{ |x| x.to_s }.ai).to eq(@arr.sort_by{ |x| x.to_s }.ai)
       end
     end
   end
@@ -571,7 +571,7 @@ EOS
     end
     
     it "empty struct" do
-      Struct.new("EmptyStruct").ai.should ==  "\e[1;33mStruct::EmptyStruct < Struct\e[0m"
+      expect(Struct.new("EmptyStruct").ai).to eq("\e[1;33mStruct::EmptyStruct < Struct\e[0m")
     end
     
     it "plain multiline" do
@@ -587,7 +587,7 @@ EOS
     :address => "1313 Mockingbird Lane"
 }
 EOS
-      @struct.ai(:plain => true).should satisfy { |match| match == s1 || match == s2 }
+      expect(@struct.ai(:plain => true)).to satisfy { |match| match == s1 || match == s2 }
     end
 
     it "plain multiline indented" do
@@ -603,13 +603,13 @@ EOS
  :address => "1313 Mockingbird Lane"
 }
 EOS
-      @struct.ai(:plain => true, :indent => 1).should satisfy { |match| match == s1 || match == s2 }
+      expect(@struct.ai(:plain => true, :indent => 1)).to satisfy { |match| match == s1 || match == s2 }
     end
 
     it "plain single line" do
       s1 = "{ :address => \"1313 Mockingbird Lane\", :name => \"Herman Munster\" }"
       s2 = "{ :name => \"Herman Munster\", :address => \"1313 Mockingbird Lane\" }"
-      @struct.ai(:plain => true, :multiline => false).should satisfy { |match| match == s1 || match == s2 }
+      expect(@struct.ai(:plain => true, :multiline => false)).to satisfy { |match| match == s1 || match == s2 }
     end
 
     it "colored multiline (default)" do
@@ -625,7 +625,7 @@ EOS
     :address\e[0;37m => \e[0m\e[0;33m\"1313 Mockingbird Lane\"\e[0m
 }
 EOS
-      @struct.ai.should satisfy { |match| match == s1 || match == s2 }
+      expect(@struct.ai).to satisfy { |match| match == s1 || match == s2 }
     end
   end
 
@@ -639,7 +639,7 @@ EOS
       class My < Array; end
 
       my = My.new([ 1, :two, "three", [ nil, [ true, false ] ] ])
-      my.ai(:plain => true).should == <<-EOS.strip
+      expect(my.ai(:plain => true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -659,7 +659,7 @@ EOS
       class My < Hash; end
 
       my = My[ { 1 => { :sym => { "str" => { [1, 2, 3] => { { :k => :v } => Hash } } } } } ]
-      my.ai(:plain => true).should == <<-EOS.strip
+      expect(my.ai(:plain => true)).to eq <<-EOS.strip
 {
     1 => {
         :sym => {
@@ -678,7 +678,7 @@ EOS
       class My < File; end
 
       my = File.new('/dev/null') rescue File.new('nul')
-      my.ai(:plain => true).should == "#{my.inspect}\n" << `ls -alF #{my.path}`.chop
+      expect(my.ai(:plain => true)).to eq("#{my.inspect}\n" << `ls -alF #{my.path}`.chop)
     end
 
     it "inherited from Dir should be displayed as Dir" do
@@ -686,7 +686,7 @@ EOS
 
       require 'tmpdir'
       my = My.new(Dir.tmpdir)
-      my.ai(:plain => true).should == "#{my.inspect}\n" << `ls -alF #{my.path}`.chop
+      expect(my.ai(:plain => true)).to eq("#{my.inspect}\n" << `ls -alF #{my.path}`.chop)
     end
 
     it "should handle a class that defines its own #send method" do
@@ -695,7 +695,7 @@ EOS
       end
 
       my = My.new
-      my.methods.ai(:plain => true).should_not raise_error(ArgumentError)
+      expect(my.methods.ai(:plain => true)).not_to raise_error
     end
 
     it "should handle a class defines its own #method method (ex. request.method)" do
@@ -706,7 +706,7 @@ EOS
       end
 
       my = My.new
-      my.methods.ai(:plain => true).should_not raise_error(ArgumentError)
+      expect(my.methods.ai(:plain => true)).not_to raise_error
     end
   end
 end

spec/methods_spec.rb

@@ -11,52 +11,52 @@ describe "Single method" do
 
   it "plain: should handle a method with no arguments" do
     method = ''.method(:upcase)
-    method.ai(:plain => true).should == 'String#upcase()'
+    expect(method.ai(:plain => true)).to eq('String#upcase()')
   end
 
   it "color: should handle a method with no arguments" do
     method = ''.method(:upcase)
-    method.ai.should == "\e[1;33mString\e[0m#\e[0;35mupcase\e[0m\e[0;37m()\e[0m"
+    expect(method.ai).to eq("\e[1;33mString\e[0m#\e[0;35mupcase\e[0m\e[0;37m()\e[0m")
   end
 
   it "plain: should handle a method with one argument" do
     method = ''.method(:include?)
-    method.ai(:plain => true).should == 'String#include?(arg1)'
+    expect(method.ai(:plain => true)).to eq('String#include?(arg1)')
   end
 
   it "color: should handle a method with one argument" do
     method = ''.method(:include?)
-    method.ai.should == "\e[1;33mString\e[0m#\e[0;35minclude?\e[0m\e[0;37m(arg1)\e[0m"
+    expect(method.ai).to eq("\e[1;33mString\e[0m#\e[0;35minclude?\e[0m\e[0;37m(arg1)\e[0m")
   end
 
   it "plain: should handle a method with two arguments" do
     method = ''.method(:tr)
-    method.ai(:plain => true).should == 'String#tr(arg1, arg2)'
+    expect(method.ai(:plain => true)).to eq('String#tr(arg1, arg2)')
   end
 
   it "color: should handle a method with two arguments" do
     method = ''.method(:tr)
-    method.ai.should == "\e[1;33mString\e[0m#\e[0;35mtr\e[0m\e[0;37m(arg1, arg2)\e[0m"
+    expect(method.ai).to eq("\e[1;33mString\e[0m#\e[0;35mtr\e[0m\e[0;37m(arg1, arg2)\e[0m")
   end
 
   it "plain: should handle a method with multiple arguments" do
     method = ''.method(:split)
-    method.ai(:plain => true).should == 'String#split(*arg1)'
+    expect(method.ai(:plain => true)).to eq('String#split(*arg1)')
   end
 
   it "color: should handle a method with multiple arguments" do
     method = ''.method(:split)
-    method.ai.should == "\e[1;33mString\e[0m#\e[0;35msplit\e[0m\e[0;37m(*arg1)\e[0m"
+    expect(method.ai).to eq("\e[1;33mString\e[0m#\e[0;35msplit\e[0m\e[0;37m(*arg1)\e[0m")
   end
 
   it "plain: should handle a method defined in mixin" do
     method = ''.method(:is_a?)
-    method.ai(:plain => true).should == 'String (Kernel)#is_a?(arg1)'
+    expect(method.ai(:plain => true)).to eq('String (Kernel)#is_a?(arg1)')
   end
 
   it "color: should handle a method defined in mixin" do
     method = ''.method(:is_a?)
-    method.ai.should == "\e[1;33mString (Kernel)\e[0m#\e[0;35mis_a?\e[0m\e[0;37m(arg1)\e[0m"
+    expect(method.ai).to eq("\e[1;33mString (Kernel)\e[0m#\e[0;35mis_a?\e[0m\e[0;37m(arg1)\e[0m")
   end
 
   it "plain: should handle an unbound method" do
@@ -64,7 +64,7 @@ describe "Single method" do
       def world; end
     end
     method = Hello.instance_method(:world)
-    method.ai(:plain => true).should == 'Hello (unbound)#world()'
+    expect(method.ai(:plain => true)).to eq('Hello (unbound)#world()')
   end
 
   it "color: should handle an unbound method" do
@@ -73,9 +73,9 @@ describe "Single method" do
     end
     method = Hello.instance_method(:world)
     if RUBY_VERSION < '1.9.2'
-      method.ai.should == "\e[1;33mHello (unbound)\e[0m#\e[0;35mworld\e[0m\e[0;37m(arg1, arg2)\e[0m"
+      expect(method.ai).to eq("\e[1;33mHello (unbound)\e[0m#\e[0;35mworld\e[0m\e[0;37m(arg1, arg2)\e[0m")
     else
-      method.ai.should == "\e[1;33mHello (unbound)\e[0m#\e[0;35mworld\e[0m\e[0;37m(a, b)\e[0m"
+      expect(method.ai).to eq("\e[1;33mHello (unbound)\e[0m#\e[0;35mworld\e[0m\e[0;37m(a, b)\e[0m")
     end
   end
 end
@@ -92,36 +92,36 @@ describe "Object methods" do
   describe "object.methods" do
     it "index: should handle object.methods" do
       out = nil.methods.ai(:plain => true).split("\n").grep(/is_a\?/).first
-      out.should =~ /^\s+\[\s*\d+\]\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+\[\s*\d+\]\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/)
     end
 
     it "no index: should handle object.methods" do
       out = nil.methods.ai(:plain => true, :index => false).split("\n").grep(/is_a\?/).first
-      out.should =~ /^\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/)
     end
   end
 
   describe "object.public_methods" do
     it "index: should handle object.public_methods" do
       out = nil.public_methods.ai(:plain => true).split("\n").grep(/is_a\?/).first
-      out.should =~ /^\s+\[\s*\d+\]\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+\[\s*\d+\]\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/)
     end
 
     it "no index: should handle object.public_methods" do
       out = nil.public_methods.ai(:plain => true, :index => false).split("\n").grep(/is_a\?/).first
-      out.should =~ /^\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+is_a\?\(arg1\)\s+NilClass \(Kernel\)$/)
     end
   end
 
   describe "object.private_methods" do
     it "index: should handle object.private_methods" do
       out = nil.private_methods.ai(:plain => true).split("\n").grep(/sleep/).first
-      out.should =~ /^\s+\[\s*\d+\]\s+sleep\(\*arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+\[\s*\d+\]\s+sleep\(\*arg1\)\s+NilClass \(Kernel\)$/)
     end
 
     it "no index: should handle object.private_methods" do
       out = nil.private_methods.ai(:plain => true, :index => false).split("\n").grep(/sleep/).first
-      out.should =~ /^\s+sleep\(\*arg1\)\s+NilClass \(Kernel\)$/
+      expect(out).to match(/^\s+sleep\(\*arg1\)\s+NilClass \(Kernel\)$/)
     end
   end
 
@@ -132,7 +132,7 @@ describe "Object methods" do
         def m1; end
         def m2; end
       end
-      Hello.new.protected_methods.ai(:plain => true).should == "[\n    [0] m1() Hello\n    [1] m2() Hello\n]"
+      expect(Hello.new.protected_methods.ai(:plain => true)).to eq("[\n    [0] m1() Hello\n    [1] m2() Hello\n]")
     end
 
     it "no index: should handle object.protected_methods" do
@@ -141,9 +141,9 @@ describe "Object methods" do
         def m3(a,b); end
       end
       if RUBY_VERSION < '1.9.2'
-        Hello.new.protected_methods.ai(:plain => true, :index => false).should == "[\n     m3(arg1, arg2) Hello\n]"
+        expect(Hello.new.protected_methods.ai(:plain => true, :index => false)).to eq("[\n     m3(arg1, arg2) Hello\n]")
       else
-        Hello.new.protected_methods.ai(:plain => true, :index => false).should == "[\n     m3(a, b) Hello\n]"
+        expect(Hello.new.protected_methods.ai(:plain => true, :index => false)).to eq("[\n     m3(a, b) Hello\n]")
       end
     end
   end
@@ -157,8 +157,8 @@ describe "Object methods" do
       end
 
       out = Hello.new.private_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello$/)
     end
 
     it "no index: should handle object.private_methods" do
@@ -168,9 +168,9 @@ describe "Object methods" do
       end
       out = Hello.new.private_methods.ai(:plain => true).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+\[\s*\d+\]\s+m3\(arg1, arg2\)\s+Hello$/
+        expect(out.first).to match(/^\s+\[\s*\d+\]\s+m3\(arg1, arg2\)\s+Hello$/)
       else
-        out.first.should =~ /^\s+\[\s*\d+\]\s+m3\(a, b\)\s+Hello$/
+        expect(out.first).to match(/^\s+\[\s*\d+\]\s+m3\(a, b\)\s+Hello$/)
       end
     end
   end
@@ -184,8 +184,8 @@ describe "Object methods" do
         end
       end
       out = Hello.singleton_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello$/)
     end
 
     it "no index: should handle object.singleton_methods" do
@@ -194,9 +194,9 @@ describe "Object methods" do
       end
       out = Hello.singleton_methods.ai(:plain => true, :index => false).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+m3\(arg1, arg2\)\s+Hello$/
+        expect(out.first).to match(/^\s+m3\(arg1, arg2\)\s+Hello$/)
       else
-        out.first.should =~ /^\s+m3\(a, b\)\s+Hello$/
+        expect(out.first).to match(/^\s+m3\(a, b\)\s+Hello$/)
       end
     end
   end
@@ -218,8 +218,8 @@ describe "Class methods" do
         def m2; end
       end
       out = Hello.instance_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/)
     end
 
     it "no index: should handle unbound class.instance_methods" do
@@ -228,9 +228,9 @@ describe "Class methods" do
       end
       out = Hello.instance_methods.ai(:plain => true, :index => false).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/)
       else
-        out.first.should =~ /^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/)
       end
     end
   end
@@ -242,8 +242,8 @@ describe "Class methods" do
         def m2; end
       end
       out = Hello.public_instance_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/)
     end
 
     it "no index: should handle class.public_instance_methods" do
@@ -252,9 +252,9 @@ describe "Class methods" do
       end
       out = Hello.public_instance_methods.ai(:plain => true, :index => false).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/)
       else
-        out.first.should =~ /^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/)
       end
     end
   end
@@ -267,8 +267,8 @@ describe "Class methods" do
         def m2; end
       end
       out = Hello.protected_instance_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/)
     end
 
     it "no index: should handle class.protected_instance_methods" do
@@ -278,9 +278,9 @@ describe "Class methods" do
       end
       out = Hello.protected_instance_methods.ai(:plain => true, :index => false).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/)
       else
-        out.first.should =~ /^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/)
       end
     end
   end
@@ -293,8 +293,8 @@ describe "Class methods" do
         def m2; end
       end
       out = Hello.private_instance_methods.ai(:plain => true).split("\n").grep(/m\d/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello\s\(unbound\)$/)
-      out.last.should  =~ /^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/
+      expect(out.last).to  match(/^\s+\[\s*\d+\]\s+m2\(\)\s+Hello\s\(unbound\)$/)
     end
 
     it "no index: should handle class.private_instance_methods" do
@@ -304,9 +304,9 @@ describe "Class methods" do
       end
       out = Hello.private_instance_methods.ai(:plain => true, :index => false).split("\n").grep(/m\d/)
       if RUBY_VERSION < '1.9.2'
-        out.first.should =~ /^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(arg1, arg2\)\s+Hello\s\(unbound\)$/)
       else
-        out.first.should =~ /^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/
+        expect(out.first).to match(/^\s+m3\(a, b\)\s+Hello\s\(unbound\)$/)
       end
     end
   end
@@ -327,7 +327,7 @@ if RUBY_VERSION >= '1.9.2'
         def m1; end
       end
       out = Hello.new.methods.ai(:plain => true).split("\n").grep(/m1/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\)\s+Hello$/)
     end
 
     it ":req" do
@@ -335,7 +335,7 @@ if RUBY_VERSION >= '1.9.2'
         def m1(a, b, c); end
       end
       out = Hello.new.methods.ai(:plain => true).split("\n").grep(/m1/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(a, b, c\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(a, b, c\)\s+Hello$/)
     end
 
     it ":opt" do
@@ -343,7 +343,7 @@ if RUBY_VERSION >= '1.9.2'
         def m1(a, b = 1, c = 2); end # m1(a, *b, *c)
       end
       out = Hello.new.methods.ai(:plain => true).split("\n").grep(/m1/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(a, \*b, \*c\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(a, \*b, \*c\)\s+Hello$/)
     end
 
     it ":rest" do
@@ -351,7 +351,7 @@ if RUBY_VERSION >= '1.9.2'
         def m1(*a); end # m1(*a)
       end
       out = Hello.new.methods.ai(:plain => true).split("\n").grep(/m1/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(\*a\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(\*a\)\s+Hello$/)
     end
 
     it ":block" do
@@ -359,7 +359,7 @@ if RUBY_VERSION >= '1.9.2'
         def m1(a, b = nil, &blk); end # m1(a, *b, &blk)
       end
       out = Hello.new.methods.ai(:plain => true).split("\n").grep(/m1/)
-      out.first.should =~ /^\s+\[\s*\d+\]\s+m1\(a, \*b, &blk\)\s+Hello$/
+      expect(out.first).to match(/^\s+\[\s*\d+\]\s+m1\(a, \*b, &blk\)\s+Hello$/)
     end
   end
 end
@@ -376,7 +376,7 @@ describe "Methods arrays" do
       def self.m1; end
     end
     out = (Hello.methods - Class.methods).ai(:plain => true)
-    out.should == "[\n    [0] m1() Hello\n]"
+    expect(out).to eq("[\n    [0] m1() Hello\n]")
   end
 
   it "obj1.methods & obj2.methods should be awesome printed" do
@@ -389,7 +389,7 @@ describe "Methods arrays" do
       def self.m1; end
     end
     out = (Hello.methods & World.methods - Class.methods).ai(:plain => true)
-    out.should == "[\n    [0] m1() Hello\n]"
+    expect(out).to eq("[\n    [0] m1() Hello\n]")
   end
 
   it "obj1.methods.grep(pattern) should be awesome printed" do
@@ -400,9 +400,9 @@ describe "Methods arrays" do
       def self.m3; end
     end
     out = Hello.methods.grep(/^m1$/).ai(:plain => true)
-    out.should == "[\n    [0] m1() Hello\n]"
+    expect(out).to eq("[\n    [0] m1() Hello\n]")
     out = Hello.methods.grep(/^m\d$/).ai(:plain => true)
-    out.should == "[\n    [0] m1() Hello\n    [1] m2() Hello\n    [2] m3() Hello\n]"
+    expect(out).to eq("[\n    [0] m1() Hello\n    [1] m2() Hello\n    [2] m3() Hello\n]")
   end
 
   it "obj1.methods.grep(pattern, &block) should pass the matching string within the block" do
@@ -412,7 +412,7 @@ describe "Methods arrays" do
     end
 
     out = Hello.methods.sort.grep(/^m_(.+)$/) { $1.to_sym }
-    out.should == [:one, :two]
+    expect(out).to eq([:one, :two])
   end
 
   it "obj1.methods.grep(pattern, &block) should be awesome printed" do
@@ -425,7 +425,7 @@ describe "Methods arrays" do
     end
 
     out = Hello.methods.grep(/^m(\d)$/) { %w(none one)[$1.to_i] }.ai(:plain => true)
-    out.should == "[\n    [0] none() Hello\n    [1]  one() Hello\n]"
+    expect(out).to eq("[\n    [0] none() Hello\n    [1]  one() Hello\n]")
   end
 
   # See https://github.com/michaeldv/awesome_print/issues/30 for details.
@@ -444,16 +444,16 @@ describe "Methods arrays" do
     end
 
     hello = Hello.new
-    (hello.send(:his) - hello.send(:her)).sort_by { |x| x.to_s }.should == [ :him, :his ]
+    expect((hello.send(:his) - hello.send(:her)).sort_by { |x| x.to_s }).to eq([ :him, :his ])
   end
 
   it "appending garbage to methods array should not raise error" do
     arr = 42.methods << [ :wtf ]
-    arr.ai(:plain => true).should_not raise_error(TypeError)
+    expect(arr.ai(:plain => true)).not_to raise_error
     if RUBY_VERSION < '1.9.2'
-      arr.ai(:plain => true).should =~ /\s+wtf\(\?\)\s+\?/      # [ :wtf ].to_s => "wtf"
+      expect(arr.ai(:plain => true)).to match(/\s+wtf\(\?\)\s+\?/)      # [ :wtf ].to_s => "wtf"
     else
-      arr.ai(:plain => true).should =~ /\s+\[:wtf\]\(\?\)\s+\?/ # [ :wtf ].to_s => [:wtf]
+      expect(arr.ai(:plain => true)).to match(/\s+\[:wtf\]\(\?\)\s+\?/) # [ :wtf ].to_s => [:wtf]
     end
   end
 end

spec/misc_spec.rb

@@ -13,7 +13,7 @@ describe "AwesomePrint" do
           nil
         end
       end
-      weird.new.ai(:plain => true).should == ''
+      expect(weird.new.ai(:plain => true)).to eq('')
     end
 
     it "handle frozen object.inspect" do
@@ -22,14 +22,14 @@ describe "AwesomePrint" do
           "ice".freeze
         end
       end
-      weird.new.ai(:plain => false).should == "ice"
+      expect(weird.new.ai(:plain => false)).to eq("ice")
     end
 
     # See https://github.com/michaeldv/awesome_print/issues/35
     it "handle array grep when pattern contains / chapacter" do
       hash = { "1/x" => 1,  "2//x" => :"2" }
       grepped = hash.keys.sort.grep(/^(\d+)\//) { $1 }
-      grepped.ai(:plain => true, :multiline => false).should == '[ "1", "2" ]'
+      expect(grepped.ai(:plain => true, :multiline => false)).to eq('[ "1", "2" ]')
     end
 
     # See https://github.com/michaeldv/awesome_print/issues/85
@@ -37,32 +37,32 @@ describe "AwesomePrint" do
       it "handle array grep when a method is defined in C and thus doesn't have a binding" do
         arr = (0..6).to_a
         grepped = arr.grep(1..4, &:succ)
-        grepped.ai(:plain => true, :multiline => false).should == '[ 2, 3, 4, 5 ]'
+        expect(grepped.ai(:plain => true, :multiline => false)).to eq('[ 2, 3, 4, 5 ]')
       end
     end
 
     it "returns value passed as a parameter" do
       object = rand
-      self.stub!(:puts)
+      allow(self).to receive(:puts)
-      (ap object).should == object
+      expect(ap object).to eq(object)
     end
 
     # Require different file name this time (lib/ap.rb vs. lib/awesome_print).
     it "several require 'awesome_print' should do no harm" do
       require File.expand_path(File.dirname(__FILE__) + '/../lib/ap')
-      lambda { rand.ai }.should_not raise_error
+      expect { rand.ai }.not_to raise_error
     end
 
     it "format ENV as hash" do
-      ENV.ai(:plain => true).should == ENV.to_hash.ai(:plain => true)
+      expect(ENV.ai(:plain => true)).to eq(ENV.to_hash.ai(:plain => true))
-      ENV.ai.should == ENV.to_hash.ai
+      expect(ENV.ai).to eq(ENV.to_hash.ai)
     end
 
     # See https://github.com/michaeldv/awesome_print/issues/134
     it "IPAddr workaround" do
       require "ipaddr"
       ipaddr = IPAddr.new("3ffe:505:2::1")
-      ipaddr.ai.should == "#<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>"
+      expect(ipaddr.ai).to eq("#<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>")
     end
 
     # See https://github.com/michaeldv/awesome_print/issues/139
@@ -74,7 +74,7 @@ describe "AwesomePrint" do
         end
         alias :eql? :==
       end
-      lambda { weird.new.ai }.should_not raise_error
+      expect { weird.new.ai }.not_to raise_error
     end
   end
 
@@ -86,17 +86,17 @@ describe "AwesomePrint" do
 
     it "wraps ap output with plain <pre> tag" do
       markup = rand
-      markup.ai(:html => true, :plain => true).should == "<pre>#{markup}</pre>"
+      expect(markup.ai(:html => true, :plain => true)).to eq("<pre>#{markup}</pre>")
     end
 
     it "wraps ap output with <pre> tag with colorized <kbd>" do
       markup = rand
-      markup.ai(:html => true).should == %Q|<pre><kbd style="color:blue">#{markup}</kbd></pre>|
+      expect(markup.ai(:html => true)).to eq(%Q|<pre><kbd style="color:blue">#{markup}</kbd></pre>|)
     end
 
     it "wraps multiline ap output with <pre> tag with colorized <kbd>" do
       markup = [ 1, :two, "three" ]
-      markup.ai(:html => true).should == <<-EOS.strip
+      expect(markup.ai(:html => true)).to eq <<-EOS.strip
 <pre>[
     <kbd style="color:white">[0] </kbd><kbd style="color:blue">1</kbd>,
     <kbd style="color:white">[1] </kbd><kbd style="color:darkcyan">:two</kbd>,
@@ -107,7 +107,7 @@ EOS
 
     it "wraps hash ap output with only an outer <pre> tag" do
       markup = [ { "hello" => "world" } ]
-      markup.ai(:html => true).should == <<-EOS.strip
+      expect(markup.ai(:html => true)).to eq <<-EOS.strip
 <pre>[
     <kbd style="color:white">[0] </kbd>{
         &quot;hello&quot;<kbd style="color:slategray"> =&gt; </kbd><kbd style="color:brown">&quot;world&quot;</kbd>
@@ -118,12 +118,12 @@ EOS
 
     it "encodes HTML entities (plain)" do
       markup = ' &<hello>'
-      markup.ai(:html => true, :plain => true).should == '<pre>&quot; &amp;&lt;hello&gt;&quot;</pre>'
+      expect(markup.ai(:html => true, :plain => true)).to eq('<pre>&quot; &amp;&lt;hello&gt;&quot;</pre>')
     end
 
     it "encodes HTML entities (color)" do
       markup = ' &<hello>'
-      markup.ai(:html => true).should == '<pre><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>'
+      expect(markup.ai(:html => true)).to eq('<pre><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>')
     end
   end
 
@@ -142,7 +142,7 @@ EOS
       AwesomePrint.defaults = { :indent => -2, :sort_keys => true }
       hash = { [0, 0, 255] => :yellow, :red => "rgb(255, 0, 0)", "magenta" => "rgb(255, 0, 255)" }
       out = hash.ai(:plain => true)
-      out.should == <<-EOS.strip
+      expect(out).to eq <<-EOS.strip
 {
   [ 0, 0, 255 ] => :yellow,
   "magenta"     => "rgb(255, 0, 255)",
@@ -178,25 +178,25 @@ EOS
     it "shoud not raise ArgumentError when formatting HTML" do
       out = "hello".ai(:color => { :string => :red }, :html => true)
       if RUBY_VERSION >= "1.9"
-        out.should == %Q|<pre>[red]<kbd style="color:red">&quot;hello&quot;</kbd>[/red]</pre>|
+        expect(out).to eq(%Q|<pre>[red]<kbd style="color:red">&quot;hello&quot;</kbd>[/red]</pre>|)
       else
-        out.should == %Q|<pre>[red]&quot;hello&quot;[/red]</pre>|
+        expect(out).to eq(%Q|<pre>[red]&quot;hello&quot;[/red]</pre>|)
       end
     end
 
     it "shoud not raise ArgumentError when formatting HTML (shade color)" do
       out = "hello".ai(:color => { :string => :redish }, :html => true)
-      out.should == %Q|<pre><kbd style="color:darkred">&quot;hello&quot;</kbd></pre>|
+      expect(out).to eq(%Q|<pre><kbd style="color:darkred">&quot;hello&quot;</kbd></pre>|)
     end
 
     it "shoud not raise ArgumentError when formatting non-HTML" do
       out = "hello".ai(:color => { :string => :red }, :html => false)
-      out.should == %Q|[red]"hello"[/red]|
+      expect(out).to eq(%Q|[red]"hello"[/red]|)
     end
 
     it "shoud not raise ArgumentError when formatting non-HTML (shade color)" do
       out = "hello".ai(:color => { :string => :redish }, :html => false)
-      out.should == %Q|\e[0;31m"hello"\e[0m|
+      expect(out).to eq(%Q|\e[0;31m"hello"\e[0m|)
     end
   end
 
@@ -204,23 +204,23 @@ EOS
   describe "Console" do
     it "should detect IRB" do
       class IRB; end
-      AwesomePrint.console?.should == true
+      expect(AwesomePrint.console?).to eq(true)
-      AwesomePrint.rails_console?.should == false
+      expect(AwesomePrint.rails_console?).to eq(false)
       Object.instance_eval{ remove_const :IRB }
     end
 
     it "should detect Pry" do
       class Pry; end
-      AwesomePrint.console?.should == true
+      expect(AwesomePrint.console?).to eq(true)
-      AwesomePrint.rails_console?.should == false
+      expect(AwesomePrint.rails_console?).to eq(false)
       Object.instance_eval{ remove_const :Pry }
     end
 
     it "should detect Rails::Console" do
       class IRB; end
       class Rails; class Console; end; end
-      AwesomePrint.console?.should == true
+      expect(AwesomePrint.console?).to eq(true)
-      AwesomePrint.rails_console?.should == true
+      expect(AwesomePrint.rails_console?).to eq(true)
       Object.instance_eval{ remove_const :IRB }
       Object.instance_eval{ remove_const :Rails }
     end
@@ -228,20 +228,20 @@ EOS
     it "should detect ENV['RAILS_ENV']" do
       class Pry; end
       ENV["RAILS_ENV"] = "development"
-      AwesomePrint.console?.should == true
+      expect(AwesomePrint.console?).to eq(true)
-      AwesomePrint.rails_console?.should == true
+      expect(AwesomePrint.rails_console?).to eq(true)
       Object.instance_eval{ remove_const :Pry }
     end
 
     it "should return the actual object when *not* running under console" do
-      capture! { ap([ 1, 2, 3 ]) }.should == [ 1, 2, 3 ]
+      expect(capture! { ap([ 1, 2, 3 ]) }).to eq([ 1, 2, 3 ])
-      capture! { ap({ :a => 1 }) }.should == { :a => 1 }
+      expect(capture! { ap({ :a => 1 }) }).to eq({ :a => 1 })
     end
 
     it "should return nil when running under console" do
       class IRB; end
-      capture! { ap([ 1, 2, 3 ]) }.should == nil
+      expect(capture! { ap([ 1, 2, 3 ]) }).to eq(nil)
-      capture! { ap({ :a => 1 }) }.should == nil
+      expect(capture! { ap({ :a => 1 }) }).to eq(nil)
       Object.instance_eval{ remove_const :IRB }
     end
   end

spec/objects_spec.rb

@@ -30,8 +30,8 @@ describe "Objects" do
     attr_writer :ca = 2
 >
 EOS
-      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      hello.ai(:plain => true, :raw => false).should == hello.inspect
+      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
     end
 
     it "instance variables" do
@@ -50,8 +50,8 @@ EOS
     @dabra = 3
 >
 EOS
-      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      hello.ai(:plain => true, :raw => false).should == hello.inspect
+      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
     end
 
     it "attributes and instance variables" do
@@ -78,8 +78,8 @@ EOS
     attr_writer :ca = 2
 >
 EOS
-      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      hello.ai(:plain => true, :raw => false).should == hello.inspect
+      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
     end
   end
 end

spec/spec_helper.rb

@@ -20,7 +20,7 @@ require 'awesome_print'
 
 def stub_dotfile!
   dotfile = File.join(ENV["HOME"], ".aprc")
-  File.should_receive(:readable?).at_least(:once).with(dotfile).and_return(false)
+  expect(File).to receive(:readable?).at_least(:once).with(dotfile).and_return(false)
 end
 
 def capture!