awesome_print_lite 0.1.0

data/lib/awesome_print_lite/inspector.rb

@@ -0,0 +1,174 @@
+# Copyright (c) 2010-2013 Michael Dvorkin
+#
+# Awesome Print is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module AwesomePrintLite
+
+  class << self # Class accessors for custom defaults.
+    attr_accessor :defaults, :force_colors
+
+    # Class accessor to force colorized output (ex. forked subprocess where TERM
+    # might be dumb).
+    #------------------------------------------------------------------------------
+    def force_colors!(value = true)
+      @force_colors = value
+    end
+
+    def console?
+      !!(defined?(IRB) || defined?(Pry)|| defined?(OpalIrb))
+    end
+
+    def rails_console?
+      console? && !!(defined?(Rails::Console) || ENV["RAILS_ENV"])
+    end
+=begin    
+    def irb!
+      return unless defined?(IRB)
+      unless IRB.version.include?("DietRB")
+        IRB::Irb.class_eval do
+          def output_value
+            ap @context.last_value
+          end
+        end
+      else # MacRuby
+        IRB.formatter = Class.new(IRB::Formatter) do
+          def inspect_object(object)
+            object.ai
+          end
+        end.new
+      end
+    end
+
+    def pry!
+      if defined?(Pry)
+        Pry.print = proc { |output, value| output.puts value.ai }
+      end
+    end
+=end
+  end
+
+  class Inspector
+    attr_accessor :options
+
+    AP = :__awesome_print__
+
+    def initialize(options = {})
+      @options = { 
+        :indent     => 4,      # Indent using 4 spaces.
+        :index      => true,   # Display array indices.
+        :html       => false,  # Use ANSI color codes rather than HTML.
+        :multiline  => true,   # Display in multiple lines.
+        :plain      => false,  # Use colors.
+        :raw        => false,  # Do not recursively format object instance variables.
+        :sort_keys  => false,  # Do not sort hash keys.
+        :limit      => false,  # Limit large output for arrays and hashes. Set to a boolean or integer.
+        :color => { 
+          :args       => :pale,
+          :array      => :white,
+          :bigdecimal => :blue,
+          :class      => :yellow,
+          :date       => :greenish,
+          :falseclass => :red,
+          :fixnum     => :blue,
+          :float      => :blue,
+          :hash       => :pale,
+          :keyword    => :cyan,
+          :method     => :purpleish,
+          :nilclass   => :red,
+          :rational   => :blue,
+          :string     => :yellowish,
+          :struct     => :pale,
+          :symbol     => :cyanish,
+          :time       => :greenish,
+          :trueclass  => :green,
+          :variable   => :cyanish
+        }
+      }
+
+      # Merge custom defaults and let explicit options parameter override them.
+      if RUBY_ENGINE != 'opal'
+        merge_custom_defaults!
+      end
+      merge_options!(options)
+
+      @formatter = AwesomePrintLite::Formatter.new(self)
+      @ap ||= []
+    end
+    
+    # Dispatcher that detects data nesting and invokes object-aware formatter.
+    #------------------------------------------------------------------------------
+    def awesome(object)
+      if @ap.include?(object.object_id)
+        nested(object)
+      else
+        begin
+          @ap << object.object_id
+          unnested(object)
+        ensure
+          @ap.pop
+        end
+      end
+    end
+
+    # Return true if we are to colorize the output.
+    #------------------------------------------------------------------------------
+    def colorize?
+      AwesomePrintLite.force_colors ||= false
+      AwesomePrintLite.force_colors || (STDOUT.tty? && ((ENV['TERM'] && ENV['TERM'] != 'dumb') || ENV['ANSICON']))
+    end
+
+    private
+
+    # Format nested data, for example:
+    #   arr = [1, 2]; arr << arr
+    #   => [1,2, [...]]
+    #   hash = { :a => 1 }; hash[:b] = hash
+    #   => { :a => 1, :b => {...} }
+    #------------------------------------------------------------------------------
+    def nested(object)
+      case printable(object)
+      when :array  then @formatter.colorize("[...]", :array)
+      when :hash   then @formatter.colorize("{...}", :hash)
+      when :struct then @formatter.colorize("{...}", :struct)
+      else @formatter.colorize("...#{object.class}...", :class)
+      end
+    end
+
+    #------------------------------------------------------------------------------
+    def unnested(object)
+      @formatter.format(object, printable(object))
+    end
+
+    # Turn class name into symbol, ex: Hello::World => :hello_world. Classes that
+    # inherit from Array, Hash, File, Dir, and Struct are treated as the base class.
+    #------------------------------------------------------------------------------
+    def printable(object)
+      case object
+      when Array  then :array
+      when Hash   then :hash
+      when File   then :file
+      when Dir    then :dir
+      when Struct then :struct
+      else object.class.to_s.gsub(/:+/, "_").downcase.to_sym
+      end
+    end
+
+    # Update @options by first merging the :color hash and then the remaining keys.
+    #------------------------------------------------------------------------------
+    def merge_options!(options = {})
+      @options[:color].merge!(options.delete(:color) || {})
+      @options.merge!(options)
+    end
+
+    # Load ~/.aprc file with custom defaults that override default options.
+    #------------------------------------------------------------------------------
+    def merge_custom_defaults!
+      dotfile = File.join(ENV["HOME"], ".aprc")
+      load dotfile if File.readable?(dotfile)
+      merge_options!(AwesomePrintLite.defaults) if AwesomePrintLite.defaults.is_a?(Hash)
+    rescue => e
+      $stderr.puts "Could not load #{dotfile}: #{e}"
+    end
+  end
+end

data/lib/awesome_print_lite/version.rb

@@ -0,0 +1,3 @@
+module AwesomePrintLite
+  VERSION = "0.1.0"
+end

data/spec/colors_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+RSpec.describe "AwesomePrint" do
+  def stub_tty!(output = true, stream = STDOUT)
+    if output
+      stream.instance_eval { def tty?;  true; end }
+    else
+      stream.instance_eval { def tty?; false; end }
+    end
+  end
+
+  before do
+    stub_dotfile!
+  end
+
+  describe "colorization" do
+    PLAIN = '[ 1, :two, "three", [ nil, [ true, false ] ] ]'
+    COLORIZED = "[ \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 ] ] ]"
+
+    before do
+      ENV['TERM'] = "xterm-colors"
+      ENV.delete('ANSICON')
+      @arr = [ 1, :two, "three", [ nil, [ true, false] ] ]
+    end
+
+    describe "default settings (no forced colors)" do
+      before do
+        AwesomePrintLite.force_colors! false
+      end
+
+      it "colorizes tty processes by default" do
+        stub_tty!
+        expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+      end
+
+      it "colorizes processes with ENV['ANSICON'] by default" do
+        begin
+          stub_tty!
+          term, ENV['ANSICON'] = ENV['ANSICON'], "1"
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+        ensure
+          ENV['ANSICON'] = term
+        end
+      end
+
+      it "does not colorize tty processes running in dumb terminals by default" do
+        begin
+          stub_tty!
+          term, ENV['TERM'] = ENV['TERM'], "dumb"
+          expect(@arr.ai(:multiline => false)).to eq(PLAIN)
+        ensure
+          ENV['TERM'] = term
+        end
+      end
+
+      it "does not colorize subprocesses by default" do
+        begin
+          stub_tty! false
+          expect(@arr.ai(:multiline => false)).to eq(PLAIN)
+        ensure
+          stub_tty!
+        end
+      end
+    end
+
+    describe "forced colors override" do
+      before do
+        AwesomePrintLite.force_colors!
+      end
+      
+      it "still colorizes tty processes" do
+        stub_tty!
+        expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+      end
+
+      it "colorizes processes with ENV['ANSICON'] set to 0" do
+        begin
+          stub_tty!
+          term, ENV['ANSICON'] = ENV['ANSICON'], "1"
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+        ensure
+          ENV['ANSICON'] = term
+        end
+      end
+      
+      it "colorizes dumb terminals" do
+        begin
+          stub_tty!
+          term, ENV['TERM'] = ENV['TERM'], "dumb"
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+        ensure
+          ENV['TERM'] = term
+        end
+      end
+
+      it "colorizes subprocess" do
+        begin
+          stub_tty! false
+          expect(@arr.ai(:multiline => false)).to eq(COLORIZED)
+        ensure
+          stub_tty!
+        end
+      end
+    end
+  end
+end

data/spec/core_ext/string_spec.rb

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

data/spec/formats_spec.rb

@@ -0,0 +1,725 @@
+require 'spec_helper'
+require "set"
+
+RSpec.describe "AwesomePrint" do
+  before do
+    stub_dotfile!
+  end
+
+  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 "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 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 "shoud show superclass (plain)" do
+             expect(self.class.ai(:plain => true)).to eq("#{self.class} < #{self.class.superclass}")
+           end
+
+           it "shoud show superclass (color)" do
+             expect(self.class.ai).to eq("#{self.class} < #{self.class.superclass}".yellow)
+           end
+         end
+
+         #------------------------------------------------------------------------------
+         describe "Rational" do
+
+           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 = AwesomePrintLite::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 { |match| match == s1 || 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 { |match| match == s1 || match == s2 }
+           end
+
+           it "plain single line" do
+             s1 = "{ :address => \"1313 Mockingbird Lane\", :name => \"Herman Munster\" }"
+             s2 = "{ :name => \"Herman Munster\", :address => \"1313 Mockingbird Lane\" }"
+             expect(@struct.ai(:plain => true, :multiline => false)).to satisfy { |match| match == s1 || 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 { |match| match == s1 || match == 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 "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