awesome_print 1.9.2 → 2.0.0.pre

data/lib/awesome_print/formatters/array_formatter.rb

@@ -3,16 +3,19 @@ require_relative 'base_formatter'
 module AwesomePrint
   module Formatters
     class ArrayFormatter < BaseFormatter
-      attr_reader :array, :inspector, :options
 
-      def initialize(array, inspector)
-        @array = array
-        @inspector = inspector
-        @options = inspector.options
+      formatter_for :array
+
+      def self.formattable?(object)
+        object.is_a?(Array)
       end
 
-      def format
-        if array.length.zero?
+      attr_reader :array
+
+      def format(object)
+        @array = object
+
+        if object.length.zero?
           '[]'
         elsif methods_array?
           methods_array
@@ -31,7 +34,7 @@ module AwesomePrint
         if options[:multiline]
           multiline_array
         else
-          "[ #{array.map { |item| inspector.awesome(item) }.join(', ')} ]"
+          '[ ' << array.map { |item| inspector.awesome(item) }.join(', ') << ' ]'
         end
       end
 

data/lib/awesome_print/formatters/base_formatter.rb

@@ -1,67 +1,33 @@
 require_relative '../colorize'
+require_relative '../limiter'
+require_relative '../registrar'
 
 module AwesomePrint
   module Formatters
     class BaseFormatter
+
       include Colorize
+      include Registrar
+      include Limiter
 
-      DEFAULT_LIMIT_SIZE = 7
+      attr_reader :object, :inspector, :options
 
-      # 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)
+      def self.formattable?(obj)
+        false
       end
 
-      def get_limit_size
-        case options[:limit]
-        when true
-          DEFAULT_LIMIT_SIZE
-        else
-          options[:limit]
-        end
+      def self.core?
+        false
       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
+      def initialize(inspector)
+        @inspector = inspector
+        @options = inspector.options
       end
 
+      def format(object)
+        raise NotImplementedError
+      end
 
       def method_tuple(method)
         if method.respond_to?(:parameters) # Ruby 1.9.2+
@@ -90,7 +56,7 @@ module AwesomePrint
         # #<Method: User(id: integer, username: string)(ActiveRecord::Base).current>
         # #<UnboundMethod: Hello#world>
         #
-        if method.to_s =~ /(Unbound)*Method: (.*?)[#\.]/
+        if method.to_s =~ /(Unbound)*Method: (.*)[#\.]/
           unbound = $1 && '(unbound)'
           klass = $2
           if klass && klass =~ /(\(\w+:\s.*?\))/  # Is this ActiveRecord-style class?
@@ -104,13 +70,14 @@ module AwesomePrint
 
       #
       # Indentation related methods
+      # FIXME: move to Indentator?...
       #-----------------------------------------
       def indentation
         inspector.current_indentation
       end
 
-      def indented(&block)
-        inspector.increase_indentation(&block)
+      def indented
+        inspector.increase_indentation(&Proc.new)
       end
 
       def indent

data/lib/awesome_print/formatters/bigdecimal_formatter.rb

@@ -0,0 +1,20 @@
+require_relative 'base_formatter'
+require 'bigdecimal'
+
+module AwesomePrint
+  module Formatters
+    class BigdecimalFormatter < BaseFormatter
+
+      formatter_for :bigdecimal
+
+      def self.formattable?(object)
+        object.is_a?(BigDecimal)
+      end
+
+      def format(object)
+        colorize(object.to_s('F'), self.class.formatted_object_type)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/class_formatter.rb

@@ -4,16 +4,15 @@ module AwesomePrint
   module Formatters
     class ClassFormatter < BaseFormatter
 
-      attr_reader :klass, :inspector, :options
+      formatter_for :class
 
-      def initialize(klass, inspector)
-        @klass = klass
-        @inspector = inspector
-        @options = inspector.options
+      def self.formattable?(object)
+        object.is_a?(Class)
       end
 
-      def format
+      def format(klass)
         superclass = klass.superclass
+
         if superclass
           colorize("#{klass.inspect} < #{superclass}", :class)
         else

data/lib/awesome_print/formatters/dir_formatter.rb

@@ -5,15 +5,13 @@ module AwesomePrint
   module Formatters
     class DirFormatter < BaseFormatter
 
-      attr_reader :dir, :inspector, :options
+      formatter_for :dir
 
-      def initialize(dir, inspector)
-        @dir = dir
-        @inspector = inspector
-        @options = inspector.options
+      def self.formattable?(object)
+        object.kind_of?(Dir)
       end
 
-      def format
+      def format(dir)
         ls = `ls -alF #{dir.path.shellescape}`
         colorize(ls.empty? ? dir.inspect : "#{dir.inspect}\n#{ls.chop}", :dir)
       end

data/lib/awesome_print/formatters/ext/active_model_error_formatter.rb

@@ -0,0 +1,44 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ActiveModelErrorFormatter < BaseFormatter
+
+      formatter_for :active_model_error
+
+      def self.formattable?(object)
+        defined?(::ActiveModel) && object.is_a?(::ActiveModel::Errors)
+      end
+
+      def format(object)
+        if @options[:raw]
+          return Formatters::ObjectFormatter.new(@inspector).format(object)
+        end
+
+        if !defined?(::ActiveSupport::OrderedHash)
+          return Formatters::SimpleFormatter.new(@inspector).format(object.inspect)
+        end
+
+        object_dump = object.marshal_dump.first
+
+        if object_dump.class.column_names != object_dump.attributes.keys
+          data = object_dump.attributes
+        else
+          data = object_dump.class.column_names.inject(::ActiveSupport::OrderedHash.new) do |hash, name|
+
+            if object_dump.has_attribute?(name) || object_dump.new_record?
+              value = object_dump.respond_to?(name) ? object_dump.send(name) : object_dump.read_attribute(name)
+              hash[name.to_sym] = value
+            end
+            hash
+          end
+        end
+
+        data.merge!({details: object.details, messages: object.messages})
+
+        "#{object} " << Formatters::HashFormatter.new(@inspector).format(data)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/active_record_attributeset_formatter.rb

@@ -0,0 +1,27 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ActiveRecordAttributesetFormatter < BaseFormatter
+
+      formatter_for :active_record_attributeset
+
+      def self.core?
+        false
+      end
+
+      def self.formattable?(object)
+        defined?(::ActiveRecord) &&
+          defined?(::ActiveRecord::AttributeSet) &&
+          object.is_a?(ActiveRecord::AttributeSet)
+      end
+
+      def format(object)
+        # simple formatter for now
+        Formatters::ObjectFormatter.new(@inspector).format(object)
+      end
+
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/active_record_class_formatter.rb

@@ -0,0 +1,43 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ActiveRecordClassFormatter < BaseFormatter
+
+      formatter_for :activerecord_base_class
+
+      def self.formattable?(object)
+        defined?(::ActiveRecord) && object.is_a?(Class) &&
+          (object.superclass == ::ActiveRecord::Base ||
+           object.ancestors.include?(::ActiveRecord::Base))
+      end
+
+      def format(object)
+        if @options[:raw] || object.to_s == "ActiveRecord::Base"
+          return Formatters::ObjectFormatter.new(@inspector).format(object)
+        end
+
+        if object.respond_to?(:abstract_class?) && object.abstract_class?
+          return Formatters::ClassFormatter.new(@inspector).format(object)
+        end
+
+        if !defined?(::ActiveSupport::OrderedHash) || !object.respond_to?(:columns)
+          return Formatters::SimpleFormatter.new(@inspector).format(object.inspect)
+        end
+
+        data = object.columns.inject(::ActiveSupport::OrderedHash.new) do |hash, c|
+          hash[c.name.to_sym] = c.type
+          hash
+        end
+
+        [
+          "class #{colorize(object.to_s, :class)}",
+          "< #{colorize(object.superclass.to_s, :class)}",
+          Formatters::HashFormatter.new(@inspector).format(data)
+        ].join(' ')
+
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/active_record_instance_formatter.rb

@@ -0,0 +1,48 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ActiveRecordInstanceFormatter < BaseFormatter
+
+      formatter_for :active_record_instance
+
+      def self.formattable?(object)
+        defined?(::ActiveRecord) && object.is_a?(::ActiveRecord::Base)
+      end
+
+      # Format ActiveRecord instance object.
+      #
+      # NOTE: by default only instance attributes (i.e. columns) are shown. To format
+      # ActiveRecord instance as regular object showing its instance variables and
+      # accessors use :raw => true option:
+      #
+      # ap record, :raw => true
+      #
+      #------------------------------------------------------------------------------
+      def format(object)
+        if @options[:raw]
+          return Formatters::ObjectFormatter.new(@inspector).format(object)
+        end
+
+        if !defined?(::ActiveSupport::OrderedHash)
+          return Formatters::SimpleFormatter.new(@inspector).format(object.inspect)
+        end
+
+        if object.class.column_names != object.attributes.keys
+          data = object.attributes
+        else
+          data = object.class.column_names.inject(::ActiveSupport::OrderedHash.new) do |hash, name|
+            if object.has_attribute?(name) || object.new_record?
+              value = object.respond_to?(name) ? object.send(name) : object.read_attribute(name)
+              hash[name.to_sym] = value
+            end
+            hash
+          end
+        end
+
+        "#{object} " << Formatters::HashFormatter.new(@inspector).format(data)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/active_record_relation_formatter.rb

@@ -0,0 +1,19 @@
+require_relative '../array_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ActiveRecordRelationFormatter < ArrayFormatter
+
+      formatter_for :active_record_relation
+
+      def self.core?
+        false
+      end
+
+      def self.formattable?(object)
+        defined?(::ActiveRecord) && object.class.ancestors.include?(::ActiveRecord::Relation)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/bson_objectid_formatter.rb

@@ -0,0 +1,20 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class BsonObjectidFormatter < BaseFormatter
+
+      formatter_for :bson_objectid
+
+      def self.formattable?(object)
+        (defined?(::BSON) && object.is_a?(::BSON::ObjectId)) ||
+          (defined?(::Moped::BSON) && object.is_a?(::Moped::BSON::ObjectId))
+      end
+
+      def format(object)
+        colorize(object.inspect, self.class.formatted_object_type)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/hash_with_indifferent_access_formatter.rb

@@ -0,0 +1,20 @@
+require_relative '../hash_formatter'
+
+module AwesomePrint
+  module Formatters
+    class HashWithIndifferentAccessFormatter < HashFormatter
+
+      formatter_for :hash_with_indifferent_access
+
+      def self.core?
+        false
+      end
+
+      def self.formattable?(object)
+        defined?(::HashWithIndifferentAccess) &&
+          object.is_a?(::HashWithIndifferentAccess)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/ext/mongoid_document_formatter.rb

@@ -0,0 +1,59 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class MongoidDocument < BaseFormatter
+
+      formatter_for :mongoid_document
+
+      def self.formattable?(object)
+        defined?(::Mongoid::Document) &&
+          (object.class.ancestors.include?(::Mongoid::Document) ||
+           (object.respond_to?(:ancestors) && object.ancestors.include?(::Mongoid::Document)))
+      end
+
+      def format(object)
+        unless defined?(::ActiveSupport::OrderedHash)
+          return Formatters::SimpleFormatter.new(@inspector).format(object.inspect)
+        end
+
+        if object.is_a?(Class)
+          puts "[MGD] formatting #{object} as class..." if AwesomePrint.debug
+          # mongoid class
+          format_as_class(object)
+        else
+          puts "[MGD] formatting #{object} as instance..." if AwesomePrint.debug
+          format_as_instance(object)
+        end
+      end
+
+      private
+
+      def format_as_class(object)
+        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.to_sym
+          hash
+        end
+
+        [
+          "class #{colorize(object.to_s, :class)}",
+          "< #{colorize(object.superclass.to_s, :class)}",
+          Formatters::HashFormatter.new(@inspector).format(data)
+        ].join(' ')
+      end
+
+      def format_as_instance(object)
+        data = (object.attributes || {}).sort_by { |key| key }.inject(::ActiveSupport::OrderedHash.new) do |hash, c|
+          hash[c[0].to_sym] = c[1]
+          hash
+        end
+
+        data = { errors: object.errors, attributes: data } if !object.errors.empty?
+
+        "#{object} #{Formatters::HashFormatter.new(@inspector).format(data)}"
+      end
+
+    end
+  end
+end
+