awesome_print 1.0.2 → 1.7.0

data/spec/formats_spec.rb

@@ -1,8 +1,9 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 require "bigdecimal"
 require "rational"
+require "set"
 
-describe "AwesomePrint" do
+RSpec.describe "AwesomePrint" do
   before do
     stub_dotfile!
   end
@@ -13,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,
@@ -34,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,
@@ -51,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,
@@ -68,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,
@@ -85,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,
@@ -106,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,
@@ -123,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
 
@@ -135,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,
@@ -145,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,
@@ -155,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
 
@@ -166,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,
@@ -181,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,
@@ -192,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,
@@ -209,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,
@@ -234,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,
@@ -253,13 +254,13 @@ EOS
     before do
       @hash = { 1 => { :sym => { "str" => { [1, 2, 3] => { { :k => :v } => Hash } } } } }
     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 => {
@@ -275,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 => {
@@ -291,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{
@@ -311,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{
@@ -327,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
@@ -340,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 => {...}
 }
@@ -348,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
 
@@ -361,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
-        out.should =~ /        "b" => "b",?/
-        out.should =~ /         :a => "a",?/
-        out.should =~ /         :z => "z",?/
-        out.should =~ /    "alpha" => "alpha",?$/
+        expect(out).to match(/^\{[^\}]+\}/m)
+        expect(out).to match(/        "b" => "b",?/)
+        expect(out).to match(/         :a => "a",?/)
+        expect(out).to match(/         :z => "z",?/)
+        expect(out).to match(/    "alpha" => "alpha",?$/)
       else
-        out.should == <<-EOS.strip
+        expect(out).to eq <<-EOS.strip
 {
         "b" => "b",
          :a => "a",
@@ -377,9 +378,9 @@ EOS
 EOS
       end
     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",
@@ -400,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)",
@@ -412,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,
@@ -431,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,
@@ -450,12 +451,12 @@ EOS
 
   #------------------------------------------------------------------------------
   describe "Class" do
-    it "shoud show superclass (plain)" do
-      self.class.ai(:plain => true).should == "#{self.class} < #{self.class.superclass}"
+    it "should show superclass (plain)" do
+      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
+    it "should show superclass (color)" do
+      expect(self.class.ai).to eq("#{self.class} < #{self.class.superclass}".yellow)
     end
   end
 
@@ -463,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
@@ -472,21 +473,31 @@ 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
 
   #------------------------------------------------------------------------------
   describe "BigDecimal and Rational" do
-    it "should present BigDecimal object as Float scalar" do
-      big = BigDecimal("2010.4")
-      big.ai(:plain => true).should == "2010.4"
-    end
-
-    it "should present Rational object as Float scalar" do
-      rat = Rational(2010, 2)
-      rat.ai(:plain => true).should == "1005.0"
+    it "should present BigDecimal object with arbitrary precision" do
+      big = BigDecimal("201020102010201020102010201020102010.4")
+      expect(big.ai(:plain => true)).to eq("201020102010201020102010201020102010.4")
+    end
+
+    it "should present Rational object with arbitrary precision" do
+      rat = Rational(201020102010201020102010201020102010, 2)
+      out = rat.ai(:plain => true)
+      #
+      # Ruby 1.9 slightly changed the format of Rational#to_s, see
+      # http://techtime.getharvest.com/blog/harvest-is-now-on-ruby-1-dot-9-3 and
+      # http://www.ruby-forum.com/topic/189397
+      #
+      if RUBY_VERSION < "1.9"
+        expect(out).to eq("100510051005100510051005100510051005")
+      else
+        expect(out).to eq("100510051005100510051005100510051005/1")
+      end
     end
   end
 
@@ -496,11 +507,56 @@ 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
-      options[:indent].should == 0
+      expect(options[:color][:array]).to eq(:black)
+      expect(options[:indent]).to eq(0)
     end
   end
 
+  #------------------------------------------------------------------------------
+  describe "Set" do
+    before do
+      @arr = [1, :two, "three" ]
+      @set = Set.new(@arr)
+    end
+
+    it "empty set" do
+      expect(Set.new.ai).to eq([].ai)
+    end
+
+    if RUBY_VERSION > "1.9"
+      it "plain multiline" do
+        expect(@set.ai(:plain => true)).to eq(@arr.ai(:plain => true))
+      end
+
+      it "plain multiline indented" do
+        expect(@set.ai(:plain => true, :indent => 1)).to eq(@arr.ai(:plain => true, :indent => 1))
+      end
+
+      it "plain single line" do
+        expect(@set.ai(:plain => true, :multiline => false)).to eq(@arr.ai(:plain => true, :multiline => false))
+      end
+
+      it "colored multiline (default)" do
+        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
+        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
+        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
+        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
+        expect(@set.sort_by{ |x| x.to_s }.ai).to eq(@arr.sort_by{ |x| x.to_s }.ai)
+      end
+    end
+  end
 
   #------------------------------------------------------------------------------
   describe "Struct" do
@@ -513,137 +569,51 @@ EOS
       @struct.name = "Herman Munster"
       @struct.address = "1313 Mockingbird Lane"
     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
       s1 = <<-EOS.strip
-{
-    :address => "1313 Mockingbird Lane",
-       :name => "Herman Munster"
-}
+    address = \"1313 Mockingbird Lane\",
+    name = \"Herman Munster\"
 EOS
       s2 = <<-EOS.strip
-{
-       :name => "Herman Munster",
-    :address => "1313 Mockingbird Lane"
-}
+    name = \"Herman Munster\",
+    address = \"1313 Mockingbird Lane\"
 EOS
-      @struct.ai(:plain => true).should satisfy { |match| match == s1 || match == s2 }
+      expect(@struct.ai(:plain => true)).to satisfy { |out| out.match(s1) || out.match(s2) }
     end
 
     it "plain multiline indented" do
       s1 = <<-EOS.strip
-{
- :address => "1313 Mockingbird Lane",
-    :name => "Herman Munster"
-}
+ address = "1313 Mockingbird Lane",
+ name = "Herman Munster"
 EOS
       s2 = <<-EOS.strip
-{
-    :name => "Herman Munster",
- :address => "1313 Mockingbird Lane"
-}
+ name = "Herman Munster",
+ 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 { |out| out.match(s1) || out.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 }
+      s1 = "address = \"1313 Mockingbird Lane\", name = \"Herman Munster\""
+      s2 = "name = \"Herman Munster\", address = \"1313 Mockingbird Lane\""
+      expect(@struct.ai(:plain => true, :multiline => false)).to satisfy { |out| out.match(s1) || out.match(s2) }
     end
 
     it "colored multiline (default)" do
       s1 = <<-EOS.strip
-{
-    :address\e[0;37m => \e[0m\e[0;33m\"1313 Mockingbird Lane\"\e[0m,
-       :name\e[0;37m => \e[0m\e[0;33m\"Herman Munster\"\e[0m
-}
+    address\e[0;37m = \e[0m\e[0;33m\"1313 Mockingbird Lane\"\e[0m,
+    name\e[0;37m = \e[0m\e[0;33m\"Herman Munster\"\e[0m
 EOS
       s2 = <<-EOS.strip
-{
-       :name\e[0;37m => \e[0m\e[0;33m\"Herman Munster\"\e[0m,
-    :address\e[0;37m => \e[0m\e[0;33m\"1313 Mockingbird Lane\"\e[0m
-}
+    name\e[0;37m = \e[0m\e[0;33m\"Herman Munster\"\e[0m,
+    address\e[0;37m = \e[0m\e[0;33m\"1313 Mockingbird Lane\"\e[0m
 EOS
-      @struct.ai.should satisfy { |match| match == s1 || match == s2 }
-    end
-  end
-
-
-  #------------------------------------------------------------------------------
-  describe "Misc" do
-    it "handle weird objects that return nil on inspect" do
-      weird = Class.new do
-        def inspect
-          nil
-        end
-      end
-      weird.new.ai(:plain => true).should == ''
-    end
-
-    it "handle frozen object.inspect" do
-      weird = Class.new do
-        def inspect
-          "ice".freeze
-        end
-      end
-      weird.new.ai(:plain => false).should == "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.grep(/^(\d+)\//) { $1 }
-      grepped.ai(:plain => true, :multiline => false).should == '[ "1", "2" ]'
-    end
-
-    it "returns value passed as a parameter" do
-      object = rand
-      self.stub!(:puts)
-      (ap object).should == 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
-    end
-  end
-
-  describe "HTML output" do
-    it "wraps ap output with plain <pre> tag" do
-      markup = rand
-      markup.ai(:html => true, :plain => true).should == "<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>|
-    end
-
-    it "wraps multiline ap output with <pre> tag with colorized <kbd>" do
-      markup = [ 1, :two, "three" ]
-      markup.ai(:html => true).should == <<-EOS.strip
-<pre>[
-    <kbd style="color:white">[0] </kbd><pre><kbd style="color:blue">1</kbd></pre>,
-    <kbd style="color:white">[1] </kbd><pre><kbd style="color:darkcyan">:two</kbd></pre>,
-    <kbd style="color:white">[2] </kbd><pre><kbd style="color:brown">&quot;three&quot;</kbd></pre>
-]</pre>
-EOS
-    end
-
-    it "encodes HTML entities (plain)" do
-      markup = ' &<hello>'
-      markup.ai(:html => true, :plain => true).should == '<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(@struct.ai).to satisfy { |out| out.include?(s1) || out.include?(s2) }
     end
   end
 
@@ -657,7 +627,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,
@@ -677,7 +647,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 => {
@@ -696,7 +666,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
@@ -704,7 +674,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
@@ -713,7 +683,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
@@ -724,7 +694,58 @@ 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
+
+    describe "should handle a class that defines its own #to_hash method" do
+      it "that takes arguments" do
+        class My
+          def to_hash(a, b)
+          end
+        end
+
+        my = My.new
+        expect { my.ai(:plain => true) }.not_to raise_error
+      end
+
+      it "that returns nil" do
+        class My
+          def to_hash()
+            return nil
+          end
+        end
+
+        my = My.new
+        expect { my.ai(:plain => true) }.not_to raise_error
+      end
+
+      it "that returns an object that doesn't support #keys" do
+        class My
+          def to_hash()
+            object = Object.new
+            object.define_singleton_method('[]') { return nil }
+
+            return object
+          end
+        end
+
+        my = My.new
+        expect { my.ai(:plain => true) }.not_to raise_error
+      end
+
+      it "that returns an object that doesn't support subscripting" do
+        class My
+          def to_hash()
+            object = Object.new
+            object.define_singleton_method(:keys) { return [:foo] }
+
+            return object
+          end
+        end
+
+        my = My.new
+        expect { my.ai(:plain => true) }.not_to raise_error
+      end
     end
   end
 end