amazing_print 1.0.0

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default do
+  if ENV['BUNDLE_GEMFILE'] =~ /gemfiles/
+    Rake::Task['spec'].invoke
+  else
+    Rake::Task['appraise'].invoke
+  end
+end
+
+task :appraise do
+  exec 'appraisal install && appraisal rake'
+end
+
+desc 'Run all amazing_print gem specs'
+task :spec do
+  # Run plain rspec command without RSpec::Core::RakeTask overrides.
+  exec 'rspec -c spec'
+end

data/lib/amazing_print.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+#
+# AmazingPrint might be loaded implicitly through ~/.irbrc or ~/.pryrc
+# so do nothing for subsequent requires.
+#
+unless defined?(AmazingPrint::Inspector)
+  %w[awesome_method_array string method object class kernel].each do |file|
+    require "amazing_print/core_ext/#{file}"
+  end
+
+  require 'amazing_print/custom_defaults'
+  require 'amazing_print/inspector'
+  require 'amazing_print/formatter'
+  require 'amazing_print/version'
+  require 'amazing_print/core_ext/logger' if defined?(Logger)
+  #
+  # Load the following under normal circumstances as well as in Rails
+  # console when required from ~/.irbrc or ~/.pryrc.
+  #
+  if defined?(ActiveRecord) || AmazingPrint.rails_console?
+    require 'amazing_print/ext/active_record'
+  end
+  if defined?(ActiveSupport) || AmazingPrint.rails_console?
+    require 'amazing_print/ext/active_support'
+  end
+  #
+  # Load remaining extensions.
+  #
+  if defined?(ActiveSupport.on_load)
+    ActiveSupport.on_load(:action_view) do
+      require 'amazing_print/ext/action_view'
+    end
+  end
+  require 'amazing_print/ext/mongo_mapper'   if defined?(MongoMapper)
+  require 'amazing_print/ext/mongoid'        if defined?(Mongoid)
+  require 'amazing_print/ext/nokogiri'       if defined?(Nokogiri)
+  require 'amazing_print/ext/nobrainer'      if defined?(NoBrainer)
+  require 'amazing_print/ext/ripple'         if defined?(Ripple)
+  require 'amazing_print/ext/sequel'         if defined?(Sequel)
+  require 'amazing_print/ext/ostruct'        if defined?(OpenStruct)
+end
+# test

data/lib/amazing_print/colorize.rb

@@ -0,0 +1,25 @@
+autoload :CGI, 'cgi'
+
+module AmazingPrint
+  module Colorize
+    # 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 amazing_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
+        if options[:html]
+          str = %(<kbd style="color:#{options[:color][type]}">#{str}</kbd>)
+        end
+        str.send(options[:color][type])
+      end
+    end
+  end
+end

data/lib/amazing_print/core_ext/awesome_method_array.rb

@@ -0,0 +1,82 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint 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 amazing_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 :-)
+#
+module AwesomeMethodArray #:nodoc:
+  def -(_other_ary)
+    super.tap do |arr|
+      arr.instance_variable_set(:@__awesome_methods__, instance_variable_get(:@__awesome_methods__))
+    end
+  end
+
+  def &(_other_ary)
+    super.tap do |arr|
+      arr.instance_variable_set(:@__awesome_methods__, instance_variable_get(:@__awesome_methods__))
+    end
+  end
+
+  #
+  # Intercepting Array#grep needs a special treatment since grep accepts
+  # an optional block.
+  #
+  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 = if blk
+            super(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)
+              #
+              begin
+                eval("%Q/#{match.to_s.gsub('/', '\/')}/ =~ #{pattern.inspect}", blk.binding)
+              rescue StandardError
+                ArgumentError
+              end
+              yield match
+            end
+          else
+            super(pattern)
+          end
+    arr.instance_variable_set(:@__awesome_methods__, instance_variable_get(:@__awesome_methods__))
+    arr.reject! { |item| !(item.is_a?(Symbol) || item.is_a?(String)) } # grep block might return crap.
+    arr
+  end
+end

data/lib/amazing_print/core_ext/class.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint 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 @__amazing_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 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)
+      methods.extend(AwesomeMethodArray)
+      methods
+    end
+  end
+end

data/lib/amazing_print/core_ext/kernel.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint 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 = AmazingPrint::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 AmazingPrint.console?
+  end
+  alias amazing_print ap
+
+  module_function :ap
+end

data/lib/amazing_print/core_ext/logger.rb

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

data/lib/amazing_print/core_ext/method.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint 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/amazing_print/core_ext/object.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint 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 @__amazing_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 protected_methods public_methods singleton_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.extend(AwesomeMethodArray)
+      methods
+    end
+  end
+end

data/lib/amazing_print/core_ext/string.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+
+# frozen_string_literal: true
+
+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|
+    # NOTE: Format strings are created once only, for performance, and remembered by closures.
+
+    term_bright_seq = "\e[1;#{30 + i}m%s\e[0m"
+    html_bright_seq = %(<kbd style="color:#{color}">%s</kbd>)
+
+    define_method color do |html = false, *|
+      (html ? html_bright_seq : term_bright_seq) % self
+    end
+
+    term_normal_seq = "\e[0;#{30 + i}m%s\e[0m"
+    html_normal_seq = %(<kbd style="color:#{shade}">%s</kbd>)
+
+    define_method "#{color}ish" do |html = false, *|
+      (html ? html_normal_seq : term_normal_seq) % self
+    end
+  end
+
+  alias black grayish
+  alias pale  whiteish
+end

data/lib/amazing_print/custom_defaults.rb

@@ -0,0 +1,57 @@
+module AmazingPrint
+  class << self
+    attr_accessor :defaults, :force_colors
+
+    # Class accessor to force colorized output (ex. forked subprocess where TERM
+    # might be dumb).
+    #---------------------------------------------------------------------------
+    def force_colors!(value = true)
+      @force_colors = value
+    end
+
+    def console?
+      boolean(defined?(IRB) || defined?(Pry))
+    end
+
+    def rails_console?
+      console? && boolean(defined?(Rails::Console) || ENV['RAILS_ENV'])
+    end
+
+    def diet_rb
+      IRB.formatter = Class.new(IRB::Formatter) do
+        def inspect_object(object)
+          object.ai
+        end
+      end.new
+    end
+
+    def usual_rb
+      IRB::Irb.class_eval do
+        def output_value
+          ap @context.last_value
+        rescue NoMethodError
+          puts "(Object doesn't support #ai)"
+        end
+      end
+    end
+
+    def irb!
+      return unless defined?(IRB)
+
+      IRB.version.include?('DietRB') ? diet_rb : usual_rb
+    end
+
+    def pry!
+      Pry.print = proc { |output, value| output.puts value.ai } if defined?(Pry)
+    end
+
+    private
+
+    # Takes a value and returns true unless it is false or nil
+    # This is an alternative to the less readable !!(value)
+    # https://github.com/bbatsov/ruby-style-guide#no-bang-bang
+    def boolean(value)
+      value ? true : false
+    end
+  end
+end

data/lib/amazing_print/ext/action_view.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module AmazingPrint
+  module ActionView
+    # 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 ap ap_debug
+  end
+end
+
+ActionView::Base.include AmazingPrint::ActionView

data/lib/amazing_print/ext/active_record.rb

@@ -0,0 +1,103 @@
+# Copyright (c) 2010-2016 Michael Dvorkin and contributors
+#
+# AmazingPrint is freely distributable under the terms of MIT license.
+# See LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+module AmazingPrint
+  module ActiveRecord
+    def self.included(base)
+      base.send :alias_method, :cast_without_active_record, :cast
+      base.send :alias_method, :cast, :cast_with_active_record
+    end
+
+    # Add ActiveRecord class names to the dispatcher pipeline.
+    #------------------------------------------------------------------------------
+    def cast_with_active_record(object, type)
+      cast = cast_without_active_record(object, type)
+      return cast unless defined?(::ActiveRecord::Base)
+
+      if object.is_a?(::ActiveRecord::Base)
+        cast = :active_record_instance
+      elsif object.is_a?(::ActiveModel::Errors)
+        cast = :active_model_error
+      elsif object.is_a?(Class) && object.ancestors.include?(::ActiveRecord::Base)
+        cast = :active_record_class
+      elsif type == :activerecord_relation || object.class.ancestors.include?(::ActiveRecord::Relation)
+        cast = :array
+      end
+      cast
+    end
+
+    private
+
+    # Format ActiveRecord instance object.
+    #
+    # NOTE: by default only instance attributes (i.e. columns) are shown. To format
+    # ActiveRecord instance as regular object showing its instance variables and
+    # accessors use :raw => true option:
+    #
+    # ap record, :raw => true
+    #
+    #------------------------------------------------------------------------------
+    def awesome_active_record_instance(object)
+      return object.inspect unless defined?(::ActiveSupport::OrderedHash)
+      return awesome_object(object) if @options[:raw]
+
+      data = if object.class.column_names != object.attributes.keys
+               object.attributes
+             else
+               object.class.column_names.each_with_object(::ActiveSupport::OrderedHash.new) do |name, hash|
+                 if object.has_attribute?(name) || object.new_record?
+                   value = object.respond_to?(name) ? object.send(name) : object.read_attribute(name)
+                   hash[name.to_sym] = value
+                 end
+               end
+             end
+      "#{object} " << awesome_hash(data)
+    end
+
+    # Format ActiveRecord class object.
+    #------------------------------------------------------------------------------
+    def awesome_active_record_class(object)
+      if !defined?(::ActiveSupport::OrderedHash) || !object.respond_to?(:columns) || object.to_s == 'ActiveRecord::Base'
+        return object.inspect
+      end
+      if object.respond_to?(:abstract_class?) && object.abstract_class?
+        return awesome_class(object)
+      end
+
+      data = object.columns.each_with_object(::ActiveSupport::OrderedHash.new) do |c, hash|
+        hash[c.name.to_sym] = c.type
+      end
+
+      name = "class #{awesome_simple(object.to_s, :class)}"
+      base = "< #{awesome_simple(object.superclass.to_s, :class)}"
+
+      [name, base, awesome_hash(data)].join(' ')
+    end
+
+    # Format ActiveModel error object.
+    #------------------------------------------------------------------------------
+    def awesome_active_model_error(object)
+      return object.inspect unless defined?(::ActiveSupport::OrderedHash)
+      return awesome_object(object) if @options[:raw]
+
+      object_dump = object.marshal_dump.first
+      data = if object_dump.class.column_names != object_dump.attributes.keys
+               object_dump.attributes
+             else
+               object_dump.class.column_names.each_with_object(::ActiveSupport::OrderedHash.new) do |name, hash|
+                 if object_dump.has_attribute?(name) || object_dump.new_record?
+                   value = object_dump.respond_to?(name) ? object_dump.send(name) : object_dump.read_attribute(name)
+                   hash[name.to_sym] = value
+                 end
+               end
+             end
+
+      data.merge!({ details: object.details, messages: object.messages })
+      "#{object} " << awesome_hash(data)
+    end
+  end
+end
+
+AmazingPrint::Formatter.include AmazingPrint::ActiveRecord