awesome_print 1.2.0 → 1.9.2

data/lib/awesome_print/formatters/method_formatter.rb

@@ -0,0 +1,22 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class MethodFormatter < BaseFormatter
+
+      attr_reader :method, :inspector, :options
+
+      def initialize(method, inspector)
+        @method = method
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        name, args, owner = method_tuple(method)
+
+        "#{colorize(owner, :class)}##{colorize(name, :method)}#{colorize(args, :args)}"
+      end
+    end
+  end
+end

data/lib/awesome_print/formatters/object_formatter.rb

@@ -0,0 +1,78 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ObjectFormatter < BaseFormatter
+
+      attr_reader :object, :variables, :inspector, :options
+
+      def initialize(object, inspector)
+        @object = object
+        @variables = object.instance_variables
+        @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 object.respond_to?(:"#{property}=")
+            object.respond_to?(property) ? :accessor : :writer
+          else
+            object.respond_to?(property) ? :reader : nil
+          end
+          if accessor
+            [String.new("attr_#{accessor} :#{property}"), var]
+          else
+            [var.to_s, var]
+          end
+        end
+
+        data = (options[:sort_vars] ? vars.sort : vars).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(object.instance_variable_get(var))
+          end
+        end
+
+        if options[:multiline]
+          "#<#{awesome_instance}\n#{data.join(%Q/,\n/)}\n#{outdent}>"
+        else
+          "#<#{awesome_instance} #{data.join(', ')}>"
+        end
+      end
+
+      private
+
+      def valid_instance_var?(variable_name)
+        variable_name.to_s.start_with?('@')
+      end
+
+      def awesome_instance
+        str = String.new
+        str << object.send(options[:class_name]).to_s
+        str << ":0x%08x" % (object.__id__ * 2) if options[:object_id]
+        str
+      end
+
+      def left_aligned
+        current = options[:indent]
+        options[:indent] = 0
+        yield
+      ensure
+        options[:indent] = current
+      end
+    end
+  end
+end

data/lib/awesome_print/formatters/simple_formatter.rb

@@ -0,0 +1,21 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class SimpleFormatter < BaseFormatter
+
+      attr_reader :string, :type, :inspector, :options
+
+      def initialize(string, type, inspector)
+        @string = string
+        @type = type
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        colorize(string, type)
+      end
+    end
+  end
+end

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/indentator.rb

@@ -0,0 +1,18 @@
+module AwesomePrint
+  class Indentator
+
+    attr_reader :shift_width, :indentation
+
+    def initialize(indentation)
+      @indentation = indentation
+      @shift_width = indentation.freeze
+    end
+
+    def indent
+      @indentation += shift_width
+      yield
+    ensure
+      @indentation -= shift_width
+    end
+  end
+end

data/lib/awesome_print/inspector.rb

@@ -1,87 +1,51 @@
-# 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
-
-  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
+require_relative 'indentator'
 
+module AwesomePrint
   class Inspector
-    attr_accessor :options
+    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.
+        class_name:    :class, # Method used to get Instance class name.
+        object_id:     true,   # Show object_id.
+        color: {
+          args:       :pale,
+          array:      :white,
+          bigdecimal: :blue,
+          class:      :yellow,
+          date:       :greenish,
+          falseclass: :red,
+          fixnum:     :blue,
+          integer:    :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
         }
       }
 
@@ -90,11 +54,20 @@ module AwesomePrint
       merge_options!(options)
 
       @formatter = AwesomePrint::Formatter.new(self)
+      @indentator = AwesomePrint::Indentator.new(@options[:indent].abs)
       Thread.current[AP] ||= []
     end
-  
+
+    def current_indentation
+      indentator.indentation
+    end
+
+    def increase_indentation(&block)
+      indentator.indent(&block)
+    end
+
     # Dispatcher that detects data nesting and invokes object-aware formatter.
-    #------------------------------------------------------------------------------
+    #---------------------------------------------------------------------------
     def awesome(object)
       if Thread.current[AP].include?(object.object_id)
         nested(object)
@@ -109,10 +82,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
@@ -122,24 +103,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
@@ -147,25 +129,41 @@ 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}"
+      $stderr.puts "Could not load '.aprc' from ENV['HOME']: #{e}"
     end
   end
 end