awesome_print 0.2.1 → 0.4.0

data/CHANGELOG

@@ -1,3 +1,31 @@
+0.4.0
+  - 'ap object' now returns the object (Stephan Hagemann)
+  - Added :html => true option to enable HTML colors rather that ANSI (ex. Sinatra templates)
+  - Added AwesomePrint.force_colors! to allow color output on demand (Andrew O'Brien)
+  - Added MongoMapper formatter mixin (Elpizo Choi)
+  - Fixed formatting of methods array when object#method is overridden
+  - Fixed potential stack errors by checking whether AwesomePrint is already loaded
+  - Improved Ruby 1.8.6 and 1.8.7 compatibility
+  - Improved Windows compatibility (Viktar Basharymau)
+
+0.3.2
+  - Make sure Rails mixins get loaded in Rails console when required from .irbrc
+  - Fixed an issue with classes that define their own #send method (ex: Socket)
+  - Fixed compatibility issue with Liquid gem that defines Module#liquid_methods
+  - Fixed hash spec for Ruby < 1.9 where order of hash keys is not guaranteed
+  - Added :sorted_hash_keys option to sort hash keys (Ed Ruder)
+
+0.3.1 RubyConf X edition
+  - Fixed Ruby 1.8.6 compatibility issues (thanks, Tim!)
+  - Fixed stack overflow issue with Rails 2.3.x console
+
+0.3.0
+  - Display object.methods and family in human readable format
+  - Objects inherited from Array, Hash, File, Dir, and Struct are shown as their base class
+  - Added option to suppress array index in output (Sean Gallagher)
+  - Updated README on how to set up ~/.irbrc for MacRuby (Eloy Duran)
+  - Specs pass 100% with Ruby 1.8.7/RSpec 1.3 and Ruby 1.9.2/RSpec 2.0
+
 0.2.1
   - ap can now be used within Rails templates (ex. <%= ap object %>)
   - Added support for printing Struct

data/LICENSE

@@ -1,4 +1,5 @@
-Copyright (c) 2010 Michael Dvorkin
+Copyright (c) 2010-2011 Michael Dvorkin
+twitter.com/mid
 %w(mike dvorkin.net) * "@" || %w(mike fatfreecrm.com) * "@"
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -8,21 +8,24 @@ objects and usage within Rails templates are supported via included mixins.
     $ gem install awesome_print
 
     # Installing as Rails plugin
-    $ ruby script/plugin install http://github.com/michaeldv/awesome_print_.git
+    $ ruby script/plugin install http://github.com/michaeldv/awesome_print.git
 
     # Cloning the repository
-    $ git clone git://github.com/michaeldv/awesome_print_.git
+    $ git clone git://github.com/michaeldv/awesome_print.git
 
 ### Usage ###
 
-    require "ap"
+    require "awesome_print"
     ap object, options = {}
 
 Default options:
 
-    :multiline => true,
-    :plain  => false,
-    :indent => 4,
+    :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,
       :bignum     => :blue,
@@ -46,7 +49,7 @@ Supported color names:
 
 ### Examples ###
     $ cat > 1.rb
-    require "ap"
+    require "awesome_print"
     data = [ false, 42, %w(forty two), { :now => Time.now, :class => Time.now.class, :distance => 42e42 } ]
     ap data
     ^D
@@ -66,7 +69,7 @@ Supported color names:
     ]
 
     $ cat > 2.rb
-    require "ap"
+    require "awesome_print"
     data = { :now => Time.now, :class => Time.now.class, :distance => 42e42 }
     ap data, :indent => -2  # <-- Left align hash keys.
     ^D
@@ -78,7 +81,7 @@ Supported color names:
     }
 
     $ cat > 3.rb
-    require "ap"
+    require "awesome_print"
     data = [ false, 42, %w(forty two) ]
     data << data  # <-- Nested array.
     ap data, :multiline => false
@@ -86,10 +89,58 @@ Supported color names:
     $ ruby 3.rb
     [ false, 42, [ "forty", "two" ], [...] ]
 
+    $ cat > 4.rb
+    require "awesome_print"
+    class Hello
+      def self.world(x, y, z = nil, &blk)
+      end
+    end
+    ap Hello.methods - Class.methods
+    ^D
+    $ ruby 4.rb
+    [
+        [0] world(x, y, *z, &blk) Hello
+    ]
+
+    $ cat > 5.rb
+    require "awesome_print"
+    ap (''.methods - Object.methods).grep(/!/)
+    ^D
+    $ ruby 5.rb
+    [
+        [ 0] capitalize!()           String
+        [ 1]      chomp!(*arg1)      String
+        [ 2]       chop!()           String
+        [ 3]     delete!(*arg1)      String
+        [ 4]   downcase!()           String
+        [ 5]     encode!(*arg1)      String
+        [ 6]       gsub!(*arg1)      String
+        [ 7]     lstrip!()           String
+        [ 8]       next!()           String
+        [ 9]    reverse!()           String
+        [10]     rstrip!()           String
+        [11]      slice!(*arg1)      String
+        [12]    squeeze!(*arg1)      String
+        [13]      strip!()           String
+        [14]        sub!(*arg1)      String
+        [15]       succ!()           String
+        [16]   swapcase!()           String
+        [17]         tr!(arg1, arg2) String
+        [18]       tr_s!(arg1, arg2) String
+        [19]     upcase!()           String
+    ]
+
+    $ cat > 6.rb
+    require "awesome_print"
+    ap 42 == ap(42)
+    ^D
+    $ ruby 6.rb
+    42
+    true
+
 ### Example (Rails console) ###
-    $ ruby script/console
-    Loading development environment (Rails 2.3.5)
-    rails> require "ap"
+    $ rails console
+    rails> require "awesome_print"
     rails> ap Account.all(:limit => 2)
     [
         [0] #<Account:0x1033220b8> {
@@ -149,33 +200,47 @@ To use awesome_print as default formatter in irb and Rails console add the follo
 lines into your ~/.irbrc file:
 
 	require "rubygems"
-	require "ap"
-	IRB::Irb.class_eval do
-	  def output_value
-	    ap @context.last_value
+	require "awesome_print"
+
+	unless IRB.version.include?('DietRB')
+	  IRB::Irb.class_eval do
+	    def output_value
+	      ap @context.last_value
+	    end
 	  end
+	else # MacRuby
+	  IRB.formatter = Class.new(IRB::Formatter) do
+	    def inspect_object(object)
+	      object.ai
+	    end
+	  end.new
 	end
 
 ### Logger Convenience Method ###
-awesome_print adds an ap method to the Logger and ActiveSupport::BufferedLogger classes,
-allowing you to call:
+awesome_print adds the 'ap' method to the Logger and ActiveSupport::BufferedLogger classes
+letting you call:
 
     logger.ap object
 
-By default, this logs at the :debug level. You can override that globally with
+By default, this logs at the :debug level. You can override that globally with:
 
     :log_level => :info
 
-in the custom defaults (see below), or you can override on a per call basis with
+in the custom defaults (see below). You can also override on a per call basis with:
 
     logger.ap object, :warn
 
 ### ActionView Convenience Method ###
-awesome_print adds an ap method to the ActionView::Base class making it available
+awesome_print adds the 'ap' method to the ActionView::Base class making it available
 within Rails templates. For example:
 
     <%= ap @accounts.first %>
 
+With other web frameworks (ex: in Sinatra templates) you can explicitly request HTML
+formatting:
+
+    <%= ap @accounts.first, :html => true %>
+
 ### Setting Custom Defaults ###
 You can set your own default options by creating ``.aprc`` file in your home
 directory. Within that file assign your  defaults to ``AwesomePrint.defaults``.
@@ -190,6 +255,12 @@ For example:
       }
     }
 
+### Running Specs ###
+
+    $ gem install rspec           # RSpec 2.x is the requirement.
+    $ rake spec                   # Run the entire spec suite.
+    $ rspec spec/logger_spec.rb   # Run individual spec file.
+
 ### Note on Patches/Pull Requests ###
 * Fork the project on Github.
 * Make your feature addition or bug fix.
@@ -199,12 +270,22 @@ For example:
 
 ### Contributors ###
 
+* Andrew O'Brien -- https://github.com/AndrewO
 * Daniel Bretoi -- http://github.com/danielb2
-* eregon -- http://github.com/eregon
+* Eloy Duran -- http://github.com/alloy
+* Elpizo Choi -- https://github.com/fuJiin
+* Benoit Daloze -- http://github.com/eregon
+* Sean Gallagher -- http://github.com/torandu
+* Stephan Hagemann -- https://github.com/shageman
+* Tim Harper -- http://github.com/timcharper
 * Tobias Crawley -- http://github.com/tobias
+* Viktar Basharymau -- https://github.com/DNNX
 
 ### License ###
-Copyright (c) 2010 Michael Dvorkin  
+Copyright (c) 2010-2011 Michael Dvorkin
+
+twitter.com/mid
+
 %w(mike dvorkin.net) * "@" || %w(mike fatfreecrm.com) * "@"
 
-Released under the MIT license. See LICENSE file for details.
+Released under the MIT license. See LICENSE file for details.

data/Rakefile

@@ -11,9 +11,8 @@ begin
     gem.email = "mike@dvorkin.net"
     gem.homepage = "http://github.com/michaeldv/awesome_print"
     gem.authors = ["Michael Dvorkin"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "rspec", ">= 2.5.0"
     gem.files = FileList["[A-Z]*", "lib/**/*.rb", "rails/*.rb", "spec/*", "init.rb"]
-    gem.has_rdoc = false
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -21,16 +20,15 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--color']
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
+RSpec::Core::RakeTask.new(:rcov) do |spec|
   spec.rcov = true
+  spec.rcov_opts =  %q[--exclude "spec"]
 end
 
 task :spec => :check_dependencies

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.4.0

data/init.rb

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

data/lib/ap/awesome_print.rb

@@ -1,19 +1,24 @@
-# Copyright (c) 2010 Michael Dvorkin
+# 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__
-  CORE = [ :array, :hash, :class, :file, :dir, :bigdecimal, :rational, :struct ]
+  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,
-      :plain     => false,
-      :indent    => 4,
+      :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,
@@ -28,7 +33,9 @@ class AwesomePrint
         :string     => :yellowish,
         :symbol     => :cyanish,
         :time       => :greenish,
-        :trueclass  => :green
+        :trueclass  => :green,
+        :method     => :purpleish,
+        :args       => :pale
       }
     }
 
@@ -39,7 +46,8 @@ class AwesomePrint
     @indentation = @options[:indent].abs
     Thread.current[AP] ||= []
   end
-  
+
+
   private
 
   # Format an array.
@@ -47,18 +55,23 @@ class AwesomePrint
   def awesome_array(a)
     return "[]" if a == []
 
-    if @options[:multiline]
+    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 = colorize("#{indent}[#{arr.size.to_s.rjust(width)}] ", :array)
+        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
-      data = a.inject([]) { |arr, item| arr << awesome(item) }
-      "[ #{data.join(', ')} ]"
+      "[ " << a.map{ |item| awesome(item) }.join(", ") << " ]"
     end
   end
 
@@ -67,23 +80,24 @@ class AwesomePrint
   def awesome_hash(h)
     return "{}" if h == {}
 
-    data = h.keys.inject([]) do |arr, key|
+    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
-        arr << [ awesome(key), h[key] ]
+        [ awesome(key), h[key] ]
       end
     end
       
     width = data.map { |key, | key.size }.max || 0
     width += @indentation if @options[:indent] > 0
   
-    data = data.inject([]) do |arr, (key, value)|
+    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
-        arr << (formatted_key << colorize(" => ", :hash) << awesome(value))
+        formatted_key << colorize(" => ", :hash) << awesome(value)
       end
     end
     if @options[:multiline]
@@ -93,7 +107,7 @@ class AwesomePrint
     end
   end
 
-  # Format a Struct. If @options[:indent] if negative left align hash keys.
+  # Format a Struct. If @options[:indent] is negative left align hash keys.
   #------------------------------------------------------------------------------
   def awesome_struct(s)
     h = {}
@@ -132,10 +146,18 @@ class AwesomePrint
   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 << appear[:with].to_s, appear[:as] || declassify(object))
+    colorize(object.inspect.to_s << appear[:with].to_s, appear[:as] || declassify(object))
   end
 
   # Dispatcher that detects data nesting and invokes object-aware formatter.
@@ -153,6 +175,40 @@ class AwesomePrint
     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, [...]]
@@ -174,26 +230,57 @@ class AwesomePrint
     CORE.grep(declassify(object))[0] || :self
   end
 
-  # Turn class name into symbol, ex: Hello::World => :hello_world.
+  # 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)
-    if object.is_a?(Struct)
-      :struct
-    else
-      object.class.to_s.gsub(/:+/, "_").downcase.to_sym
+    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)
-    if @options[:plain] || @options[:color][type].nil?
-      s
+    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])
+      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
@@ -239,6 +326,19 @@ class AwesomePrint
     $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

data/lib/ap/core_ext/array.rb

@@ -0,0 +1,71 @@
+# 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
+#------------------------------------------------------------------------------
+#
+# The following makes it possible to invoke awesome_print while performing
+# operations on method arrays, ex:
+#
+#   ap [].methods - Object.methods
+#   ap ''.methods.grep(/!|\?/)
+#
+# If you could think of a better way please let me know :-)
+#
+class Array #:nodoc:
+  [ :-, :& ].each do |operator|
+    original_operator = instance_method(operator)
+
+    define_method operator do |*args|
+      arr = original_operator.bind(self).call(*args)
+      if self.instance_variable_defined?('@__awesome_methods__')
+        arr.instance_variable_set('@__awesome_methods__', self.instance_variable_get('@__awesome_methods__'))
+        arr.sort! { |a, b| a.to_s <=> b.to_s }  # Need the block since Ruby 1.8.x can't sort arrays of symbols.
+      end
+      arr
+    end
+  end
+  #
+  # Intercepting Array#grep needs a special treatment since grep accepts
+  # an optional block.
+  #
+  alias :original_grep :grep
+  def grep(pattern, &blk)
+    #
+    # The following looks rather insane and I've sent numerous hours trying
+    # to figure it out. The problem is that if grep gets called with the
+    # block, for example:
+    #
+    #    [].methods.grep(/(.+?)_by/) { $1.to_sym }
+    #
+    # ...then simple:
+    #
+    #    original_grep(pattern, &blk)
+    #
+    # doesn't set $1 within the grep block which causes nil.to_sym failure.
+    # The workaround below has been tested with Ruby 1.8.7/Rails 2.3.8 and
+    # Ruby 1.9.2/Rails 3.0.0. For more info see the following thread dating
+    # back to 2003 when Ruby 1.8.0 was as fresh off the grill as Ruby 1.9.2
+    # is in 2010 :-)
+    #
+    # http://www.justskins.com/forums/bug-when-rerouting-string-52852.html
+    #
+    # BTW, if you figure out a better way of intercepting Array#grep please
+    # let me know: twitter.com/mid -- or just say hi so I know you've read
+    # the comment :-)
+    #
+    arr = unless blk
+      original_grep(pattern)
+    else
+      original_grep(pattern) do |match|
+        eval("%Q/#{match.to_s.gsub('/', '\/')}/ =~ #{pattern.inspect}", blk.binding)
+        yield match
+      end
+    end
+    if self.instance_variable_defined?('@__awesome_methods__')
+      arr.instance_variable_set('@__awesome_methods__', self.instance_variable_get('@__awesome_methods__'))
+      arr.reject! { |item| !(item.is_a?(Symbol) || item.is_a?(String)) } # grep block might return crap.
+    end
+    arr
+  end
+end

data/lib/ap/core_ext/class.rb

@@ -0,0 +1,17 @@
+# 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
+#------------------------------------------------------------------------------
+class Class #:nodoc:
+  # Remaining public/private etc. '_methods' are handled in core_ext/object.rb.
+  %w(instance_methods private_instance_methods protected_instance_methods public_instance_methods).each do |name|
+    original_method = instance_method(name)
+
+    define_method name do |*args|
+      methods = original_method.bind(self).call(*args)
+      methods.instance_variable_set('@__awesome_methods__', self) # Evil?!
+      methods.sort!
+    end
+  end
+end

data/lib/ap/core_ext/kernel.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 Michael Dvorkin
+# 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
@@ -13,6 +13,7 @@ module Kernel
 
   def ap(object, options = {})
     puts object.ai(options)
+    object
   end
   alias :awesome_print :ap
 

data/lib/ap/core_ext/logger.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 Michael Dvorkin
+# 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
@@ -14,5 +14,5 @@ module AwesomePrintLogger
 
 end
 
-Logger.send(:include, AwesomePrintLogger) if defined?(Logger)
+Logger.send(:include, AwesomePrintLogger)
 ActiveSupport::BufferedLogger.send(:include, AwesomePrintLogger) if defined?(::ActiveSupport::BufferedLogger)