awesome_print 1.6.1 → 1.9.2

data/lib/awesome_print/formatters/base_formatter.rb

@@ -0,0 +1,140 @@
+require_relative '../colorize'
+
+module AwesomePrint
+  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] or (options[:limit].is_a?(Integer) and 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>
+        # #<UnboundMethod: Hello#world>
+        #
+        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]
+      end
+
+      #
+      # Indentation related methods
+      #-----------------------------------------
+      def indentation
+        inspector.current_indentation
+      end
+
+      def indented(&block)
+        inspector.increase_indentation(&block)
+      end
+
+      def indent
+        ' ' * indentation
+      end
+
+      def outdent
+        ' ' * (indentation - options[:indent].abs)
+      end
+
+      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
+
+    end
+  end
+end

data/lib/awesome_print/formatters/class_formatter.rb

@@ -0,0 +1,25 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  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

data/lib/awesome_print/formatters/dir_formatter.rb

@@ -0,0 +1,22 @@
+require_relative 'base_formatter'
+require 'shellwords'
+
+module AwesomePrint
+  module Formatters
+    class DirFormatter < BaseFormatter
+
+      attr_reader :dir, :inspector, :options
+
+      def initialize(dir, inspector)
+        @dir = dir
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        ls = `ls -alF #{dir.path.shellescape}`
+        colorize(ls.empty? ? dir.inspect : "#{dir.inspect}\n#{ls.chop}", :dir)
+      end
+    end
+  end
+end

data/lib/awesome_print/formatters/file_formatter.rb

@@ -0,0 +1,22 @@
+require_relative 'base_formatter'
+require 'shellwords'
+
+module AwesomePrint
+  module Formatters
+    class FileFormatter < BaseFormatter
+
+      attr_reader :file, :inspector, :options
+
+      def initialize(file, inspector)
+        @file = file
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        ls = File.directory?(file) ? `ls -adlF #{file.path.shellescape}` : `ls -alF #{file.path.shellescape}`
+        colorize(ls.empty? ? file.inspect : "#{file.inspect}\n#{ls.chop}", :file)
+      end
+    end
+  end
+end

data/lib/awesome_print/formatters/hash_formatter.rb

@@ -0,0 +1,106 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class HashFormatter < BaseFormatter
+      attr_reader :hash, :inspector, :options
+
+      def initialize(hash, inspector)
+        @hash = hash
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        if hash.empty?
+          empty_hash
+        elsif multiline_hash?
+          multiline_hash
+        else
+          simple_hash
+        end
+      end
+
+      private
+
+      def empty_hash
+        '{}'
+      end
+
+      def multiline_hash?
+        options[:multiline]
+      end
+
+      def multiline_hash
+        ["{\n", printable_hash.join(",\n"), "\n#{outdent}}"].join
+      end
+
+      def simple_hash
+        "{ #{printable_hash.join(', ')} }"
+      end
+
+      def printable_hash
+        data = printable_keys
+        width = left_width(data)
+
+        data.map! do |key, value|
+          indented do
+            if options[:ruby19_syntax] && symbol?(key)
+              ruby19_syntax(key, value, width)
+            else
+              pre_ruby19_syntax(key, value, width)
+            end
+          end
+        end
+
+        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
+
+      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 = options[:plain]
+        multiline = options[:multiline]
+        options[:plain] = true
+        options[:multiline] = false
+        yield
+      ensure
+        options[:plain] = plain
+        options[:multiline] = multiline
+      end
+    end
+  end
+end

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/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/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