awesome_print 1.7.0 → 1.8.0

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
+

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.empty?
+          '[]'
+        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
@@ -90,14 +91,15 @@ module AwesomePrint
         # #<UnboundMethod: Hello#world>
         #
         if method.to_s =~ /(Unbound)*Method: (.*)[#\.]/
-          unbound, klass = $1 && '(unbound)', $2
+          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
 
       #

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}}"
+      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
+            [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 ]
+            ["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,7 +53,7 @@ module AwesomePrint
         end
       end
 
-      private 
+      private
 
       def valid_instance_var?(variable_name)
         variable_name.to_s.start_with?('@')
@@ -70,7 +64,8 @@ module AwesomePrint
       end
 
       def left_aligned
-        current, options[:indent] = options[:indent], 0
+        current = options[:indent]
+        options[:indent] = 0
         yield
       ensure
         options[:indent] = current