awesome_print_lite 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f3400fae6f84fbf525f275d9833ded8c13f369b
+  data.tar.gz: 01c1f2e67c6aa05b2252b64face23bb9e32fc9cb
+SHA512:
+  metadata.gz: 160a8cb0ff782da5316bf8f29ed769ad87f020a3c7ded6e0905dd5d0f1bfdbc800bf0a302cf266bab10b2b1cc504dccb1a7ae4967a35b0cc072bc09cf72eb727
+  data.tar.gz: 1a97e0ae4cc6e329c7d14c48cbdf6d9a74ed563d51c68f77ad848f2a6525f957f4da37f407f71ffd0590964586c1c495c9894d5316cfc8f075483baccce50650

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in awesome_print_lite.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Forrest Chang
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# AwesomePrintLite
+
+This gem exists to provide basic
+https://github.com/michaeldv/awesome_print (from which large portions
+of code were taken) type functionality for opalrb.org apps,
+particularly opal-irb, as such I've named it awesome_print_lite.  It
+need not limited to opal apps only, though I'm not sure why one would
+use it over awesome_print if not using it in opal.
+
+As such, this is basically a port of awesome_print to run on oapl
+
+## Porting Consideratinos
+- Mutable strings not supported in Opal
+- Now Thread in Opal
+- No access to filesystem, and similar
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'awesome_print_lite'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install awesome_print_lite
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/awesome_print_lite/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require 'opal'
+require 'opal-rspec'
+require 'opal/sprockets/environment'
+require 'awesome_print_lite'
+require 'opal/rspec/rake_task'
+Opal::RSpec::RakeTask.new(:default)
+
+
+require "bundler/gem_tasks"
+desc "Run allspecs"
+task :spec do
+  # Run plain rspec command without RSpec::Core::RakeTask overrides.
+  exec "rspec -c spec"
+end

data/awesome_print_lite.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'awesome_print_lite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "awesome_print_lite"
+  spec.version       = AwesomePrintLite::VERSION
+  spec.authors       = ["Forrest Chang"]
+  spec.email         = ["fkc_email-ruby@hedgeye.com"]
+  spec.summary       = %q{Subset of Awesome print functionality for Opal.}
+  spec.description   = %q{Subset of Awesome print functionality for Opal.}
+  spec.homepage      = "https://github.com/fkchang/awesome_print_lite"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "opal"
+  spec.add_development_dependency "opal-rspec"
+  
+end

data/lib/awesome_print_lite.rb

@@ -0,0 +1,20 @@
+require "awesome_print_lite/version"
+require "awesome_print_lite/inspector"
+require "awesome_print_lite/formatter"
+
+require 'awesome_print_lite/core_ext/array'
+require 'awesome_print_lite/core_ext/string'
+require 'awesome_print_lite/core_ext/method'
+require 'awesome_print_lite/core_ext/object'
+require 'awesome_print_lite/core_ext/class' 
+require 'awesome_print_lite/core_ext/kernel'
+                             
+
+module AwesomePrintLite
+  # Your code goes here...
+end
+
+if RUBY_ENGINE != 'opal'
+  require "opal"
+  Opal.append_path File.expand_path('..', __FILE__)
+end

data/lib/awesome_print_lite/core_ext/array.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2010-2013 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|
+        #
+        # The binding can only be used with Ruby-defined methods, therefore
+        # we must rescue potential "ArgumentError: Can't create Binding from
+        # C level Proc" error.
+        #
+        # For example, the following raises ArgumentError since #succ method
+        # is defined in C.
+        #
+        # [ 0, 1, 2, 3, 4 ].grep(1..2, &:succ)
+        #
+        eval("%Q/#{match.to_s.gsub('/', '\/')}/ =~ #{pattern.inspect}", blk.binding) rescue ArgumentError
+        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/awesome_print_lite/core_ext/class.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2010-2013 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:
+  #
+  # Intercept methods below to inject @__awesome_print__ instance variable
+  # so we know it is the *methods* array when formatting an array.
+  #
+  # Remaining public/private etc. '_methods' are handled in core_ext/object.rb.
+  #
+  %w(instance_methods private_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)
+      methods
+    end
+  end
+end

data/lib/awesome_print_lite/core_ext/kernel.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2010-2013 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 Kernel
+
+  def ai(options = {})
+    ap = AwesomePrintLite::Inspector.new(options)
+    awesome = ap.awesome self
+    if options[:html]
+      awesome = "<pre>#{awesome}</pre>"
+      awesome = awesome.html_safe if defined? ActiveSupport
+    end
+    awesome
+  end
+  alias :awesome_inspect :ai
+
+  def ap(object, options = {})
+    puts object.ai(options)
+    object unless AwesomePrintLite.console?
+  end
+  alias :awesome_print :ap
+
+  module_function :ap
+end

data/lib/awesome_print_lite/core_ext/logger.rb

@@ -0,0 +1,20 @@
+# Copyright (c) 2010-2013 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 AwesomePrintLite
+  module Logger
+
+    # Add ap method to logger
+    #------------------------------------------------------------------------------
+    def ap(object, level = nil)
+      level ||= AwesomePrintLite.defaults[:log_level] if AwesomePrintLite.defaults
+      level ||= :debug
+      send level, object.ai
+    end
+  end
+end
+
+Logger.send(:include, AwesomePrintLite::Logger)
+ActiveSupport::BufferedLogger.send(:include, AwesomePrintLite::Logger) if defined?(ActiveSupport::BufferedLogger)

data/lib/awesome_print_lite/core_ext/method.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2010-2013 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
+#------------------------------------------------------------------------------
+#
+# Method#name was intorduced in Ruby 1.8.7 so we define it here as necessary.
+#
+unless nil.method(:class).respond_to?(:name)
+  class Method
+    def name
+      inspect.split(/[#.>]/)[-1]
+    end
+  end
+
+  class UnboundMethod
+    def name
+      inspect.split(/[#.>]/)[-1]
+    end
+  end
+end

data/lib/awesome_print_lite/core_ext/object.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2010-2013 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 Object #:nodoc:
+  #
+  # Intercept methods below to inject @__awesome_print__ instance variable
+  # so we know it is the *methods* array when formatting an array.
+  #
+  # Remaining instance '_methods' are handled in core_ext/class.rb.
+  #
+  %w(methods private_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)
+      methods
+    end
+  end
+end

data/lib/awesome_print_lite/core_ext/string.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2010-2013 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 String
+  #
+  # ANSI color codes:
+  #   \e => escape
+  #   30 => color base
+  #    1 => bright
+  #    0 => normal
+  #
+  # For HTML coloring we use <kbd> tag instead of <span> to require monospace
+  # font. Note that beloved <tt> has been removed from HTML5.
+  #
+  %w(gray red green yellow blue purple cyan white).zip(
+  %w(black darkred darkgreen brown navy darkmagenta darkcyan slategray)).each_with_index do |(color, shade), i|
+    define_method color do |*html|
+      # JS/opal can't deal the escapes and interpolation
+      html[0] ? %Q|<kbd style="color:#{color}">#{self}</kbd>| : "\e[1;" + "#{30+i}m#{self}"+ "\e[0m"
+    end
+
+    define_method "#{color}ish" do |*html|
+      html[0] ? %Q|<kbd style="color:#{shade}">#{self}</kbd>| : "\e[0;" + "#{30+i}m#{self}" + "\e[0m"
+    end
+  end
+
+  alias :black :grayish
+  alias :pale  :whiteish
+
+end

data/lib/awesome_print_lite/formatter.rb

@@ -0,0 +1,410 @@
+# Copyright (c) 2010-2013 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
+#------------------------------------------------------------------------------
+autoload :CGI, "cgi"
+# require "shellwords"
+
+module AwesomePrintLite
+  class Formatter
+
+    CORE = [ :array, :class, :dir, :file, :hash, :method, :rational, :set, :struct, :unboundmethod ]
+    DEFAULT_LIMIT_SIZE = 7
+
+    def initialize(inspector)
+      @inspector   = inspector
+      @options     = inspector.options
+      @indentation = @options[:indent].abs
+    end
+
+    # Main entry point to format an object.
+    #------------------------------------------------------------------------------
+    def format(object, type = nil)
+      core_class = cast(object, type)
+      awesome = if core_class != :self
+                  send(:"awesome_#{core_class}", object) # Core formatters.
+                else
+                  awesome_self(object, type) # Catch all that falls back to object.inspect.
+                end
+      awesome
+    end
+
+    # Hook this when adding custom formatters. Check out lib/awesome_print/ext
+    # directory for custom formatters that ship with awesome_print.
+    #------------------------------------------------------------------------------
+    def cast(object, type)
+      CORE.grep(type)[0] || :self
+    end
+
+    # Pick the color and apply it to the given string as necessary.
+    #------------------------------------------------------------------------------
+    def colorize(str, type)
+      str = CGI.escapeHTML(str) if @options[:html]
+      if @options[:plain] || !@options[:color][type] || !@inspector.colorize?
+        str
+      #
+      # Check if the string color method is defined by awesome_print and accepts
+      # html parameter or it has been overriden by some gem such as colorize.
+      #
+      elsif str.method(@options[:color][type]).arity == -1 # Accepts html parameter.
+        str.send(@options[:color][type], @options[:html])
+      else
+        str = %Q|<kbd style="color:#{@options[:color][type]}">#{str}</kbd>| if @options[:html]
+        str.send(@options[:color][type])
+      end
+    end
+
+
+    private
+
+    # Catch all method to format an arbitrary object.
+    #------------------------------------------------------------------------------
+    def awesome_self(object, type)
+      # alert "#{object.inspect} #{object.instance_variables}"
+      # `console.log(#{object.instance_variables})`
+      if @options[:raw] && instance_variables_opal(object).any?
+        return awesome_object(object)
+      elsif hash = convert_to_hash(object)
+        awesome_hash(hash)
+      else
+        colorize(object.inspect.to_s, type)
+      end
+    end
+
+    # because we put instance variables on everything in opal
+    def instance_variables_opal(object)
+      object.instance_variables - %w(@0 @1 @2 @3 @4 @5 @6 @7 @8 @9 @encoding)
+    end
+    
+    # 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 = indent
+          index += colorize("[#{arr.size.to_s.rjust(width)}] ", :array) if @options[:index]
+          indented do
+            index += @inspector.awesome(item)
+            arr << index
+          end
+        end
+        data = limited(data, width) if should_be_limited?
+        "[\n" + data.join(",\n") + "\n#{outdent}]"
+      else
+        "[ " + a.map{ |item| @inspector.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[:sort_keys] ? h.keys.sort { |a, b| a.to_s <=> b.to_s } : h.keys
+      data = keys.map do |key|
+        plain_single_line do
+          [ @inspector.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|
+        indented do
+          align(key, width) + colorize(" => ", :hash) + @inspector.awesome(value)
+        end
+      end
+
+      data = limited(data, width, :hash => true) if should_be_limited?
+      if @options[:multiline]
+        "{\n" + data.join(",\n") + "\n#{outdent}}"
+      else
+        "{ #{data.join(', ')} }"
+      end
+    end
+
+    # Format an object.
+    #------------------------------------------------------------------------------
+    def awesome_object(o)
+      vars = instance_variables_opal(o).map do |var|
+        property = var.to_s[1..-1].to_sym # to_s because of some monkey patching done by Puppet.
+        accessor = if o.respond_to?(:"#{property}=")
+                     o.respond_to?(property) ? :accessor : :writer
+                   else
+                     o.respond_to?(property) ? :reader : nil
+                   end
+        if accessor
+          [ "attr_#{accessor} :#{property}", var ]
+        else
+          [ var.to_s, var ]
+        end
+      end
+
+      data = vars.sort.map do |declaration, var|
+        key = left_aligned do
+          align(declaration, declaration.size)
+        end
+
+        unless @options[:plain]
+          if key =~ /(@\w+)/
+            key = key.sub($1, colorize($1, :variable))
+          else
+            key = key.sub(/(attr_\w+)\s(\:\w+)/, "#{colorize('\\1', :keyword)} #{colorize('\\2', :method)}")
+          end
+        end
+        indented do
+          key + colorize(" = ", :hash) + @inspector.awesome(o.instance_variable_get(var))
+        end
+      end
+      if @options[:multiline]
+        "#<#{awesome_instance(o)}\n#{data.join(%Q/,\n/)}\n#{outdent}>"
+      else
+        "#<#{awesome_instance(o)} #{data.join(', ')}>"
+      end
+    end
+
+    # Format a set.
+    #------------------------------------------------------------------------------
+    def awesome_set(s)
+      awesome_array(s.to_a)
+    end
+
+    # Format a Struct.
+    #------------------------------------------------------------------------------
+    def awesome_struct(s)
+      #
+      # The code is slightly uglier because of Ruby 1.8.6 quirks:
+      # awesome_hash(Hash[s.members.zip(s.values)]) <-- ArgumentError: odd number of arguments for Hash)
+      # awesome_hash(Hash[*s.members.zip(s.values).flatten]) <-- s.members returns strings, not symbols.
+      #
+      hash = {}
+      s.each_pair { |key, value| hash[key] = value }
+      awesome_hash(hash)
+    end
+
+    # Format Class object.
+    #------------------------------------------------------------------------------
+    def awesome_class(c)
+      if superclass = c.superclass # <-- Assign and test if nil.
+        colorize("#{c.inspect} < #{superclass}", :class)
+      else
+        colorize(c.inspect, :class)
+      end
+    end
+
+    # Format Rational object.
+    #------------------------------------------------------------------------------
+    def awesome_rational(n)
+      colorize(n.to_s, :rational)
+    end
+
+    # 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
+
+    # Format object instance.
+    #------------------------------------------------------------------------------
+    def awesome_instance(o)
+      "#{o.class}:0x%08x" % (o.__id__ * 2)
+    end
+
+    # Format object.methods array.
+    #------------------------------------------------------------------------------
+    def methods_array(a)
+      a.sort! { |x, y| x.to_s <=> y.to_s }                  # Can't simply a.sort! because of o.methods << [ :blah ]
+      object = a.instance_variable_get('@__awesome_methods__')
+      tuples = a.map do |name|
+        if name.is_a?(Symbol) || name.is_a?(String)         # Ignore garbage, ex. 42.methods << [ :blah ]
+          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)) rescue nil # Rescue to avoid NameError when the method is not
+                  end                                                     # available (ex. File.lchmod on Ubuntu 12).
+        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 = indent
+        index += "[#{arr.size.to_s.rjust(width)}]" if @options[:index]
+        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
+
+    # 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
+
+      # method.to_s formats to handle:
+      #
+      # #<Method: Fixnum#zero?>
+      # #<Method: Fixnum(Integer)#years>
+      # #<Method: User(#<Module:0x00000103207c00>)#_username>
+      # #<Method: User(id: integer, username: string).table_name>
+      # #<Method: User(id: integer, username: string)(ActiveRecord::Base).current>
+      # #<UnboundMethod: Hello#world>
+      #
+      if method.to_s =~ /(Unbound)*Method: (.*)[#\.]/
+        unbound, klass = $1 && '(unbound)', $2
+        if klass && klass =~ /(\(\w+:\s.*?\))/  # Is this ActiveRecord-style class?
+          klass.sub!($1, '')                    # Yes, strip the fields leaving class name only.
+        end
+        owner = "#{klass}#{unbound}".gsub('(', ' (')
+      end
+
+      [ method.name.to_s, "(#{args.join(', ')})", owner.to_s ]
+    end
+
+    # Format hash keys as plain strings 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
+
+    # Utility methods.
+    #------------------------------------------------------------------------------
+    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
+
+    def align(value, width)
+      if @options[:multiline]
+        if @options[:indent] > 0
+          value.rjust(width)
+        elsif @options[:indent] == 0
+          indent + value.ljust(width)
+        else
+          indent[0, @indentation + @options[:indent]] + value.ljust(width)
+        end
+      else
+        value
+      end
+    end
+
+    def indented
+      @indentation += @options[:indent].abs
+      yield
+    ensure
+      @indentation -= @options[:indent].abs
+    end
+
+    def left_aligned
+      current, @options[:indent] = @options[:indent], 0
+      yield
+    ensure
+      @options[:indent] = current
+    end
+
+    def indent
+      ' ' * @indentation
+    end
+
+    def outdent
+      ' ' * (@indentation - @options[:indent].abs)
+    end
+
+    # 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] == true or (@options[:limit].is_a?(Fixnum) and @options[:limit] > 0)
+    end
+
+    def get_limit_size
+      @options[:limit] == true ? DEFAULT_LIMIT_SIZE : @options[:limit]
+    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]
+
+        if is_hash
+          temp[head] = "#{indent}#{data[head].strip} .. #{data[data.length - tail - 1].strip}"
+        else
+          temp[head] = "#{indent}[#{head.to_s.rjust(width)}] .. [#{data.length - tail - 1}]"
+        end
+
+        temp
+      end
+    end
+  end
+end