amazing_print 1.0.0

data/lib/amazing_print/formatters/dir_formatter.rb

@@ -0,0 +1,21 @@
+require_relative 'base_formatter'
+require 'shellwords'
+
+module AmazingPrint
+  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/amazing_print/formatters/file_formatter.rb

@@ -0,0 +1,21 @@
+require_relative 'base_formatter'
+require 'shellwords'
+
+module AmazingPrint
+  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/amazing_print/formatters/hash_formatter.rb

@@ -0,0 +1,106 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  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
+            [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/amazing_print/formatters/method_formatter.rb

@@ -0,0 +1,21 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  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/amazing_print/formatters/object_formatter.rb

@@ -0,0 +1,82 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  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
+            ["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!(Regexp.last_match(1), colorize(Regexp.last_match(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(%(,\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 = object.send(options[:class_name]).to_s
+        # We need to ensure that the original Kernel#format is used here instead of the one defined
+        # above.
+        # rubocop:disable Style/ColonMethodCall
+        if options[:object_id]
+          str << Kernel::format(':0x%08x', (object.__id__ * 2))
+        end
+        # rubocop:enable Style/ColonMethodCall
+        str
+      end
+
+      def left_aligned
+        current = options[:indent]
+        options[:indent] = 0
+        yield
+      ensure
+        options[:indent] = current
+      end
+    end
+  end
+end

data/lib/amazing_print/formatters/simple_formatter.rb

@@ -0,0 +1,20 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  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/amazing_print/formatters/struct_formatter.rb

@@ -0,0 +1,74 @@
+require_relative 'base_formatter'
+
+module AmazingPrint
+  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!(Regexp.last_match(1), colorize(Regexp.last_match(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(%(,\n))}\n#{outdent}>"
+        else
+          "#<#{awesome_instance} #{data.join(', ')}>"
+        end
+      end
+
+      private
+
+      def awesome_instance
+        # We need to ensure that the original Kernel#format is used here instead of the one defined
+        # above.
+        # rubocop:disable Style/ColonMethodCall
+        Kernel::format("#{struct.class.superclass}:#{struct.class}:0x%08x", (struct.__id__ * 2))
+        # rubocop:enable Style/ColonMethodCall
+      end
+
+      def left_aligned
+        current = options[:indent]
+        options[:indent] = 0
+        yield
+      ensure
+        options[:indent] = current
+      end
+    end
+  end
+end

data/lib/amazing_print/indentator.rb

@@ -0,0 +1,17 @@
+module AmazingPrint
+  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

data/lib/amazing_print/inspector.rb

@@ -0,0 +1,175 @@
+# 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_relative 'indentator'
+
+module AmazingPrint
+  class Inspector
+    attr_accessor :options, :indentator
+
+    AP = :__amazing_print__
+
+    def initialize(options = {})
+      @options = {
+        indent: 4, # Number of spaces for indenting.
+        index: true, # Display array indices.
+        html: false, # Use ANSI color codes rather than HTML.
+        multiline: true, # Display in multiple lines.
+        plain: false, # Use colors.
+        raw: false, # Do not recursively format instance variables.
+        sort_keys: false,  # Do not sort hash keys.
+        sort_vars: true,   # Sort instance variables.
+        limit: false, # Limit arrays & hashes. Accepts bool or int.
+        ruby19_syntax: false, # Use Ruby 1.9 hash syntax in output.
+        class_name: :class, # Method used to get Instance class name.
+        object_id: true, # Show object_id.
+        color: {
+          args: :pale,
+          array: :white,
+          bigdecimal: :blue,
+          class: :yellow,
+          date: :greenish,
+          falseclass: :red,
+          fixnum: :blue,
+          integer: :blue,
+          float: :blue,
+          hash: :pale,
+          keyword: :cyan,
+          method: :purpleish,
+          nilclass: :red,
+          rational: :blue,
+          string: :yellowish,
+          struct: :pale,
+          symbol: :cyanish,
+          time: :greenish,
+          trueclass: :green,
+          variable: :cyanish
+        }
+      }
+
+      # Merge custom defaults and let explicit options parameter override them.
+      merge_custom_defaults!
+      merge_options!(options)
+
+      @formatter = AmazingPrint::Formatter.new(self)
+      @indentator = AmazingPrint::Indentator.new(@options[:indent].abs)
+      Thread.current[AP] ||= []
+    end
+
+    def current_indentation
+      indentator.indentation
+    end
+
+    def increase_indentation(&blk)
+      indentator.indent(&blk)
+    end
+
+    # Dispatcher that detects data nesting and invokes object-aware formatter.
+    #---------------------------------------------------------------------------
+    def awesome(object)
+      if Thread.current[AP].include?(object.object_id)
+        nested(object)
+      else
+        begin
+          Thread.current[AP] << object.object_id
+          unnested(object)
+        ensure
+          Thread.current[AP].pop
+        end
+      end
+    end
+
+    # Return true if we are to colorize the output.
+    #---------------------------------------------------------------------------
+    def colorize?
+      AmazingPrint.force_colors ||= false
+      AmazingPrint.force_colors || (
+        if defined? @colorize_STDOUT
+          @colorize_STDOUT
+        else
+          @colorize_STDOUT = STDOUT.tty? && (
+            (
+              ENV['TERM'] &&
+              ENV['TERM'] != 'dumb'
+            ) ||
+            ENV['ANSICON']
+          )
+        end
+      )
+    end
+
+    private
+
+    # Format nested data, for example:
+    #   arr = [1, 2]; arr << arr
+    #   => [1,2, [...]]
+    #   hash = { :a => 1 }; hash[:b] = hash
+    #   => { :a => 1, :b => {...} }
+    #---------------------------------------------------------------------------
+    def nested(object)
+      case printable(object)
+      when :array  then @formatter.colorize('[...]', :array)
+      when :hash   then @formatter.colorize('{...}', :hash)
+      when :struct then @formatter.colorize('{...}', :struct)
+      else @formatter.colorize("...#{object.class}...", :class)
+      end
+    end
+
+    #---------------------------------------------------------------------------
+    def unnested(object)
+      @formatter.format(object, printable(object))
+    end
+
+    # Turn class name into symbol, ex: Hello::World => :hello_world. Classes
+    # that inherit from Array, Hash, File, Dir, and Struct are treated as the
+    # base class.
+    #---------------------------------------------------------------------------
+    def printable(object)
+      case object
+      when Array  then :array
+      when Hash   then :hash
+      when File   then :file
+      when Dir    then :dir
+      when Struct then :struct
+      else object.class.to_s.gsub(/:+/, '_').downcase.to_sym
+      end
+    end
+
+    # Update @options by first merging the :color hash and then the remaining
+    # keys.
+    #---------------------------------------------------------------------------
+    def merge_options!(options = {})
+      @options[:color].merge!(options.delete(:color) || {})
+      @options.merge!(options)
+    end
+
+    # This method needs to be mocked during testing so that it always loads
+    # predictable values
+    #---------------------------------------------------------------------------
+    def load_dotfile
+      dotfile = File.join(ENV['HOME'], '.aprc')
+      load dotfile if dotfile_readable?(dotfile)
+    end
+
+    def dotfile_readable?(dotfile)
+      if @@dotfile_readable.nil? || @@dotfile != dotfile
+        @@dotfile_readable = File.readable?(@@dotfile = dotfile)
+      end
+      @@dotfile_readable
+    end
+    @@dotfile_readable = @@dotfile = nil
+
+    # Load ~/.aprc file with custom defaults that override default options.
+    #---------------------------------------------------------------------------
+    def merge_custom_defaults!
+      load_dotfile
+      if AmazingPrint.defaults.is_a?(Hash)
+        merge_options!(AmazingPrint.defaults)
+      end
+    rescue StandardError => e
+      warn "Could not load '.aprc' from ENV['HOME']: #{e}"
+    end
+  end
+end