awesome_print 1.2.0 → 1.9.2

data/lib/awesome_print/ext/active_support.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

data/lib/awesome_print/ext/mongo_mapper.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
@@ -18,7 +18,7 @@ module AwesomePrint
       cast = cast_without_mongo_mapper(object, type)
 
       if defined?(::MongoMapper::Document)
-        if object.is_a?(Class) && (object.ancestors & [ ::MongoMapper::Document, ::MongoMapper::EmbeddedDocument ]).size > 0
+        if object.is_a?(Class) && (object.ancestors & [::MongoMapper::Document, ::MongoMapper::EmbeddedDocument]).size > 0
           cast = :mongo_mapper_class
         elsif object.is_a?(::MongoMapper::Document) || object.is_a?(::MongoMapper::EmbeddedDocument)
           cast = :mongo_mapper_instance
@@ -38,7 +38,7 @@ module AwesomePrint
       return object.inspect if !defined?(::ActiveSupport::OrderedHash) || !object.respond_to?(:keys)
 
       data = object.keys.sort.inject(::ActiveSupport::OrderedHash.new) do |hash, c|
-        hash[c.first] = (c.last.type || "undefined").to_s.underscore.intern
+        hash[c.first] = (c.last.type || 'undefined').to_s.underscore.intern
         hash
       end
 
@@ -49,7 +49,10 @@ module AwesomePrint
         end
       end
 
-      "class #{object} < #{object.superclass} " << awesome_hash(data)
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
     end
 
     # Format MongoMapper instance object.
@@ -65,7 +68,7 @@ module AwesomePrint
       return object.inspect if !defined?(::ActiveSupport::OrderedHash)
       return awesome_object(object) if @options[:raw]
 
-      data = object.keys.keys.sort_by{|k| k}.inject(::ActiveSupport::OrderedHash.new) do |hash, name|
+      data = object.keys.keys.sort_by { |k| k }.inject(::ActiveSupport::OrderedHash.new) do |hash, name|
         hash[name] = object[name]
         hash
       end
@@ -73,11 +76,11 @@ module AwesomePrint
       # Add in associations
       if @options[:mongo_mapper][:show_associations]
         object.associations.each do |name, assoc|
-          if @options[:mongo_mapper][:inline_embedded] and assoc.embeddable?
-            data[name.to_s] = object.send(name)
-          else
-            data[name.to_s] = assoc
-          end
+          data[name.to_s] = if @options[:mongo_mapper][:inline_embedded] and assoc.embeddable?
+                              object.send(name)
+                            else
+                              assoc
+                            end
         end
       end
 
@@ -93,7 +96,7 @@ module AwesomePrint
       return object.inspect if !defined?(::ActiveSupport::OrderedHash)
       return awesome_object(object) if @options[:raw]
 
-      association = object.class.name.split('::').last.titleize.downcase.sub(/ association$/,'')
+      association = object.class.name.split('::').last.titleize.downcase.sub(/ association$/, '')
       association = "embeds #{association}" if object.embeddable?
       class_name = object.class_name
 
@@ -111,8 +114,8 @@ module AwesomePrint
     def apply_default_mongo_mapper_options
       @options[:color][:assoc] ||= :greenish
       @options[:mongo_mapper]  ||= {
-        :show_associations => false, # Display association data for MongoMapper documents and classes.
-        :inline_embedded => false    # Display embedded associations inline with MongoMapper documents.
+        show_associations: false, # Display association data for MongoMapper documents and classes.
+        inline_embedded: false    # Display embedded associations inline with MongoMapper documents.
       }
     end
   end

data/lib/awesome_print/ext/mongoid.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
@@ -20,7 +20,7 @@ module AwesomePrint
           cast = :mongoid_class
         elsif object.class.ancestors.include?(::Mongoid::Document)
           cast = :mongoid_document
-        elsif (defined?(::BSON) && object.is_a?(::BSON::ObjectId)) || (defined?(::Moped) && object.is_a?(::Moped::BSON::ObjectId))
+        elsif (defined?(::BSON) && object.is_a?(::BSON::ObjectId)) || (defined?(::Moped::BSON) && object.is_a?(::Moped::BSON::ObjectId))
           cast = :mongoid_bson_id
         end
       end
@@ -33,10 +33,14 @@ module AwesomePrint
       return object.inspect if !defined?(::ActiveSupport::OrderedHash) || !object.respond_to?(:fields)
 
       data = object.fields.sort_by { |key| key }.inject(::ActiveSupport::OrderedHash.new) do |hash, c|
-        hash[c[1].name.to_sym] = (c[1].type || "undefined").to_s.underscore.intern
+        hash[c[1].name.to_sym] = (c[1].type || 'undefined').to_s.underscore.intern
         hash
       end
-      "class #{object} < #{object.superclass} " << awesome_hash(data)
+
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
     end
 
     # Format Mongoid Document object.
@@ -48,9 +52,7 @@ module AwesomePrint
         hash[c[0].to_sym] = c[1]
         hash
       end
-      if !object.errors.empty?
-        data = {:errors => object.errors, :attributes => data}
-      end
+      data = { errors: object.errors, attributes: data } if !object.errors.empty?
       "#{object} #{awesome_hash(data)}"
     end
 

data/lib/awesome_print/ext/nobrainer.rb

@@ -0,0 +1,52 @@
+# 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
+  module NoBrainer
+
+    def self.included(base)
+      base.send :alias_method, :cast_without_nobrainer, :cast
+      base.send :alias_method, :cast, :cast_with_nobrainer
+    end
+
+    # Add NoBrainer class names to the dispatcher pipeline.
+    #------------------------------------------------------------------------------
+    def cast_with_nobrainer(object, type)
+      cast = cast_without_nobrainer(object, type)
+      if defined?(::NoBrainer::Document)
+        if object.is_a?(Class) && object < ::NoBrainer::Document
+          cast = :nobrainer_class
+        elsif object.is_a?(::NoBrainer::Document)
+          cast = :nobrainer_document
+        end
+      end
+      cast
+    end
+
+    # Format NoBrainer class object.
+    #------------------------------------------------------------------------------
+    def awesome_nobrainer_class(object)
+      name = "#{awesome_simple(object, :class)} < #{awesome_simple(object.superclass, :class)}"
+      data = Hash[object.fields.map do |field, options|
+        [field, (options[:type] || Object).to_s.underscore.to_sym]
+      end]
+
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
+    end
+
+    # Format NoBrainer Document object.
+    #------------------------------------------------------------------------------
+    def awesome_nobrainer_document(object)
+      data = object.inspectable_attributes.symbolize_keys
+      data = { errors: object.errors, attributes: data } if object.errors.present?
+      "#{object} #{awesome_hash(data)}"
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::NoBrainer)

data/lib/awesome_print/ext/nokogiri.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
@@ -15,7 +15,7 @@ module AwesomePrint
     #------------------------------------------------------------------------------
     def cast_with_nokogiri(object, type)
       cast = cast_without_nokogiri(object, type)
-      if (defined?(::Nokogiri::XML::Node) && object.is_a?(::Nokogiri::XML::Node)) || 
+      if (defined?(::Nokogiri::XML::Node) && object.is_a?(::Nokogiri::XML::Node)) ||
          (defined?(::Nokogiri::XML::NodeSet) && object.is_a?(::Nokogiri::XML::NodeSet))
         cast = :nokogiri_xml_node
       end
@@ -25,9 +25,9 @@ module AwesomePrint
     #------------------------------------------------------------------------------
     def awesome_nokogiri_xml_node(object)
       if object.is_a?(::Nokogiri::XML::NodeSet) && object.empty?
-        return "[]"
+        return '[]'
       end
-      xml = object.to_xml(:indent => 2)
+      xml = object.to_xml(indent: 2)
       #
       # Colorize tag, id/class name, and contents.
       #

data/lib/awesome_print/ext/ostruct.rb

@@ -0,0 +1,27 @@
+# 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
+  module OpenStruct
+    def self.included(base)
+      base.send :alias_method, :cast_without_ostruct, :cast
+      base.send :alias_method, :cast, :cast_with_ostruct
+    end
+
+    def cast_with_ostruct(object, type)
+      cast = cast_without_ostruct(object, type)
+      if (defined?(::OpenStruct)) && (object.is_a?(::OpenStruct))
+        cast = :open_struct_instance
+      end
+      cast
+    end
+
+    def awesome_open_struct_instance(object)
+      "#{object.class} #{awesome_hash(object.marshal_dump)}"
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::OpenStruct)

data/lib/awesome_print/ext/ripple.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
@@ -52,7 +52,7 @@ module AwesomePrint
         end
       end
 
-      "##{object} " << awesome_hash(data)
+      "#{object} " << awesome_hash(data)
     end
 
     # Format Ripple class object.
@@ -60,11 +60,10 @@ module AwesomePrint
     def awesome_ripple_document_class(object)
       return object.inspect if !defined?(::ActiveSupport::OrderedHash) || !object.respond_to?(:properties)
 
-      data = object.properties.inject(::ActiveSupport::OrderedHash.new) do |hash, (name, defn)|
-        hash[name.to_sym] = defn.type.to_s.downcase.to_sym
-        hash
-      end
-      "class #{object} < #{object.superclass} " << awesome_hash(data)
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
     end
   end
 end

data/lib/awesome_print/ext/sequel.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
@@ -32,9 +32,7 @@ module AwesomePrint
         hash[c[0].to_sym] = c[1]
         hash
       end
-      if !object.errors.empty?
-        data = {:errors => object.errors, :values => data}
-      end
+      data = { errors: object.errors, values: data } if !object.errors.empty?
       "#{object} #{awesome_hash(data)}"
     end
 
@@ -47,8 +45,11 @@ module AwesomePrint
     # Format Sequel Model class.
     #------------------------------------------------------------------------------
     def awesome_sequel_model_class(object)
-      data = object.db_schema.inject({}) {|h, (name,data)| h.merge(name => data[:db_type])}
-      "class #{object} < #{object.superclass} " << awesome_hash(data)
+      data = object.db_schema.inject({}) { |h, (prop, defn)| h.merge(prop => defn[:db_type]) }
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
     end
   end
 

data/lib/awesome_print/formatter.rb

@@ -1,21 +1,21 @@
-# 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
 #------------------------------------------------------------------------------
-autoload :CGI, "cgi"
-require "shellwords"
+require 'awesome_print/formatters'
 
 module AwesomePrint
   class Formatter
+    include Colorize
 
-    CORE = [ :array, :bigdecimal, :class, :dir, :file, :hash, :method, :rational, :set, :struct, :unboundmethod ]
-    DEFAULT_LIMIT_SIZE = 7
+    attr_reader :inspector, :options
+
+    CORE_FORMATTERS = [:array, :bigdecimal, :class, :dir, :file, :hash, :method, :rational, :set, :struct, :unboundmethod]
 
     def initialize(inspector)
       @inspector   = inspector
       @options     = inspector.options
-      @indentation = @options[:indent].abs
     end
 
     # Main entry point to format an object.
@@ -34,28 +34,9 @@ module AwesomePrint
     # directory for custom formatters that ship with awesome_print.
     #------------------------------------------------------------------------------
     def cast(object, type)
-      CORE.grep(type)[0] || :self
-    end
-
-    # Pick the color and apply it to the given string as necessary.
-    #------------------------------------------------------------------------------
-    def colorize(str, type)
-      str = CGI.escapeHTML(str) if @options[:html]
-      if @options[:plain] || !@options[:color][type] || !@inspector.colorize?
-        str
-      #
-      # Check if the string color method is defined by awesome_print and accepts
-      # html parameter or it has been overriden by some gem such as colorize.
-      #
-      elsif str.method(@options[:color][type]).arity == -1 # Accepts html parameter.
-        str.send(@options[:color][type], @options[:html])
-      else
-        str = %Q|<kbd style="color:#{@options[:color][type]}">#{str}</kbd>| if @options[:html]
-        str.send(@options[:color][type])
-      end
+      CORE_FORMATTERS.include?(type) ? type : :self
     end
 
-
     private
 
     # Catch all method to format an arbitrary object.
@@ -63,345 +44,91 @@ module AwesomePrint
     def awesome_self(object, type)
       if @options[:raw] && object.instance_variables.any?
         awesome_object(object)
-      elsif object == ENV
-        awesome_hash(object.to_hash)
-      else
-        colorize(object.inspect.to_s, type)
-      end
-    end
-
-    # Format an array.
-    #------------------------------------------------------------------------------
-    def awesome_array(a)
-      return "[]" if a == []
-
-      if a.instance_variable_defined?('@__awesome_methods__')
-        methods_array(a)
-      elsif @options[:multiline]
-        width = (a.size - 1).to_s.size 
-
-        data = a.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}]"
-      else
-        "[ " << a.map{ |item| @inspector.awesome(item) }.join(", ") << " ]"
-      end
-    end
-
-    # Format a hash. If @options[:indent] if negative left align hash keys.
-    #------------------------------------------------------------------------------
-    def awesome_hash(h)
-      return "{}" if h == {}
-
-      keys = @options[:sort_keys] ? h.keys.sort { |a, b| a.to_s <=> b.to_s } : h.keys
-      data = keys.map do |key|
-        plain_single_line do
-          [ @inspector.awesome(key), h[key] ]
-        end
-      end
-      
-      width = data.map { |key, | key.size }.max || 0
-      width += @indentation if @options[:indent] > 0
-  
-      data = data.map do |key, value|
-        indented do
-          align(key, width) << colorize(" => ", :hash) << @inspector.awesome(value)
-        end
-      end
-
-      data = limited(data, width, :hash => true) if should_be_limited?
-      if @options[:multiline]
-        "{\n" << data.join(",\n") << "\n#{outdent}}"
+      elsif (hash = convert_to_hash(object))
+        awesome_hash(hash)
       else
-        "{ #{data.join(', ')} }"
+        awesome_simple(object.inspect.to_s, type, @inspector)
       end
     end
 
-    # Format an object.
-    #------------------------------------------------------------------------------
-    def awesome_object(o)
-      vars = o.instance_variables.map do |var|
-        property = var.to_s[1..-1].to_sym # to_s because of some monkey patching done by Puppet.
-        accessor = if o.respond_to?(:"#{property}=")
-          o.respond_to?(property) ? :accessor : :writer
-        else
-          o.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(o.instance_variable_get(var))
-        end
-      end
-      if @options[:multiline]
-        "#<#{awesome_instance(o)}\n#{data.join(%Q/,\n/)}\n#{outdent}>"
-      else
-        "#<#{awesome_instance(o)} #{data.join(', ')}>"
-      end
+    def awesome_bigdecimal(n)
+      o = n.to_s('F')
+      type = :bigdecimal
+      awesome_simple(o, type, @inspector)
     end
 
-    # Format a set.
-    #------------------------------------------------------------------------------
-    def awesome_set(s)
-      awesome_array(s.to_a)
+    def awesome_rational(n)
+      o = n.to_s
+      type = :rational
+      awesome_simple(o, type, @inspector)
     end
 
-    # Format a Struct.
-    #------------------------------------------------------------------------------
-    def awesome_struct(s)
-      #
-      # The code is slightly uglier because of Ruby 1.8.6 quirks:
-      # awesome_hash(Hash[s.members.zip(s.values)]) <-- ArgumentError: odd number of arguments for Hash)
-      # awesome_hash(Hash[*s.members.zip(s.values).flatten]) <-- s.members returns strings, not symbols.
-      #
-      hash = {}
-      s.each_pair { |key, value| hash[key] = value }
-      awesome_hash(hash)
+    def awesome_simple(o, type, inspector = @inspector)
+      AwesomePrint::Formatters::SimpleFormatter.new(o, type, inspector).format
     end
 
-    # Format Class object.
-    #------------------------------------------------------------------------------
-    def awesome_class(c)
-      if superclass = c.superclass # <-- Assign and test if nil.
-        colorize("#{c.inspect} < #{superclass}", :class)
-      else
-        colorize(c.inspect, :class)
-      end
+    def awesome_array(a)
+      Formatters::ArrayFormatter.new(a, @inspector).format
     end
 
-    # Format File object.
-    #------------------------------------------------------------------------------
-    def awesome_file(f)
-      ls = File.directory?(f) ? `ls -adlF #{f.path.shellescape}` : `ls -alF #{f.path.shellescape}`
-      colorize(ls.empty? ? f.inspect : "#{f.inspect}\n#{ls.chop}", :file)
+    def awesome_set(s)
+      Formatters::ArrayFormatter.new(s.to_a, @inspector).format
     end
 
-    # Format Dir object.
-    #------------------------------------------------------------------------------
-    def awesome_dir(d)
-      ls = `ls -alF #{d.path.shellescape}`
-      colorize(ls.empty? ? d.inspect : "#{d.inspect}\n#{ls.chop}", :dir)
+    def awesome_hash(h)
+      Formatters::HashFormatter.new(h, @inspector).format
     end
 
-    # Format BigDecimal object.
-    #------------------------------------------------------------------------------
-    def awesome_bigdecimal(n)
-      colorize(n.to_s("F"), :bigdecimal)
+    def awesome_object(o)
+      Formatters::ObjectFormatter.new(o, @inspector).format
     end
 
-    # Format Rational object.
-    #------------------------------------------------------------------------------
-    def awesome_rational(n)
-      colorize(n.to_s, :rational)
+    def awesome_struct(s)
+      Formatters::StructFormatter.new(s, @inspector).format
     end
 
-    # Format a method.
-    #------------------------------------------------------------------------------
     def awesome_method(m)
-      name, args, owner = method_tuple(m)
-      "#{colorize(owner, :class)}##{colorize(name, :method)}#{colorize(args, :args)}"
+      Formatters::MethodFormatter.new(m, @inspector).format
     end
     alias :awesome_unboundmethod :awesome_method
 
-    # Format object instance.
-    #------------------------------------------------------------------------------
-    def awesome_instance(o)
-      "#{o.class}:0x%08x" % (o.__id__ * 2)
-    end
-
-    # Format object.methods array.
-    #------------------------------------------------------------------------------
-    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).
-        end
-        tuple || [ name.to_s, '(?)', '?' ]                  # Return WTF default if all the above fails.
-      end
-
-      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 = 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)}"
-        end
-      end
-
-      "[\n" << data.join("\n") << "\n#{outdent}]"
+    def awesome_class(c)
+      Formatters::ClassFormatter.new(c, @inspector).format
     end
 
-    # Return [ name, arguments, owner ] tuple for a given method.
-    #------------------------------------------------------------------------------
-    def method_tuple(method)
-      if method.respond_to?(:parameters) # Ruby 1.9.2+
-        # See http://ruby.runpaint.org/methods#method-objects-parameters
-        args = method.parameters.inject([]) do |arr, (type, name)|
-          name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
-          arr << case type
-            when :req        then name.to_s
-            when :opt, :rest then "*#{name}"
-            when :block      then "&#{name}"
-            else '?'
-          end
-        end
-      else # See http://ruby-doc.org/core/classes/Method.html#M001902
-        args = (1..method.arity.abs).map { |i| "arg#{i}" }
-        args[-1] = "*#{args[-1]}" if method.arity < 0
-      end
-
-      # method.to_s formats to handle:
-      #
-      # #<Method: Fixnum#zero?>
-      # #<Method: Fixnum(Integer)#years>
-      # #<Method: User(#<Module:0x00000103207c00>)#_username>
-      # #<Method: User(id: integer, username: string).table_name>
-      # #<Method: User(id: integer, username: string)(ActiveRecord::Base).current>
-      # #<UnboundMethod: Hello#world>
-      #
-      if method.to_s =~ /(Unbound)*Method: (.*)[#\.]/
-        unbound, klass = $1 && '(unbound)', $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 ]
+    def awesome_file(f)
+      Formatters::FileFormatter.new(f, @inspector).format
     end
 
-    # Format hash keys as plain strings regardless of underlying data type.
-    #------------------------------------------------------------------------------
-    def plain_single_line
-      plain, multiline = @options[:plain], @options[:multiline]
-      @options[:plain], @options[:multiline] = true, false
-      yield
-    ensure
-      @options[:plain], @options[:multiline] = plain, multiline
+    def awesome_dir(d)
+      Formatters::DirFormatter.new(d, @inspector).format
     end
 
     # Utility methods.
     #------------------------------------------------------------------------------
-    def align(value, width)
-      if @options[:multiline]
-        if @options[:indent] > 0
-          value.rjust(width)
-        elsif @options[:indent] == 0
-          indent + value.ljust(width)
-        else
-          indent[0, @indentation + @options[:indent]] + value.ljust(width)
-        end
-      else
-        value
-      end
-    end
 
-    def indented
-      @indentation += @options[:indent].abs
-      yield
-    ensure
-      @indentation -= @options[:indent].abs
+    # 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 left_aligned
-      current, @options[:indent] = @options[:indent], 0
-      yield
-    ensure
-      @options[:indent] = current
-    end
+    def convert_to_hash(object)
+      return nil if has_method_accessor?(object)
+      return nil if !object.respond_to?(:to_hash) || object.method(:to_hash).arity != 0
 
-    def indent
-      ' ' * @indentation
-    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?
 
-    def outdent
-      ' ' * (@indentation - @options[:indent].abs)
-    end
-
-    # To support limited output, for example:
-    #
-    # ap ('a'..'z').to_a, :limit => 3
-    # [
-    #     [ 0] "a",
-    #     [ 1] .. [24],
-    #     [25] "z"
-    # ]
-    #
-    # ap (1..100).to_a, :limit => true # Default limit is 7.
-    # [
-    #     [ 0] 1,
-    #     [ 1] 2,
-    #     [ 2] 3,
-    #     [ 3] .. [96],
-    #     [97] 98,
-    #     [98] 99,
-    #     [99] 100
-    # ]
-    #------------------------------------------------------------------------------
-    def should_be_limited?
-      @options[:limit] == true or (@options[:limit].is_a?(Fixnum) and @options[:limit] > 0)
-    end
-
-    def get_limit_size
-      @options[:limit] == true ? DEFAULT_LIMIT_SIZE : @options[:limit]
-    end
+      hash = object.to_hash
+      return nil if !hash.respond_to?(:keys) || !hash.respond_to?(:[])
 
-    def limited(data, width, is_hash = false)
-      limit = get_limit_size
-      if data.length <= limit
-        data
-      else
-        # Calculate how many elements to be displayed above and below the separator.
-        head = limit / 2
-        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]
-
-        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
-      end
+      hash
     end
   end
 end