wirble 0.1.2

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (C) 2002-2006 Paul Duncan
+ 
+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 of the Software, its documentation and marketing & publicity 
+materials, and acknowledgment shall be given in the documentation, materials
+and software packages that this Software was used.
+   
+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 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/ChangeLog

@@ -0,0 +1,29 @@
+
+* Wed Sep 06 00:01:21 2006, pabs <pabs@pablotron.org>
+  * initial import
+
+* Wed Sep 06 00:10:13 2006, pabs <pabs@pablotron.org>
+  * wirble.rb: remove symbol hackery to prevent
+    ri/rdoc from barfing
+
+* Wed Sep  6 02:49:02 EDT 2006, Paul Duncan <pabs@pablotron.org>
+  * wirble.rb: fix typo
+  * re-release 0.1.0
+
+* Fri Sep  8 04:01:40 EDT 2006, Paul Duncan <pabs@pablotron.org>
+  * README: updated version to 0.1.1
+  * wirble.gemspec: ditto
+  * wirble.rb: ditto
+  * wirble.rb: wrap colorize in an exception (just in case)
+
+* Fri Sep 08 13:11:05 2006, pabs <pabs@pablotron.org>
+  * increment version to 0.1.2
+  * wirble.gemspec: remove rubilicious dependency
+
+* Fri Sep  8 13:17:29 EDT 2006, Paul Duncan <pabs@pablotron.org>
+  * README: increment version to 0.1.2
+  * wirble.gemspec: ditto
+  * wirble.rb: ditto
+
+* Fri Sep 08 13:18:15 2006, pabs <pabs@pablotron.org>
+  * releasing 0.1.2

data/README

@@ -0,0 +1,433 @@
+Wirble 0.1.2 README
+===================
+
+This document was last updated on Fri Sep 08 13:16:55 2006.  See the
+file COPYING for licensing and warranty information.  The latest version
+of this software is available at the following URL:
+
+    http://pablotron.org/software/wirble/
+
+Table of Contents
+=================
+  * Introduction to Wirble
+  * Installing Wirble
+      o Via RubyGems
+      o Via a Tarball
+      o As a User
+  * Using Wirble
+      o Editing Your ~/.irbrc
+      o Enabling Color
+  * Configuring Wirble
+  * Color Settings
+      o Color Keys
+      o Color Values
+      o Default Color Map
+  * Frequently Asked Questions (FAQ)
+  * Reporting Bugs
+  * About the Author
+
+
+Introduction to Wirble
+======================
+Wirble is a set of enhancements to Irb all included together in one
+easy-to-use package.  Specifically, Wirble adds a saved history, a
+couple of useful shortcuts, and color to Irb.  Wirble also enables a
+Irb's built-in tab-completion and a simpler prompt.
+
+Before we begin, I should mention that several of Wirble's features were
+shamelessly inspired (read: borrowed with extreme prejudice) from the
+"Irb Tips and Tricks" page of the Ruby Garden Wiki, which you can find
+at the following URL:
+
+    http://wiki.rubygarden.org/Ruby/page/show/Irb/TipsAndTricks
+
+In particular, the Irb history and ri features bear a striking
+resemblence to their Ruby Garden counterparts.
+
+
+Installing Wirble
+=================
+The easiest way to install Wirble is via RubyGems
+(http://rubygems.org/).  If you've already got RubyGems installed,
+simply do the following, then skip to the "Using Wirble" section below:
+
+    # install wirble via RubyGems
+    sudo gem install wirble
+
+If you don't have RubyGems, you can also install the Wirble library
+this:
+
+    # install wirble to library directory
+    sudo cp -v wirble.rb $(ruby -e 'puts $LOAD_PATH[0]')
+
+Or, if you don't use sudo, you can do the same thing with su, like so:
+
+    # install wirble to library directory
+    su -c "cp -v wirble.rb $(ruby -e 'puts $LOAD_PATH[0]')"
+
+Finally, if you don't have an administrator account, you can still
+install Wirble in your local home directory like so:
+
+    # create local ruby library directory
+    mkdir ~/.ruby && chmod 700 ~/.ruby
+    cp -v wirble.rb ~/.ruby
+
+Then add the following line at the _top_ of your ~/.irbrc file:
+
+    # add ~/.ruby to the library search path
+    $LOAD_PATH << File.expand_path('~/.ruby')
+
+
+Using Wirble
+============
+Using Wirble is easy: just add the following lines to your ~/.irbrc
+file:
+
+    # load rubygems and wirble
+    require 'rubygems' rescue nil
+    require 'wirble'
+
+    # load wirble
+    Wirble.init
+
+A lot of people really don't like colors, so I've kept the color
+disabled by default.  To enable it, add the following bit to your
+~/.irbrc file after "Wirble.init":
+
+    # enable color
+    Wirble.colorize
+
+If you want to terrify your grandmother and impress your buddies, your
+entire ~/.irbrc can also be written like so:
+
+    %w{rubygems wirble}.each { |lib| require lib rescue nil }
+    %w{init colorize}.each { |str| Wirble.send(str.intern) }
+
+Configuring Wirble
+==================
+You can pass a hash of options to Wirble.init in order to adjust the
+behavior of Wirble.  Here's a full list of options and a brief
+description of each one:
+
+  * :skip_internals
+
+    Don't load the internal Irb features.  Equivalent to setting both
+    :skip_libraries and :skip_prompt (see below).
+
+  * :skip_libraries
+
+    Don't load any libraries.  At the moment, Wirble attempts to load
+    the following libraries: "pp", "irb/completion", and "rubygems".
+
+  * :skip_prompt
+
+    Down't load the simple prompt.  Shouldn't ever be necessary, but
+    I've included it for the sake of completeness.  Wirble's default
+    behavior is to the prompt setting before making any changes.  If the
+    prompt is anything other than :DEFAULT, Wirble won't override it.
+
+  * :skip_history
+
+    Don't load the Irb history.  There are a few additional history
+    options as well; see :history_path, :history_size, and
+    :history_perms below.
+
+  * :history_path 
+
+    Set the path to the Irb history file.  Defaults to "~/.irb_history".
+    If an environment variable named IRB_HISTORY_FILE is set, Wirble
+    will use that instead of the default value.
+
+  * :history_size
+
+    Set the size (in lines) of the Irb history file.  Defaults to 1000
+    lines.  If an environment variable named IRB_HISTORY_SIZE is set,
+    Wirble will use that instead of the default value.
+
+  * :history_perms
+
+    Set the permissions of the Irb history file.  Defaults to
+    File::WRONLY.
+
+  * :skip_shortcuts
+
+    Don't load any shortcut methods.  at the moment there are three
+    shortcut methods: "ri", "po", and "poc". The first calls the "ri"
+    command on the specified value -- you"ll need to use proper quoting
+    to pass the name properly.  As for "po" and "poc": the former lists
+    an object's instance methods (excluding methods that belong to
+    Object), sorted by name, and the latter lists an object's constants,
+    sorted by name.
+
+  * :init_colors
+
+    Enable colors.  Equivalent to calling Wirble.colorize directly.
+
+  * :colors
+
+    A hash of colors.  Only makes sense in conjunction with the
+    :init_colors option.  See below for additional information on
+    customizing color settings.
+ 
+Here's an example of passing a list of options to Wirble.init():
+
+    wirble_opts = {
+      # skip shortcuts
+      :skip_shortcuts => true,
+
+      # don't set the prompt
+      :skip_prompt    => true,
+
+      # override some of the default colors
+      :colors => {
+        :open_hash    => :green.
+        :close_hash   => :green.
+        :string       => :blue,
+      },
+
+      # enable color
+      :init_color     => true,
+    }
+
+    # initialize wirble with options above
+    Wirble.init(wirble_opts)
+
+For a full description of the color options, see the next section.
+
+
+Color Settings
+==============
+You can set colors in Wirble by passing a hash of color options via
+Wirble.init (see the :color option for Wirble.init above), or by setting
+Wirble::Colorize.color directly.  For example:
+
+    # get the default colors and add in your own
+    colors = Wirble::Colorize.colors.merge({
+      # set the comma color to blue
+      :comma => :blue,
+    })
+
+    # set the colors used by Wirble
+    Wirble::Colorize.colors = colors
+
+Below is a list of all the recognized color keys.  
+ 
+  * :comma (',')
+
+    A comma character.  The element delimiter in arrays and hashes.
+
+  * :refers ('=>')
+
+    The hash reference operator.  The key/value delimiter in hashes.
+
+  * :open_hash ('{')
+
+    The opening curly brace for a hash.
+
+  * :close_hash ('}')
+
+    The opening curly brace for a hash.
+
+  * :open_array ('[')
+
+    The opening brace for a array.
+
+  * :close_array (']')
+
+    The opening brace for a array.
+
+  * :open_object ('#<')
+
+    The opening delimiter for an object.
+
+  * :close_object ('>')
+
+    The closing delimiter for an object inspection.
+
+  * :object_class 
+
+    The class attribute of an object inspection.  For example, in the
+    string "#<Proc:0xb7be4968@(irb):8>", the string "Proc" is the class
+    attribute.
+
+  * :object_addr_prefix (':')
+
+    The colon prefixing the address attribute of an object inspection.
+    For example, in the string "#<Proc:0xb7be4968@(irb):8>", the string
+    "0xb7be4968" is the memory address attribute, so the ':' is the
+    address prefix.
+
+  * :object_addr
+
+    The memory address attribute of an object inspection.  For example,
+    in the string "#<Proc:0xb7be4968@(irb):8>", the string "0xb7be4968"
+    is the memory address attribute.
+
+  * :object_addr_prefix ('@')
+
+    The at symbol prefixing the line attribute of an object inspection.
+    For example, in the string "#<Proc:0xb7be4968@(irb):8>", the string
+    "(irb):8" is the line attribute, so the '@' is the line attribute
+    prefix.
+
+  * :object_line
+
+    The line number attribute of an object inspection.  For example,
+    in the string "#<Proc:0xb7be4968@(irb):8>", the string "(irb):8"
+    is the line number attribute.
+
+  * :symbol_prefix (':')
+
+    The colon prefix for a symbol object.
+
+  * :symbol 
+
+    The string of a symbol object.
+
+  * :open_string ('"')
+
+    The opening quote of a string object.
+
+  * :close_string ('"')
+
+    The closing quote of a string object.
+
+  * :number
+
+    A number (integer or float).
+
+  * :range ('..')
+
+    The delimeter of a range object.
+
+  * :keyword
+
+    A built-in Ruby keyword.  This includes values like "true", "false",
+    and "nil".
+
+  * :class
+    
+    A class.  This includes strings like "Class" and "Object".
+
+  * :whitespace
+
+    Whitespace character (i.e. space, newline, tab, etc).
+
+The highlighting is implemented with a simple hand-rolled state-based
+tokenizer (wow, that was a mouthful).  This should be adequate most of
+the time, but since it's not a actual LALR parser, Wirble can get
+confused in a few specific instances.  If you find a serious
+highlighting problem, please let me know.  Oh yeah, before I forget,
+here's a list of the valid color codes:
+
+        :nothing        :green            :light_purple
+        :black          :light_blue       :purple
+        :blue           :light_cyan       :red
+        :brown          :light_gray       :white
+        :cyan           :light_green      :yellow
+        :dark_gray      :light_red
+
+Note that I'm not a designer, and I also use a terminal with a dark
+background.  I've also been accused of having a Vim color scheme that
+looks like "a beat up clown".  With those caveats in mind, here's the
+default color scheme for Wirble:
+
+    #
+    # Default Wirble color scheme.
+    # 
+    DEFAULT_COLORS = {
+      # delimiter colors
+      :comma              => :blue,
+      :refers             => :blue,
+
+      # container colors (hash and array)
+      :open_hash          => :green,
+      :close_hash         => :green,
+      :open_array         => :green,
+      :close_array        => :green,
+
+      # object colors
+      :open_object        => :light_red,
+      :object_class       => :white,
+      :object_addr_prefix => :blue,
+      :object_line_prefix => :blue,
+      :close_object       => :light_red,
+
+      # symbol colors
+      :symbol             => :yellow,
+      :symbol_prefix      => :yellow,
+
+      # string colors
+      :open_string        => :red,
+      :string             => :cyan,
+      :close_string       => :red,
+
+      # misc colors
+      :number             => :cyan,
+      :keyword            => :green,
+      :class              => :light_green,
+      :range              => :red,
+    }
+
+This map is also available via programmatically via
+Wirble::Colorize::DEFAULT_COLORS.
+
+
+Frequently Asked Questions (FAQ)
+================================
+Q.  Where did the name come from?
+A.  Beats me.  It's the only thing I could find in the dictionary, and
+    the only name I came up with that I could pronounce.
+
+Q.  How do I use color in my Irb prompts?
+A.  You can use standard color escape codes in the format string used by
+    Irb.  For example, to set the user prompt to cyan, you could do
+    something like this:
+
+        ctx = IRB.CurrentContext
+        ctx.prompt_i = Wirble::Colorize.colorize_string(ctx.prompt_i, :cyan)
+
+Q.  How can I do syntax highlighting as I type?
+A.  I don't know.  If there is an answer, I suspect it's not very
+    portable and probably requires some modification to Irb.  There's a
+    sneaky hack called eval.rb that seems to do a little bit of
+    highlight, but it doesn't use Irb, and it doesn't really do what
+    you're asking.  That said, you can find it here:
+
+        http://www.rubyist.net/~slagell/ruby/eval.txt
+
+    Incidentally, part of the problem is that there's no real easy way
+    to do the following:
+
+        1.  Access to the token stream or parser state incrementally.
+        2.  Process partial strings in readline.
+        
+    A bit more about #1:  both Irb and the internal Ruby lexer kind of
+    muddle the traditionally separate concepts of lexer and parser, so
+    it's difficult to, say, parse a string into components and do syntax
+    highlighting on them.  Vim and Emacs both handle this with sneaky
+    regular expressions, and a simple Ruby parser, respectively.  Wirble
+    and Irb both roll their own (albeit limited) Ruby lexers.
+
+
+Reporting Bugs
+==============
+Have a bug to report or a feature you'd like me to add to Wirble?
+Feel free to email me at the address below.  Alternatively, you can
+submit your feature request or bug directly to my bug-tracking web
+interface at the following URL:
+
+    http://bugs.pablotron.org/
+
+Note: you'll need to create an account in order to submit a feature
+request or a bug report via the web interface.  Also, I'm a busy guy!  I
+make every effort to respond quickly to bug reports, but detailed
+descriptions and or patches really do make my life a whole lot easier.
+
+
+About the Author
+================
+Paul Duncan <pabs@pablotron.org>
+http://pablotron.org/
+
+And of course, all the fine folks from the Ruby Garden Wiki. :)

data/wirble.gemspec

@@ -0,0 +1,54 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+
+  #### Basic information.
+
+  s.name = 'wirble'
+  s.version = '0.1.2'
+  s.summary = <<-EOF
+    Handful of common Irb features, made easy.
+  EOF
+  s.description = <<-EOF
+    A handful of useful Irb features, including colorized results,
+    tab-completion, history, a simple prompt, and several helper
+    methods, all rolled into one easy to use package.
+  EOF
+
+  s.requirements << 'Ruby, version 1.8.0 (or newer)'
+
+  #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
+
+  s.files = Dir.glob("**/*").delete_if { |item| item.include?("CVS") }
+
+  #### C code extensions.
+
+  s.require_path = '.' # is this correct?
+  # s.extensions << "extconf.rb"
+
+  #### Load-time details: library and application (you will need one or both).
+  s.autorequire = 'wirble'
+  s.has_rdoc = true
+  s.rdoc_options = ['--webcvs',
+  'http://cvs.pablotron.org/cgi-bin/viewcvs.cgi/wirble/', '--title',
+  'Wirble API Documentation', 'wirble.rb', 'README', 'ChangeLog',
+  'COPYING']
+
+  #### Author and project details.
+
+  s.author = 'Paul Duncan'
+  s.email = 'pabs@pablotron.org'
+  s.homepage = 'http://pablotron.org/software/wirble/'
+  s.rubyforge_project = 'wirble'
+
+
+
+  # Add this shit to teh bottom of gem files for signing:
+  # TODO: move ~/.rubygems to ~/.gem/sign or something
+
+  s.cert_chain = %w{ca rubygems}.map { |f|
+    File.expand_path("~/.rubygems/#{f}.crt")
+  }
+  s.signing_key = File.expand_path('~/.rubygems/rubygems.key')
+
+end

data/wirble.rb

@@ -0,0 +1,519 @@
+require 'ostruct'
+
+#
+# Wirble: A collection of useful Irb features.
+#
+# To use, add the following to your ~/.irbrc:
+#
+#   require 'rubygems'
+#   require 'wirble'
+#   Wirble.init
+#
+# If you want color in Irb, add this to your ~/.irbrc as well:
+#
+#   Wirble.colorize
+#
+# Note:  I spent a fair amount of time documenting this code in the
+# README.  If you've installed via RubyGems, root around your cache a
+# little bit (or fire up gem_server) and read it before you tear your
+# hair out sifting through the code below.
+# 
+module Wirble
+  VERSION = '0.1.2'
+
+  #
+  # Load internal Ruby features, including tab-completion, rubygems,
+  # and a simple prompt.
+  #
+  module Internals
+    # list of internal libraries to automatically load
+    LIBRARIES = %w{pp irb/completion rubygems}
+
+    #
+    # load tab completion and rubygems
+    #
+    def self.init_libraries
+      LIBRARIES.each { |lib| require lib rescue nil }
+    end
+
+    #
+    # Set a simple prompt, unless a custom one has been specified.
+    #
+    def self.init_prompt
+      # set the prompt
+      if IRB.conf[:PROMPT_MODE] == :DEFAULT
+        IRB.conf[:PROMPT_MODE] = :SIMPLE
+      end
+    end
+
+    #
+    # Load all Ruby internal features.
+    #
+    def self.init(opt = nil)
+      init_libraries unless opt && opt[:skip_libraries]
+      init_prompt unless opt && opt[:skip_prompt]
+    end
+  end
+
+  #
+  # Basic IRB history support.  This is based on the tips from 
+  # http://wiki.rubygarden.org/Ruby/page/show/Irb/TipsAndTricks
+  #
+  class History
+    DEFAULTS = {
+      :history_path   => ENV['IRB_HISTORY_FILE'] || "~/.irb_history",
+      :history_size   => (ENV['IRB_HISTORY_SIZE'] || 1000).to_i,
+      :history_perms  => File::WRONLY | File::CREAT | File::TRUNC,
+    }
+ 
+    private
+
+    def say(*args)
+      puts *args if @verbose
+    end
+
+    def cfg(key)
+      @opt["history_#{key}".intern]
+    end
+
+    def save_history
+      path, max_size, perms = %w{path size perms}.map { |v| cfg(v) }
+
+      # read lines from history, and truncate the list (if necessary)
+      lines = Readline::HISTORY.to_a.uniq
+      lines = lines[-max_size, -1] if lines.size > max_size
+
+      # write the history file
+      real_path = File.expand_path(path)
+      File.open(real_path, perms) { |fh| fh.puts lines }
+      say 'Saved %d lines to history file %s.' % [lines.size, path]
+    end
+
+    def load_history
+      # expand history file and make sure it exists
+      real_path = File.expand_path(cfg('path'))
+      unless File.exist?(real_path)
+        say "History file #{real_path} doesn't exist."
+        return
+      end
+
+      # read lines from file and add them to history
+      lines = File.readlines(real_path).map { |line| line.chomp }
+      Readline::HISTORY.push(*lines)
+
+      say 'Read %d lines from history file %s' % [lines.size, cfg('path')]
+    end
+
+    public
+
+    def initialize(opt = nil)
+      @opt = DEFAULTS.merge(opt || {})
+      return unless defined? Readline::HISTORY
+      load_history
+      Kernel.at_exit { save_history }
+    end
+  end
+
+  #
+  # Add color support to IRB.
+  #
+  module Colorize
+    #
+    # Tokenize an inspection string.
+    #
+    module Tokenizer
+      def self.tokenize(str)
+        raise 'missing block' unless block_given?
+        chars = str.split(//)
+
+        # $stderr.puts "DEBUG: chars = #{chars.join(',')}"
+
+        state, val, i, lc = [], '', 0, nil
+        while i <= chars.size
+          repeat = false
+          c = chars[i]
+
+          # $stderr.puts "DEBUG: state = #{state}"
+
+          case state[-1]
+          when nil
+            case c
+            when ':': state << :symbol
+            when '"': state << :string
+            when '#': state << :object
+            when /[a-z]/i
+              state << :keyword
+              repeat = true
+            when /[0-9-]/
+              state << :number
+              repeat = true
+            when '{': yield :open_hash, '{'
+            when '[': yield :open_array, '['
+            when ']': yield :close_array, ']'
+            when '}': yield :close_hash, '}'
+            when /\s/: yield :whitespace, c
+            when ',': yield :comma, ','
+            when '>'
+              yield :refers, '=>' if lc == '='
+            when '.'
+              yield :range, '..' if lc == '.'
+            when '='
+              # ignore these, they're used elsewhere
+              nil
+            else 
+              # $stderr.puts "DEBUG: ignoring char #{c}"
+            end
+          when :symbol
+            case c
+            # XXX: should have =, but that messes up foo=>bar
+            when /[a-z0-9_!?]/
+              val << c
+            else
+              yield :symbol_prefix, ':'
+              yield state[-1], val
+              state.pop; val = ''
+              repeat = true
+            end
+          when :string
+            case c
+            when '"'
+              if lc == "\\"
+                val[-1] = ?"
+              else
+                yield :open_string, '"'
+                yield state[-1], val
+                state.pop; val = ''
+                yield :close_string, '"'
+              end
+            else
+              val << c
+            end
+          when :keyword
+            case c
+            when /[a-z0-9_]/i
+              val << c
+            else
+              # is this a class?
+              st = val =~ /^[A-Z]/ ? :class : state[-1]
+
+              yield st, val
+              state.pop; val = ''
+              repeat = true
+            end
+          when :number
+            case c
+            when /[0-9e-]/
+              val << c
+            when '.'
+              if lc == '.'
+                val[/\.$/] = ''
+                yield state[-1], val
+                state.pop; val = ''
+                yield :range, '..'
+              else
+                val << c
+              end
+            else
+              yield state[-1], val
+              state.pop; val = ''
+              repeat = true
+            end
+          when :object
+            case c
+            when '<': 
+              yield :open_object, '#<'
+              state << :object_class
+            when ':': 
+              state << :object_addr
+            when '@': 
+              state << :object_line
+            when '>'
+              yield :close_object, '>'
+              state.pop; val = ''
+            end
+          when :object_class
+            case c
+            when ':'
+              yield state[-1], val
+              state.pop; val = ''
+              repeat = true
+            else
+              val << c
+            end
+          when :object_addr
+            case c
+            when '>'
+            when '@'
+              yield :object_addr_prefix, ':'
+              yield state[-1], val
+              state.pop; val = ''
+              repeat = true
+            else
+              val << c
+            end
+          when :object_line
+            case c
+            when '>'
+              yield :object_line_prefix, '@'
+              yield state[-1], val
+              state.pop; val = ''
+              repeat = true
+            else
+              val << c
+            end
+          else
+            raise "unknown state #{state}"
+          end
+
+          unless repeat
+            i += 1
+            lc = c
+          end
+        end
+      end
+    end
+
+    #
+    # Terminal escape codes for colors.
+    #
+    module Color
+      COLORS = {
+        :nothing      => '0;0',
+        :black        => '0;30',
+        :red          => '0;31',
+        :green        => '0;32',
+        :brown        => '0;33',
+        :blue         => '0;34',
+        :cyan         => '0;36',
+        :purple       => '0;35',
+        :light_gray   => '0;37',
+        :dark_gray    => '1;30',
+        :light_red    => '1;31',
+        :light_green  => '1;32',
+        :yellow       => '1;33',
+        :light_blue   => '1;34',
+        :light_cyan   => '1;36',
+        :light_purple => '1;35',
+        :white        => '1;37',
+      }
+      
+      #
+      # Return the escape code for a given color.
+      #
+      def self.escape(key)
+        COLORS.key?(key) && "\033[#{COLORS[key]}m"
+      end
+    end
+
+    #
+    # Default Wirble color scheme.
+    # 
+    DEFAULT_COLORS = {
+      # delimiter colors
+      :comma              => :blue,
+      :refers             => :blue,
+
+      # container colors (hash and array)
+      :open_hash          => :green,
+      :close_hash         => :green,
+      :open_array         => :green,
+      :close_array        => :green,
+
+      # object colors
+      :open_object        => :light_red,
+      :object_class       => :white,
+      :object_addr_prefix => :blue,
+      :object_line_prefix => :blue,
+      :close_object       => :light_red,
+
+      # symbol colors
+      :symbol             => :yellow,
+      :symbol_prefix      => :yellow,
+
+      # string colors
+      :open_string        => :red,
+      :string             => :cyan,
+      :close_string       => :red,
+
+      # misc colors
+      :number             => :cyan,
+      :keyword            => :green,
+      :class              => :light_green,
+      :range              => :red,
+    }
+
+    #
+    # Fruity testing colors.
+    # 
+    TESTING_COLORS = {
+      :comma            => :red,
+      :refers           => :red,
+      :open_hash        => :blue,
+      :close_hash       => :blue,
+      :open_array       => :green,
+      :close_array      => :green,
+      :open_object      => :light_red,
+      :object_class     => :light_green,
+      :object_addr      => :purple,
+      :object_line      => :light_purple,
+      :close_object     => :light_red,
+      :symbol           => :yellow,
+      :symbol_prefix    => :yellow,
+      :number           => :cyan,
+      :string           => :cyan,
+      :keyword          => :white,
+      :range            => :light_blue,
+    }
+
+    #
+    # Set color map to hash
+    # 
+    def self.colors=(hash)
+      @colors = hash
+    end
+
+    #
+    # Get current color map
+    # 
+    def self.colors
+      @colors ||= {}.update(DEFAULT_COLORS)
+    end
+
+    #
+    # Return a string with the given color.
+    #
+    def self.colorize_string(str, color)
+      col, nocol = [color, :nothing].map { |key| Color.escape(key) }
+      col ? "#{col}#{str}#{nocol}" : str
+    end
+
+    #
+    # Colorize the results of inspect
+    # 
+    def self.colorize(str)
+      begin
+        ret, nocol = '', Color.escape(:nothing)
+        Tokenizer.tokenize(str) do |tok, val|
+          # c = Color.escape(colors[tok])
+          ret << colorize_string(val, colors[tok])
+        end
+        ret
+      rescue
+        # catch any errors from the tokenizer (just in case)
+        str
+      end
+    end
+
+    #
+    # Enable colorized IRB results.
+    # 
+    def self.enable(custom_colors = nil)
+      # if there's a better way to do this, I'm all ears.
+      ::IRB::Irb.class_eval do
+        alias :non_color_output_value  :output_value
+
+        def output_value
+          if @context.inspect?
+            val = Colorize.colorize(@context.last_value.inspect)
+            printf @context.return_format, val
+          else
+            printf @context.return_format, @context.last_value
+          end
+        end
+      end
+
+      colors = custom_colors if custom_colors
+    end
+
+    #
+    # Disable colorized IRB results.
+    # 
+    def self.disable
+      ::IRB::Irb.class_eval do
+        alias :output_value  :non_color_output_value
+      end
+    end
+  end
+
+  #
+  # Convenient shortcut methods.
+  #
+  module Shortcuts
+    #
+    # Print object methods, sorted by name. (excluding methods that
+    # exist in the class Object) .
+    #
+    def po(o)
+      o.methods.sort - Object.methods
+    end
+
+    #
+    # Print object constants, sorted by name.
+    #
+    def poc(o)
+      o.constants.sort
+    end
+  end
+
+  #
+  # Convenient shortcut for ri
+  #
+  module RiShortcut
+    def self.init
+      Kernel.class_eval {
+        def ri(arg)
+           puts `ri '#{arg}'`
+        end
+      }
+
+      Module.instance_eval {
+         def ri(meth=nil)
+           if meth
+             if instance_methods(false).include? meth.to_s
+               puts `ri #{self}##{meth}`
+             else
+               super
+             end
+           else
+             puts `ri #{self}`
+           end
+         end
+      }
+    end
+  end
+
+
+
+  #
+  # Enable color results.
+  #
+  def self.colorize(custom_colors = nil)
+    Colorize.enable(custom_colors)
+  end
+
+  #
+  # Load everything except color.
+  #
+  def self.init(opt = nil)
+    # make sure opt isn't nil
+    opt ||= {}
+
+    # load internal irb/ruby features
+    Internals.init(opt) unless opt && opt[:skip_internals]
+
+    # load the history
+    History.new(opt) unless opt && opt[:skip_history]
+
+    # load shortcuts
+    unless opt && opt[:skip_shortcuts]
+      # load ri shortcuts
+      RiShortcut.init
+
+      # include common shortcuts
+      Object.class_eval { include Shortcuts }
+    end
+
+    colorize(opt[:colors]) if opt && opt[:init_colors]
+  end
+end
+

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: wirble
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+date: 2006-09-08 00:00:00 -04:00
+summary: Handful of common Irb features, made easy.
+require_paths: 
+- .
+email: pabs@pablotron.org
+homepage: http://pablotron.org/software/wirble/
+rubyforge_project: wirble
+description: A handful of useful Irb features, including colorized results, tab-completion, history, a simple prompt, and several helper methods, all rolled into one easy to use package.
+autorequire: wirble
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIHRDCCBSygAwIBAgIJALaV65AlSniTMA0GCSqGSIb3DQEBBQUAMIGRMQswCQYD
+  VQQGEwJVUzERMA8GA1UECBMIVmlyZ2luaWExEjAQBgNVBAcTCUFubmFuZGFsZTES
+  MBAGA1UEChMJUGFibG90cm9uMQswCQYDVQQLEwJDQTEZMBcGA1UEAxMQY2EucGFi
+  bG90cm9uLm9yZzEfMB0GCSqGSIb3DQEJARYQY2FAcGFibG90cm9uLm9yZzAeFw0w
+  NTA3MjkwODA5MTlaFw0xNTA3MjcwODA5MTlaMIGRMQswCQYDVQQGEwJVUzERMA8G
+  A1UECBMIVmlyZ2luaWExEjAQBgNVBAcTCUFubmFuZGFsZTESMBAGA1UEChMJUGFi
+  bG90cm9uMQswCQYDVQQLEwJDQTEZMBcGA1UEAxMQY2EucGFibG90cm9uLm9yZzEf
+  MB0GCSqGSIb3DQEJARYQY2FAcGFibG90cm9uLm9yZzCCAiIwDQYJKoZIhvcNAQEB
+  BQADggIPADCCAgoCggIBAKkvfnVeuIqI6seCVnVG949P3iL0YVfalkeSIto0Z18e
+  H9VDPtpEsK3rWFY0Fh+BL+G86IU0Pg0ers9JFeuBZBJf00/P9F4In+I04kvUUFFk
+  WnV+E6RGyMxRIOJblVfNVEQs0xLRqGtgwqosxfDs3sTNkdJMxEHJGOqbr5miATv9
+  lWQSSfSiEj6kFBNhHN+Lsde36YFJFLp/ATw/J3chpjqdmFDzDlBub/3usZENJTWc
+  u7JmxIFDLGeR/0lcgYGGEquu66mzjOILDwQTXWGGMnjkcdEzmhYfrTBc4lpXxITk
+  F9vXd1iu9iSjf4zQGtxIqW3PN8UVzsoKiAhu9UcInoX6lF4HS23cfrATG/eqzdWn
+  icUrJKIhGT9+i6mnQgGXXduUitrKGTpL27+PYelExRbL7eD/a61OvOKHdO0hwpMq
+  AedWDDPBwZ+xKmVkR1fzxBVAPYiydEugwO9mbLb/vTkDCZ1YJUrWsebaKcrKji67
+  QDgT8EiPNUie+KHnsXA4kbiTh5sgNISVaUikqZtbOw+NjsdbzfOC2e11787Ny5lp
+  2zrPuAH8xWd/PIHPPR7+8TNJw0aGkLqOvAwBkcxPYQxUM+zm3eoLeSOgK6hhevN6
+  3oGFcA4PYw7wolnzQOEOb4EG1EpzBResYRz7op6J8itp9gq1AVlsjdSnVll2ltcr
+  AgMBAAGjggGbMIIBlzAdBgNVHQ4EFgQUIPJy81wR7jiFGawew2x1akQE6xIwgcYG
+  A1UdIwSBvjCBu4AUIPJy81wR7jiFGawew2x1akQE6xKhgZekgZQwgZExCzAJBgNV
+  BAYTAlVTMREwDwYDVQQIEwhWaXJnaW5pYTESMBAGA1UEBxMJQW5uYW5kYWxlMRIw
+  EAYDVQQKEwlQYWJsb3Ryb24xCzAJBgNVBAsTAkNBMRkwFwYDVQQDExBjYS5wYWJs
+  b3Ryb24ub3JnMR8wHQYJKoZIhvcNAQkBFhBjYUBwYWJsb3Ryb24ub3JnggkAtpXr
+  kCVKeJMwDwYDVR0TAQH/BAUwAwEB/zARBglghkgBhvhCAQEEBAMCAQYwCQYDVR0S
+  BAIwADAgBglghkgBhvhCAQ0EExYRUGFibG90cm9uIFJvb3QgQ0EwLwYJYIZIAYb4
+  QgEDBCIWIGh0dHA6Ly9jYS5wYWJsb3Ryb24ub3JnL3Jvb3QuY3JsMBsGA1UdEQQU
+  MBKBEGNhQHBhYmxvdHJvbi5vcmcwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEB
+  BQUAA4ICAQAwmQpJEFByJM6z1yL6GApYkGxqfVmNNsaSwKD+k1VZt2OQV8DToT/l
+  kMCYJU6wUHTQMDiCY0JDaKmWHGzr2taga9J5mFsUePSjFWgt49KG3FBJUP1ebDIJ
+  /leqcMFmFJMBTj05m3aZoTx/tP0vvGxkgzhiV5bYqKtB4hpRCwLJP9ToNhUjexlN
+  WiUU3RU2QglZi+bvHfprq8/DOEn/blhM7BYNHRErj25YgywuaB1e4gUU3hafoG1O
+  nwh+fcsNfF0F4SKocqdkEFH+p5O4iwopvJhjc4c80cg6hmXflNn9iIc6sdtxKiFa
+  QhpkgQJTDrZCDGk1gMNjjyqfK9um7UURWO1f15hsQkXkWq1C0LIe7u3fuZwlz3G8
+  CdQR/ao0P7b7adggmY+J7lJVC/bYg4Xo0zwvtMWYDx8PxHpva7QZ9HmiGNPSoAjn
+  lRvjzUhJYYJBpgh0aF6GiocqG+sSfzJoWoyYlNhVK7NeDKDDD2e2b8Tsv+8gDc/h
+  iKVCv5/Cfq70AkcxbNj09jU7Oh6hy7sYUwxSEF7hUgrkipp4HR/ET+Mu2FeqAaDZ
+  pJQyevxgIYV9g9j/GfPeNkgH5Q/WJycWktPaijhr1RFHVKqaj4E04ET3XQ6QyR+Q
+  JF4DfILMWJLc89ONPLbGISSMzZGviKyQXpSroLyHCccbJb4ncyc8uQ==
+  -----END CERTIFICATE-----
+
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIHMTCCBRmgAwIBAgIBAzANBgkqhkiG9w0BAQUFADCBkTELMAkGA1UEBhMCVVMx
+  ETAPBgNVBAgTCFZpcmdpbmlhMRIwEAYDVQQHEwlBbm5hbmRhbGUxEjAQBgNVBAoT
+  CVBhYmxvdHJvbjELMAkGA1UECxMCQ0ExGTAXBgNVBAMTEGNhLnBhYmxvdHJvbi5v
+  cmcxHzAdBgkqhkiG9w0BCQEWEGNhQHBhYmxvdHJvbi5vcmcwHhcNMDYwODMxMDU1
+  ODM4WhcNMDgwODMwMDU1ODM4WjCBnTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZp
+  cmdpbmlhMRIwEAYDVQQHEwlBbm5hbmRhbGUxEjAQBgNVBAoTCVBhYmxvdHJvbjEL
+  MAkGA1UECxMCQ0ExHzAdBgNVBAMTFlBhdWwgRHVuY2FuIChydWJ5Z2VtcykxJTAj
+  BgkqhkiG9w0BCQEWFnJ1YnlnZW1zQHBhYmxvdHJvbi5vcmcwggIiMA0GCSqGSIb3
+  DQEBAQUAA4ICDwAwggIKAoICAQCpEOGkHV/vH9ySYE9U3vGxG1vISP4EWFRUEez6
+  NbQcJs/m+KXXXoyBMD4QD8iIK3GynTgHCFVkMwRsaiC8nj5CPASoEEjC8Xy+r3lt
+  zvIRtkUqxZG9NNfmKLbkm88O/7K1Gv0bhdADTa9EbhyvOJ6kZB0XxjjCoV/mYbFw
+  DG1MToAu8JrfABO/rwUyw4nKeteWymYc5Wx/JmSXEjJaHqryF/vJiDdg4Mvf6I1x
+  siOjuhtTAN8dJn+rhcqA1kPzu0lNx0FxYCsPJa1Y1GJLg0mfd+Hnku30NgsHrrl+
+  wm2iFYVbvL7hD/o7fwPctl21AuTjy5YUyjxK9LOHvNtrssfah+8CSaa8FyVe89pw
+  J4o6iFp8wDWJHj0C4Rt8m/9Vra9sqei73IIW5VAuSRK3e8TB/dP3UQI7BxjkyAMS
+  MIkDnOV1EHugT59CUV0VDHaXBzfdVpFHXOHn1jFm5/G7pkNEMFq7l9CSJZ9EGAsI
+  j3HZlfnDLono+fL/PNo1lXJ5Stylrqpa40LESuaGl5q+MfNvJqrGr2iplRup3y7P
+  mzhAz08zSdcvsyPQSRXfW8umFn2iDxcvAEulTXyQP33eX5lr9vaCUq+BCKVuiWYW
+  sQehEn5NiNdcbXxpvoqrD/Kl28652Sv7svKenArFcAtsOL3j8kl0nzxLVkyKumz7
+  4oeNdwIDAQABo4IBhDCCAYAwCQYDVR0TBAIwADARBglghkgBhvhCAQEEBAMCBLAw
+  KwYJYIZIAYb4QgENBB4WHFRpbnlDQSBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYD
+  VR0OBBYEFD4zi3QaKvIdOrCm5ecvRTRkIRb0MIHGBgNVHSMEgb4wgbuAFCDycvNc
+  Ee44hRmsHsNsdWpEBOsSoYGXpIGUMIGRMQswCQYDVQQGEwJVUzERMA8GA1UECBMI
+  VmlyZ2luaWExEjAQBgNVBAcTCUFubmFuZGFsZTESMBAGA1UEChMJUGFibG90cm9u
+  MQswCQYDVQQLEwJDQTEZMBcGA1UEAxMQY2EucGFibG90cm9uLm9yZzEfMB0GCSqG
+  SIb3DQEJARYQY2FAcGFibG90cm9uLm9yZ4IJALaV65AlSniTMBsGA1UdEgQUMBKB
+  EGNhQHBhYmxvdHJvbi5vcmcwIQYDVR0RBBowGIEWcnVieWdlbXNAcGFibG90cm9u
+  Lm9yZzALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQEFBQADggIBAJWFBhtrg6xYioR6
+  OJQqfZ9KnOUZeg6r99OUUzC+eUdxdB1WWkVy7cozAbNFCwNiShMaKTENp++xDkf4
+  tV9iflL1UOof+vOV3744dcOeulD10tRkkcdwm4aGb26QGDAImpYaj5DvO0705jt2
+  Ik3LVa4rIbgqKZCKvwPVAIC6ja2JdoEBAHqroxL5QGTEOg/UjB082Jg8cihgqcv2
+  rQmIOknAmi9r2DG8X9o8bhDeHmfCQLlUCczCLZXYek+TQWTkwlzBUYjC2DMhH6RK
+  u9PUe9wAEun7mrduPzEnSf9Lwz2m6YzQbEKrcKpFtZFfEXPyPLBcV6FTnyurTZNj
+  82of9lvOQbOSA3WxZ5Nftea2RI195ISrFIFN3JvGeH5qlY2rTU5KoPa+GwJ9Ded2
+  hdA21917OmS+JXWMIEgGHm9OW2VZ2sPZt9J/VotXBWh1jk/Bmo5/UCdjv67xGdK1
+  RyL+r+HmUwvTMPvime/oPS17wa9ZpA5awI8of0Awa9qLSGnEbmRDGdniGBb4SXZc
+  yve8SLbALak48wH4mA9RxrCL+gsm5fUZpSYfqdLOAe42nEvGWCQsyAe9wJjafUK2
+  seoSPfDoJ/hF0bm3HGiK29FF58k15/+V+SPhZZgNX8lynkxt2Z8bsElfj61LoieV
+  /LANFBa55ghGzqax1mF/yGfF/utO
+  -----END CERTIFICATE-----
+
+post_install_message: 
+authors: 
+- Paul Duncan
+files: 
+- ChangeLog
+- COPYING
+- wirble.rb
+- README
+- wirble.gemspec
+test_files: []
+
+rdoc_options: 
+- --webcvs
+- http://cvs.pablotron.org/cgi-bin/viewcvs.cgi/wirble/
+- --title
+- Wirble API Documentation
+- wirble.rb
+- README
+- ChangeLog
+- COPYING
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- Ruby, version 1.8.0 (or newer)
+dependencies: []
+