amazing_print 1.0.0

data/lib/amazing_print/formatter.rb

@@ -0,0 +1,120 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require 'amazing_print/formatters'
+
+module AmazingPrint
+  class Formatter
+    include Colorize
+
+    attr_reader :inspector, :options
+
+    CORE_FORMATTERS = %i[array bigdecimal class dir file hash method rational set struct unboundmethod].freeze
+
+    def initialize(inspector)
+      @inspector   = inspector
+      @options     = inspector.options
+    end
+
+    # Main entry point to format an object.
+    #------------------------------------------------------------------------------
+    def format(object, type = nil)
+      core_class = cast(object, type)
+      awesome = if core_class != :self
+                  send(:"awesome_#{core_class}", object) # Core formatters.
+                else
+                  awesome_self(object, type) # Catch all that falls back to object.inspect.
+      end
+      awesome
+    end
+
+    # Hook this when adding custom formatters. Check out lib/amazing_print/ext
+    # directory for custom formatters that ship with amazing_print.
+    #------------------------------------------------------------------------------
+    def cast(_object, type)
+      CORE_FORMATTERS.include?(type) ? type : :self
+    end
+
+    private
+
+    # Catch all method to format an arbitrary object.
+    #------------------------------------------------------------------------------
+    def awesome_self(object, type)
+      if @options[:raw] && object.instance_variables.any?
+        awesome_object(object)
+      elsif (hash = convert_to_hash(object))
+        awesome_hash(hash)
+      else
+        awesome_simple(object.inspect.to_s, type, @inspector)
+      end
+    end
+
+    def awesome_bigdecimal(n)
+      o = n.to_s('F')
+      type = :bigdecimal
+      awesome_simple(o, type, @inspector)
+    end
+
+    def awesome_rational(n)
+      o = n.to_s
+      type = :rational
+      awesome_simple(o, type, @inspector)
+    end
+
+    def awesome_simple(o, type, inspector = @inspector)
+      AmazingPrint::Formatters::SimpleFormatter.new(o, type, inspector).format
+    end
+
+    def awesome_array(a)
+      Formatters::ArrayFormatter.new(a, @inspector).format
+    end
+
+    def awesome_set(s)
+      Formatters::ArrayFormatter.new(s.to_a, @inspector).format
+    end
+
+    def awesome_hash(h)
+      Formatters::HashFormatter.new(h, @inspector).format
+    end
+
+    def awesome_object(o)
+      Formatters::ObjectFormatter.new(o, @inspector).format
+    end
+
+    def awesome_struct(s)
+      Formatters::StructFormatter.new(s, @inspector).format
+    end
+
+    def awesome_method(m)
+      Formatters::MethodFormatter.new(m, @inspector).format
+    end
+    alias awesome_unboundmethod awesome_method
+
+    def awesome_class(c)
+      Formatters::ClassFormatter.new(c, @inspector).format
+    end
+
+    def awesome_file(f)
+      Formatters::FileFormatter.new(f, @inspector).format
+    end
+
+    def awesome_dir(d)
+      Formatters::DirFormatter.new(d, @inspector).format
+    end
+
+    # Utility methods.
+    #------------------------------------------------------------------------------
+    def convert_to_hash(object)
+      return nil unless object.respond_to?(:to_hash)
+
+      return nil if object.method(:to_hash).arity != 0
+
+      hash = object.to_hash
+      return nil if !hash.respond_to?(:keys) || !hash.respond_to?(:[])
+
+      hash
+    end
+  end
+end

data/lib/amazing_print/formatters.rb

@@ -0,0 +1,14 @@
+module AmazingPrint
+  module Formatters
+    require 'amazing_print/formatters/object_formatter'
+    require 'amazing_print/formatters/struct_formatter'
+    require 'amazing_print/formatters/hash_formatter'
+    require 'amazing_print/formatters/array_formatter'
+    require 'amazing_print/formatters/simple_formatter'
+    require 'amazing_print/formatters/method_formatter'
+    require 'amazing_print/formatters/class_formatter'
+    require 'amazing_print/formatters/dir_formatter'
+    require 'amazing_print/formatters/file_formatter'
+    require 'amazing_print/colorize'
+  end
+end

data/lib/amazing_print/formatters/array_formatter.rb

@@ -0,0 +1,139 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  module Formatters
+    class ArrayFormatter < BaseFormatter
+      attr_reader :array, :inspector, :options
+
+      def initialize(array, inspector)
+        @array = array
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        if array.length.zero?
+          '[]'
+        elsif methods_array?
+          methods_array
+        else
+          simple_array
+        end
+      end
+
+      private
+
+      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 = if should_be_limited?
+                 limited(generate_printable_array, width(array))
+               else
+                 generate_printable_array
+               end
+
+        %([\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
+        end
+      end
+
+      def array_prefix(iteration, width)
+        generic_prefix(iteration, width)
+      end
+
+      def methods_array
+        array.map!(&:to_s).sort!
+
+        data = generate_printable_tuples.join("\n")
+
+        "[\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
+
+        [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
+
+      def width(items)
+        (items.size - 1).to_s.size
+      end
+    end
+  end
+end

data/lib/amazing_print/formatters/base_formatter.rb

@@ -0,0 +1,148 @@
+require_relative '../colorize'
+
+module AmazingPrint
+  module Formatters
+    class BaseFormatter
+      include Colorize
+
+      DEFAULT_LIMIT_SIZE = 7
+
+      # 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] || (options[:limit].is_a?(Integer) && (options[:limit] > 0))
+      end
+
+      def get_limit_size
+        case options[:limit]
+        when true
+          DEFAULT_LIMIT_SIZE
+        else
+          options[:limit]
+        end
+      end
+
+      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]
+
+          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
+      end
+
+      def method_tuple(method)
+        if method.respond_to?(:parameters) # Ruby 1.9.2+
+          # 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
+                   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>
+        # #<Method: #<Class:0x100c567f>(ActiveRecord::Querying)#first>
+        # #<UnboundMethod: Hello#world>
+        # #<UnboundMethod: Hello#world() /home/hs/code/amazing_print/spec/methods_spec.rb:68>
+        #
+        if method.to_s =~ /(Unbound)*Method: ((#<)?[^\/#]*)[#\.]/
+          unbound = Regexp.last_match(1) && '(unbound)'
+          klass = Regexp.last_match(2)
+          if klass && klass =~ /(\(\w+:\s.*?\))/ # Is this ActiveRecord-style class?
+            klass.sub!(Regexp.last_match(1), '') # Yes, strip the fields leaving class name only.
+          end
+
+          owner = "#{klass}#{unbound}".gsub('(', ' (')
+        end
+
+        [method.name.to_s, "(#{args.join(', ')})", owner.to_s]
+      end
+
+      #
+      # Indentation related methods
+      #-----------------------------------------
+      def indentation
+        inspector.current_indentation
+      end
+
+      def indented(&blk)
+        inspector.increase_indentation(&blk)
+      end
+
+      # precompute common indentations
+      INDENT_CACHE = (0..100).map { |i| ' ' * i }.map(&:freeze).freeze
+
+      def indent(n = indentation)
+        INDENT_CACHE[n] || ' ' * n
+      end
+
+      def outdent
+        ' ' * (indentation - options[:indent].abs)
+        i = indentation - options[:indent].abs
+
+        INDENT_CACHE[i] || ' ' * i
+      end
+
+      def align(value, width)
+        if options[:multiline]
+          indent_option = options[:indent]
+          if indent_option > 0
+            value.rjust(width)
+          elsif indent_option == 0
+            "#{indent}#{value.ljust(width)}"
+          else
+            "#{indent(indentation + indent_option)}#{value.ljust(width)}"
+          end
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/amazing_print/formatters/class_formatter.rb

@@ -0,0 +1,24 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  module Formatters
+    class ClassFormatter < BaseFormatter
+      attr_reader :klass, :inspector, :options
+
+      def initialize(klass, inspector)
+        @klass = klass
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        superclass = klass.superclass
+        if superclass
+          colorize("#{klass.inspect} < #{superclass}", :class)
+        else
+          colorize(klass.inspect, :class)
+        end
+      end
+    end
+  end
+end