awesome_print 1.8.0 → 2.0.0.pre

data/spec/ext/action_view_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'AwesomePrint ActionView extensions', skip: -> { !ExtVerifier.has_rails? }.call do
-
-  before do
-    @view = ActionView::Base.new
-  end
-
-  it "uses HTML and adds 'debug_dump' class to plain <pre> tag" do
-    markup = rand
-    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>'
-    expect(@view.ap(markup)).to eq('<pre class="debug_dump"><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>')
-  end
-end

data/spec/ext/mongo_mapper_spec.rb

@@ -1,261 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'AwesomePrint/MongoMapper', skip: -> { !ExtVerifier.has_mongo_mapper? }.call do
-  if ExtVerifier.has_mongo_mapper?
-    before :all do
-      class MongoUser
-        include MongoMapper::Document
-
-        key :first_name, String
-        key :last_name, 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
-
-  describe 'with the raw option set to true' do
-    # before { @ap.options[:raw] = true }
-    before { @ap = AwesomePrint::Inspector.new(plain: true, sort_keys: true, raw: true) }
-
-    it 'should print class instance' do
-      user = MongoUser.new(first_name: 'Al', last_name: 'Capone')
-
-      out = @ap.send(:awesome, user)
-      out.gsub!(/#\<Proc:.+?\>/, 'AWESOME_PRINT_PROC_STUB')
-      out.gsub!(/BSON::ObjectId\('[\da-f]+?'\)/, "BSON::ObjectId('123456789')")
-
-      str = if MongoMapper::Version >= '0.13'
-              <<-EOS.strip
-#<MongoUser:placeholder_id
-    @__mm_default_keys = [
-        [0] #<MongoMapper::Plugins::Keys::Key:placeholder_id
-            @dynamic = false,
-            @embeddable = false,
-            @has_default = true,
-            @is_id = true,
-            @typecast = nil,
-            attr_accessor :accessors = [],
-            attr_accessor :default = AWESOME_PRINT_PROC_STUB,
-            attr_accessor :ivar = :@_id,
-            attr_accessor :name = "_id",
-            attr_accessor :options = {
-                :default => AWESOME_PRINT_PROC_STUB
-            },
-            attr_accessor :type = ObjectId < Object
-        >
-    ],
-    @__mm_keys = {
-               "_id" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-            @dynamic = false,
-            @embeddable = false,
-            @has_default = true,
-            @is_id = true,
-            @typecast = nil,
-            attr_accessor :accessors = [],
-            attr_accessor :default = AWESOME_PRINT_PROC_STUB,
-            attr_accessor :ivar = :@_id,
-            attr_accessor :name = "_id",
-            attr_accessor :options = {
-                :default => AWESOME_PRINT_PROC_STUB
-            },
-            attr_accessor :type = ObjectId < Object
-        >,
-        "first_name" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-            @dynamic = false,
-            @embeddable = false,
-            @has_default = false,
-            @is_id = false,
-            @typecast = nil,
-            attr_accessor :accessors = [],
-            attr_accessor :ivar = :@first_name,
-            attr_accessor :name = "first_name",
-            attr_accessor :options = {},
-            attr_accessor :type = String < Object
-        >,
-         "last_name" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-            @dynamic = false,
-            @embeddable = false,
-            @has_default = false,
-            @is_id = false,
-            @typecast = nil,
-            attr_accessor :accessors = [],
-            attr_accessor :ivar = :@last_name,
-            attr_accessor :name = "last_name",
-            attr_accessor :options = {},
-            attr_accessor :type = String < Object
-        >
-    },
-    @__mm_pre_cast = {
-        "first_name" => "Al",
-         "last_name" => "Capone"
-    },
-    @_dynamic_attributes = {},
-    @_new = true,
-    attr_accessor :_id = BSON::ObjectId('123456789'),
-    attr_accessor :attributes = nil,
-    attr_accessor :first_name = "Al",
-    attr_accessor :last_name = "Capone",
-    attr_reader :changed_attributes = {
-        "first_name" => nil,
-         "last_name" => nil
-    }
->
-              EOS
-            else
-              <<-EOS.strip
-#<MongoUser:placeholder_id
-    @_new = true,
-    attr_accessor :first_name = "Al",
-    attr_accessor :last_name = "Capone",
-    attr_reader :changed_attributes = {
-        "first_name" => nil,
-         "last_name" => nil
-    },
-    attr_reader :first_name_before_type_cast = "Al",
-    attr_reader :last_name_before_type_cast = "Capone"
->
-              EOS
-            end
-      expect(out).to be_similar_to(str)
-    end
-
-    it 'should print the class' do
-      expect(@ap.send(:awesome, MongoUser)).to eq <<-EOS.strip
-class MongoUser < Object {
-           "_id" => :object_id,
-    "first_name" => :string,
-     "last_name" => :string
-}
-      EOS
-    end
-
-    it 'should print the class when type is undefined' do
-      class Chamelion
-        include MongoMapper::Document
-        key :last_attribute
-      end
-
-      expect(@ap.send(:awesome, Chamelion)).to eq <<-EOS.strip
-class Chamelion < Object {
-               "_id" => :object_id,
-    "last_attribute" => :undefined
-}
-      EOS
-    end
-  end
-
-  describe 'with associations' do
-
-    if ExtVerifier.has_mongo_mapper?
-      before :all do
-        class Child
-          include MongoMapper::EmbeddedDocument
-          key :data
-        end
-
-        class Sibling
-          include MongoMapper::Document
-          key :title
-        end
-
-        class Parent
-          include MongoMapper::Document
-          key :name
-
-          one :child
-          one :sibling
-        end
-      end
-    end
-
-    describe 'with show associations turned off (default)' do
-      it 'should render the class as normal' do
-        expect(@ap.send(:awesome, Parent)).to eq <<-EOS.strip
-class Parent < Object {
-     "_id" => :object_id,
-    "name" => :undefined
-}
-        EOS
-      end
-
-      it 'should render an instance as normal' do
-        parent = Parent.new(name: 'test')
-        out = @ap.send(:awesome, parent)
-        str = <<-EOS.strip
-#<Parent:placeholder_id> {
-     "_id" => placeholder_bson_id,
-    "name" => "test"
-}
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-
-    describe 'with show associations turned on and inline embedded turned off' do
-      before :each do
-        @ap = AwesomePrint::Inspector.new(plain: true, mongo_mapper: { show_associations: true })
-      end
-
-      it 'should render the class with associations shown' do
-        expect(@ap.send(:awesome, Parent)).to eq <<-EOS.strip
-class Parent < Object {
-        "_id" => :object_id,
-       "name" => :undefined,
-      "child" => embeds one Child,
-    "sibling" => one Sibling
-}
-        EOS
-      end
-
-      it 'should render an instance with associations shown' do
-        parent = Parent.new(name: 'test')
-        out = @ap.send(:awesome, parent)
-        str = <<-EOS.strip
-#<Parent:placeholder_id> {
-        "_id" => placeholder_bson_id,
-       "name" => "test",
-      "child" => embeds one Child,
-    "sibling" => one Sibling
-}
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-
-    describe 'with show associations turned on and inline embedded turned on' do
-      before :each do
-        @ap = AwesomePrint::Inspector.new(plain: true,
-                                          mongo_mapper: {
-          show_associations: true,
-          inline_embedded: true
-        }
-                                         )
-      end
-
-      it 'should render an instance with associations shown and embeds there' do
-        parent = Parent.new(name: 'test', child: Child.new(data: 5))
-        out = @ap.send(:awesome, parent)
-        str = <<-EOS.strip
-#<Parent:placeholder_id> {
-        "_id" => placeholder_bson_id,
-       "name" => "test",
-      "child" => embedded #<Child:placeholder_id> {
-         "_id" => placeholder_bson_id,
-        "data" => 5
-    },
-    "sibling" => one Sibling
-}
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-  end
-end

data/spec/ext/nobrainer_spec.rb

@@ -1,59 +0,0 @@
-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/ripple_spec.rb

@@ -1,48 +0,0 @@
-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,779 +0,0 @@
-require 'spec_helper'
-require 'bigdecimal'
-require 'rational'
-require 'set'
-
-RSpec.describe 'AwesomePrint' do
-  describe 'Array' do
-    before do
-      @arr = [1, :two, 'three', [nil, [true, false]]]
-    end
-
-    it 'empty array' do
-      expect([].ai).to eq('[]')
-    end
-
-    it 'plain multiline' do
-      expect(@arr.ai(plain: true)).to eq <<-EOS.strip
-[
-    [0] 1,
-    [1] :two,
-    [2] "three",
-    [3] [
-        [0] nil,
-        [1] [
-            [0] true,
-            [1] false
-        ]
-    ]
-]
-EOS
-      end
-
-    it 'plain multiline without index' do
-      expect(@arr.ai(plain: true, index: false)).to eq <<-EOS.strip
-[
-    1,
-    :two,
-    "three",
-    [
-        nil,
-        [
-            true,
-            false
-        ]
-    ]
-]
-EOS
-      end
-
-    it 'plain multiline indented' do
-      expect(@arr.ai(plain: true, indent: 2)).to eq <<-EOS.strip
-[
-  [0] 1,
-  [1] :two,
-  [2] "three",
-  [3] [
-    [0] nil,
-    [1] [
-      [0] true,
-      [1] false
-    ]
-  ]
-]
-EOS
-    end
-
-    it 'plain multiline indented without index' do
-      expect(@arr.ai(plain: true, indent: 2, index: false)).to eq <<-EOS.strip
-[
-  1,
-  :two,
-  "three",
-  [
-    nil,
-    [
-      true,
-      false
-    ]
-  ]
-]
-EOS
-    end
-
-    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
-      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,
-    \e[1;37m[2] \e[0m\e[0;33m\"three\"\e[0m,
-    \e[1;37m[3] \e[0m[
-        \e[1;37m[0] \e[0m\e[1;31mnil\e[0m,
-        \e[1;37m[1] \e[0m[
-            \e[1;37m[0] \e[0m\e[1;32mtrue\e[0m,
-            \e[1;37m[1] \e[0m\e[1;31mfalse\e[0m
-        ]
-    ]
-]
-EOS
-      end
-
-    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,
-        \e[1;37m[2] \e[0m\e[0;33m\"three\"\e[0m,
-        \e[1;37m[3] \e[0m[
-                \e[1;37m[0] \e[0m\e[1;31mnil\e[0m,
-                \e[1;37m[1] \e[0m[
-                        \e[1;37m[0] \e[0m\e[1;32mtrue\e[0m,
-                        \e[1;37m[1] \e[0m\e[1;31mfalse\e[0m
-                ]
-        ]
-]
-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 ] ] ]")
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  describe 'Nested Array' do
-    before do
-      @arr = [1, 2]
-      @arr << @arr
-    end
-
-    it 'plain multiline' do
-      expect(@arr.ai(plain: true)).to eq <<-EOS.strip
-[
-    [0] 1,
-    [1] 2,
-    [2] [...]
-]
-EOS
-    end
-
-    it 'plain multiline without index' do
-      expect(@arr.ai(plain: true, index: false)).to eq <<-EOS.strip
-[
-    1,
-    2,
-    [...]
-]
-EOS
-    end
-
-    it 'plain single line' do
-      expect(@arr.ai(plain: true, multiline: false)).to eq('[ 1, 2, [...] ]')
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  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
-[
-    [  0] 1,
-    [  1] 2,
-    [  2] 3,
-    [  3] .. [996],
-    [997] 998,
-    [998] 999,
-    [999] 1000
-]
-EOS
-    end
-
-    it 'plain limited output small' do
-      @arr = @arr[0..3]
-      expect(@arr.ai(plain: true, limit: true)).to eq <<-EOS.strip
-[
-    [0] 1,
-    [1] 2,
-    [2] 3,
-    [3] 4
-]
-EOS
-    end
-
-    it 'plain limited output with 10 lines' do
-      expect(@arr.ai(plain: true, limit: 10)).to eq <<-EOS.strip
-[
-    [  0] 1,
-    [  1] 2,
-    [  2] 3,
-    [  3] 4,
-    [  4] 5,
-    [  5] .. [995],
-    [996] 997,
-    [997] 998,
-    [998] 999,
-    [999] 1000
-]
-EOS
-    end
-
-    it 'plain limited output with 11 lines' do
-      expect(@arr.ai(plain: true, limit: 11)).to eq <<-EOS.strip
-[
-    [  0] 1,
-    [  1] 2,
-    [  2] 3,
-    [  3] 4,
-    [  4] 5,
-    [  5] .. [994],
-    [995] 996,
-    [996] 997,
-    [997] 998,
-    [998] 999,
-    [999] 1000
-]
-EOS
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  describe 'Limited Output Hash' do
-    before(:each) do
-      @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
-{
-    "a" => :a,
-    "b" => :b,
-    "c" => :c,
-    "d" => :d .. "w" => :w,
-    "x" => :x,
-    "y" => :y,
-    "z" => :z
-}
-EOS
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  describe 'Hash' do
-    before do
-      @hash = { 1 => { sym: { 'str' => { [1, 2, 3] => { { k: :v } => Hash } } } } }
-    end
-
-    it 'empty hash' do
-      expect({}.ai).to eq('{}')
-    end
-
-    it 'plain multiline' do
-      expect(@hash.ai(plain: true)).to eq <<-EOS.strip
-{
-    1 => {
-        :sym => {
-            "str" => {
-                [ 1, 2, 3 ] => {
-                    { :k => :v } => Hash < Object
-                }
-            }
-        }
-    }
-}
-EOS
-    end
-
-    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 => {
-   "str" => {
-    [ 1, 2, 3 ] => {
-     { :k => :v } => Hash < Object
-    }
-   }
-  }
- }
-}
-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 } } } } }')
-    end
-
-    it 'colored multiline (default)' do
-      expect(@hash.ai).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 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{
-      \"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 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
-    before do
-      @hash = {}
-      @hash[:a] = @hash
-    end
-
-    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 => {...} }')
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  describe 'Hash with several keys' do
-    before do
-      @hash = { 'b' => 'b', :a => 'a', :z => 'z', 'alpha' => 'alpha' }
-    end
-
-    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",?/)
-        expect(out).to match(/         :a => "a",?/)
-        expect(out).to match(/         :z => "z",?/)
-        expect(out).to match(/    "alpha" => "alpha",?$/)
-      else
-        expect(out).to eq <<-EOS.strip
-{
-        "b" => "b",
-         :a => "a",
-         :z => "z",
-    "alpha" => "alpha"
-}
-EOS
-      end
-    end
-
-    it 'plain multiline with sorted keys' do
-      expect(@hash.ai(plain: true, sort_keys: true)).to eq <<-EOS.strip
-{
-         :a => "a",
-    "alpha" => "alpha",
-        "b" => "b",
-         :z => "z"
-}
-EOS
-    end
-
-  end
-
-  #------------------------------------------------------------------------------
-  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)
-      expect(out).to eq <<-EOS.strip
-{
-    [ 0, 0, 255 ] => :yellow,
-    "magenta"     => "rgb(255, 0, 255)",
-    :red          => "rgb(255, 0, 0)"
-}
-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)
-      expect(out).to eq <<-EOS.strip
-[
-    [0] {
-        :a   => 1,
-        :bb  => 22,
-        :ccc => 333
-    },
-    [1] {
-        1   => :a,
-        22  => :bb,
-        333 => :ccc
-    }
-]
-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)
-      expect(out).to eq <<-EOS.strip
-{
-    :first  => {
-        :a   => 1,
-        :bb  => 22,
-        :ccc => 333
-    },
-    :second => {
-        1   => :a,
-        22  => :bb,
-        333 => :ccc
-    }
-}
-EOS
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  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
-      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)
-      end
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  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)
-      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')
-    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
-
-  #------------------------------------------------------------------------------
-  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')
-      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
-    before do
-      @struct = unless defined?(Struct::SimpleStruct)
-        Struct.new('SimpleStruct', :name, :address).new
-      else
-        Struct::SimpleStruct.new
-      end
-      @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")
-    end
-
-    it 'plain multiline' do
-      s1 = <<-EOS.strip
-    address = \"1313 Mockingbird Lane\",
-    name = \"Herman Munster\"
-EOS
-      s2 = <<-EOS.strip
-    name = \"Herman Munster\",
-    address = \"1313 Mockingbird Lane\"
-EOS
-      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"
-EOS
-      s2 = <<-EOS.strip
- name = "Herman Munster",
- address = "1313 Mockingbird Lane"
-EOS
-      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) }
-    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
-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
-EOS
-      expect(@struct.ai).to satisfy { |out| out.include?(s1) || out.include?(s2) }
-    end
-  end
-
-  #------------------------------------------------------------------------------
-  describe 'Inherited from standard Ruby classes' do
-    after do
-      Object.instance_eval { remove_const :My } if defined?(My)
-    end
-
-    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
-[
-    [0] 1,
-    [1] :two,
-    [2] "three",
-    [3] [
-        [0] nil,
-        [1] [
-            [0] true,
-            [1] false
-        ]
-    ]
-]
-EOS
-    end
-
-    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
-{
-    1 => {
-        :sym => {
-            "str" => {
-                [ 1, 2, 3 ] => {
-                    { :k => :v } => Hash < Object
-                }
-            }
-        }
-    }
-}
-EOS
-    end
-
-    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)
-    end
-
-    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)
-    end
-
-    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
-    end
-
-    it 'should handle a class defines its own #method method (ex. request.method)' do
-      class My
-        def method
-          'POST'
-        end
-      end
-
-      my = My.new
-      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