pp-colour 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Stefan Penner
+
+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.rdoc

@@ -0,0 +1,25 @@
+= pp-colour
+
+A colourized version of ruby's builtin pp. Not fully complete, but it coveres the common cases.
+
+= install
+  sudo gem install pp-colour 
+
+= usage
+  require 'pp-colour'
+  pp some_awesomely_huge_datastructure
+  > syntax highlighted goodness
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Stefan Penner. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pp-colour"
+    gem.summary = %Q{colourized pp}
+    gem.description = %Q{colourized version of the builtin pp}
+    gem.email = "stefan.penner@gmail.com"
+    gem.homepage = "http://github.com/stefanpenner/pp-colour"
+    gem.authors = ["Stefan Penner"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pp-colour #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Jeweler::GemcutterTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/pp-colour.rb

@@ -0,0 +1,11 @@
+require 'prettyprint'
+require 'pp-colour/string'
+require 'pp-colour/kernel'
+require 'pp-colour/temp'
+require 'pp-colour/array'
+require 'pp-colour/hash'
+require 'pp-colour/struct'
+require 'pp-colour/file'
+require 'pp-colour/range'
+require 'pp-colour/matchdata'
+require 'pp-colour/other'

data/lib/pp-colour/array.rb

@@ -0,0 +1,14 @@
+class Array
+  def pretty_print(q)
+    q.group(1, '['.green, ']'.green) {
+      q.seplist(self) {|v|
+        q.pp v
+      }
+    }
+  end
+ 
+  def pretty_print_cycle(q)
+    q.text(empty? ? '[]'.green : '[...]'.green)
+  end
+end
+

data/lib/pp-colour/file.rb

@@ -0,0 +1,82 @@
+class File
+  class Stat
+    def pretty_print(q)
+      require 'etc.so'
+      q.object_group(self) {
+        q.breakable
+        q.text sprintf("dev=0x%x", self.dev); q.comma_breakable
+        q.text "ino="; q.pp self.ino; q.comma_breakable
+        q.group {
+          m = self.mode
+          q.text sprintf("mode=0%o", m)
+          q.breakable
+          q.text sprintf("(%s %c%c%c%c%c%c%c%c%c)",
+            self.ftype,
+            (m & 0400 == 0 ? ?- : ?r),
+            (m & 0200 == 0 ? ?- : ?w),
+            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
+                             (m & 04000 == 0 ? ?x : ?s)),
+            (m & 0040 == 0 ? ?- : ?r),
+            (m & 0020 == 0 ? ?- : ?w),
+            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
+                             (m & 02000 == 0 ? ?x : ?s)),
+            (m & 0004 == 0 ? ?- : ?r),
+            (m & 0002 == 0 ? ?- : ?w),
+            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
+                             (m & 01000 == 0 ? ?x : ?t)))
+        }
+        q.comma_breakable
+        q.text "nlink="; q.pp self.nlink; q.comma_breakable
+        q.group {
+          q.text "uid="; q.pp self.uid
+          begin
+            pw = Etc.getpwuid(self.uid)
+          rescue ArgumentError
+          end
+          if pw
+            q.breakable; q.text "(#{pw.name})"
+          end
+        }
+        q.comma_breakable
+        q.group {
+          q.text "gid="; q.pp self.gid
+          begin
+            gr = Etc.getgrgid(self.gid)
+          rescue ArgumentError
+          end
+          if gr
+            q.breakable; q.text "(#{gr.name})"
+          end
+        }
+        q.comma_breakable
+        q.group {
+          q.text sprintf("rdev=0x%x", self.rdev)
+          q.breakable
+          q.text sprintf('(%d, %d)', self.rdev_major, self.rdev_minor)
+        }
+        q.comma_breakable
+        q.text "size="; q.pp self.size; q.comma_breakable
+        q.text "blksize="; q.pp self.blksize; q.comma_breakable
+        q.text "blocks="; q.pp self.blocks; q.comma_breakable
+        q.group {
+          t = self.atime
+          q.text "atime="; q.pp t
+          q.breakable; q.text "(#{t.tv_sec})"
+        }
+        q.comma_breakable
+        q.group {
+          t = self.mtime
+          q.text "mtime="; q.pp t
+          q.breakable; q.text "(#{t.tv_sec})"
+        }
+        q.comma_breakable
+        q.group {
+          t = self.ctime
+          q.text "ctime="; q.pp t
+          q.breakable; q.text "(#{t.tv_sec})"
+        }
+      }
+    end
+  end
+end
+

data/lib/pp-colour/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  def pretty_print(q)
+    q.pp_hash self
+  end
+ 
+  def pretty_print_cycle(q)
+    q.text(empty? ? '{}'.green : '{...}'.green)
+  end
+end
+

data/lib/pp-colour/kernel.rb

@@ -0,0 +1,19 @@
+module Kernel
+  # returns a pretty printed object as a string.
+  def pretty_inspect
+    PP.pp(self, '')
+  end
+ 
+  private
+  # prints arguments in pretty form.
+  #
+  # pp returns nil.
+  def pp(*objs) # :doc:
+    objs.each {|obj|
+      PP.pp(obj)
+    }
+    nil
+  end
+  module_function :pp
+end
+

data/lib/pp-colour/matchdata.rb

@@ -0,0 +1,11 @@
+class MatchData
+  def pretty_print(q)
+    q.object_group(self) {
+      q.breakable
+      q.seplist(1..self.size, lambda { q.breakable }) {|i|
+        q.pp self[i-1]
+      }
+    }
+  end
+end
+

data/lib/pp-colour/object.rb

@@ -0,0 +1,3 @@
+class Object
+  include PP::ObjectMixin
+end

data/lib/pp-colour/other.rb

@@ -0,0 +1,23 @@
+[Numeric, Symbol, FalseClass, TrueClass, NilClass, Module].each do |c|
+  c.class_eval do
+    def pretty_print_cycle(q)
+      q.text inspect.cyan
+    end
+  end
+end
+ 
+[Numeric].each do |c|
+  c.class_eval do
+    def pretty_print(q)
+      q.text inspect.cyan
+    end
+  end
+end
+
+[FalseClass, TrueClass, Module].each do |c|
+  c.class_eval do
+    def pretty_print(q)
+      q.text inspect.green.bold
+    end
+  end
+end

data/lib/pp-colour/range.rb

@@ -0,0 +1,10 @@
+class Range
+  def pretty_print(q)
+    q.pp self.begin
+    q.breakable ''
+    q.text(self.exclude_end? ? '...'.green : '..'.green)
+    q.breakable ''
+    q.pp self.end
+  end
+end
+

data/lib/pp-colour/string.rb

@@ -0,0 +1,55 @@
+# credit goes to burke@burkelibbey.org
+class String
+  COLORS = {
+    :black     => '0',
+    :red       => '1',
+    :green     => '2',
+    :yellow    => '3',
+    :blue      => '4',
+    :magenta   => '5',
+    :cyan      => '6',
+    :white     => '7'
+  }
+ 
+  FORMAT_CODES = {
+    :bold      => '1',
+    :italic    => '3',
+    :underline => '4',
+    :blink     => '5',
+  }
+ 
+  def ansi_formatted
+    ansi_csi = "#{(0x1B).chr}["
+    formats = {}
+    FORMAT_CODES.each do |name, code|
+      formats[name] = code if @properties[name]
+    end
+    formats[:color] = "3#{COLORS[@properties[:color]]}" if @properties[:color]
+    "#{ansi_csi}#{formats.values.join(';')}m#{self}#{ansi_csi}m"
+  end
+  
+  def make_colorized(color)
+    @properties ||= {}
+    @properties[:color] = color
+    ansi_formatted
+  end
+  
+  COLORS.each do |color,v|
+    eval <<-EOS
+      def #{color.to_s}
+        make_colorized(:#{color})
+      end
+    EOS
+  end
+ 
+  FORMAT_CODES.each do |name, code|
+    eval <<-EOS
+      def #{name}
+        @properties ||= {}
+        @properties[:#{name}] = true
+        ansi_formatted
+      end
+    EOS
+  end
+end
+

data/lib/pp-colour/struct.rb

@@ -0,0 +1,20 @@
+class Struct
+  def pretty_print(q)
+    q.group(1, '#<struct ' + PP.mcall(self, Kernel, :class).name, '>') {
+      q.seplist(PP.mcall(self, Struct, :members), lambda { q.text "," }) {|member|
+        q.breakable
+        q.text member.to_s
+        q.text '='
+        q.group(1) {
+          q.breakable ''
+          q.pp self[member]
+        }
+      }
+    }
+  end
+ 
+  def pretty_print_cycle(q)
+    q.text sprintf("#<struct %s:...>", PP.mcall(self, Kernel, :class).name)
+  end
+end
+

data/lib/pp-colour/temp.rb

@@ -0,0 +1,294 @@
+ 
+# == Pretty-printer for Ruby objects.
+# 
+# = Which seems better?
+# 
+# non-pretty-printed output by #p is:
+#   #<PP:0x81fedf0 @genspace=#<Proc:0x81feda0>, @group_queue=#<PrettyPrint::GroupQueue:0x81fed3c @queue=[[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], []]>, @buffer=[], @newline="\n", @group_stack=[#<PrettyPrint::Group:0x81fed78 @breakables=[], @depth=0, @break=false>], @buffer_width=0, @indent=0, @maxwidth=79, @output_width=2, @output=#<IO:0x8114ee4>>
+# 
+# pretty-printed output by #pp is:
+#   #<PP:0x81fedf0
+#    @buffer=[],
+#    @buffer_width=0,
+#    @genspace=#<Proc:0x81feda0>,
+#    @group_queue=
+#     #<PrettyPrint::GroupQueue:0x81fed3c
+#      @queue=
+#       [[#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
+#        []]>,
+#    @group_stack=
+#     [#<PrettyPrint::Group:0x81fed78 @break=false, @breakables=[], @depth=0>],
+#    @indent=0,
+#    @maxwidth=79,
+#    @newline="\n",
+#    @output=#<IO:0x8114ee4>,
+#    @output_width=2>
+# 
+# I like the latter.  If you do too, this library is for you.
+# 
+# = Usage
+# 
+#   pp(obj)
+#
+# output +obj+ to +$>+ in pretty printed format.
+# 
+# It returns +nil+.
+# 
+# = Output Customization
+# To define your customized pretty printing function for your classes,
+# redefine a method #pretty_print(+pp+) in the class.
+# It takes an argument +pp+ which is an instance of the class PP.
+# The method should use PP#text, PP#breakable, PP#nest, PP#group and
+# PP#pp to print the object.
+#
+# = Author
+# Tanaka Akira <akr@m17n.org>
+require 'prettyprint'
+ 
+class PP < PrettyPrint
+  # Outputs +obj+ to +out+ in pretty printed format of
+  # +width+ columns in width.
+  # 
+  # If +out+ is omitted, +$>+ is assumed.
+  # If +width+ is omitted, 79 is assumed.
+  # 
+  # PP.pp returns +out+.
+  def PP.pp(obj, out=$>, width=79)
+    q = PP.new(out, width)
+    q.guard_inspect_key {q.pp obj}
+    q.flush
+    #$pp = q
+    out << "\n"
+    out
+  end
+ 
+  # Outputs +obj+ to +out+ like PP.pp but with no indent and
+  # newline.
+  # 
+  # PP.singleline_pp returns +out+.
+  def PP.singleline_pp(obj, out=$>)
+    q = SingleLine.new(out)
+    q.guard_inspect_key {q.pp obj}
+    q.flush
+    out
+  end
+ 
+  # :stopdoc:
+  def PP.mcall(obj, mod, meth, *args, &block)
+    mod.instance_method(meth).bind(obj).call(*args, &block)
+  end
+  # :startdoc:
+ 
+  @sharing_detection = false
+  class << self
+    # Returns the sharing detection flag as a boolean value.
+    # It is false by default.
+    attr_accessor :sharing_detection
+  end
+ 
+  module PPMethods
+    InspectKey = :__inspect_key__ unless defined? InspectKey
+ 
+    def guard_inspect_key
+      if Thread.current[InspectKey] == nil
+        Thread.current[InspectKey] = []
+      end
+ 
+      save = Thread.current[InspectKey]
+ 
+      begin
+        Thread.current[InspectKey] = []
+        yield
+      ensure
+        Thread.current[InspectKey] = save
+      end
+    end
+ 
+    # Adds +obj+ to the pretty printing buffer
+    # using Object#pretty_print or Object#pretty_print_cycle.
+    # 
+    # Object#pretty_print_cycle is used when +obj+ is already
+    # printed, a.k.a the object reference chain has a cycle.
+    def pp(obj)
+      id = obj.__id__
+ 
+      if Thread.current[InspectKey].include? id
+        group {obj.pretty_print_cycle self}
+        return
+      end
+ 
+      begin
+        Thread.current[InspectKey] << id
+        group {obj.pretty_print self}
+      ensure
+        Thread.current[InspectKey].pop unless PP.sharing_detection
+      end
+    end
+ 
+    # A convenience method which is same as follows:
+    # 
+    #   group(1, '#<' + obj.class.name, '>') { ... }
+    def object_group(obj, &block) # :yield:
+      group(1, '#<'.green + obj.class.name.magenta, '>'.green, &block)
+    end
+ 
+    def object_address_group(obj, &block)
+      id = "%x" % (obj.__id__ * 2)
+      id.sub!(/\Af(?=[[:xdigit:]]{2}+\z)/, '') if id.sub!(/\A\.\./, '')
+      group(1, "\#<#{obj.class.to_s.magenta}:".green + "0x#{id}".blue, '>'.green, &block)
+    end
+ 
+    # A convenience method which is same as follows:
+    # 
+    #   text ','
+    #   breakable
+    def comma_breakable
+      text ','.blue
+      breakable
+    end
+ 
+    # Adds a separated list.
+    # The list is separated by comma with breakable space, by default.
+    # 
+    # #seplist iterates the +list+ using +iter_method+.
+    # It yields each object to the block given for #seplist.
+    # The procedure +separator_proc+ is called between each yields.
+    # 
+    # If the iteration is zero times, +separator_proc+ is not called at all.
+    # 
+    # If +separator_proc+ is nil or not given,
+    # +lambda { comma_breakable }+ is used.
+    # If +iter_method+ is not given, :each is used.
+    # 
+    # For example, following 3 code fragments has similar effect.
+    # 
+    #   q.seplist([1,2,3]) {|v| xxx v }
+    # 
+    #   q.seplist([1,2,3], lambda { comma_breakable }, :each) {|v| xxx v }
+    # 
+    #   xxx 1
+    #   q.comma_breakable
+    #   xxx 2
+    #   q.comma_breakable
+    #   xxx 3
+    def seplist(list, sep=nil, iter_method=:each) # :yield: element
+      sep ||= lambda { comma_breakable }
+      first = true
+      list.__send__(iter_method) {|*v|
+        if first
+          first = false
+        else
+          sep.call
+        end
+        yield(*v)
+      }
+    end
+ 
+    def pp_object(obj)
+      object_address_group(obj) {
+        seplist(obj.pretty_print_instance_variables, lambda { text ','.green }) {|v|
+          breakable
+          v = v.to_s if Symbol === v
+          text v
+          text '='
+          group(1) {
+            breakable ''
+            pp(obj.instance_eval(v))
+          }
+        }
+      }
+    end
+ 
+    def pp_hash(obj)
+      group(1, '{'.green, '}'.green) {
+        seplist(obj, nil, :each_pair) {|k, v|
+          group {
+            pp k
+            text '=>'.blue
+            group(1) {
+              breakable ''
+              pp v
+            }
+          }
+        }
+      }
+    end
+  end
+ 
+  include PPMethods
+ 
+  class SingleLine < PrettyPrint::SingleLine
+    include PPMethods
+  end
+ 
+  module ObjectMixin
+    # 1. specific pretty_print
+    # 2. specific inspect
+    # 3. specific to_s if instance variable is empty
+    # 4. generic pretty_print
+ 
+    # A default pretty printing method for general objects.
+    # It calls #pretty_print_instance_variables to list instance variables.
+    # 
+    # If +self+ has a customized (redefined) #inspect method,
+    # the result of self.inspect is used but it obviously has no
+    # line break hints.
+    # 
+    # This module provides predefined #pretty_print methods for some of
+    # the most commonly used built-in classes for convenience.
+    def pretty_print(q)
+      if /\(Kernel\)#/ !~ Object.instance_method(:method).bind(self).call(:inspect).inspect
+        q.text self.inspect.yellow.bold
+      elsif /\(Kernel\)#/ !~ Object.instance_method(:method).bind(self).call(:to_s).inspect && instance_variables.empty?
+        q.text self.to_s
+      else
+        q.pp_object(self)
+      end
+    end
+ 
+    # A default pretty printing method for general objects that are
+    # detected as part of a cycle.
+    def pretty_print_cycle(q)
+      q.object_address_group(self) {
+        q.breakable
+        q.text '...'.green
+      }
+    end
+ 
+    # Returns a sorted array of instance variable names.
+    # 
+    # This method should return an array of names of instance variables as symbols or strings as:
+    # +[:@a, :@b]+.
+    def pretty_print_instance_variables
+      instance_variables.sort
+    end
+ 
+    # Is #inspect implementation using #pretty_print.
+    # If you implement #pretty_print, it can be used as follows.
+    # 
+    #   alias inspect pretty_print_inspect
+    #
+    # However, doing this requires that every class that #inspect is called on
+    # implement #pretty_print, or a RuntimeError will be raised.
+    def pretty_print_inspect
+      if /\(PP::ObjectMixin\)#/ =~ Object.instance_method(:method).bind(self).call(:pretty_print).inspect
+        raise "pretty_print is not overridden for #{self.class}"
+      end
+      PP.singleline_pp(self, '')
+    end
+  end
+end
+ 
+class << ENV
+  def pretty_print(q)
+    q.pp_hash self
+  end
+end
+ 
+# :enddoc:
+if __FILE__ == $0
+  require 'test/unit'
+ 
+end
+
+

data/pp-colour.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pp-colour}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stefan Penner"]
+  s.date = %q{2009-11-26}
+  s.description = %q{colourized version of the builtin pp}
+  s.email = %q{stefan.penner@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/pp-colour.rb",
+     "lib/pp-colour/array.rb",
+     "lib/pp-colour/file.rb",
+     "lib/pp-colour/hash.rb",
+     "lib/pp-colour/kernel.rb",
+     "lib/pp-colour/matchdata.rb",
+     "lib/pp-colour/object.rb",
+     "lib/pp-colour/other.rb",
+     "lib/pp-colour/range.rb",
+     "lib/pp-colour/string.rb",
+     "lib/pp-colour/struct.rb",
+     "lib/pp-colour/temp.rb",
+     "pp-colour.gemspec",
+     "test/helper.rb",
+     "test/setup.rb",
+     "test/test_test.rb"
+  ]
+  s.homepage = %q{http://github.com/stefanpenner/pp-colour}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{colourized pp}
+  s.test_files = [
+    "test/helper.rb",
+     "test/setup.rb",
+     "test/test_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..','lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'pp-colour'
+require 'setup'
+
+class Test::Unit::TestCase
+end
+

data/test/setup.rb

@@ -0,0 +1,46 @@
+class HasInspect
+  def initialize(a)
+    @a = a
+  end
+ 
+  def inspect
+    return "<inspect:#{@a.inspect}>"
+  end
+end
+ 
+class HasPrettyPrint
+  def initialize(a)
+    @a = a
+  end
+ 
+  def pretty_print(q)
+    q.text "<pretty_print:"
+    q.pp @a
+    q.text ">"
+  end
+end
+ 
+class HasBoth
+  def initialize(a)
+    @a = a
+  end
+ 
+  def inspect
+    return "<inspect:#{@a.inspect}>"
+  end
+ 
+  def pretty_print(q)
+    q.text "<pretty_print:"
+    q.pp @a
+    q.text ">"
+  end
+end
+ 
+class PrettyPrintInspect < HasPrettyPrint
+  alias inspect pretty_print_inspect
+end
+ 
+class PrettyPrintInspectWithoutPrettyPrint
+  alias inspect pretty_print_inspect
+end
+

data/test/test_test.rb

@@ -0,0 +1,135 @@
+require 'helper'
+
+class TestPPColour < Test::Unit::TestCase
+  def test_list0123_12
+    assert_equal("[0, 1, 2, 3]\n", PP.pp([0,1,2,3], '', 12))
+  end
+ 
+  def test_list0123_11
+    assert_equal("[0,\n 1,\n 2,\n 3]\n", PP.pp([0,1,2,3], '', 11))
+  end
+ 
+  OverriddenStruct = Struct.new("OverriddenStruct", :members, :class)
+  def test_struct_override_members # [ruby-core:7865]
+    a = OverriddenStruct.new(1,2)
+    assert_equal("#<struct Struct::OverriddenStruct members=1, class=2>\n", PP.pp(a, ''))
+  end
+ 
+  def test_redefined_method
+    o = ""
+    def o.method
+    end
+    assert_equal(%(""\n), PP.pp(o, ""))
+  end
+end
+ 
+class PPInspectTest < Test::Unit::TestCase
+  def test_hasinspect
+    a = HasInspect.new(1)
+    assert_equal("<inspect:1>\n", PP.pp(a, ''))
+  end
+ 
+  def test_hasprettyprint
+    a = HasPrettyPrint.new(1)
+    assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
+  end
+ 
+  def test_hasboth
+    a = HasBoth.new(1)
+    assert_equal("<pretty_print:1>\n", PP.pp(a, ''))
+  end
+ 
+  def test_pretty_print_inspect
+    a = PrettyPrintInspect.new(1)
+    assert_equal("<pretty_print:1>", a.inspect)
+    a = PrettyPrintInspectWithoutPrettyPrint.new
+    assert_raise(RuntimeError) { a.inspect }
+  end
+ 
+  def test_proc
+    a = proc {1}
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+  end
+ 
+  def test_to_s_with_iv
+    a = Object.new
+    def a.to_s() "aaa" end
+    a.instance_eval { @a = nil }
+    result = PP.pp(a, '')
+    assert_equal("#{a.inspect}\n", result)
+    assert_match(/\A#<Object.*>\n\z/m, result)
+    a = 1.0
+    a.instance_eval { @a = nil }
+    result = PP.pp(a, '')
+    assert_equal("#{a.inspect}\n", result)
+  end
+  
+  def test_to_s_without_iv
+    a = Object.new
+    def a.to_s() "aaa" end
+    result = PP.pp(a, '')
+    assert_equal("#{a.inspect}\n", result)
+    assert_equal("aaa\n", result)
+  end
+end
+ 
+class PPCycleTest < Test::Unit::TestCase
+  def test_array
+    a = []
+    a << a
+    assert_equal("[[...]]\n", PP.pp(a, ''))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+  end
+ 
+  def test_hash
+    a = {}
+    a[0] = a
+    assert_equal("{0=>{...}}\n", PP.pp(a, ''))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+  end
+ 
+  S = Struct.new("S", :a, :b)
+  def test_struct
+    a = S.new(1,2)
+    a.b = a
+    assert_equal("#<struct Struct::S a=1, b=#<struct Struct::S:...>>\n", PP.pp(a, ''))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+  end
+ 
+  def test_object
+    a = Object.new
+    a.instance_eval {@a = a}
+    assert_equal(a.inspect + "\n", PP.pp(a, ''))
+  end
+ 
+  def test_anonymous
+    a = Class.new.new
+    assert_equal(a.inspect + "\n", PP.pp(a, ''))
+  end
+ 
+  def test_withinspect
+    a = []
+    a << HasInspect.new(a)
+    assert_equal("[<inspect:[...]>]\n", PP.pp(a, ''))
+    assert_equal("#{a.inspect}\n", PP.pp(a, ''))
+  end
+ 
+  def test_share_nil
+    begin
+      PP.sharing_detection = true
+      a = [nil, nil]
+      assert_equal("[nil, nil]\n", PP.pp(a, ''))
+    ensure
+      PP.sharing_detection = false
+    end
+  end
+end
+ 
+class PPSingleLineTest < Test::Unit::TestCase
+  def test_hash
+    assert_equal("{1=>1}", PP.singleline_pp({ 1 => 1}, '')) # [ruby-core:02699]
+    assert_equal("[1#{', 1'*99}]", PP.singleline_pp([1]*100, ''))
+  end
+end
+ 
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: pp-colour
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stefan Penner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-26 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: colourized version of the builtin pp
+email: stefan.penner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/pp-colour.rb
+- lib/pp-colour/array.rb
+- lib/pp-colour/file.rb
+- lib/pp-colour/hash.rb
+- lib/pp-colour/kernel.rb
+- lib/pp-colour/matchdata.rb
+- lib/pp-colour/object.rb
+- lib/pp-colour/other.rb
+- lib/pp-colour/range.rb
+- lib/pp-colour/string.rb
+- lib/pp-colour/struct.rb
+- lib/pp-colour/temp.rb
+- pp-colour.gemspec
+- test/helper.rb
+- test/setup.rb
+- test/test_test.rb
+has_rdoc: true
+homepage: http://github.com/stefanpenner/pp-colour
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: colourized pp
+test_files: 
+- test/helper.rb
+- test/setup.rb
+- test/test_test.rb