awesome_print 1.7.0 → 1.9.2

data/spec/misc_spec.rb

@@ -1,47 +1,44 @@
+require 'net/http'
 require 'spec_helper'
 
-RSpec.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 @@ RSpec.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 @@ RSpec.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,76 +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,28 +1,26 @@
 require 'spec_helper'
 
-RSpec.describe "Objects" do
-  before do
-    stub_dotfile!
-  end
-
+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:placeholder_id
     attr_accessor :dabra = 3,
@@ -31,18 +29,20 @@ RSpec.describe "Objects" do
 >
 EOS
       expect(out).to be_similar_to(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      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:placeholder_id
     @abra = 1,
@@ -51,23 +51,27 @@ EOS
 >
 EOS
       expect(out).to be_similar_to(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      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:placeholder_id
     @doo = 1,
@@ -79,22 +83,23 @@ EOS
 >
 EOS
       expect(out).to be_similar_to(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
     end
 
-    it "without the plain options print the colorized values" do
+    it 'without the plain options print the colorized values' do
       class Hello
         attr_reader   :abra
         attr_writer   :ca
 
         def initialize
-          @abra, @ca = 1, 2
+          @abra = 1
+          @ca = 2
           @dabra = 3
         end
       end
 
       hello = Hello.new
-      out = hello.ai(:raw => true)
+      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,
@@ -103,27 +108,113 @@ EOS
 >
 EOS
       expect(out).to be_similar_to(str)
-      expect(hello.ai(:plain => true, :raw => false)).to eq(hello.inspect)
+      expect(hello.ai(plain: true, raw: false)).to eq(hello.inspect)
     end
 
-    it "with multine as false show inline values" do
+    it 'with multine as false show inline values' do
       class Hello
         attr_reader   :abra
         attr_writer   :ca
 
         def initialize
-          @abra, @ca = 1, 2
+          @abra = 1
+          @ca = 2
           @dabra = 3
         end
       end
 
       hello = Hello.new
-      out = hello.ai(:multiline => false, :plain => true, :raw => true)
+      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)
+      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

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010-2013 Michael Dvorkin
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
 #
 # Awesome Print is freely distributable under the terms of MIT license.
 # See LICENSE file or http://www.opensource.org/licenses/mit-license.php
@@ -14,8 +14,10 @@
 # $ gem install bundler -v=1.0.2
 # $ gem install rspec -v=2.6.0
 #
-require 'codeclimate-test-reporter'
-CodeClimate::TestReporter.start
+
+# require 'simplecov'
+# SimpleCov.start
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
@@ -23,9 +25,19 @@ Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each do |file|
   require file
 end
 
-ExtVerifier.require_dependencies!(%w{rails active_record action_view
-                                  active_support/all mongoid mongo_mapper ripple nobrainer})
+ExtVerifier.require_dependencies!(
+  %w(
+    rails
+    active_record
+    action_view
+    active_support/all
+    mongoid
+    mongo_mapper
+    ripple nobrainer
+  )
+)
 require 'nokogiri'
+require 'ostruct'
 require 'awesome_print'
 
 RSpec.configure do |config|
@@ -42,8 +54,13 @@ RSpec.configure do |config|
     mocks.syntax = :expect
     mocks.verify_partial_doubles = true
   end
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  # Run before all examples. Using suite or all will not work as stubs are
+  # killed after each example ends.
+  config.before(:each) do |_example|
+    stub_dotfile!
   end
 end
 
@@ -71,12 +88,14 @@ def normalize_object_id_strings(str, options)
 end
 
 def stub_dotfile!
-  dotfile = File.join(ENV["HOME"], ".aprc")
-  expect(File).to receive(:readable?).at_least(:once).with(dotfile).and_return(false)
+  allow_any_instance_of(AwesomePrint::Inspector)
+    .to receive(:load_dotfile)
+    .and_return(true)
 end
 
 def capture!
-  standard, $stdout = $stdout, StringIO.new
+  standard = $stdout
+  $stdout = StringIO.new
   yield
 ensure
   $stdout = standard

data/spec/support/active_record_data/3_2_diana.txt

@@ -0,0 +1,24 @@
+#<User:placeholder_id
+    @aggregation_cache = {},
+    @attributes_cache = {},
+    @destroyed = false,
+    @marked_for_destruction = false,
+    @mass_assignment_options = nil,
+    @new_record = true,
+    @previously_changed = {},
+    @readonly = false,
+    attr_accessor :attributes = {
+             "admin" => false,
+        "created_at" => "1992-10-10 12:30:00",
+                "id" => nil,
+              "name" => "Diana",
+              "rank" => 1
+    },
+    attr_reader :association_cache = {},
+    attr_reader :changed_attributes = {
+             "admin" => nil,
+        "created_at" => nil,
+              "name" => nil,
+              "rank" => nil
+    }
+>