awesome_print 1.6.1 → 1.9.2

data/spec/misc_spec.rb

@@ -1,47 +1,44 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'net/http'
+require 'spec_helper'
 
-describe "AwesomePrint" do
+RSpec.describe 'AwesomePrint' do
 
-  describe "Misc" do
-    before do
-      stub_dotfile!
-    end
-
-    it "handle weird objects that return nil on inspect" do
+  describe 'Misc' do
+    it 'handle weird objects that return nil on inspect' do
       weird = Class.new do
         def inspect
           nil
         end
       end
-      expect(weird.new.ai(:plain => true)).to eq('')
+      expect(weird.new.ai(plain: true)).to eq('')
     end
 
-    it "handle frozen object.inspect" do
+    it 'handle frozen object.inspect' do
       weird = Class.new do
         def inspect
-          "ice".freeze
+          'ice'.freeze
         end
       end
-      expect(weird.new.ai(:plain => false)).to eq("ice")
+      expect(weird.new.ai(plain: false)).to eq('ice')
     end
 
-    # See https://github.com/michaeldv/awesome_print/issues/35
-    it "handle array grep when pattern contains / chapacter" do
-      hash = { "1/x" => 1,  "2//x" => :"2" }
+    # See https://github.com/awesome-print/awesome_print/issues/35
+    it 'handle array grep when pattern contains / chapacter' do
+      hash = { '1/x' => 1,  '2//x' => :"2" }
       grepped = hash.keys.sort.grep(/^(\d+)\//) { $1 }
-      expect(grepped.ai(:plain => true, :multiline => false)).to eq('[ "1", "2" ]')
+      expect(grepped.ai(plain: true, multiline: false)).to eq('[ "1", "2" ]')
     end
 
-    # See https://github.com/michaeldv/awesome_print/issues/85
-    if RUBY_VERSION >= "1.8.7"
+    # See https://github.com/awesome-print/awesome_print/issues/85
+    if RUBY_VERSION >= '1.8.7'
       it "handle array grep when a method is defined in C and thus doesn't have a binding" do
         arr = (0..6).to_a
         grepped = arr.grep(1..4, &:succ)
-        expect(grepped.ai(:plain => true, :multiline => false)).to eq('[ 2, 3, 4, 5 ]')
+        expect(grepped.ai(plain: true, multiline: false)).to eq('[ 2, 3, 4, 5 ]')
       end
     end
 
-    it "returns value passed as a parameter" do
+    it 'returns value passed as a parameter' do
       object = rand
       allow(self).to receive(:puts)
       expect(ap object).to eq(object)
@@ -53,20 +50,20 @@ describe "AwesomePrint" do
       expect { rand.ai }.not_to raise_error
     end
 
-    it "format ENV as hash" do
-      expect(ENV.ai(:plain => true)).to eq(ENV.to_hash.ai(:plain => true))
+    it 'format ENV as hash' do
+      expect(ENV.ai(plain: true)).to eq(ENV.to_hash.ai(plain: true))
       expect(ENV.ai).to eq(ENV.to_hash.ai)
     end
 
-    # See https://github.com/michaeldv/awesome_print/issues/134
-    it "IPAddr workaround" do
-      require "ipaddr"
-      ipaddr = IPAddr.new("3ffe:505:2::1")
-      expect(ipaddr.ai).to eq("#<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>")
+    # See https://github.com/awesome-print/awesome_print/issues/134
+    it 'IPAddr workaround' do
+      require 'ipaddr'
+      ipaddr = IPAddr.new('3ffe:505:2::1')
+      expect(ipaddr.ai).to eq('#<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>')
     end
 
-    # See https://github.com/michaeldv/awesome_print/issues/139
-    it "Object that overrides == and expects the :id method" do
+    # See https://github.com/awesome-print/awesome_print/issues/139
+    it 'Object that overrides == and expects the :id method' do
       weird = Class.new do
         # Raises NoMethodError: undefined method `id' when "other" is nil or ENV.
         def ==(other)
@@ -76,90 +73,84 @@ describe "AwesomePrint" do
       end
       expect { weird.new.ai }.not_to raise_error
     end
-  end
 
-  #------------------------------------------------------------------------------
-  describe "HTML output" do
-    before do
-      stub_dotfile!
+    it 'handles attr_reader :method' do
+      uri = URI.parse('https://hello.nx/world')
+      req = Net::HTTP::Get.new(uri)
+      expect(req.ai(plain: true)).to eq('#<Net::HTTP::Get GET>')
     end
+  end
 
-    it "wraps ap output with plain <pre> tag" do
+  #------------------------------------------------------------------------------
+  describe 'HTML output' do
+    it 'wraps ap output with plain <pre> tag' do
       markup = rand
-      expect(markup.ai(:html => true, :plain => true)).to eq("<pre>#{markup}</pre>")
+      expect(markup.ai(html: true, plain: true)).to eq("<pre>#{markup}</pre>")
     end
 
-    it "wraps ap output with <pre> tag with colorized <kbd>" do
+    it 'wraps ap output with <pre> tag with colorized <kbd>' do
       markup = rand
-      expect(markup.ai(:html => true)).to eq(%Q|<pre><kbd style="color:blue">#{markup}</kbd></pre>|)
+      expect(markup.ai(html: true)).to eq(%Q|<pre><kbd style="color:blue">#{markup}</kbd></pre>|)
     end
 
-    it "wraps multiline ap output with <pre> tag with colorized <kbd>" do
-      markup = [ 1, :two, "three" ]
-      expect(markup.ai(:html => true)).to eq <<-EOS.strip
+    it 'wraps multiline ap output with <pre> tag with colorized <kbd>' do
+      markup = [1, :two, 'three']
+      expect(markup.ai(html: true)).to eq <<-EOS.strip
 <pre>[
     <kbd style="color:white">[0] </kbd><kbd style="color:blue">1</kbd>,
     <kbd style="color:white">[1] </kbd><kbd style="color:darkcyan">:two</kbd>,
     <kbd style="color:white">[2] </kbd><kbd style="color:brown">&quot;three&quot;</kbd>
 ]</pre>
-EOS
+      EOS
     end
 
-    it "wraps hash ap output with only an outer <pre> tag" do
-      markup = [ { "hello" => "world" } ]
-      expect(markup.ai(:html => true)).to eq <<-EOS.strip
+    it 'wraps hash ap output with only an outer <pre> tag' do
+      markup = [{ 'hello' => 'world' }]
+      expect(markup.ai(html: true)).to eq <<-EOS.strip
 <pre>[
     <kbd style="color:white">[0] </kbd>{
         &quot;hello&quot;<kbd style="color:slategray"> =&gt; </kbd><kbd style="color:brown">&quot;world&quot;</kbd>
     }
 ]</pre>
-    EOS
+      EOS
     end
 
-    it "encodes HTML entities (plain)" do
+    it 'encodes HTML entities (plain)' do
       markup = ' &<hello>'
-      expect(markup.ai(:html => true, :plain => true)).to eq('<pre>&quot; &amp;&lt;hello&gt;&quot;</pre>')
+      expect(markup.ai(html: true, plain: true)).to eq('<pre>&quot; &amp;&lt;hello&gt;&quot;</pre>')
     end
 
-    it "encodes HTML entities (color)" do
+    it 'encodes HTML entities (color)' do
       markup = ' &<hello>'
-      expect(markup.ai(:html => true)).to eq('<pre><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>')
+      expect(markup.ai(html: true)).to eq('<pre><kbd style="color:brown">&quot; &amp;&lt;hello&gt;&quot;</kbd></pre>')
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "AwesomePrint.defaults" do
-    before do
-      stub_dotfile!
-    end
-
+  describe 'AwesomePrint.defaults' do
     after do
       AwesomePrint.defaults = nil
     end
 
-    # See https://github.com/michaeldv/awesome_print/issues/98
-    it "should properly merge the defaults" do
-      AwesomePrint.defaults = { :indent => -2, :sort_keys => true }
-      hash = { [0, 0, 255] => :yellow, :red => "rgb(255, 0, 0)", "magenta" => "rgb(255, 0, 255)" }
-      out = hash.ai(:plain => true)
+    # See https://github.com/awesome-print/awesome_print/issues/98
+    it 'should properly merge the defaults' do
+      AwesomePrint.defaults = { indent: -2, sort_keys: true }
+      hash = { [0, 0, 255] => :yellow, :red => 'rgb(255, 0, 0)', 'magenta' => 'rgb(255, 0, 255)' }
+      out = hash.ai(plain: true)
       expect(out).to eq <<-EOS.strip
 {
   [ 0, 0, 255 ] => :yellow,
   "magenta"     => "rgb(255, 0, 255)",
   :red          => "rgb(255, 0, 0)"
 }
-EOS
+      EOS
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Coexistence with the colorize gem" do
-    before do
-      stub_dotfile!
-    end
-
+  describe 'Coexistence with the colorize gem' do
     before do # Redefine String#red just like colorize gem does it.
-      @awesome_method = "".method(:red)
+      @awesome_method = ''.method(:red)
 
       String.instance_eval do
         define_method :red do   # Method arity is now 0 in Ruby 1.9+.
@@ -175,74 +166,88 @@ EOS
       end
     end
 
-    it "shoud not raise ArgumentError when formatting HTML" do
-      out = "hello".ai(:color => { :string => :red }, :html => true)
-      if RUBY_VERSION >= "1.9"
+    it 'shoud not raise ArgumentError when formatting HTML' do
+      out = 'hello'.ai(color: { string: :red }, html: true)
+      if RUBY_VERSION >= '1.9'
         expect(out).to eq(%Q|<pre>[red]<kbd style="color:red">&quot;hello&quot;</kbd>[/red]</pre>|)
       else
         expect(out).to eq(%Q|<pre>[red]&quot;hello&quot;[/red]</pre>|)
       end
     end
 
-    it "shoud not raise ArgumentError when formatting HTML (shade color)" do
-      out = "hello".ai(:color => { :string => :redish }, :html => true)
+    it 'shoud not raise ArgumentError when formatting HTML (shade color)' do
+      out = 'hello'.ai(color: { string: :redish }, html: true)
       expect(out).to eq(%Q|<pre><kbd style="color:darkred">&quot;hello&quot;</kbd></pre>|)
     end
 
-    it "shoud not raise ArgumentError when formatting non-HTML" do
-      out = "hello".ai(:color => { :string => :red }, :html => false)
+    it 'shoud not raise ArgumentError when formatting non-HTML' do
+      out = 'hello'.ai(color: { string: :red }, html: false)
       expect(out).to eq(%Q|[red]"hello"[/red]|)
     end
 
-    it "shoud not raise ArgumentError when formatting non-HTML (shade color)" do
-      out = "hello".ai(:color => { :string => :redish }, :html => false)
+    it 'shoud not raise ArgumentError when formatting non-HTML (shade color)' do
+      out = 'hello'.ai(color: { string: :redish }, html: false)
       expect(out).to eq(%Q|\e[0;31m"hello"\e[0m|)
     end
   end
 
   #------------------------------------------------------------------------------
-  describe "Console" do
-    it "should detect IRB" do
+  describe 'Console' do
+    it 'should detect IRB' do
       class IRB; end
+      ENV.delete('RAILS_ENV')
       expect(AwesomePrint.console?).to eq(true)
       expect(AwesomePrint.rails_console?).to eq(false)
-      Object.instance_eval{ remove_const :IRB }
+      Object.instance_eval { remove_const :IRB }
     end
 
-    it "should detect Pry" do
+    it 'should detect Pry' do
       class Pry; end
+      ENV.delete('RAILS_ENV')
       expect(AwesomePrint.console?).to eq(true)
       expect(AwesomePrint.rails_console?).to eq(false)
-      Object.instance_eval{ remove_const :Pry }
+      Object.instance_eval { remove_const :Pry }
     end
 
-    it "should detect Rails::Console" do
+    it 'should detect Rails::Console' do
       class IRB; end
       module Rails; class Console; end; end
       expect(AwesomePrint.console?).to eq(true)
       expect(AwesomePrint.rails_console?).to eq(true)
-      Object.instance_eval{ remove_const :IRB }
-      Object.instance_eval{ remove_const :Rails }
+      Object.instance_eval { remove_const :IRB }
+      Object.instance_eval { remove_const :Rails }
     end
 
     it "should detect ENV['RAILS_ENV']" do
       class Pry; end
-      ENV["RAILS_ENV"] = "development"
+      ENV['RAILS_ENV'] = 'development'
       expect(AwesomePrint.console?).to eq(true)
       expect(AwesomePrint.rails_console?).to eq(true)
-      Object.instance_eval{ remove_const :Pry }
+      Object.instance_eval { remove_const :Pry }
     end
 
-    it "should return the actual object when *not* running under console" do
-      expect(capture! { ap([ 1, 2, 3 ]) }).to eq([ 1, 2, 3 ])
-      expect(capture! { ap({ :a => 1 }) }).to eq({ :a => 1 })
+    it 'should return the actual object when *not* running under console' do
+      expect(capture! { ap([1, 2, 3]) }).to eq([1, 2, 3])
+      expect(capture! { ap({ a: 1 }) }).to eq({ a: 1 })
     end
 
-    it "should return nil when running under console" do
+    it 'should return nil when running under console' do
       class IRB; end
-      expect(capture! { ap([ 1, 2, 3 ]) }).to eq(nil)
-      expect(capture! { ap({ :a => 1 }) }).to eq(nil)
-      Object.instance_eval{ remove_const :IRB }
+      expect(capture! { ap([1, 2, 3]) }).to eq(nil)
+      expect(capture! { ap({ a: 1 }) }).to eq(nil)
+      Object.instance_eval { remove_const :IRB }
+    end
+
+    it 'handles NoMethodError on IRB implicit #ai' do
+      module IRB; class Irb; end; end
+      irb_context = double('irb_context', last_value: BasicObject.new)
+      IRB.define_singleton_method :version, -> { 'test_version' }
+      irb = IRB::Irb.new
+      irb.instance_eval { @context = irb_context }
+      AwesomePrint.irb!
+      expect(irb).to receive(:puts).with("(Object doesn't support #ai)")
+      expect { irb.output_value }.to_not raise_error
+      Object.instance_eval { remove_const :IRB }
     end
   end
 end

data/spec/objects_spec.rb

@@ -1,75 +1,79 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Objects" do
-  before do
-    stub_dotfile!
-  end
+require 'spec_helper'
 
+RSpec.describe 'Objects' do
   after do
-    Object.instance_eval{ remove_const :Hello } if defined?(Hello)
+    Object.instance_eval { remove_const :Hello } if defined?(Hello)
   end
 
-  describe "Formatting an object" do
-    it "attributes" do
+  describe 'Formatting an object' do
+    it 'attributes' do
       class Hello
         attr_reader   :abra
         attr_writer   :ca
         attr_accessor :dabra
 
         def initialize
-          @abra, @ca, @dabra = 1, 2, 3
+          @abra = 1
+          @ca = 2
+          @dabra = 3
         end
       end
 
       hello = Hello.new
-      out = hello.ai(:plain => true, :raw => true)
+      out = hello.ai(plain: true, raw: true)
       str = <<-EOS.strip
-#<Hello:0x01234567
+#<Hello:placeholder_id
     attr_accessor :dabra = 3,
     attr_reader :abra = 1,
     attr_writer :ca = 2
 >
 EOS
-      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
     end
 
-    it "instance variables" do
+    it 'instance variables' do
       class Hello
         def initialize
-          @abra, @ca, @dabra = 1, 2, 3
+          @abra = 1
+          @ca = 2
+          @dabra = 3
         end
       end
 
       hello = Hello.new
-      out = hello.ai(:plain => true, :raw => true)
+      out = hello.ai(plain: true, raw: true)
       str = <<-EOS.strip
-#<Hello:0x01234567
+#<Hello:placeholder_id
     @abra = 1,
     @ca = 2,
     @dabra = 3
 >
 EOS
-      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
     end
 
-    it "attributes and instance variables" do
+    it 'attributes and instance variables' do
       class Hello
         attr_reader   :abra
         attr_writer   :ca
         attr_accessor :dabra
 
         def initialize
-          @abra, @ca, @dabra = 1, 2, 3
-          @scooby, @dooby, @doo = 3, 2, 1
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+          @scooby = 3
+          @dooby = 2
+          @doo = 1
         end
       end
 
       hello = Hello.new
-      out = hello.ai(:plain => true, :raw => true)
+      out = hello.ai(plain: true, raw: true)
       str = <<-EOS.strip
-#<Hello:0x01234567
+#<Hello:placeholder_id
     @doo = 1,
     @dooby = 2,
     @scooby = 3,
@@ -78,8 +82,139 @@ EOS
     attr_writer :ca = 2
 >
 EOS
-      expect(out.gsub(/0x([a-f\d]+)/, "0x01234567")).to eq(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
     end
+
+    it 'without the plain options print the colorized values' do
+      class Hello
+        attr_reader   :abra
+        attr_writer   :ca
+
+        def initialize
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+        end
+      end
+
+      hello = Hello.new
+      out = hello.ai(raw: true)
+      str = <<-EOS.strip
+#<Hello:placeholder_id
+    \e[0;36m@dabra\e[0m\e[0;37m = \e[0m\e[1;34m3\e[0m,
+    \e[1;36mattr_reader\e[0m \e[0;35m:abra\e[0m\e[0;37m = \e[0m\e[1;34m1\e[0m,
+    \e[1;36mattr_writer\e[0m \e[0;35m:ca\e[0m\e[0;37m = \e[0m\e[1;34m2\e[0m
+>
+EOS
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
+    end
+
+    it 'with multine as false show inline values' do
+      class Hello
+        attr_reader   :abra
+        attr_writer   :ca
+
+        def initialize
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+        end
+      end
+
+      hello = Hello.new
+      out = hello.ai(multiline: false, plain: true, raw: true)
+      str = <<-EOS.strip
+#<Hello:placeholder_id @dabra = 3, attr_reader :abra = 1, attr_writer :ca = 2>
+EOS
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
+    end
+
+    it 'without the sort_vars option does not sort instance variables' do
+      class Hello
+        attr_reader   :abra
+        attr_writer   :ca
+        attr_accessor :dabra
+
+        def initialize
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+          @scooby = 3
+          @dooby = 2
+          @doo = 1
+        end
+
+        def instance_variables
+          [:@scooby, :@dooby, :@doo, :@abra, :@ca, :@dabra]
+        end
+      end
+
+      hello = Hello.new
+      out = hello.ai(plain: true, raw: true, sort_vars: false)
+      str = <<-EOS.strip
+#<Hello:placeholder_id
+    @scooby = 3,
+    @dooby = 2,
+    @doo = 1,
+    attr_reader :abra = 1,
+    attr_writer :ca = 2,
+    attr_accessor :dabra = 3
+>
+EOS
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
+    end
+
+    it 'object_id' do
+      class Hello
+        def initialize
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+        end
+      end
+
+      hello = Hello.new
+      out = hello.ai(plain: true, raw: true, object_id: false)
+      str = <<-EOS.strip
+#<Hello
+    @abra = 1,
+    @ca = 2,
+    @dabra = 3
+>
+EOS
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
+    end
+
+    it 'class_name' do
+      class Hello
+        def initialize
+          @abra = 1
+          @ca = 2
+          @dabra = 3
+        end
+
+        def to_s
+          "CustomizedHello"
+        end
+      end
+
+      hello = Hello.new
+      out = hello.ai(plain: true, raw: true, class_name: :to_s)
+      str = <<-EOS.strip
+#<CustomizedHello:placeholder_id
+    @abra = 1,
+    @ca = 2,
+    @dabra = 3
+>
+EOS
+      expect(out).to be_similar_to(str)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
+    end
+
   end
 end