awesome_print 1.7.0 → 1.9.2

data/lib/awesome_print/formatter.rb

@@ -1,17 +1,9 @@
-# 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 "formatters/object_formatter"
-require_relative "formatters/hash_formatter"
-require_relative "formatters/array_formatter"
-require_relative "formatters/simple_formatter"
-require_relative "formatters/method_formatter"
-require_relative "formatters/class_formatter"
-require_relative "formatters/dir_formatter"
-require_relative "formatters/file_formatter"
-require_relative "colorize"
+require 'awesome_print/formatters'
 
 module AwesomePrint
   class Formatter
@@ -19,7 +11,7 @@ module AwesomePrint
 
     attr_reader :inspector, :options
 
-    CORE = [ :array, :bigdecimal, :class, :dir, :file, :hash, :method, :rational, :set, :struct, :unboundmethod ]
+    CORE_FORMATTERS = [:array, :bigdecimal, :class, :dir, :file, :hash, :method, :rational, :set, :struct, :unboundmethod]
 
     def initialize(inspector)
       @inspector   = inspector
@@ -42,7 +34,7 @@ module AwesomePrint
     # directory for custom formatters that ship with awesome_print.
     #------------------------------------------------------------------------------
     def cast(object, type)
-      CORE.grep(type)[0] || :self
+      CORE_FORMATTERS.include?(type) ? type : :self
     end
 
     private
@@ -52,7 +44,7 @@ module AwesomePrint
     def awesome_self(object, type)
       if @options[:raw] && object.instance_variables.any?
         awesome_object(object)
-      elsif hash = convert_to_hash(object)
+      elsif (hash = convert_to_hash(object))
         awesome_hash(hash)
       else
         awesome_simple(object.inspect.to_s, type, @inspector)
@@ -60,7 +52,7 @@ module AwesomePrint
     end
 
     def awesome_bigdecimal(n)
-      o = n.to_s("F")
+      o = n.to_s('F')
       type = :bigdecimal
       awesome_simple(o, type, @inspector)
     end
@@ -71,7 +63,7 @@ module AwesomePrint
       awesome_simple(o, type, @inspector)
     end
 
-    def awesome_simple(o, type, inspector)
+    def awesome_simple(o, type, inspector = @inspector)
       AwesomePrint::Formatters::SimpleFormatter.new(o, type, inspector).format
     end
 
@@ -88,15 +80,15 @@ module AwesomePrint
     end
 
     def awesome_object(o)
-      Formatters::ObjectFormatter.new(o, o.instance_variables, @inspector).format
+      Formatters::ObjectFormatter.new(o, @inspector).format
     end
 
     def awesome_struct(s)
-      Formatters::ObjectFormatter.new(s, s.members, @inspector).format
+      Formatters::StructFormatter.new(s, @inspector).format
     end
 
     def awesome_method(m)
-      Formatters::MethodFormatter.new(m, @inspector).format  
+      Formatters::MethodFormatter.new(m, @inspector).format
     end
     alias :awesome_unboundmethod :awesome_method
 
@@ -114,21 +106,29 @@ module AwesomePrint
 
     # Utility methods.
     #------------------------------------------------------------------------------
+
+    # A class (ex. `Net::HTTP.Get`) might have `attr_reader :method` accessor
+    # which causes `object.method(:to_hash)` throw `ArgumentError (wrong number
+    # of arguments (given 1, expected 0))`. The following tries to avoid that.
+    def has_method_accessor?(object)
+      !object.method(:method)
+    rescue ArgumentError
+      true
+    end
+
     def convert_to_hash(object)
-      if ! object.respond_to?(:to_hash)
-        return nil
-      end
+      return nil if has_method_accessor?(object)
+      return nil if !object.respond_to?(:to_hash) || object.method(:to_hash).arity != 0
 
-      if object.method(:to_hash).arity != 0
-        return nil
-      end
+      # ActionController::Parameters will raise if they are not yet permitted
+      # and we try to convert to hash.
+      # https://api.rubyonrails.org/classes/ActionController/Parameters.html
+      return nil if object.respond_to?(:permitted?) && !object.permitted?
 
       hash = object.to_hash
-      if ! hash.respond_to?(:keys) || ! hash.respond_to?('[]')
-        return nil
-      end
+      return nil if !hash.respond_to?(:keys) || !hash.respond_to?(:[])
 
-      return hash
+      hash
     end
   end
 end

data/lib/awesome_print/formatters/array_formatter.rb

@@ -3,7 +3,6 @@ require_relative 'base_formatter'
 module AwesomePrint
   module Formatters
     class ArrayFormatter < BaseFormatter
-
       attr_reader :array, :inspector, :options
 
       def initialize(array, inspector)
@@ -13,60 +12,127 @@ module AwesomePrint
       end
 
       def format
-        return "[]" if array == []
-
-        if array.instance_variable_defined?('@__awesome_methods__')
-          methods_array(array)
-        elsif options[:multiline]
-          width = (array.size - 1).to_s.size
-
-          data = array.inject([]) do |arr, item|
-            index = indent
-            index << colorize("[#{arr.size.to_s.rjust(width)}] ", :array) if options[:index]
-            indented do
-              arr << (index << inspector.awesome(item))
-            end
-          end
-
-          data = limited(data, width) if should_be_limited?
-          "[\n" << data.join(",\n") << "\n#{outdent}]"
+        if array.length.zero?
+          '[]'
+        elsif methods_array?
+          methods_array
         else
-          "[ " << array.map{ |item| inspector.awesome(item) }.join(", ") << " ]"
+          simple_array
         end
       end
 
       private
 
-      def methods_array(a)
-        a.sort! { |x, y| x.to_s <=> y.to_s }                  # Can't simply a.sort! because of o.methods << [ :blah ]
-        object = a.instance_variable_get('@__awesome_methods__')
-        tuples = a.map do |name|
-          if name.is_a?(Symbol) || name.is_a?(String)         # Ignore garbage, ex. 42.methods << [ :blah ]
-            tuple = if object.respond_to?(name, true)         # Is this a regular method?
-              the_method = object.method(name) rescue nil     # Avoid potential ArgumentError if object#method is overridden.
-              if the_method && the_method.respond_to?(:arity) # Is this original object#method?
-                method_tuple(the_method)                      # Yes, we are good.
-              end
-            elsif object.respond_to?(:instance_method)              # Is this an unbound method?
-              method_tuple(object.instance_method(name)) rescue nil # Rescue to avoid NameError when the method is not
-            end                                                     # available (ex. File.lchmod on Ubuntu 12).
+      def methods_array?
+        array.instance_variable_defined?('@__awesome_methods__')
+      end
+
+      def simple_array
+        if options[:multiline]
+          multiline_array
+        else
+          "[ #{array.map { |item| inspector.awesome(item) }.join(', ')} ]"
+        end
+      end
+
+      def multiline_array
+        data = unless should_be_limited?
+                 generate_printable_array
+               else
+                 limited(generate_printable_array, width(array))
+               end
+
+        %Q([\n#{data.join(",\n")}\n#{outdent}])
+      end
+
+      def generate_printable_array
+        array.map.with_index do |item, index|
+          array_prefix(index, width(array)).tap do |temp|
+            indented { temp << inspector.awesome(item) }
           end
-          tuple || [ name.to_s, '(?)', '?' ]                  # Return WTF default if all the above fails.
         end
+      end
+
+      def array_prefix(iteration, width)
+        generic_prefix(iteration, width)
+      end
+
+      def methods_array
+        array.map!(&:to_s).sort!
 
-        width = (tuples.size - 1).to_s.size
-        name_width = tuples.map { |item| item[0].size }.max || 0
-        args_width = tuples.map { |item| item[1].size }.max || 0
+        data = generate_printable_tuples.join("\n")
 
-        data = tuples.inject([]) do |arr, item|
-          index = indent
-          index << "[#{arr.size.to_s.rjust(width)}]" if @options[:index]
-          indented do
-            arr << "#{index} #{colorize(item[0].rjust(name_width), :method)}#{colorize(item[1].ljust(args_width), :args)} #{colorize(item[2], :class)}"
+        "[\n#{data}\n#{outdent}]"
+      end
+
+      def generate_printable_tuples
+        tuples.map.with_index do |item, index|
+          tuple_prefix(index, width(tuples)).tap do |temp|
+            indented { temp << tuple_template(item) }
           end
         end
+      end
+
+      def tuple_template(item)
+        name_width, args_width = name_and_args_width
+
+        [
+          colorize(item[0].rjust(name_width), :method),
+          colorize(item[1].ljust(args_width), :args),
+          ' ',
+          colorize(item[2], :class)
+        ].join
+      end
+
+      def tuples
+        @tuples ||= array.map { |name| generate_tuple(name) }
+      end
+
+      def name_and_args_width
+        name_and_args = tuples.transpose
+
+        return name_and_args[0].map(&:size).max, name_and_args[1].map(&:size).max
+      end
+
+      def tuple_prefix(iteration, width)
+        generic_prefix(iteration, width, ' ')
+      end
+
+      def generate_tuple(name)
+        meth = case name
+               when Symbol, String
+                 find_method(name)
+               end
+
+        meth ? method_tuple(meth) : [name.to_s, '(?)', '?']
+      end
+
+      def find_method(name)
+        object = array.instance_variable_get('@__awesome_methods__')
+
+        meth = begin
+          object.method(name)
+        rescue NameError, ArgumentError
+          nil
+        end
+
+        meth || begin
+          object.instance_method(name)
+        rescue NameError
+          nil
+        end
+      end
+
+      def generic_prefix(iteration, width, padding='')
+        if options[:index]
+          indent + colorize("[#{iteration.to_s.rjust(width)}] ", :array)
+        else
+          indent + padding
+        end
+      end
 
-        "[\n" << data.join("\n") << "\n#{outdent}]"
+      def width(items)
+        (items.size - 1).to_s.size
       end
     end
   end

data/lib/awesome_print/formatters/base_formatter.rb

@@ -1,4 +1,4 @@
-require_relative "../colorize"
+require_relative '../colorize'
 
 module AwesomePrint
   module Formatters
@@ -28,7 +28,7 @@ module AwesomePrint
       # ]
       #------------------------------------------------------------------------------
       def should_be_limited?
-        options[:limit] or (options[:limit].is_a?(Fixnum) and options[:limit] > 0)
+        options[:limit] or (options[:limit].is_a?(Integer) and options[:limit] > 0)
       end
 
       def get_limit_size
@@ -50,13 +50,13 @@ module AwesomePrint
           tail = head - (limit - 1) % 2
 
           # Add the proper elements to the temp array and format the separator.
-          temp = data[0, head] + [ nil ] + data[-tail, tail]
+          temp = data[0, head] + [nil] + data[-tail, tail]
 
-          if is_hash
-            temp[head] = "#{indent}#{data[head].strip} .. #{data[data.length - tail - 1].strip}"
-          else
-            temp[head] = "#{indent}[#{head.to_s.rjust(width)}] .. [#{data.length - tail - 1}]"
-          end
+          temp[head] = if is_hash
+                         "#{indent}#{data[head].strip} .. #{data[data.length - tail - 1].strip}"
+                       else
+                         "#{indent}[#{head.to_s.rjust(width)}] .. [#{data.length - tail - 1}]"
+                       end
 
           temp
         end
@@ -65,7 +65,8 @@ module AwesomePrint
 
       def method_tuple(method)
         if method.respond_to?(:parameters) # Ruby 1.9.2+
-          # See http://ruby.runpaint.org/methods#method-objects-parameters
+          # See http://readruby.chengguangnan.com/methods#method-objects-parameters
+          # (mirror: http://archive.is/XguCA#selection-3381.1-3381.11)
           args = method.parameters.inject([]) do |arr, (type, name)|
             name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
             arr << case type
@@ -89,15 +90,16 @@ module AwesomePrint
         # #<Method: User(id: integer, username: string)(ActiveRecord::Base).current>
         # #<UnboundMethod: Hello#world>
         #
-        if method.to_s =~ /(Unbound)*Method: (.*)[#\.]/
-          unbound, klass = $1 && '(unbound)', $2
+        if method.to_s =~ /(Unbound)*Method: (.*?)[#\.]/
+          unbound = $1 && '(unbound)'
+          klass = $2
           if klass && klass =~ /(\(\w+:\s.*?\))/  # Is this ActiveRecord-style class?
             klass.sub!($1, '')                    # Yes, strip the fields leaving class name only.
           end
           owner = "#{klass}#{unbound}".gsub('(', ' (')
         end
 
-        [ method.name.to_s, "(#{args.join(', ')})", owner.to_s ]
+        [method.name.to_s, "(#{args.join(', ')})", owner.to_s]
       end
 
       #
@@ -107,8 +109,8 @@ module AwesomePrint
         inspector.current_indentation
       end
 
-      def indented
-        inspector.increase_indentation(&Proc.new)
+      def indented(&block)
+        inspector.increase_indentation(&block)
       end
 
       def indent

data/lib/awesome_print/formatters/class_formatter.rb

@@ -13,7 +13,8 @@ module AwesomePrint
       end
 
       def format
-        if superclass = klass.superclass # <-- Assign and test if nil.
+        superclass = klass.superclass
+        if superclass
           colorize("#{klass.inspect} < #{superclass}", :class)
         else
           colorize(klass.inspect, :class)

data/lib/awesome_print/formatters/dir_formatter.rb

@@ -1,5 +1,5 @@
 require_relative 'base_formatter'
-require "shellwords"
+require 'shellwords'
 
 module AwesomePrint
   module Formatters

data/lib/awesome_print/formatters/file_formatter.rb

@@ -1,5 +1,5 @@
 require_relative 'base_formatter'
-require "shellwords"
+require 'shellwords'
 
 module AwesomePrint
   module Formatters

data/lib/awesome_print/formatters/hash_formatter.rb

@@ -3,7 +3,6 @@ require_relative 'base_formatter'
 module AwesomePrint
   module Formatters
     class HashFormatter < BaseFormatter
-
       attr_reader :hash, :inspector, :options
 
       def initialize(hash, inspector)
@@ -13,41 +12,94 @@ module AwesomePrint
       end
 
       def format
-        return "{}" if hash == {}
-
-        keys = hash.keys
-        keys = keys.sort { |a, b| a.to_s <=> b.to_s } if options[:sort_keys]
-        data = keys.map do |key|
-          plain_single_line do
-            [ inspector.awesome(key), hash[key] ]
-          end
+        if hash.empty?
+          empty_hash
+        elsif multiline_hash?
+          multiline_hash
+        else
+          simple_hash
         end
+      end
+
+      private
 
-        width = data.map { |key, | key.size }.max || 0
-        width += indentation if options[:indent] > 0
+      def empty_hash
+        '{}'
+      end
+
+      def multiline_hash?
+        options[:multiline]
+      end
+
+      def multiline_hash
+        ["{\n", printable_hash.join(",\n"), "\n#{outdent}}"].join
+      end
 
-        data = data.map do |key, value|
+      def simple_hash
+        "{ #{printable_hash.join(', ')} }"
+      end
+
+      def printable_hash
+        data = printable_keys
+        width = left_width(data)
+
+        data.map! do |key, value|
           indented do
-            align(key, width) << colorize(" => ", :hash) << inspector.awesome(value)
+            if options[:ruby19_syntax] && symbol?(key)
+              ruby19_syntax(key, value, width)
+            else
+              pre_ruby19_syntax(key, value, width)
+            end
           end
         end
 
-        data = limited(data, width, :hash => true) if should_be_limited?
-        if options[:multiline]
-          "{\n" << data.join(",\n") << "\n#{outdent}}"
-        else
-          "{ #{data.join(', ')} }"
+        should_be_limited? ? limited(data, width, hash: true) : data
+      end
+
+      def left_width(keys)
+        result = max_key_width(keys)
+        result += indentation if options[:indent] > 0
+        result
+      end
+
+      def max_key_width(keys)
+        keys.map { |key, _value| key.size }.max || 0
+      end
+
+      def printable_keys
+        keys = hash.keys
+
+        keys.sort! { |a, b| a.to_s <=> b.to_s } if options[:sort_keys]
+
+        keys.map! do |key|
+          plain_single_line do
+            [String.new(inspector.awesome(key)), hash[key]]
+          end
         end
       end
 
-      private
+      def symbol?(key)
+        key[0] == ':'
+      end
+
+      def ruby19_syntax(key, value, width)
+        key[0] = ''
+        align(key, width - 1) << colorize(': ', :hash) << inspector.awesome(value)
+      end
+
+      def pre_ruby19_syntax(key, value, width)
+        align(key, width) << colorize(' => ', :hash) << inspector.awesome(value)
+      end
 
       def plain_single_line
-        plain, multiline = options[:plain], options[:multiline]
-        options[:plain], options[:multiline] = true, false
+        plain = options[:plain]
+        multiline = options[:multiline]
+        options[:plain] = true
+        options[:multiline] = false
         yield
       ensure
-        options[:plain], options[:multiline] = plain, multiline
+        options[:plain] = plain
+        options[:multiline] = multiline
       end
     end
   end

data/lib/awesome_print/formatters/object_formatter.rb

@@ -6,9 +6,9 @@ module AwesomePrint
 
       attr_reader :object, :variables, :inspector, :options
 
-      def initialize(object, variables, inspector)
+      def initialize(object, inspector)
         @object = object
-        @variables = variables
+        @variables = object.instance_variables
         @inspector = inspector
         @options = inspector.options
       end
@@ -22,13 +22,13 @@ module AwesomePrint
             object.respond_to?(property) ? :reader : nil
           end
           if accessor
-            [ "attr_#{accessor} :#{property}", var ]
+            [String.new("attr_#{accessor} :#{property}"), var]
           else
-            [ var.to_s, var ]
+            [var.to_s, var]
           end
         end
 
-        data = vars.sort.map do |declaration, var|
+        data = (options[:sort_vars] ? vars.sort : vars).map do |declaration, var|
           key = left_aligned do
             align(declaration, declaration.size)
           end
@@ -42,13 +42,7 @@ module AwesomePrint
           end
 
           indented do
-            var_contents = if valid_instance_var?(var)
-              object.instance_variable_get(var)
-            else
-              object.send(var) # Enables handling of Struct attributes
-            end
-
-            key << colorize(" = ", :hash) + inspector.awesome(var_contents)
+            key << colorize(' = ', :hash) + inspector.awesome(object.instance_variable_get(var))
           end
         end
 
@@ -59,18 +53,22 @@ module AwesomePrint
         end
       end
 
-      private 
+      private
 
       def valid_instance_var?(variable_name)
         variable_name.to_s.start_with?('@')
       end
 
       def awesome_instance
-        "#{object.class}:0x%08x" % (object.__id__ * 2)
+        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
+        current = options[:indent]
+        options[:indent] = 0
         yield
       ensure
         options[:indent] = current

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

@@ -0,0 +1,15 @@
+module AwesomePrint
+  module Formatters
+    require 'awesome_print/formatters/object_formatter'
+    require 'awesome_print/formatters/struct_formatter'
+    require 'awesome_print/formatters/hash_formatter'
+    require 'awesome_print/formatters/array_formatter'
+    require 'awesome_print/formatters/simple_formatter'
+    require 'awesome_print/formatters/method_formatter'
+    require 'awesome_print/formatters/class_formatter'
+    require 'awesome_print/formatters/dir_formatter'
+    require 'awesome_print/formatters/file_formatter'
+    require 'awesome_print/colorize'
+  end
+end
+