awesome_print 0.4.0 → 1.0.0

data/spec/methods_spec.rb

@@ -1,6 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Single method" do
+  before do
+    stub_dotfile!
+  end
+
   after do
     Object.instance_eval{ remove_const :Hello } if defined?(Hello)
   end
@@ -77,6 +81,10 @@ describe "Single method" do
 end
 
 describe "Object methods" do
+  before do
+    stub_dotfile!
+  end
+
   after do
     Object.instance_eval{ remove_const :Hello } if defined?(Hello)
   end
@@ -194,6 +202,10 @@ describe "Object methods" do
 end
 
 describe "Class methods" do
+  before do
+    stub_dotfile!
+  end
+
   after do
     Object.instance_eval{ remove_const :Hello } if defined?(Hello)
   end
@@ -301,6 +313,10 @@ end
 
 if RUBY_VERSION >= '1.9.2'
   describe "Ruby 1.9.2+ Method#parameters" do
+    before do
+      stub_dotfile!
+    end
+
     after do
       Object.instance_eval{ remove_const :Hello } if defined?(Hello)
     end
@@ -354,6 +370,7 @@ describe "Methods arrays" do
   end
 
   it "obj1.methods - obj2.methods should be awesome printed" do
+    stub_dotfile!
     class Hello
       def self.m1; end
     end
@@ -362,6 +379,7 @@ describe "Methods arrays" do
   end
 
   it "obj1.methods & obj2.methods should be awesome printed" do
+    stub_dotfile!
     class Hello
       def self.m1; end
       def self.m2; end
@@ -374,6 +392,7 @@ describe "Methods arrays" do
   end
 
   it "obj1.methods.grep(pattern) should be awesome printed" do
+    stub_dotfile!
     class Hello
       def self.m1; end
       def self.m2; end
@@ -396,6 +415,7 @@ describe "Methods arrays" do
   end
 
   it "obj1.methods.grep(pattern, &block) should be awesome printed" do
+    stub_dotfile!
     class Hello
       def self.m0; end
       def self.none; end

data/spec/objects_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Single method" do
+  before do
+    stub_dotfile!
+  end
+
+  after do
+    Object.instance_eval{ remove_const :Hello } if defined?(Hello)
+  end
+
+  describe "object" do
+    it "attributes" do
+      class Hello
+        attr_reader   :abra
+        attr_writer   :ca
+        attr_accessor :dabra
+
+        def initialize
+          @abra, @ca, @dabra = 1, 2, 3
+        end
+      end
+
+      out = Hello.new.ai(:plain => true)
+      str = <<-EOS.strip
+#<Hello:0x01234567
+    attr_accessor :dabra = 3,
+    attr_reader :abra = 1,
+    attr_writer :ca = 2
+>
+EOS
+      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+    end
+
+    it "instance variables" do
+      class Hello
+        def initialize
+          @abra, @ca, @dabra = 1, 2, 3
+        end
+      end
+
+      out = Hello.new.ai(:plain => true)
+      str = <<-EOS.strip
+#<Hello:0x01234567
+    @abra = 1,
+    @ca = 2,
+    @dabra = 3
+>
+EOS
+      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+    end
+
+    it "attributes and instance variables" do
+      class Hello
+        attr_reader   :abra
+        attr_writer   :ca
+        attr_accessor :dabra
+
+        def initialize
+          @abra, @ca, @dabra = 1, 2, 3
+          @scooby, @dooby, @doo = 3, 2, 1
+        end
+      end
+
+      out = Hello.new.ai(:plain => true)
+      str = <<-EOS.strip
+#<Hello:0x01234567
+    @doo = 1,
+    @dooby = 2,
+    @scooby = 3,
+    attr_accessor :dabra = 3,
+    attr_reader :abra = 1,
+    attr_writer :ca = 2
+>
+EOS
+      out.gsub(/0x([a-f\d]+)/, "0x01234567").should == str
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -19,7 +19,7 @@ end
 
 # The following is needed for the Infinity Test. It runs tests as subprocesses,
 # which sets STDOUT.tty? to false and would otherwise prematurely disallow colors.
-AwesomePrint.force_colors!
+### AwesomePrint.force_colors!
 
 # Ruby 1.8.6 only: define missing String methods that are needed for the specs to pass.
 if RUBY_VERSION < '1.8.7'

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.0
 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-11-08 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