awesome_print 1.7.0 → 1.8.0

data/lib/awesome_print/formatters/struct_formatter.rb

@@ -0,0 +1,71 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class StructFormatter < BaseFormatter
+
+      attr_reader :struct, :variables, :inspector, :options
+
+      def initialize(struct, inspector)
+        @struct = struct
+        @variables = struct.members
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        vars = variables.map do |var|
+          property = var.to_s[1..-1].to_sym # to_s because of some monkey patching done by Puppet.
+          accessor = if struct.respond_to?(:"#{property}=")
+            struct.respond_to?(property) ? :accessor : :writer
+          else
+            struct.respond_to?(property) ? :reader : nil
+          end
+          if accessor
+            ["attr_#{accessor} :#{property}", var]
+          else
+            [var.to_s, var]
+          end
+        end
+
+        data = vars.sort.map do |declaration, var|
+          key = left_aligned do
+            align(declaration, declaration.size)
+          end
+
+          unless options[:plain]
+            if key =~ /(@\w+)/
+              key.sub!($1, colorize($1, :variable))
+            else
+              key.sub!(/(attr_\w+)\s(\:\w+)/, "#{colorize('\\1', :keyword)} #{colorize('\\2', :method)}")
+            end
+          end
+
+          indented do
+            key << colorize(' = ', :hash) + inspector.awesome(struct.send(var))
+          end
+        end
+
+        if options[:multiline]
+          "#<#{awesome_instance}\n#{data.join(%Q/,\n/)}\n#{outdent}>"
+        else
+          "#<#{awesome_instance} #{data.join(', ')}>"
+        end
+      end
+
+      private
+
+      def awesome_instance
+        "#{struct.class.superclass}:#{struct.class}:0x%08x" % (struct.__id__ * 2)
+      end
+
+      def left_aligned
+        current = options[:indent]
+        options[:indent] = 0
+        yield
+      ensure
+        options[:indent] = current
+      end
+    end
+  end
+end

data/lib/awesome_print/inspector.rb

@@ -1,89 +1,48 @@
-# 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
 #------------------------------------------------------------------------------
-require_relative "indentator"
+require_relative 'indentator'
 
 module AwesomePrint
-
-  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))
-    end
-
-    def rails_console?
-      console? && !!(defined?(Rails::Console) || ENV["RAILS_ENV"])
-    end
-
-    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
-
   class Inspector
     attr_accessor :options, :indentator
 
     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
+      @options = {
+        indent:        4,      # Number of spaces for indenting.
+        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 instance variables.
+        sort_keys:     false,  # Do not sort hash keys.
+        sort_vars:     true,   # Sort instance variables.
+        limit:         false,  # Limit arrays & hashes. Accepts bool or int.
+        ruby19_syntax: false,  # Use Ruby 1.9 hash syntax in output.
+        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
         }
       }
 
@@ -103,9 +62,9 @@ module AwesomePrint
     def increase_indentation
       indentator.indent(&Proc.new)
     end
-  
+
     # Dispatcher that detects data nesting and invokes object-aware formatter.
-    #------------------------------------------------------------------------------
+    #---------------------------------------------------------------------------
     def awesome(object)
       if Thread.current[AP].include?(object.object_id)
         nested(object)
@@ -120,10 +79,18 @@ module AwesomePrint
     end
 
     # Return true if we are to colorize the output.
-    #------------------------------------------------------------------------------
+    #---------------------------------------------------------------------------
     def colorize?
       AwesomePrint.force_colors ||= false
-      AwesomePrint.force_colors || (STDOUT.tty? && ((ENV['TERM'] && ENV['TERM'] != 'dumb') || ENV['ANSICON']))
+      AwesomePrint.force_colors || (
+        STDOUT.tty? && (
+          (
+            ENV['TERM'] &&
+            ENV['TERM'] != 'dumb'
+          ) ||
+          ENV['ANSICON']
+        )
+      )
     end
 
     private
@@ -133,24 +100,25 @@ module AwesomePrint
     #   => [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)
+      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.
-    #------------------------------------------------------------------------------
+    # 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
@@ -158,22 +126,38 @@ module AwesomePrint
       when File   then :file
       when Dir    then :dir
       when Struct then :struct
-      else object.class.to_s.gsub(/:+/, "_").downcase.to_sym
+      else object.class.to_s.gsub(/:+/, '_').downcase.to_sym
       end
     end
 
-    # Update @options by first merging the :color hash and then the remaining keys.
-    #------------------------------------------------------------------------------
+    # 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
 
+    # This method needs to be mocked during testing so that it always loads
+    # predictable values
+    #---------------------------------------------------------------------------
+    def load_dotfile
+      dotfile = File.join(ENV['HOME'], '.aprc')
+      load dotfile if dotfile_readable?(dotfile)
+    end
+
+    def dotfile_readable? dotfile
+      if @@dotfile_readable.nil? || @@dotfile != dotfile
+        @@dotfile_readable = File.readable?(@@dotfile = dotfile)
+      end
+      @@dotfile_readable
+    end
+    @@dotfile_readable = @@dotfile = nil
+
     # 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)
+      load_dotfile
       merge_options!(AwesomePrint.defaults) if AwesomePrint.defaults.is_a?(Hash)
     rescue => e
       $stderr.puts "Could not load #{dotfile}: #{e}"

data/lib/awesome_print/version.rb

@@ -1,10 +1,10 @@
-# 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
 #------------------------------------------------------------------------------
 module AwesomePrint
   def self.version
-    '1.7.0'
+    '1.8.0'
   end
 end

data/spec/active_record_helper.rb

@@ -7,7 +7,7 @@ if ExtVerifier.has_rails?
   end
 
   # Establish connection to in-memory SQLite DB
-  ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+  ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
 
   # Create the users table
   ActiveRecord::Migration.verbose = false
@@ -18,7 +18,13 @@ if ExtVerifier.has_rails?
     t.datetime :created_at
   end
 
+  ActiveRecord::Migration.create_table :emails do |t|
+    t.references :user
+    t.string :email_address
+  end
+
   # Create models
-  class User < ActiveRecord::Base; end
+  class User < ActiveRecord::Base; has_many :emails; end
   class SubUser < User; end
+  class Email < ActiveRecord::Base; belongs_to :user; end
 end

data/spec/colors_spec.rb

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