awesome_print 1.7.0 → 1.8.0

data/spec/ext/mongoid_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+RSpec.describe 'AwesomePrint/Mongoid', skip: -> { !ExtVerifier.has_mongoid? }.call do
+
+  if ExtVerifier.has_mongoid?
+    before :all do
+      class MongoUser
+        include Mongoid::Document
+
+        field :first_name, type: String
+        field :last_name,  type: String
+      end
+    end
+
+    after :all do
+      Object.instance_eval { remove_const :MongoUser }
+      Object.instance_eval { remove_const :Chamelion }
+    end
+  end
+
+  before do
+    @ap = AwesomePrint::Inspector.new plain: true, sort_keys: true
+  end
+
+  it 'should print class instance' do
+    user = MongoUser.new first_name: 'Al', last_name: 'Capone'
+    out = @ap.send :awesome, user
+
+    object_id = user.id.inspect
+    str = <<-EOS.strip
+#<MongoUser:placeholder_id> {
+           :_id => #{object_id},
+    :first_name => "Al",
+     :last_name => "Capone"
+}
+    EOS
+    expect(out).to be_similar_to(str, { skip_bson: true })
+  end
+
+  it 'should print the class' do
+    class_spec = if mongoid_3_0?
+                   <<-EOS.strip
+class MongoUser < Object {
+           :_id => :"moped/bson/object_id",
+         :_type => :string,
+    :first_name => :string,
+     :last_name => :string
+}
+                   EOS
+                 elsif mongoid_3_1?
+                   <<-EOS.strip
+class MongoUser < Object {
+           :_id => :"moped/bson/object_id",
+    :first_name => :string,
+     :last_name => :string
+}
+                   EOS
+                 elsif mongoid_4_0?
+                   <<-EOS.strip
+class MongoUser < Object {
+           :_id => :"bson/object_id",
+    :first_name => :string,
+     :last_name => :string
+}
+                   EOS
+                 end
+
+    expect(@ap.send(:awesome, MongoUser)).to eq class_spec
+  end
+
+  it 'should print the class when type is undefined' do
+    class Chamelion
+      include Mongoid::Document
+      field :last_attribute
+    end
+
+    class_spec = if mongoid_3_0?
+                   <<-EOS.strip
+class Chamelion < Object {
+               :_id => :"moped/bson/object_id",
+             :_type => :string,
+    :last_attribute => :object
+}
+                   EOS
+                 elsif mongoid_3_1?
+                   <<-EOS.strip
+class Chamelion < Object {
+               :_id => :"moped/bson/object_id",
+    :last_attribute => :object
+}
+                   EOS
+                 elsif mongoid_4_0?
+                   <<-EOS.strip
+class Chamelion < Object {
+               :_id => :"bson/object_id",
+    :last_attribute => :object
+}
+                   EOS
+                 end
+
+
+    expect(@ap.send(:awesome, Chamelion)).to eq class_spec
+  end
+end

data/spec/ext/nobrainer_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe 'AwesomePrint/NoBrainer', skip: -> { !ExtVerifier.has_nobrainer? }.call do
+
+  if ExtVerifier.has_nobrainer?
+    before :all do
+      NoBrainer.configure do |config|
+        config.app_name = 'ap_test'
+        config.environment = :test
+      end
+    end
+
+    before :all do
+      class SomeModel
+        include NoBrainer::Document
+
+        field :first_name, type: String
+        field :last_name,  type: String
+        field :some_field
+      end
+    end
+
+    after :all do
+      Object.instance_eval { remove_const :SomeModel }
+    end
+  end
+
+  before do
+    @ap = AwesomePrint::Inspector.new plain: true
+  end
+
+  it 'should print class instance' do
+    user = SomeModel.new first_name: 'Al', last_name: 'Capone'
+    out = @ap.send :awesome, user
+
+    object_id = user.id.inspect
+    str = <<-EOS.strip
+#<SomeModel id: #{object_id}> {
+            :id => #{object_id},
+    :first_name => "Al",
+     :last_name => "Capone"
+}
+    EOS
+    expect(out).to eq(str)
+  end
+
+  it 'should print the class' do
+    class_spec = <<-EOS.strip
+class SomeModel < Object {
+            :id => :string,
+    :first_name => :string,
+     :last_name => :string,
+    :some_field => :object
+}
+                   EOS
+
+    expect(@ap.send(:awesome, SomeModel)).to eq class_spec
+  end
+end

data/spec/ext/nokogiri_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe 'AwesomePrint/Nokogiri' do
+  it 'should colorize tags' do
+    xml = Nokogiri::XML('<html><body><h1></h1></body></html>')
+    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
+    \e[0m<\e[1;36mh1\e[0m/>\e[1;32m
+  \e[0m<\e[1;36m/body\e[0m>\e[1;32m
+\e[0m<\e[1;36m/html\e[0m>
+    EOS
+  end
+
+  it 'should colorize contents' do
+    xml = Nokogiri::XML('<html><body><h1>Hello</h1></body></html>')
+    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
+    \e[0m<\e[1;36mh1\e[0m>\e[1;32mHello\e[0m<\e[1;36m/h1\e[0m>\e[1;32m
+  \e[0m<\e[1;36m/body\e[0m>\e[1;32m
+\e[0m<\e[1;36m/html\e[0m>
+    EOS
+  end
+
+  it 'should colorize class and id' do
+    xml = Nokogiri::XML('<html><body><h1><span id="hello" class="world"></span></h1></body></html>')
+    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
+    \e[0m<\e[1;36mh1\e[0m>\e[1;32m
+      \e[0m<\e[1;36mspan\e[0m \e[1;33mid=\"hello\"\e[0m \e[1;33mclass=\"world\"\e[0m/>\e[1;32m
+    \e[0m<\e[1;36m/h1\e[0m>\e[1;32m
+  \e[0m<\e[1;36m/body\e[0m>\e[1;32m
+\e[0m<\e[1;36m/html\e[0m>
+    EOS
+  end
+
+  it 'handle empty NodeSet' do
+    xml = Nokogiri::XML::NodeSet.new(Nokogiri::XML(''))
+    expect(xml.ai).to eq('[]')
+  end
+end

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 'spec_helper'
-require "bigdecimal"
-require "rational"
-require "set"
+require 'bigdecimal'
+require 'rational'
+require 'set'
 
-RSpec.describe "AwesomePrint" do
-  before do
-    stub_dotfile!
-  end
-
-  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
-      expect([].ai).to eq("[]")
+    it 'empty array' do
+      expect([].ai).to eq('[]')
     end
 
-    it "plain multiline" do
-      expect(@arr.ai(:plain => true)).to eq <<-EOS.strip
+    it 'plain multiline' do
+      expect(@arr.ai(plain: true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -34,8 +30,8 @@ RSpec.describe "AwesomePrint" do
 EOS
       end
 
-    it "plain multiline without index" do
-      expect(@arr.ai(:plain => true, :index => false)).to eq <<-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
-      expect(@arr.ai(:plain => true, :indent => 2)).to eq <<-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
-      expect(@arr.ai(:plain => true, :indent => 2, :index => false)).to eq <<-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,11 +81,11 @@ EOS
 EOS
     end
 
-    it "plain single line" do
-      expect(@arr.ai(:plain => true, :multiline => false)).to eq('[ 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
+    it 'colored multiline (default)' do
       expect(@arr.ai).to eq <<-EOS.strip
 [
     \e[1;37m[0] \e[0m\e[1;34m1\e[0m,
@@ -106,8 +102,8 @@ EOS
 EOS
       end
 
-    it "colored multiline indented" do
-      expect(@arr.ai(:indent => 8)).to eq <<-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
-      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 ] ] ]")
+    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
-      expect(@arr.ai(:plain => true)).to eq <<-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
-      expect(@arr.ai(:plain => true, :index => false)).to eq <<-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
-      expect(@arr.ai(:plain => true, :multiline => false)).to eq("[ 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
-      expect(@arr.ai(:plain => true, :limit => true)).to eq <<-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]
-      expect(@arr.ai(:plain => true, :limit => true)).to eq <<-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
-      expect(@arr.ai(:plain => true, :limit => 10)).to eq <<-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
-      expect(@arr.ai(:plain => true, :limit => 11)).to eq <<-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
-      expect(@hash.ai(:sort_keys => true, :plain => true, :limit => true)).to eq <<-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
-      expect({}.ai).to eq("{}")
+    it 'empty hash' do
+      expect({}.ai).to eq('{}')
     end
 
-    it "plain multiline" do
-      expect(@hash.ai(:plain => true)).to eq <<-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
-      expect(@hash.ai(:plain => true, :indent => 1)).to eq <<-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,11 +303,11 @@ EOS
 EOS
     end
 
-    it "plain single line" do
-      expect(@hash.ai(:plain => true, :multiline => false)).to eq('{ 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
+    it 'colored multiline (default)' do
       expect(@hash.ai).to eq <<-EOS.strip
 {
     1\e[0;37m => \e[0m{
@@ -311,8 +323,24 @@ EOS
 EOS
     end
 
-    it "colored multiline indented" do
-      expect(@hash.ai(:indent => 2)).to eq <<-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,40 +355,40 @@ EOS
 EOS
     end
 
-    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 } } } } }")
+    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
-      expect(@hash.ai(:plain => true)).to eq <<-EOS.strip
+    it 'plain multiline' do
+      expect(@hash.ai(plain: true)).to eq <<-EOS.strip
 {
     :a => {...}
 }
 EOS
     end
 
-    it "plain single line" do
-      expect(@hash.ai(:plain => true, :multiline => false)).to eq('{ :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.
         expect(out).to match(/^\{[^\}]+\}/m)
         expect(out).to match(/        "b" => "b",?/)
@@ -379,8 +407,8 @@ EOS
       end
     end
 
-    it "plain multiline with sorted keys" do
-      expect(@hash.ai(:plain => true, :sort_keys => true)).to eq <<-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,14 +421,14 @@ 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)
+    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,
@@ -410,9 +438,9 @@ 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)
+    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] {
@@ -429,9 +457,9 @@ 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)
+    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  => {
@@ -450,131 +478,131 @@ EOS
   end
 
   #------------------------------------------------------------------------------
-  describe "Class" do
-    it "should show superclass (plain)" do
-      expect(self.class.ai(:plain => true)).to eq("#{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 "should show superclass (color)" do
+    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|
-        expect(f.ai(:plain => true)).to eq("#{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|
-        expect(d.ai(:plain => true)).to eq("#{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")
-      expect(big.ai(:plain => true)).to eq("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"
-        expect(out).to eq("100510051005100510051005100510051005")
+      if RUBY_VERSION < '1.9'
+        expect(out).to eq('100510051005100510051005100510051005')
       else
-        expect(out).to eq("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")
+      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
+    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))
+    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))
+      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))
+      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
+      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))
+      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))
+      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))
+      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)
+      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
-      expect(Struct.new("EmptyStruct").ai).to eq("\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\"
@@ -583,10 +611,10 @@ EOS
     name = \"Herman Munster\",
     address = \"1313 Mockingbird Lane\"
 EOS
-      expect(@struct.ai(:plain => true)).to satisfy { |out| out.match(s1) || out.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"
@@ -595,16 +623,16 @@ EOS
  name = "Herman Munster",
  address = "1313 Mockingbird Lane"
 EOS
-      expect(@struct.ai(:plain => true, :indent => 1)).to satisfy { |out| out.match(s1) || out.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\""
-      expect(@struct.ai(:plain => true, :multiline => false)).to satisfy { |out| out.match(s1) || out.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
@@ -618,16 +646,16 @@ EOS
   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 ] ] ])
-      expect(my.ai(:plain => true)).to eq <<-EOS.strip
+      my = My.new([1, :two, 'three', [nil, [true, false]]])
+      expect(my.ai(plain: true)).to eq <<-EOS.strip
 [
     [0] 1,
     [1] :two,
@@ -643,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 } } } } } ]
-      expect(my.ai(:plain => true)).to eq <<-EOS.strip
+      my = My[{ 1 => { sym: { 'str' => { [1, 2, 3] => { { k: :v } => Hash } } } } }]
+      expect(my.ai(plain: true)).to eq <<-EOS.strip
 {
     1 => {
         :sym => {
@@ -662,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')
-      expect(my.ai(:plain => true)).to eq("#{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)
-      expect(my.ai(:plain => true)).to eq("#{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
-      expect { my.methods.ai(:plain => true) }.not_to raise_error
+      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'
@@ -694,21 +722,21 @@ EOS
       end
 
       my = My.new
-      expect { my.methods.ai(:plain => true) }.not_to raise_error
+      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
+    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
+        expect { my.ai(plain: true) }.not_to raise_error
       end
 
-      it "that returns nil" do
+      it 'that returns nil' do
         class My
           def to_hash()
             return nil
@@ -716,7 +744,7 @@ EOS
         end
 
         my = My.new
-        expect { my.ai(:plain => true) }.not_to raise_error
+        expect { my.ai(plain: true) }.not_to raise_error
       end
 
       it "that returns an object that doesn't support #keys" do
@@ -730,7 +758,7 @@ EOS
         end
 
         my = My.new
-        expect { my.ai(:plain => true) }.not_to raise_error
+        expect { my.ai(plain: true) }.not_to raise_error
       end
 
       it "that returns an object that doesn't support subscripting" do
@@ -744,7 +772,7 @@ EOS
         end
 
         my = My.new
-        expect { my.ai(:plain => true) }.not_to raise_error
+        expect { my.ai(plain: true) }.not_to raise_error
       end
     end
   end