awesome_print 0.4.0 → 1.0.2

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: awesome_print
 version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 0
-  version: 0.4.0
+  prerelease: 
+  version: 1.0.2
 platform: ruby
 authors: 
 - Michael Dvorkin
@@ -15,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-13 00:00:00 -07:00
-default_executable: 
+date: 2011-12-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -26,55 +20,59 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
-        version: 2.5.0
+        version: 2.6.0
   type: :development
   version_requirements: *id001
-description: "Great Ruby dubugging companion: pretty print Ruby objects to visualize their structure. Supports Rails ActiveRecord objects via included mixin."
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+  type: :development
+  version_requirements: *id002
+description: "Great Ruby dubugging companion: pretty print Ruby objects to visualize their structure. Supports custom object formatting via plugins"
 email: mike@dvorkin.net
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
 - CHANGELOG
+- Gemfile
+- Gemfile.lock
 - LICENSE
-- README.md
 - Rakefile
-- VERSION
-- init.rb
+- README.md
 - lib/ap.rb
-- lib/ap/awesome_print.rb
-- lib/ap/core_ext/array.rb
-- lib/ap/core_ext/class.rb
-- lib/ap/core_ext/kernel.rb
-- lib/ap/core_ext/logger.rb
-- lib/ap/core_ext/method.rb
-- lib/ap/core_ext/object.rb
-- lib/ap/core_ext/string.rb
-- lib/ap/mixin/action_view.rb
-- lib/ap/mixin/active_record.rb
-- lib/ap/mixin/active_support.rb
-- lib/ap/mixin/mongo_mapper.rb
+- lib/awesome_print/core_ext/array.rb
+- lib/awesome_print/core_ext/class.rb
+- lib/awesome_print/core_ext/kernel.rb
+- lib/awesome_print/core_ext/logger.rb
+- lib/awesome_print/core_ext/method.rb
+- lib/awesome_print/core_ext/object.rb
+- lib/awesome_print/core_ext/string.rb
+- lib/awesome_print/ext/action_view.rb
+- lib/awesome_print/ext/active_record.rb
+- lib/awesome_print/ext/active_support.rb
+- lib/awesome_print/ext/mongo_mapper.rb
+- lib/awesome_print/ext/mongoid.rb
+- lib/awesome_print/ext/nokogiri.rb
+- lib/awesome_print/formatter.rb
+- lib/awesome_print/inspector.rb
+- lib/awesome_print/version.rb
 - lib/awesome_print.rb
-- rails/init.rb
-- spec/action_view_spec.rb
-- spec/active_record_spec.rb
-- spec/awesome_print_spec.rb
-- spec/colorization_spec.rb
-- spec/logger_spec.rb
+- spec/colors_spec.rb
+- spec/formats_spec.rb
 - spec/methods_spec.rb
-- spec/mongo_mapper_spec.rb
+- spec/objects_spec.rb
 - spec/spec_helper.rb
-- spec/string_spec.rb
-has_rdoc: true
+- .gitignore
 homepage: http://github.com/michaeldv/awesome_print
 licenses: []
 
@@ -88,25 +86,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: awesome_print
-rubygems_version: 1.3.7
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: Pretty print Ruby objects with proper indentation and colors.
-test_files: []
-
+summary: Pretty print Ruby objects with proper indentation and colors
+test_files: 
+- spec/colors_spec.rb
+- spec/formats_spec.rb
+- spec/methods_spec.rb
+- spec/objects_spec.rb
+- spec/spec_helper.rb

data/VERSION

@@ -1 +0,0 @@
-0.4.0

data/init.rb

@@ -1 +0,0 @@
-require File.join(File.dirname(__FILE__), "lib", "awesome_print")

data/lib/ap/awesome_print.rb

@@ -1,352 +0,0 @@
-# Copyright (c) 2010-2011 Michael Dvorkin
-#
-# Awesome Print is freely distributable under the terms of MIT license.
-# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-require "cgi"
-require "shellwords"
-
-class AwesomePrint
-  AP = :__awesome_print__ unless defined?(AwesomePrint::AP)
-  CORE = [ :array, :hash, :class, :file, :dir, :bigdecimal, :rational, :struct, :method, :unboundmethod ] unless defined?(AwesomePrint::CORE)
-  @@force_colors = false
-
-  def initialize(options = {})
-    @options = { 
-      :multiline => true,           # Display in multiple lines.
-      :plain     => false,          # Use colors.
-      :indent    => 4,              # Indent using 4 spaces.
-      :index     => true,           # Display array indices.
-      :html      => false,          # Use ANSI color codes rather than HTML.
-      :sorted_hash_keys => false,   # Do not sort hash keys.
-      :color     => { 
-        :array      => :white,
-        :bigdecimal => :blue,
-        :class      => :yellow,
-        :date       => :greenish,
-        :falseclass => :red,
-        :fixnum     => :blue,
-        :float      => :blue,
-        :hash       => :pale,
-        :struct     => :pale,
-        :nilclass   => :red,
-        :string     => :yellowish,
-        :symbol     => :cyanish,
-        :time       => :greenish,
-        :trueclass  => :green,
-        :method     => :purpleish,
-        :args       => :pale
-      }
-    }
-
-    # Merge custom defaults and let explicit options parameter override them.
-    merge_custom_defaults!
-    merge_options!(options)
-
-    @indentation = @options[:indent].abs
-    Thread.current[AP] ||= []
-  end
-
-
-  private
-
-  # Format an array.
-  #------------------------------------------------------------------------------
-  def awesome_array(a)
-    return "[]" if a == []
-
-    if a.instance_variable_defined?('@__awesome_methods__')
-      methods_array(a)
-    elsif @options[:multiline]
-      width = (a.size - 1).to_s.size 
-      data = a.inject([]) do |arr, item|
-        index = if @options[:index]
-          colorize("#{indent}[#{arr.size.to_s.rjust(width)}] ", :array)
-        else
-          colorize(indent, :array)
-        end
-        indented do
-          arr << (index << awesome(item))
-        end
-      end
-      "[\n" << data.join(",\n") << "\n#{outdent}]"
-    else
-      "[ " << a.map{ |item| awesome(item) }.join(", ") << " ]"
-    end
-  end
-
-  # Format a hash. If @options[:indent] if negative left align hash keys.
-  #------------------------------------------------------------------------------
-  def awesome_hash(h)
-    return "{}" if h == {}
-
-    keys = @options[:sorted_hash_keys] ? h.keys.sort { |a, b| a.to_s <=> b.to_s } : h.keys
-    data = keys.map do |key|
-      plain_single_line do
-        [ awesome(key), h[key] ]
-      end
-    end
-      
-    width = data.map { |key, | key.size }.max || 0
-    width += @indentation if @options[:indent] > 0
-  
-    data = data.map do |key, value|
-      if @options[:multiline]
-        formatted_key = (@options[:indent] >= 0 ? key.rjust(width) : indent + key.ljust(width))
-      else
-        formatted_key = key
-      end
-      indented do
-        formatted_key << colorize(" => ", :hash) << awesome(value)
-      end
-    end
-    if @options[:multiline]
-      "{\n" << data.join(",\n") << "\n#{outdent}}"
-    else
-      "{ #{data.join(', ')} }"
-    end
-  end
-
-  # Format a Struct. If @options[:indent] is negative left align hash keys.
-  #------------------------------------------------------------------------------
-  def awesome_struct(s)
-    h = {}
-    s.each_pair { |k,v| h[k] = v }
-    awesome_hash(h)
-  end
-
-  # Format Class object.
-  #------------------------------------------------------------------------------
-  def awesome_class(c)
-    if superclass = c.superclass # <-- Assign and test if nil.
-      awesome_self(c, :with => " < #{superclass}")
-    else
-      awesome_self(c)
-    end
-  end
-
-  # Format File object.
-  #------------------------------------------------------------------------------
-  def awesome_file(f)
-    ls = File.directory?(f) ? `ls -adlF #{f.path.shellescape}` : `ls -alF #{f.path.shellescape}`
-    awesome_self(f, :with => ls.empty? ? nil : "\n#{ls.chop}")
-  end
-
-  # Format Dir object.
-  #------------------------------------------------------------------------------
-  def awesome_dir(d)
-    ls = `ls -alF #{d.path.shellescape}`
-    awesome_self(d, :with => ls.empty? ? nil : "\n#{ls.chop}")
-  end
-
-  # Format BigDecimal and Rational objects by convering them to Float.
-  #------------------------------------------------------------------------------
-  def awesome_bigdecimal(n)
-    awesome_self(n.to_f, :as => :bigdecimal)
-  end
-  alias :awesome_rational :awesome_bigdecimal
-
-  # Format a method.
-  #------------------------------------------------------------------------------
-  def awesome_method(m)
-    name, args, owner = method_tuple(m)
-    "#{colorize(owner, :class)}##{colorize(name, :method)}#{colorize(args, :args)}"
-  end
-  alias :awesome_unboundmethod :awesome_method
-
-  # Catch all method to format an arbitrary object.
-  #------------------------------------------------------------------------------
-  def awesome_self(object, appear = {})
-    colorize(object.inspect.to_s << appear[:with].to_s, appear[:as] || declassify(object))
-  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
-        send(:"awesome_#{printable(object)}", object)
-      ensure
-        Thread.current[AP].pop
-      end
-    end
-  end
-
-  # Format object.methods array.
-  #------------------------------------------------------------------------------
-  def methods_array(a)
-    object = a.instance_variable_get('@__awesome_methods__')
-    tuples = a.map do |name|
-      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))
-      end
-      tuple || [ name.to_s, '(?)', '' ]                 # Return WTF default if all the above fails.
-    end
-
-    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 = tuples.inject([]) do |arr, item|
-      index = if @options[:index]
-        "#{indent}[#{arr.size.to_s.rjust(width)}]"
-      else
-        indent
-      end
-      indented do
-        arr << "#{index} #{colorize(item[0].rjust(name_width), :method)}#{colorize(item[1].ljust(args_width), :args)} #{colorize(item[2], :class)}"
-      end
-    end
-
-    "[\n" << data.join("\n") << "\n#{outdent}]"
-  end
-
-  # Format nested data, for example:
-  #   arr = [1, 2]; arr << arr
-  #   => [1,2, [...]]
-  #   hsh = { :a => 1 }; hsh[:b] = hsh
-  #   => { :a => 1, :b => {...} }
-  #------------------------------------------------------------------------------
-  def nested(object)
-    case printable(object)
-      when :array  then colorize("[...]", :array)
-      when :hash   then colorize("{...}", :hash)
-      when :struct then colorize("{...}", :struct)
-      else colorize("...#{object.class}...", :class)
-    end
-  end
-
-  # Return one of the "core" types that have a formatter of :self otherwise.
-  #------------------------------------------------------------------------------
-  def printable(object)
-    CORE.grep(declassify(object))[0] || :self
-  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 declassify(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
-
-  # Pick the color and apply it to the given string as necessary.
-  #------------------------------------------------------------------------------
-  def colorize(s, type)
-    s = CGI.escapeHTML(s) if @options[:html]
-    if @options[:plain] || !@options[:color][type] || !colorize?
-      @options[:html] ? "<pre>#{s}</pre>" : s
-    else
-      s.send(@options[:color][type], @options[:html])
-    end
-  end
-
-  # Return [ name, arguments, owner ] tuple for a given method.
-  #------------------------------------------------------------------------------
-  def method_tuple(method)
-    if method.respond_to?(:parameters) # Ruby 1.9.2+
-      # See http://ruby.runpaint.org/methods#method-objects-parameters
-      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
-
-    if method.to_s =~ /(Unbound)*Method: (.*?)[#\.]/
-      owner = "#{$2}#{$1 ? '(unbound)' : ''}".gsub('(', ' (')
-    end
-
-    [ method.name.to_s, "(#{args.join(', ')})", owner.to_s ]
-  end
-
-  # Format hash keys as plain string regardless of underlying data type.
-  #------------------------------------------------------------------------------
-  def plain_single_line
-    plain, multiline = @options[:plain], @options[:multiline]
-    @options[:plain], @options[:multiline] = true, false
-    yield
-  ensure
-    @options[:plain], @options[:multiline] = plain, multiline
-  end
-
-  #------------------------------------------------------------------------------
-  def indented
-    @indentation += @options[:indent].abs
-    yield
-  ensure
-    @indentation -= @options[:indent].abs
-  end
-
-  def indent
-    @indent = ' ' * @indentation
-  end
-
-  def outdent
-    @outdent = ' ' * (@indentation - @options[:indent].abs)
-  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
-
-  # Load ~/.aprc file with custom defaults that override default options.
-  #------------------------------------------------------------------------------
-  def merge_custom_defaults!
-    dotfile = File.join(ENV["HOME"], ".aprc")
-    if File.readable?(dotfile)
-      load dotfile
-      merge_options!(self.class.defaults)
-    end
-  rescue => e
-    $stderr.puts "Could not load #{dotfile}: #{e}"
-  end
-
-  # Return true if we are to colorize the output.
-  #------------------------------------------------------------------------------
-  def colorize?
-    @@force_colors || (STDOUT.tty? && ((ENV['TERM'] && ENV['TERM'] != 'dumb') || ENV['ANSICON']))
-  end
-
-  # Class accessor to force colorized output (ex. forked subprocess where TERM
-  # might be dumb).
-  #------------------------------------------------------------------------------
-  def self.force_colors!(value = true)
-    @@force_colors = value
-  end
-
-  # Class accessors for custom defaults.
-  #------------------------------------------------------------------------------
-  def self.defaults
-    @@defaults ||= {}
-  end
-
-  def self.defaults=(args = {})
-    @@defaults = args
-  end
-
-end

data/lib/ap/core_ext/logger.rb

@@ -1,18 +0,0 @@
-# Copyright (c) 2010-2011 Michael Dvorkin
-#
-# Awesome Print is freely distributable under the terms of MIT license.
-# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-module AwesomePrintLogger
-
-  # Add ap method to logger
-  #------------------------------------------------------------------------------
-  def ap(object, level = nil)
-    level ||= AwesomePrint.defaults[:log_level] || :debug
-    send level, object.ai
-  end
-
-end
-
-Logger.send(:include, AwesomePrintLogger)
-ActiveSupport::BufferedLogger.send(:include, AwesomePrintLogger) if defined?(::ActiveSupport::BufferedLogger)

data/lib/ap/mixin/action_view.rb

@@ -1,17 +0,0 @@
-# Copyright (c) 2010-2011 Michael Dvorkin
-#
-# Awesome Print is freely distributable under the terms of MIT license.
-# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-module AwesomePrintActionView
-
-  # Use HTML colors and add default "debug_dump" class to the resulting HTML.
-  def ap_debug(object, options = {})
-    object.ai(options.merge(:html => true)).sub(/^<pre([\s>])/, '<pre class="debug_dump"\\1')
-  end
-
-  alias_method :ap, :ap_debug
-
-end
-
-ActionView::Base.send(:include, AwesomePrintActionView) if defined?(ActionView)

data/lib/ap/mixin/active_record.rb

@@ -1,54 +0,0 @@
-# Copyright (c) 2010-2011 Michael Dvorkin
-#
-# Awesome Print is freely distributable under the terms of MIT license.
-# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-module AwesomePrintActiveRecord
-
-  def self.included(base)
-    base.send :alias_method, :printable_without_active_record, :printable
-    base.send :alias_method, :printable, :printable_with_active_record
-  end
-
-  # Add ActiveRecord class names to the dispatcher pipeline.
-  #------------------------------------------------------------------------------
-  def printable_with_active_record(object)
-    printable = printable_without_active_record(object)
-    return printable if !defined?(ActiveRecord::Base)
-
-    if printable == :self
-      if object.is_a?(ActiveRecord::Base)
-        printable = :active_record_instance
-      end
-    elsif printable == :class and object.ancestors.include?(ActiveRecord::Base)
-      printable = :active_record_class
-    end
-    printable
-  end
-
-  # Format ActiveRecord instance object.
-  #------------------------------------------------------------------------------
-  def awesome_active_record_instance(object)
-    return object.inspect if !defined?(ActiveSupport::OrderedHash)
-
-    data = object.class.column_names.inject(ActiveSupport::OrderedHash.new) do |hash, name|
-      hash[name.to_sym] = object.send(name) if object.has_attribute?(name) || object.new_record?
-      hash
-    end
-    "#{object} " + awesome_hash(data)
-  end
-
-  # Format ActiveRecord class object.
-  #------------------------------------------------------------------------------
-  def awesome_active_record_class(object)
-    return object.inspect if !defined?(ActiveSupport::OrderedHash) || !object.respond_to?(:columns)
-
-    data = object.columns.inject(ActiveSupport::OrderedHash.new) do |hash, c|
-      hash[c.name.to_sym] = c.type
-      hash
-    end
-    "class #{object} < #{object.superclass} " << awesome_hash(data)
-  end
-end
-
-AwesomePrint.send(:include, AwesomePrintActiveRecord)

data/lib/ap/mixin/active_support.rb

@@ -1,46 +0,0 @@
-# Copyright (c) 2010-2011 Michael Dvorkin
-#
-# Awesome Print is freely distributable under the terms of MIT license.
-# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-module AwesomePrintActiveSupport
-
-  def self.included(base)
-    base.send :alias_method, :printable_without_active_support, :printable
-    base.send :alias_method, :printable, :printable_with_active_support
-  end
-
-  # Add ActiveSupport class names to the dispatcher pipeline.
-  #------------------------------------------------------------------------------
-  def printable_with_active_support(object)
-    printable = printable_without_active_support(object)
-    return printable if !defined?(ActiveSupport::TimeWithZone) || !defined?(HashWithIndifferentAccess)
-
-    if printable == :self
-      if object.is_a?(ActiveSupport::TimeWithZone)
-        printable = :active_support_time
-      elsif object.is_a?(HashWithIndifferentAccess)
-        printable = :hash_with_indifferent_access
-      end
-    end
-    printable
-  end
-
-  # Format ActiveSupport::TimeWithZone as standard Time.
-  #------------------------------------------------------------------------------
-  def awesome_active_support_time(object)
-    awesome_self(object, :as => :time)
-  end
-
-  # Format HashWithIndifferentAccess as standard Hash.
-  #
-  # NOTE: can't use awesome_self(object, :as => :hash) since awesome_self uses
-  # object.inspect internally, i.e. it would convert hash to string.
-  #------------------------------------------------------------------------------
-  def awesome_hash_with_indifferent_access(object)
-    awesome_hash(object)
-  end
-
-end
-
-AwesomePrint.send(:include, AwesomePrintActiveSupport)