awesome_print 1.2.0 → 1.9.2

data/spec/ext/ostruct_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe 'AwesomePrint Ostruct extension' do
+  before do
+    @ap = AwesomePrint::Inspector.new(plain: true, sort_keys: true)
+  end
+
+  it 'empty hash' do
+    struct = OpenStruct.new
+    expect(@ap.send(:awesome, struct)).to eq('OpenStruct {}')
+  end
+
+  it 'plain multiline' do
+    struct = OpenStruct.new name: 'Foo', address: 'Bar'
+    expect(@ap.send(:awesome, struct)).to eq <<-EOS.strip
+OpenStruct {
+    :address => "Bar",
+       :name => "Foo"
+}
+    EOS
+  end
+end

data/spec/ext/ripple_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe 'AwesomePrint/Ripple', skip: -> { !ExtVerifier.has_ripple? }.call do
+
+  if ExtVerifier.has_ripple?
+    before :all do
+      class RippleUser
+        include Ripple::Document
+
+        key_on :_id
+        property :_id, String
+        property :first_name, String
+        property :last_name,  String
+      end
+    end
+
+    after :all do
+      Object.instance_eval { remove_const :RippleUser }
+    end
+  end
+
+  before do
+    @ap = AwesomePrint::Inspector.new plain: true, sort_keys: true
+  end
+
+  it 'should print class instance' do
+    user = RippleUser.new _id: '12345', first_name: 'Al', last_name: 'Capone'
+    out = @ap.send :awesome, user
+
+    expect(out).to be_similar_to <<-EOS.strip
+#<RippleUser:placeholder_id> {
+           :_id => "12345",
+    :first_name => "Al",
+     :last_name => "Capone"
+}
+    EOS
+  end
+
+  it 'should print the class' do
+    expect(@ap.send(:awesome, RippleUser)).to eq <<-EOS.strip
+class RippleUser < Object {
+           :_id => :string,
+    :first_name => :string,
+     :last_name => :string
+}
+    EOS
+  end
+end

data/spec/formats_spec.rb

@@ -1,24 +1,20 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require "bigdecimal"
-require "rational"
-require "set"
-
-describe "AwesomePrint" do
-  before do
-    stub_dotfile!
-  end
+require 'spec_helper'
+require 'bigdecimal'
+require 'rational'
+require 'set'
 
-  describe "Array" do
+RSpec.describe 'AwesomePrint' do
+  describe 'Array' do
     before do
-      @arr = [ 1, :two, "three", [ nil, [ true, false] ] ]
+      @arr = [1, :two, 'three', [nil, [true, false]]]
     end
 
-    it "empty array" do
-      [].ai.should == "[]"
+    it 'empty array' do
+      expect([].ai).to eq('[]')
     end
 
-    it "plain multiline" do
-      @arr.ai(:plain => true).should == <<-EOS.strip
+    it 'plain multiline' do
+      expect(@arr.ai(plain: true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -34,8 +30,8 @@ describe "AwesomePrint" do
 EOS
       end
 
-    it "plain multiline without index" do
-      @arr.ai(:plain => true, :index => false).should == <<-EOS.strip
+    it 'plain multiline without index' do
+      expect(@arr.ai(plain: true, index: false)).to eq <<-EOS.strip
 [
     1,
     :two,
@@ -51,8 +47,8 @@ EOS
 EOS
       end
 
-    it "plain multiline indented" do
-      @arr.ai(:plain => true, :indent => 2).should == <<-EOS.strip
+    it 'plain multiline indented' do
+      expect(@arr.ai(plain: true, indent: 2)).to eq <<-EOS.strip
 [
   [0] 1,
   [1] :two,
@@ -68,8 +64,8 @@ EOS
 EOS
     end
 
-    it "plain multiline indented without index" do
-      @arr.ai(:plain => true, :indent => 2, :index => false).should == <<-EOS.strip
+    it 'plain multiline indented without index' do
+      expect(@arr.ai(plain: true, indent: 2, index: false)).to eq <<-EOS.strip
 [
   1,
   :two,
@@ -85,12 +81,12 @@ EOS
 EOS
     end
 
-    it "plain single line" do
-      @arr.ai(:plain => true, :multiline => false).should == '[ 1, :two, "three", [ nil, [ true, false ] ] ]'
+    it 'plain single line' do
+      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
+    it 'colored multiline (default)' do
+      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,8 +102,8 @@ EOS
 EOS
       end
 
-    it "colored multiline indented" do
-      @arr.ai(:indent => 8).should == <<-EOS.strip
+    it 'colored multiline indented' do
+      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,20 +119,20 @@ EOS
 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 ] ] ]"
+    it 'colored single line' do
+      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
 
   #------------------------------------------------------------------------------
-  describe "Nested Array" do
+  describe 'Nested Array' do
     before do
-      @arr = [ 1, 2 ]
+      @arr = [1, 2]
       @arr << @arr
     end
 
-    it "plain multiline" do
-      @arr.ai(:plain => true).should == <<-EOS.strip
+    it 'plain multiline' do
+      expect(@arr.ai(plain: true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] 2,
@@ -145,8 +141,8 @@ EOS
 EOS
     end
 
-    it "plain multiline without index" do
-      @arr.ai(:plain => true, :index => false).should == <<-EOS.strip
+    it 'plain multiline without index' do
+      expect(@arr.ai(plain: true, index: false)).to eq <<-EOS.strip
 [
     1,
     2,
@@ -155,19 +151,19 @@ EOS
 EOS
     end
 
-    it "plain single line" do
-      @arr.ai(:plain => true, :multiline => false).should == "[ 1, 2, [...] ]"
+    it 'plain single line' do
+      expect(@arr.ai(plain: true, multiline: false)).to eq('[ 1, 2, [...] ]')
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Limited Output Array" do
+  describe 'Limited Output Array' do
     before(:each) do
       @arr = (1..1000).to_a
     end
 
-    it "plain limited output large" do
-      @arr.ai(:plain => true, :limit => true).should == <<-EOS.strip
+    it 'plain limited output large' do
+      expect(@arr.ai(plain: true, limit: true)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -180,9 +176,9 @@ EOS
 EOS
     end
 
-    it "plain limited output small" do
+    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,8 +188,8 @@ EOS
 EOS
     end
 
-    it "plain limited output with 10 lines" do
-      @arr.ai(:plain => true, :limit => 10).should == <<-EOS.strip
+    it 'plain limited output with 10 lines' do
+      expect(@arr.ai(plain: true, limit: 10)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -209,8 +205,8 @@ EOS
 EOS
     end
 
-    it "plain limited output with 11 lines" do
-      @arr.ai(:plain => true, :limit => 11).should == <<-EOS.strip
+    it 'plain limited output with 11 lines' do
+      expect(@arr.ai(plain: true, limit: 11)).to eq <<-EOS.strip
 [
     [  0] 1,
     [  1] 2,
@@ -229,13 +225,13 @@ EOS
   end
 
   #------------------------------------------------------------------------------
-  describe "Limited Output Hash" do
+  describe 'Limited Output Hash' do
     before(:each) do
-      @hash = ("a".."z").inject({}) { |h, v| h.merge({ v => v.to_sym }) }
+      @hash = ('a'..'z').inject({}) { |h, v| h.merge({ v => v.to_sym }) }
     end
 
-    it "plain limited output" do
-      @hash.ai(:sort_keys => true, :plain => true, :limit => true).should == <<-EOS.strip
+    it 'plain limited output' do
+      expect(@hash.ai(sort_keys: true, plain: true, limit: true)).to eq <<-EOS.strip
 {
     "a" => :a,
     "b" => :b,
@@ -250,17 +246,17 @@ EOS
   end
 
   #------------------------------------------------------------------------------
-  describe "Hash" do
+  describe 'Hash' do
     before do
-      @hash = { 1 => { :sym => { "str" => { [1, 2, 3] => { { :k => :v } => Hash } } } } }
+      @hash = { 1 => { sym: { 'str' => { [1, 2, 3] => { { k: :v } => Hash } } } } }
     end
-    
-    it "empty hash" do
-      {}.ai.should == "{}"
+
+    it 'empty hash' do
+      expect({}.ai).to eq('{}')
     end
-    
-    it "plain multiline" do
-      @hash.ai(:plain => true).should == <<-EOS.strip
+
+    it 'plain multiline' do
+      expect(@hash.ai(plain: true)).to eq <<-EOS.strip
 {
     1 => {
         :sym => {
@@ -275,8 +271,24 @@ EOS
 EOS
     end
 
-    it "plain multiline indented" do
-      @hash.ai(:plain => true, :indent => 1).should == <<-EOS.strip
+    it 'new hash syntax' do
+      expect(@hash.ai(plain: true, ruby19_syntax: true)).to eq <<-EOS.strip
+{
+    1 => {
+        sym: {
+            "str" => {
+                [ 1, 2, 3 ] => {
+                    { k: :v } => Hash < Object
+                }
+            }
+        }
+    }
+}
+EOS
+    end
+
+    it 'plain multiline indented' do
+      expect(@hash.ai(plain: true, indent: 1)).to eq <<-EOS.strip
 {
  1 => {
   :sym => {
@@ -291,12 +303,12 @@ EOS
 EOS
     end
 
-    it "plain single line" do
-      @hash.ai(:plain => true, :multiline => false).should == '{ 1 => { :sym => { "str" => { [ 1, 2, 3 ] => { { :k => :v } => Hash < Object } } } } }'
+    it 'plain single line' do
+      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
+    it 'colored multiline (default)' do
+      expect(@hash.ai).to eq <<-EOS.strip
 {
     1\e[0;37m => \e[0m{
         :sym\e[0;37m => \e[0m{
@@ -311,8 +323,24 @@ EOS
 EOS
     end
 
-    it "colored multiline indented" do
-      @hash.ai(:indent => 2).should == <<-EOS.strip
+    it 'colored with new hash syntax' do
+      expect(@hash.ai(ruby19_syntax: true)).to eq <<-EOS.strip
+{
+    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
+                }
+            }
+        }
+    }
+}
+EOS
+    end
+
+    it 'colored multiline indented' do
+      expect(@hash.ai(indent: 2)).to eq <<-EOS.strip
 {
   1\e[0;37m => \e[0m{
     :sym\e[0;37m => \e[0m{
@@ -327,48 +355,48 @@ EOS
 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 } } } } }"
+    it 'colored single line' do
+      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
 
   #------------------------------------------------------------------------------
-  describe "Nested Hash" do
+  describe 'Nested Hash' do
     before do
       @hash = {}
       @hash[:a] = @hash
     end
 
-    it "plain multiline" do
-      @hash.ai(:plain => true).should == <<-EOS.strip
+    it 'plain multiline' do
+      expect(@hash.ai(plain: true)).to eq <<-EOS.strip
 {
     :a => {...}
 }
 EOS
     end
 
-    it "plain single line" do
-      @hash.ai(:plain => true, :multiline => false).should == '{ :a => {...} }'
+    it 'plain single line' do
+      expect(@hash.ai(plain: true, multiline: false)).to eq('{ :a => {...} }')
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Hash with several keys" do
+  describe 'Hash with several keys' do
     before do
-      @hash = {"b" => "b", :a => "a", :z => "z", "alpha" => "alpha"}
+      @hash = { 'b' => 'b', :a => 'a', :z => 'z', 'alpha' => 'alpha' }
     end
 
-    it "plain multiline" do
-      out = @hash.ai(:plain => true)
+    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",
@@ -378,9 +406,9 @@ EOS
 EOS
       end
     end
-    
-    it "plain multiline with sorted keys" do
-      @hash.ai(:plain => true, :sort_keys => true).should == <<-EOS.strip
+
+    it 'plain multiline with sorted keys' do
+      expect(@hash.ai(plain: true, sort_keys: true)).to eq <<-EOS.strip
 {
          :a => "a",
     "alpha" => "alpha",
@@ -393,15 +421,15 @@ EOS
   end
 
   #------------------------------------------------------------------------------
-  describe "Negative options[:indent]" do
+  describe 'Negative options[:indent]' do
     #
     # With Ruby < 1.9 the order of hash keys is not defined so we can't
     # reliably compare the output string.
     #
-    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
+    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)
+      expect(out).to eq <<-EOS.strip
 {
     [ 0, 0, 255 ] => :yellow,
     "magenta"     => "rgb(255, 0, 255)",
@@ -410,10 +438,10 @@ EOS
 EOS
     end
 
-    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
+    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)
+      expect(out).to eq <<-EOS.strip
 [
     [0] {
         :a   => 1,
@@ -429,10 +457,10 @@ EOS
 EOS
     end
 
-    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
+    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)
+      expect(out).to eq <<-EOS.strip
 {
     :first  => {
         :a   => 1,
@@ -450,196 +478,184 @@ EOS
   end
 
   #------------------------------------------------------------------------------
-  describe "Class" do
-    it "shoud show superclass (plain)" do
-      self.class.ai(:plain => true).should == "#{self.class} < #{self.class.superclass}"
+  describe 'Class' do
+    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
 
   #------------------------------------------------------------------------------
-  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
+  describe 'File' do
+    it 'should display a file (plain)' do
+      File.open(__FILE__, 'r') do |f|
+        expect(f.ai(plain: true)).to eq("#{f.inspect}\n#{`ls -alF #{f.path}`.chop}")
       end
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Dir" do
-    it "should display a direcory (plain)" do
+  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 with arbitrary precision" do
-      big = BigDecimal("201020102010201020102010201020102010.4")
-      big.ai(:plain => true).should == "201020102010201020102010201020102010.4"
+  describe 'BigDecimal and Rational' do
+    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
+    it 'should present Rational object with arbitrary precision' do
       rat = Rational(201020102010201020102010201020102010, 2)
-      out = rat.ai(:plain => true)
+      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"
-        out.should == "100510051005100510051005100510051005"
+      if RUBY_VERSION < '1.9'
+        expect(out).to eq('100510051005100510051005100510051005')
       else
-        out.should == "100510051005100510051005100510051005/1"
+        expect(out).to eq('100510051005100510051005100510051005/1')
       end
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Utility methods" do
-    it "should merge options" do
+  describe 'Utility methods' do
+    it 'should merge options' do
       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
+      ap.send(:merge_options!, { color: { array: :black }, indent: 0 })
+      options = ap.instance_variable_get('@options')
+      expect(options[:color][:array]).to eq(:black)
+      expect(options[:indent]).to eq(0)
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Set" do
+  describe 'Set' do
     before do
-      @arr = [1, :two, "three" ]
+      @arr = [1, :two, 'three']
       @set = Set.new(@arr)
     end
 
-    it "empty set" do
-      Set.new.ai.should == [].ai
+    it 'empty set' do
+      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)
+    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
-        @set.ai(:plain => true, :indent => 1).should == @arr.ai(:plain => true, :indent => 1)
+      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
-        @set.ai(:plain => true, :multiline => false).should == @arr.ai(:plain => true, :multiline => false)
+      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
-        @set.ai.should == @arr.ai
+      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
-        @set.sort_by{ |x| x.to_s }.ai(:plain => true).should == @arr.sort_by{ |x| x.to_s }.ai(:plain => true)
+      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
-        @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)
+      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
-        @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)
+      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
-        @set.sort_by{ |x| x.to_s }.ai.should == @arr.sort_by{ |x| x.to_s }.ai
+      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
+  describe 'Struct' do
     before do
       @struct = unless defined?(Struct::SimpleStruct)
-        Struct.new("SimpleStruct", :name, :address).new
+        Struct.new('SimpleStruct', :name, :address).new
       else
         Struct::SimpleStruct.new
       end
-      @struct.name = "Herman Munster"
-      @struct.address = "1313 Mockingbird Lane"
+      @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"
+
+    it 'empty struct' do
+      expect(Struct.new('EmptyStruct').ai).to eq("\e[1;33mStruct::EmptyStruct < Struct\e[0m")
     end
-    
-    it "plain multiline" do
+
+    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
+    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 }
+    it 'plain single line' do
+      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
+    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 }
+      expect(@struct.ai).to satisfy { |out| out.include?(s1) || out.include?(s2) }
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Inherited from standard Ruby classes" do
+  describe 'Inherited from standard Ruby classes' do
     after do
-      Object.instance_eval{ remove_const :My } if defined?(My)
+      Object.instance_eval { remove_const :My } if defined?(My)
     end
 
-    it "inherited from Array should be displayed as Array" do
+    it 'inherited from Array should be displayed as Array' do
       class My < Array; end
 
-      my = My.new([ 1, :two, "three", [ nil, [ true, false ] ] ])
-      my.ai(:plain => true).should == <<-EOS.strip
+      my = My.new([1, :two, 'three', [nil, [true, false]]])
+      expect(my.ai(plain: true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -655,11 +671,11 @@ EOS
 EOS
     end
 
-    it "inherited from Hash should be displayed as Hash" do
+    it 'inherited from Hash should be displayed as Hash' do
       class My < Hash; end
 
-      my = My[ { 1 => { :sym => { "str" => { [1, 2, 3] => { { :k => :v } => Hash } } } } } ]
-      my.ai(:plain => true).should == <<-EOS.strip
+      my = My[{ 1 => { sym: { 'str' => { [1, 2, 3] => { { k: :v } => Hash } } } } }]
+      expect(my.ai(plain: true)).to eq <<-EOS.strip
 {
     1 => {
         :sym => {
@@ -674,31 +690,31 @@ EOS
 EOS
     end
 
-    it "inherited from File should be displayed as File" do
+    it 'inherited from File should be displayed as File' do
       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
+    it 'inherited from Dir should be displayed as Dir' do
       class My < Dir; end
 
       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
+    it 'should handle a class that defines its own #send method' do
       class My
         def send(arg1, arg2, arg3); end
       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
+    it 'should handle a class defines its own #method method (ex. request.method)' do
       class My
         def method
           'POST'
@@ -706,7 +722,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