awesome_print 1.9.2 → 2.0.0.pre

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

@@ -0,0 +1,30 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class NokogiriDocumentFormatter < BaseFormatter
+
+      formatter_for :nokogiri_xml_document
+
+      def self.formattable?(object)
+        defined?(::Nokogiri) && object.is_a?(::Nokogiri::XML::Document)
+      end
+
+      def format(object)
+
+        xml = object.to_xml(indent: 2)
+        #
+        # Colorize tag, id/class name, and contents.
+        #
+        xml.gsub!(/(<)(\/?[A-Za-z1-9]+)/) { |tag| "#{$1}#{colorize($2, :keyword)}" }
+        xml.gsub!(/(id|class)="[^"]+"/i) { |id| colorize(id, :class) }
+        xml.gsub!(/>([^<]+)</) do |contents|
+          contents = colorize($1, :trueclass) if contents && !contents.empty?
+          ">#{contents}<"
+        end
+        xml
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class NokogiriNodeFormatter < BaseFormatter
+
+      formatter_for :nokogiri_xml_node
+
+      def self.formattable?(object)
+        defined?(::Nokogiri) && object.is_a?(::Nokogiri::XML::Node)
+      end
+
+      def format(object)
+        xml = object.to_xml(indent: 2)
+        #
+        # Colorize tag, id/class name, and contents.
+        #
+        xml.gsub!(/(<)(\/?[A-Za-z1-9]+)/) { |tag| "#{$1}#{colorize($2, :keyword)}" }
+        xml.gsub!(/(id|class)="[^"]+"/i) { |id| colorize(id, :class) }
+        xml.gsub!(/>([^<]+)</) do |contents|
+          contents = colorize($1, :trueclass) if contents && !contents.empty?
+          ">#{contents}<"
+        end
+        xml
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class NokogiriNodesetFormatter < BaseFormatter
+
+      formatter_for :nokogiri_xml_nodeset
+
+      def self.formattable?(object)
+        defined?(::Nokogiri) && object.is_a?(::Nokogiri::XML::NodeSet)
+      end
+
+      def format(object)
+
+        return '[]' if object.empty?
+
+        xml = object.to_xml(indent: 2)
+        #
+        # Colorize tag, id/class name, and contents.
+        #
+        xml.gsub!(/(<)(\/?[A-Za-z1-9]+)/) { |tag| "#{$1}#{colorize($2, :keyword)}" }
+        xml.gsub!(/(id|class)="[^"]+"/i) { |id| colorize(id, :class) }
+        xml.gsub!(/>([^<]+)</) do |contents|
+          contents = colorize($1, :trueclass) if contents && !contents.empty?
+          ">#{contents}<"
+        end
+        xml
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class SequelDatasetFormatter < BaseFormatter
+
+      formatter_for :sequel_dataset
+
+      def self.formattable?(object)
+        defined?(::Sequel::Mysql2::Dataset) && object.class.ancestors.include?(::Sequel::Mysql2::Dataset)
+      end
+
+      def format(object)
+        af = Formatters::ArrayFormatter.new(@inspector)
+        [af.format(dataset.to_a), colorize(dataset.sql, :string)].join("\n")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class SequelModelClassFormatter < BaseFormatter
+
+      formatter_for :sequel_model_class
+
+      def self.formattable?(object)
+        defined?(::Sequel::Model) && object.is_a?(Class) && object.ancestors.include?(::Sequel::Model)
+      end
+
+      def format(object)
+        data = object.db_schema.inject({}) { |h, (prop, defn)| h.merge(prop => defn[:db_type]) }
+
+        [
+          "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/sequel_model_formatter.rb

@@ -0,0 +1,26 @@
+require_relative '../base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class SequelModelFormatter < BaseFormatter
+
+      formatter_for :sequel_model
+
+      def self.formattable?(object)
+        defined?(::Sequel::Model) && object.is_a?(::Sequel::Model)
+      end
+
+      def format(object)
+        data = object.values.sort_by { |key| key.to_s }.inject({}) do |hash, c|
+          hash[c[0].to_sym] = c[1]
+          hash
+        end
+        data = { errors: object.errors, values: data } if !object.errors.empty?
+        hf = Formatters::HashFormatter.new(@inspector)
+
+        "#{colorize(object.to_s, :sequel)} #{hf.format(data)}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative '../base_formatter'
+require 'date'
+
+module AwesomePrint
+  module Formatters
+    class TimeWithZoneFormatter < BaseFormatter
+
+      formatter_for :time_with_zone
+
+      # FIXME: should date/time/datetime not become more formal core formatters
+      # [maybe with tz info and other more useful things]?
+
+      def self.formattable?(object)
+        (defined?(::ActiveSupport::TimeWithZone) && object.is_a?(::ActiveSupport::TimeWithZone)) ||
+          object.is_a?(::DateTime) || object.is_a?(::Time) || object.is_a?(::Date)
+      end
+
+      def format(object)
+        colorize(object.inspect, :time)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/fallback_formatter.rb

@@ -0,0 +1,55 @@
+require_relative 'base_formatter'
+
+# this handles some fallback logic to route things we don't know what they are
+
+module AwesomePrint
+  module Formatters
+    class FallbackFormatter < BaseFormatter
+
+      formatter_for :self
+
+      def self.formattable?(object)
+        true
+      end
+
+      def self.core?
+        true
+      end
+
+      def format(object)
+        if @options[:raw] && object.instance_variables.any?
+          Formatters::ObjectFormatter.new(@inspector).format(object)
+        elsif (hash = convert_to_hash(object))
+          Formatters::HashFormatter.new(@inspector).format(hash)
+        else
+          Formatters::SimpleFormatter.new(@inspector).format(object.inspect.to_s)
+        end
+      end
+
+
+      private
+
+      # Utility methods.
+      #------------------------------------------------------------------------------
+      # FIXME: this could be super fixed.
+      #
+      def convert_to_hash(object)
+        if !object.respond_to?(:to_hash)
+          return nil
+        end
+
+        if object.method(:to_hash).arity != 0
+          return nil
+        end
+
+        hash = object.to_hash
+        if !hash.respond_to?(:keys) || !hash.respond_to?('[]')
+          return nil
+        end
+
+        return hash
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/false_class_formatter.rb

@@ -0,0 +1,15 @@
+require_relative 'simple_formatter'
+
+module AwesomePrint
+  module Formatters
+    class FalseClassFormatter < SimpleFormatter
+
+      formatter_for :falseclass
+
+      def self.formattable?(object)
+        object == false
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/file_formatter.rb

@@ -5,15 +5,13 @@ module AwesomePrint
   module Formatters
     class FileFormatter < BaseFormatter
 
-      attr_reader :file, :inspector, :options
+      formatter_for :file
 
-      def initialize(file, inspector)
-        @file = file
-        @inspector = inspector
-        @options = inspector.options
+      def self.formattable?(object)
+        object.is_a?(File)
       end
 
-      def format
+      def format(file)
         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

data/lib/awesome_print/formatters/hash_formatter.rb

@@ -3,15 +3,20 @@ 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
+      attr_reader :hash
+
+      formatter_for :hash
+
+      def self.formattable?(object)
+        object.is_a?(Hash)
       end
 
-      def format
+      # INSTANCE METHODS BELOW
+
+      def format(hash)
+        @hash = hash
+
         if hash.empty?
           empty_hash
         elsif multiline_hash?
@@ -73,7 +78,7 @@ module AwesomePrint
 
         keys.map! do |key|
           plain_single_line do
-            [String.new(inspector.awesome(key)), hash[key]]
+            [inspector.awesome(key), hash[key]]
           end
         end
       end

data/lib/awesome_print/formatters/integer_formatter.rb

@@ -0,0 +1,11 @@
+require_relative 'simple_formatter'
+
+module AwesomePrint
+  module Formatters
+    class IntegerFormatter < SimpleFormatter
+
+      formatter_for :integer
+
+    end
+  end
+end

data/lib/awesome_print/formatters/method_formatter.rb

@@ -4,15 +4,17 @@ module AwesomePrint
   module Formatters
     class MethodFormatter < BaseFormatter
 
-      attr_reader :method, :inspector, :options
+      formatter_for :method
 
-      def initialize(method, inspector)
-        @method = method
-        @inspector = inspector
-        @options = inspector.options
+      def self.core?
+        true
       end
 
-      def format
+      def self.formattable?(object)
+        object.is_a?(Method)
+      end
+
+      def format(method)
         name, args, owner = method_tuple(method)
 
         "#{colorize(owner, :class)}##{colorize(name, :method)}#{colorize(args, :args)}"

data/lib/awesome_print/formatters/module_formatter.rb

@@ -0,0 +1,18 @@
+require_relative 'base_formatter'
+
+module AwesomePrint
+  module Formatters
+    class ModuleFormatter < BaseFormatter
+
+      formatter_for :module
+
+      def self.formattable?(object)
+        object.is_a?(Module)
+      end
+
+      def format(object)
+        colorize(object.inspect, :module)
+      end
+    end
+  end
+end

data/lib/awesome_print/formatters/nil_class_formatter.rb

@@ -0,0 +1,19 @@
+require_relative 'simple_formatter'
+
+module AwesomePrint
+  module Formatters
+    class NilClassFormatter < SimpleFormatter
+
+      formatter_for :nilclass
+
+      def self.formattable?(object)
+        object == nil
+      end
+
+      def format(object)
+        colorize('nil', self.class.formatted_object_type)
+      end
+
+    end
+  end
+end

data/lib/awesome_print/formatters/object_formatter.rb

@@ -4,16 +4,27 @@ module AwesomePrint
   module Formatters
     class ObjectFormatter < BaseFormatter
 
-      attr_reader :object, :variables, :inspector, :options
+      formatter_for :object
 
-      def initialize(object, inspector)
+      def self.core?
+        true
+      end
+
+      def self.formattable?(object)
+        object.is_a?(Object)
+      end
+
+      attr_reader :variables
+
+      def format(object)
         @object = object
         @variables = object.instance_variables
-        @inspector = inspector
-        @options = inspector.options
-      end
 
-      def format
+        # special case for ENV hashes, as they are objects but hash.
+        if object.to_s == 'ENV' && object.respond_to?(:to_h)
+          return Formatters::HashFormatter.new(@inspector).format(object.to_h)
+        end
+
         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}=")
@@ -22,7 +33,7 @@ module AwesomePrint
             object.respond_to?(property) ? :reader : nil
           end
           if accessor
-            [String.new("attr_#{accessor} :#{property}"), var]
+            ["attr_#{accessor} :#{property}", var]
           else
             [var.to_s, var]
           end
@@ -60,8 +71,7 @@ module AwesomePrint
       end
 
       def awesome_instance
-        str = String.new
-        str << object.send(options[:class_name]).to_s
+        str = object.send(options[:class_name]).to_s
         str << ":0x%08x" % (object.__id__ * 2) if options[:object_id]
         str
       end