awesome_print 1.9.2 → 2.0.0.pre

data/spec/formatters/big_decimal_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+require 'bigdecimal'
+require 'rational'
+
+RSpec.describe 'AwesomePrint' do
+  #------------------------------------------------------------------------------
+  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
+end

data/spec/formatters/class_spec.rb

@@ -0,0 +1,91 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'AwesomePrint' do
+
+  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 'Inherited from standard Ruby classes' do
+    after do
+      Object.instance_eval { remove_const :My } if defined?(My)
+    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

data/spec/formatters/dir_file_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'AwesomePrint' do
+
+  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 'Inherited from standard Ruby classes' do
+    after do
+      Object.instance_eval { remove_const :My } if defined?(My)
+    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
+
+  end
+end

data/spec/{ext → formatters/ext}/active_record_spec.rb

@@ -21,11 +21,7 @@ RSpec.describe 'AwesomePrint/ActiveRecord', skip: -> { !ExtVerifier.has_rails? }
           :rank => 1
 }
       EOS
-
-			expect(RUBY_VERSION).to be >= '2.5'
-
       str.sub!('?', '1992-10-10 12:30:00 UTC')
-
       expect(out).to be_similar_to(str)
     end
 
@@ -49,10 +45,8 @@ RSpec.describe 'AwesomePrint/ActiveRecord', skip: -> { !ExtVerifier.has_rails? }
     }
 ]
       EOS
-
       str.sub!('??', '1992-10-10 12:30:00 UTC')
       str.sub!('?!', '2003-05-26 14:15:00 UTC')
-
       expect(out).to be_similar_to(str)
     end
 
@@ -78,10 +72,8 @@ RSpec.describe 'AwesomePrint/ActiveRecord', skip: -> { !ExtVerifier.has_rails? }
     }
 ]
       EOS
-
       str.sub!('??', '1992-10-10 12:30:00 UTC')
       str.sub!('?!', '2003-05-26 14:15:00 UTC')
-
       expect(out).to be_similar_to(str)
     end
   end
@@ -120,24 +112,12 @@ EOS
       out = @ap.awesome(@diana)
 
       raw_object_string =
-        if activerecord_6_1?
-          ActiveRecordData.raw_6_1_diana
-        elsif activerecord_6_0?
-          ActiveRecordData.raw_6_0_diana
-        elsif activerecord_5_2?
+        if activerecord_5_2?
           ActiveRecordData.raw_5_2_diana
         elsif activerecord_5_1?
           ActiveRecordData.raw_5_1_diana
         elsif activerecord_5_0?
           ActiveRecordData.raw_5_0_diana
-        elsif activerecord_4_2?
-          ActiveRecordData.raw_4_2_diana
-        elsif activerecord_4_1?
-          ActiveRecordData.raw_4_1_diana
-        elsif activerecord_4_0?
-          ActiveRecordData.raw_4_0_diana
-        elsif activerecord_3_2?
-          ActiveRecordData.raw_3_2_diana
         end
       raw_object_string.sub!('?', '1992-10-10 12:30:00')
       expect(out).to be_similar_to(raw_object_string)
@@ -147,27 +127,16 @@ EOS
       out = @ap.awesome([@diana, @laura])
 
       raw_object_string =
-        if activerecord_6_1?
-          ActiveRecordData.raw_6_1_multi
-        elsif activerecord_6_0?
-          ActiveRecordData.raw_6_0_multi
-        elsif activerecord_5_2?
+        if activerecord_5_2?
           ActiveRecordData.raw_5_2_multi
         elsif activerecord_5_1?
           ActiveRecordData.raw_5_1_multi
         elsif activerecord_5_0?
           ActiveRecordData.raw_5_0_multi
-        elsif activerecord_4_2?
-          ActiveRecordData.raw_4_2_multi
-        elsif activerecord_4_1?
-          ActiveRecordData.raw_4_1_multi
-        elsif activerecord_4_0?
-          ActiveRecordData.raw_4_0_multi
-        elsif activerecord_3_2?
-          ActiveRecordData.raw_3_2_multi
         end
       raw_object_string.sub!('?', '1992-10-10 12:30:00')
       raw_object_string.sub!('?', '2003-05-26 14:15:00')
+
       expect(out).to be_similar_to(raw_object_string)
     end
   end
@@ -218,43 +187,30 @@ class SubUser < User {
       # spec 1
       out = @ap.awesome(User.methods.grep(/first/))
 
-      if RUBY_VERSION >= '3.0.0'
-        expect(out).to match(/\sfirst\(\*\*,\s&&\)/)
-      elsif RUBY_VERSION >= '2.7.0'
-        if ActiveRecord::VERSION::STRING >= '3.2'
-          expect(out).to match(/\sfirst\(\*\*,\s&&\)\s+User/)
-        else
-          expect(out).to match(/\sfirst\(\*\*,\s&&\)\s+User \(ActiveRecord::Base\)/)
-        end
+      if RUBY_VERSION >= '2.4.4'
+        expect(out).to match(/\sfirst\(\*arg.*?\)\s+User/)
       else
-        if ActiveRecord::VERSION::STRING >= '3.2'
-          expect(out).to match(/\sfirst\(\*arg.*?\)\s+User/)
-        else
-          expect(out).to match(/\sfirst\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/)
-        end
+        expect(out).to match(/\sfirst\(\*args,\s&block\)\s+Class \(ActiveRecord::Querying\)/)
       end
 
       # spec 2
       out = @ap.awesome(User.methods.grep(/primary_key/))
-      if RUBY_VERSION >= '3.0.0'
-        expect(out).to match(/\sprimary_key\(.*?\)/)
-      else
+
+      if RUBY_VERSION >= '2.4.4'
         expect(out).to match(/\sprimary_key\(.*?\)\s+User/)
+      else
+        expect(out).to match(/\sprimary_key\(.*?\)\s+Class \(ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods\)/)
       end
 
       # spec 3
       out = @ap.awesome(User.methods.grep(/validate/))
-      if ActiveRecord::VERSION::MAJOR < 3
-        expect(out).to match(/\svalidate\(\*arg.*?\)\s+User \(ActiveRecord::Base\)/)
+
+      if RUBY_VERSION >= '2.4.4'
+        expect(out).to match(/\svalidate\(\*arg.*?\)\s+User/)
       else
-        if RUBY_VERSION >= '3.0.0'
-          expect(out).to match(/\svalidate\(\*arg.*?\)/)
-        else
-          expect(out).to match(/\svalidate\(\*arg.*?\)\s+User/)
-        end
+        expect(out).to match(/\svalidate\(\*arg.*?\)\s+Class \(ActiveModel::Validations::ClassMethods\)/)
       end
 
     end
   end
 end
-

data/spec/{ext → formatters/ext}/active_support_spec.rb

@@ -8,18 +8,9 @@ RSpec.describe 'AwesomePrint::ActiveSupport', skip: -> { !ExtVerifier.has_rails?
   it 'should format ActiveSupport::TimeWithZone as regular Time' do
     Time.zone = 'Eastern Time (US & Canada)'
     time = Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone
-    if activerecord_6_1?
-      expect(@ap.send(:awesome, time)).to eq("\e[0;32mSat, 10 Feb 2007 15:30:45.000000000 EST -05:00\e[0m")
-    else
-      expect(@ap.send(:awesome, time)).to eq("\e[0;32mSat, 10 Feb 2007 15:30:45 EST -05:00\e[0m")
-    end
+    expect(@ap.send(:awesome, time)).to eq("\e[0;32mSat, 10 Feb 2007 15:30:45 EST -05:00\e[0m")
   end
-
-  it 'should format HashWithIndifferentAccess as regular Hash' do
-    hash = HashWithIndifferentAccess.new({ hello: 'world' })
-    expect(@ap.send(:awesome, hash)).to eq("{\n    \"hello\"\e[0;37m => \e[0m\e[0;33m\"world\"\e[0m\n}")
-  end
-
+  #
   # ActiveSupport sticks in instance variables to the date object. Make sure
   # we ignore that and format Date instance as regular date.
   it 'should formate Date object as date' do
@@ -27,4 +18,9 @@ RSpec.describe 'AwesomePrint::ActiveSupport', skip: -> { !ExtVerifier.has_rails?
     expect(date.ai(plain: true)).to eq('Mon, 26 May 2003')
     expect(date.ai).to eq("\e[0;32mMon, 26 May 2003\e[0m")
   end
+
+  it 'should format HashWithIndifferentAccess as regular Hash' do
+    hash = HashWithIndifferentAccess.new({ hello: 'world' })
+    expect(@ap.send(:awesome, hash)).to eq("{\n    \"hello\"\e[0;37m => \e[0m\e[0;33m\"world\"\e[0m\n}")
+  end
 end

data/spec/{ext → formatters/ext}/mongoid_spec.rb

@@ -40,7 +40,7 @@ RSpec.describe 'AwesomePrint/Mongoid', skip: -> { !ExtVerifier.has_mongoid? }.ca
   it 'should print the class' do
     class_spec = <<-EOS.strip
 class MongoUser < Object {
-           :_id => :"bson/object_id",
+           :_id => :bson/object_id,
     :first_name => :string,
      :last_name => :string
 }
@@ -57,7 +57,7 @@ class MongoUser < Object {
 
     class_spec = <<-EOS.strip
 class Chamelion < Object {
-               :_id => :"bson/object_id",
+               :_id => :bson/object_id,
     :last_attribute => :object
 }
                    EOS

data/spec/formatters/hash_spec.rb

@@ -0,0 +1,284 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'AwesomePrint' do
+
+  #------------------------------------------------------------------------------
+  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 'Inherited from standard Ruby classes' do
+    after do
+      Object.instance_eval { remove_const :My } if defined?(My)
+    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
+
+  end
+end