cldwalker-hirb 0.1.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2009 Gabriel Horner
+
+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,216 @@
+== Description
+
+Hirb currently provides a mini view framework for console applications, designed with irb in mind.
+This framework is activated by one method, which given the output of a console application, renders
+a configured view based on the output's class. The framework encourages reusing views by letting you
+package them in classes and associate them with any number of output classes.  Hirb comes with table
+views (see Hirb::Helpers::Table) which work out of the box with any output class, especially Rails'
+model classes.
+
+== Install
+
+Install the gem with:
+
+    sudo gem install cldwalker-hirb -s http://gems.github.com
+
+== Rails Example
+
+Let's load and enable the view framework:
+  bash> script/console
+  Loading local environment (Rails 2.2.2)
+  irb>> require 'hirb'
+  => true
+  irb>> Hirb::View.enable
+  => nil
+
+The default configuration provides table views for ActiveRecord::Base descendants.
+If a class isn't configured, Hirb reverts to irb's default echo mode.
+  irb>> Hirb::View.output_config
+  => {"ActiveRecord::Base"=>{:class=>"Hirb::Views::ActiveRecord_Base", :ancestor=>true}}
+
+  # Tag is a model class and descendant of ActiveRecord::Base
+  irb>> Tag.last
+  +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
+  | id  | created_at              | description | name          | namespace | predicate | value |
+  +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
+  | 907 | 2009-03-06 21:10:41 UTC |             | gem:tags=yaml | gem       | tags      | yaml  |
+  +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
+  1 row in set
+
+  irb>> 'plain ol irb'
+  => 'plain ol irb'
+  irb>> :blah
+  => :blah
+
+From above you can see there were no views configured for a String or a Symbol so Hirb defaulted to
+irb's echo mode. Also note that Tag was able to inherit its view from the ActiveRecord::Base config
+because it had an :ancestor option.
+
+Now that you understand that Hirb displays views based on an output object's class,
+you may appreciate it also detects configured output objects in an array:
+
+  irb>> Tag.all :limit=>3, :order=>"id DESC"
+  +-----+-------------------------+-------------+-------------------+-----------+-----------+----------+
+  | id  | created_at              | description | name              | namespace | predicate | value    |
+  +-----+-------------------------+-------------+-------------------+-----------+-----------+----------+
+  | 907 | 2009-03-06 21:10:41 UTC |             | gem:tags=yaml     | gem       | tags      | yaml     |
+  | 906 | 2009-03-06 08:47:04 UTC |             | gem:tags=nomonkey | gem       | tags      | nomonkey |
+  | 905 | 2009-03-04 00:30:10 UTC |             | article:tags=ruby | article   | tags      | ruby     |
+  +-----+-------------------------+-------------+-------------------+-----------+-----------+----------+
+  3 rows in set
+
+At any time you can disable Hirb if you really like irb's lovely echo mode:
+  irb>> Hirb::View.disable
+  => nil
+  irb>> Tag.all :limit=>3, :order=>"id DESC"
+  => [#<Tag id: 907, name: "gem:tags=yaml", description: nil, created_at: "2009-03-06 21:10:41",
+  namespace: "gem", predicate: "tags", value: "yaml">, #<Tag id: 906, name: "gem:tags=nomonkey",
+  description: nil, created_at: "2009-03-06 08:47:04", namespace: "gem", predicate: "tags", value:
+  "nomonkey">, #<Tag id: 905, name: "article:tags=ruby", description: nil, created_at: "2009-03-04
+  00:30:10", namespace: "article", predicate: "tags", value: "ruby">]
+
+== Views: Anytime, Anywhere
+While preconfigured tables are great for database records, sometimes you just want to create
+tables/views for any output object:
+  
+  #These examples don't need to have Hirb::View enabled.
+  irb>>Hirb::View.disable
+  =>nil
+
+  # Imports table() and view()
+  irb>>extend Hirb::Console
+  =>main
+
+  # Create a table of Dates comparing them with different formats.
+  irb>> table [Date.today, Date.today.next_month], :fields=>[:to_s, :ld, :ajd, :amjd, :asctime]
+  +------------+--------+-----------+-------+--------------------------+
+  | to_s       | ld     | ajd       | amjd  | asctime                  |
+  +------------+--------+-----------+-------+--------------------------+
+  | 2009-03-11 | 155742 | 4909803/2 | 54901 | Wed Mar 11 00:00:00 2009 |
+  | 2009-04-11 | 155773 | 4909865/2 | 54932 | Sat Apr 11 00:00:00 2009 |
+  +------------+--------+-----------+-------+--------------------------+
+  2 rows in set
+
+  # Same table as the previous method. However view() will be able to call any view created.
+  irb>> view [Date.today, Date.today.next_month], :class=>Hirb::Helpers::ObjectTable,
+    :fields=>[:to_s, :ld, :ajd, :amjd, :asctime]
+
+If these console methods weren't convenient enough, try:
+
+  # Imports view() to all objects.
+  irb>> require 'hirb/import_object'
+  =>true
+  # Yields same table as above examples.
+  irb>> [Date.today, Date.today.next_month].view :class=>Hirb::Helpers::ObjectTable,
+    :fields=>[:to_s, :ld, :ajd, :amjd, :asctime]
+
+Although views by default are printed to STDOUT, they can be easily modified to write anywhere:
+  # Setup views to write to file 'console.log'.
+  irb>> Hirb::View.render_method = lambda {|output| File.open("console.log", 'w') {|f| f.write(output) } }
+
+  # Writes to file with same table output as above example.
+  irb>> view [Date.today, Date.today.next_month], :class=>Hirb::Helpers::ObjectTable,
+    :fields=>[:to_s, :ld, :ajd, :amjd, :asctime]
+
+  # Doesn't write to file because Symbol isn't configured to use Hirb::View and thus defaults to irb's echo mode.
+  irb>> :blah
+  =>:blah
+
+  # Go back to printing Hirb views to STDOUT.
+  irb>> Hirb::View.reset_render_method
+
+== Create and Configure Views
+Let's create a simple view and configure it in different ways to be Hash's default view:
+
+=== Setup
+  irb>> require 'hirb'
+  =>true
+  irb>> Hirb::View.enable
+  =>nil
+  irb>> require 'yaml'
+  =>true
+
+=== Configure As View Method
+A view method is the smallest reuseable view.
+  # Create yaml view method
+  irb>> def yaml(output); output.to_yaml; end
+  =>nil
+
+  # Configure view and reload it
+  irb>>Hirb::View.output_config = {"Hash"=>{:method=>:yaml}}
+  =>{"Hash"=>{:method=>:yaml}}
+  irb>>Hash::View.reload_config
+  =>true
+
+  # Hashes now appear as yaml
+  irb>>{:a=>1, :b=>{:c=>3}}
+  ---
+  :a : 1
+  :b : 
+    :c : 3
+  => true
+
+=== Configure As View Class
+A view class is suited for more complex views. View classes can be under any namespace
+and are expected to provide a render method. However, if a class is under the Hirb::Views namespace,
+it will be automatically loaded with no configuration. Something to think about when
+sharing views with others.
+
+  # Create yaml view class
+  irb>> class Hirb::Views::Hash; def self.render(output); output.to_yaml; end ;end
+  =>nil
+  # Just reload since no configuration is necessary
+  irb>>Hirb::View.reload_config
+
+  # Hashes now appear as yaml ...
+
+Although the Hirb::Views namespace is great for quick classes that just plug and play, you
+often want view classes that can be reused with multiple outputs. For this case, it's recommended to
+use the Hirb::Helpers namespace.
+  
+  # Create yaml view class
+  irb>> class Hirb::Helpers::Yaml; def self.render(output); output.to_yaml; end ;end
+  =>nil
+
+  # Configure view and reload it
+  irb>>Hirb::View.output_config = {"Hash"=>{:class=>"Hirb::Helpers::Yaml"}}
+  =>{"Hash"=>{:class=>"Hirb::Helpers::Yaml"}}
+  irb>>Hirb::View.reload_config
+
+  # Hashes now appear as yaml ...
+
+=== Configure At Startup
+Once you know what views are associated with what output classes, you can configure
+them at startup by passing Hirb::View.enable a block:
+  # In .irbrc
+  require 'hirb'
+  # View class needs to come before enable()
+  class Hirb::Helpers::Yaml; def self.render(output); output.to_yaml; end ;end
+  Hirb::View.enable {|conf| conf.output = {"Hash"=>{:class=>"Hirb::Helpers::Yaml"}} }
+  
+Or by creating a config file at config/hirb.yml or ~/.hirb.yml:
+  # The config file for the yaml example would look like:
+  # ---
+  # :view :
+  #  :output :
+  #    Hash :
+  #      :class : Hirb::Helpers::Yaml
+
+  # In .irbrc
+  require 'hirb'
+  # View class needs to come before enable()
+  class Hirb::Helpers::Yaml; def self.render(output); output.to_yaml; end ;end
+  Hirb::View.enable
+
+== Limitations
+Although Hirb preserves Wirble colorizing irb's default echo mode, it doesn't colorize its own views.
+This is mainly because colorizing caused table classes to render incorrectly. If you can get tables
+and colors to work nicely, please fork. To colorize your Hirb output:
+  Hirb::View.render_method = lambda {|output| puts Wirble::Colorize.colorize(output) }
+
+== Todo
+* Create tree views.
+* Possibly add non-view irb goodies ie command manager.
+* Configurable max height, which if exceeded activates a pager.
+* Provides helper methods to all view classes.
+* Consider adding a template system as needed.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "hirb"
+    s.description = "A mini view framework for console/irb that's easy to use, even while under its influence."
+    s.summary = s.description
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/hirb"
+    s.authors = ["Gabriel Horner"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+    s.files = FileList["Rakefile", "VERSION.yml", "README.rdoc", "LICENSE.txt", "{bin,lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/hirb/console.rb

@@ -0,0 +1,17 @@
+module Hirb
+  # This class is meant to be extended to provide methods for use in a console/irb shell.
+  # For example:
+  #    irb>> extend Hirb::Console
+  #    irb>> view 'some string', :class=>Some::String::Formatter
+  #    irb>> table [[:row1], [:row2]]
+  module Console
+    # Renders a table for the given object. Takes same options as Hirb::Helpers::Table.render.
+    def table(output, options={})
+      Hirb::View.console_render_output(output, options.merge(:class=>"Hirb::Helpers::AutoTable"))
+    end
+    # Renders any specified view for the given object. Takes same options as Hirb::View.render_output.
+    def view(*args)
+      Hirb::View.console_render_output(*args)
+    end
+  end
+end

data/lib/hirb/hash_struct.rb

@@ -0,0 +1,17 @@
+require 'ostruct'
+
+class Hirb::HashStruct < OpenStruct #:nodoc:
+  def self.block_to_hash(block=nil)
+    config = self.new
+    if block
+      block.call(config)
+      config.to_hash
+    else
+      {}
+    end
+  end
+
+  def to_hash
+    @table
+  end
+end

data/lib/hirb/helpers/active_record_table.rb

@@ -0,0 +1,17 @@
+class Hirb::Helpers::ActiveRecordTable < Hirb::Helpers::ObjectTable
+  # Rows are Rails' ActiveRecord::Base objects.
+  # Takes same options as Hirb::Helpers::Table.render except as noted below.
+  #
+  # Options:
+  #   :fields- Can be any attribute, column or not. If not given, this defaults to the database table's columns.
+  def self.render(rows, options={})
+    rows = [rows] unless rows.is_a?(Array)
+    options[:fields] ||= 
+      begin
+        fields = rows.first.attribute_names
+        fields.unshift(fields.delete('id')) if fields.include?('id')
+        fields
+      end
+    super(rows, options)
+  end
+end

data/lib/hirb/helpers/auto_table.rb

@@ -0,0 +1,14 @@
+# Attempts to autodetect the table class the output represents and delegates rendering to it.
+class Hirb::Helpers::AutoTable
+  # Same options as Hirb::Helpers::Table.render.
+  def self.render(output, options={})
+    klass = if ((output.is_a?(Array) && output[0].is_a?(ActiveRecord::Base)) or output.is_a?(ActiveRecord::Base) rescue false)
+      Hirb::Helpers::ActiveRecordTable
+    elsif options[:fields]
+      Hirb::Helpers::ObjectTable
+    else
+      Hirb::Helpers::Table
+    end
+    klass.render(output, options)
+  end
+end

data/lib/hirb/helpers/object_table.rb

@@ -0,0 +1,15 @@
+class Hirb::Helpers::ObjectTable < Hirb::Helpers::Table
+  # Rows are any ruby objects. Takes same options as Hirb::Helpers::Table.render except as noted below.
+  #
+  # Options:
+  #   :fields- Methods of the object which are represented as columns in the table. Required option.
+  #     All method values are converted to strings via to_s.
+  def self.render(rows, options ={})
+    raise(ArgumentError, "Option 'fields' is required.") unless options[:fields]
+    rows = [rows] unless rows.is_a?(Array)
+    item_hashes = rows.inject([]) {|t,item|
+      t << options[:fields].inject({}) {|h,f| h[f] = item.send(f).to_s; h}
+    }
+    super(item_hashes, options)
+  end
+end

data/lib/hirb/helpers/table.rb

@@ -0,0 +1,169 @@
+# Base Table class from which other table classes inherit.
+# By default, a table is constrained to a default width but this can be adjusted
+# via options as well as Hirb:Helpers::Table.max_width.
+# Rows can be an array of arrays or an array of hashes.
+#
+# An array of arrays ie [[1,2], [2,3]], would render:
+#   +---+---+
+#   | 0 | 1 |
+#   +---+---+
+#   | 1 | 2 |
+#   | 2 | 3 |
+#   +---+---+
+#
+# By default, the fields/columns are the numerical indices of the array.
+# 
+# An array of hashes ie [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], would render:
+#   +-----+--------+
+#   | age | weight |
+#   +-----+--------+
+#   | 10  | 100    |
+#   | 80  | 500    |
+#   +-----+--------+
+#
+# By default, the fields/columns are the keys of the first hash.
+#--
+# derived from http://gist.github.com/72234
+class Hirb::Helpers::Table
+  DEFAULT_MAX_WIDTH = 150
+  class << self
+    attr_accessor :max_width
+    
+    # Main method which returns a formatted table.
+    # ==== Options:
+    # [:fields] An array which overrides the default fields and can be used to indicate field order.
+    # [:headers] A hash of fields and their header names. Fields that aren't specified here default to their name.
+    #            This option can also be an array but only for array rows.
+    # [:field_lengths] A hash of fields and their maximum allowed lengths. If a field exceeds it's maximum
+    #                  length than it's truncated and has a ... appended to it. Fields that aren't specified here have no maximum allowed
+    #                  length.
+    # [:max_width] The maximum allowed width of all fields put together. This option is enforced except when the field_lengths option is set.
+    # Examples:
+    #    Hirb::Helpers::Table.render [[1,2], [2,3]]
+    #    Hirb::Helpers::Table.render [[1,2], [2,3]], :field_lengths=>{0=>10}
+    #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}]
+    #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], :headers=>{:weight=>"Weight(lbs)"}
+    def render(rows, options={})
+      new(rows,options).render
+    end
+  end
+  
+  #:stopdoc:
+  def initialize(rows, options={})
+    @options = options
+    @fields = options[:fields] || ((rows[0].is_a?(Hash)) ? rows[0].keys.sort {|a,b| a.to_s <=> b.to_s} : 
+      rows[0].is_a?(Array) ? (0..rows[0].length - 1).to_a : [])
+    @rows = setup_rows(rows)
+    @headers = @fields.inject({}) {|h,e| h[e] = e.to_s; h}
+    if options.has_key?(:headers)
+      @headers = options[:headers].is_a?(Hash) ? @headers.merge(options[:headers]) : 
+        (options[:headers].is_a?(Array) ? array_to_indices_hash(options[:headers]) : options[:headers])
+    end
+  end
+  
+  def setup_rows(rows)
+    rows ||= []
+    rows = [rows] unless rows.is_a?(Array)
+    if rows[0].is_a?(Array)
+      rows = rows.inject([]) {|new_rows, row|
+        new_rows << array_to_indices_hash(row)
+      }
+    end
+    validate_values(rows)
+    rows
+  end
+  
+  def render
+    body = []
+    unless @rows.length == 0
+      setup_field_lengths
+      body += @headers ? render_header : [render_border]
+      body += render_rows
+      body << render_border
+    end
+    body << render_table_description
+    body.join("\n")
+  end
+  
+  def render_header
+    title_row = '| ' + @fields.map {|f|
+      format_cell(@headers[f], @field_lengths[f])
+    }.join(' | ') + ' |'
+    [render_border, title_row, render_border]
+  end
+  
+  def render_border
+    '+-' + @fields.map {|f| '-' * @field_lengths[f] }.join('-+-') + '-+'
+  end
+  
+  def format_cell(value, cell_width)
+    text = value.length > cell_width ? 
+      (
+      (cell_width < 3) ? value.slice(0,cell_width) : value.slice(0, cell_width - 3) + '...'
+      ) : value
+    sprintf("%-#{cell_width}s", text)
+  end
+  
+  def render_rows
+    @rows.map do |row|
+      row = '| ' + @fields.map {|f|
+        format_cell(row[f], @field_lengths[f])
+      }.join(' | ') + ' |'
+    end
+  end
+  
+  def render_table_description
+    (@rows.length == 0) ? "0 rows in set" :
+      "#{@rows.length} #{@rows.length == 1 ? 'row' : 'rows'} in set"
+  end
+  
+  def setup_field_lengths
+    @field_lengths = default_field_lengths
+    if @options[:field_lengths]
+      @field_lengths.merge!(@options[:field_lengths])
+    else
+      max_width = @options[:max_width] || Hirb::Helpers::Table.max_width || DEFAULT_MAX_WIDTH
+      restrict_field_lengths(@field_lengths, max_width)
+    end
+  end
+  
+  # Simple algorithm which given a max width, allows smaller fields to be displayed while
+  # restricting longer fields at a new_long_field_length.
+  def restrict_field_lengths(field_lengths, max_width)
+    total_length = field_lengths.values.inject {|t,n| t += n}
+    if total_length > max_width
+      average_field_length = total_length / @fields.size.to_f
+      long_lengths, short_lengths = field_lengths.values.partition {|e| e > average_field_length}
+      new_long_field_length = (max_width - short_lengths.inject {|t,n| t += n}) / long_lengths.size
+      field_lengths.each {|f,length|
+        field_lengths[f] = new_long_field_length if length > new_long_field_length
+      }
+    end
+  end
+
+  # find max length for each field; start with the headers
+  def default_field_lengths
+    field_lengths = @headers ? @headers.inject({}) {|h,(k,v)| h[k] = v.length; h} : {}
+    @rows.each do |row|
+      @fields.each do |field|
+        len = row[field].length
+        field_lengths[field] = len if len > field_lengths[field].to_i
+      end
+    end
+    field_lengths
+  end
+
+  def validate_values(rows)
+    rows.each {|row|
+      @fields.each {|f|
+        row[f] = row[f].to_s || ''
+      }
+    }
+  end
+  
+  # Converts an array to a hash mapping a numerical index to its array value.
+  def array_to_indices_hash(array)
+    array.inject({}) {|hash,e|  hash[hash.size] = e; hash }
+  end
+  #:startdoc:
+end

data/lib/hirb/helpers.rb

@@ -0,0 +1,7 @@
+module Hirb
+  module Helpers #:nodoc:
+  end
+end
+%w{table object_table active_record_table auto_table}.each do |e|
+  require "hirb/helpers/#{e}"
+end

data/lib/hirb/import_object.rb

@@ -0,0 +1,10 @@
+module Hirb
+  module ObjectMethods
+    # Takes same options as Hirb::View.render_output.
+    def view(*args)
+      Hirb::View.console_render_output(*(args.unshift(self)))
+    end
+  end
+end
+
+Object.send :include, Hirb::ObjectMethods

data/lib/hirb/util.rb

@@ -0,0 +1,19 @@
+module Hirb
+  module Util
+    extend self
+    # Returns a constant like const_get() no matter what namespace it's nested in.
+    # Returns nil if the constant is not found.
+    def any_const_get(name)
+      return name if name.is_a?(Module)
+      begin
+        klass = Object
+        name.split('::').each {|e|
+          klass = klass.const_get(e)
+        }
+        klass
+      rescue
+         nil
+      end
+    end
+  end
+end

data/lib/hirb/view.rb

@@ -0,0 +1,179 @@
+module Hirb
+  # This class contains one method, render_output, which formats and renders the output its given from a console application.
+  # However, this only happens for output classes that are configured to do so or if render_output is explicitly given
+  # a view formatter. The hash with the following keys are valid for Hirb::View.config as well as the :view key mentioned in Hirb:
+  # [:output] This hash is saved to output_config. It maps output classes to hashes that are passed to render_output. Thus these hashes
+  #           take the same options as render_output. In addition it takes the following keys:
+  #           * :ancestor- Boolean which if true allows all subclasses of the configured output class to inherit this config.
+  # 
+  #           Example: {'String'=>{:class=>'Hirb::Helpers::Table', :ancestor=>true, :options=>{:max_width=>180}}}
+  module View
+    class<<self
+      attr_accessor :config, :render_method
+
+      # Overrides irb's output method with Hirb::View.render_output. Takes an optional
+      # block which sets the view config.
+      # Examples:
+      #   Hirb.enable
+      #   Hirb.enable {|c| c.output = {'String'=>{:class=>'Hirb::Helpers::Table'}} }
+      def enable(&block)
+        return puts("Already enabled.") if @enabled
+        @enabled = true
+        load_config(Hirb::HashStruct.block_to_hash(block))
+        ::IRB::Irb.class_eval do
+          alias :non_hirb_render_output  :output_value
+          def output_value #:nodoc:
+            Hirb::View.render_output(@context.last_value) || non_hirb_render_output
+          end
+        end
+      end
+      
+      # Disable's Hirb's output by reverting back to irb's.
+      def disable
+        @enabled = false
+        ::IRB::Irb.class_eval do
+          alias :output_value :non_hirb_render_output
+        end
+      end
+      
+      # This is the main method of this class. This method searches for the first formatter it can apply
+      # to the object in this order: local block, method option, class option. If a formatter is found it applies it to the object
+      # and returns true. Returns false if no formatter found.
+      # ==== Options:
+      # [:method] Specifies a global (Kernel) method to do the formatting.
+      # [:class] Specifies a class to do the formatting, using its render() class method.
+      # [:options] Options to pass the formatter method or class.
+      def render_output(output, options={}, &block)
+        if block && block.arity > 0
+          formatted_output = block.call(output)
+          render_method.call(formatted_output)
+          true
+        elsif (formatted_output = format_output(output, options))
+          render_method.call(formatted_output)
+          true
+        else
+          false
+        end
+      end
+
+      # A lambda or proc which handles the final formatted object.
+      # Although this puts the object by default, it could be set to do other things
+      # ie write the formatted object to a file.
+      def render_method
+        @render_method ||= default_render_method
+      end
+
+      def reset_render_method
+        @render_method = default_render_method
+      end
+
+      # Config hash which maps classes to view hashes. View hashes are the same as the options hash of render_output().
+      def output_config
+        @config[:output]
+      end
+
+      def output_config=(value)
+        @config[:output] = value
+      end
+      
+      # Needs to be called for config changes to take effect. Reloads Hirb::Views classes and registers
+      # most recent config changes.
+      def reload_config
+        current_config = self.config.dup.merge(:output=>output_config)
+        load_config(current_config)
+      end
+
+      #:stopdoc:
+      def console_render_output(output, options={}, &block)
+        # iterates over format_output options that aren't :options
+        real_options = [:method, :class].inject({}) do |h, e|
+          h[e] = options.delete(e) if options[e]
+          h
+        end
+        render_output(output, real_options.merge(:options=>options), &block)
+      end
+
+      def format_output(output, options={})
+        output_class = determine_output_class(output)
+        options = output_class_options(output_class).merge(options)
+        args = [output]
+        args << options[:options] if options[:options] && !options[:options].empty?
+        if options[:method]
+          new_output = send(options[:method],*args)
+        elsif options[:class] && (view_class = Util.any_const_get(options[:class]))
+          new_output = view_class.render(*args)
+        end
+        new_output
+      end
+
+      def determine_output_class(output)
+        if output.is_a?(Array)
+          output[0].class
+        else
+          output.class
+        end
+      end
+
+      # Loads config
+      def load_config(additional_config={})
+        new_config = default_config
+        new_config[:output].merge!(additional_config.delete(:output) || {})
+        self.config = new_config.merge(additional_config)
+        true
+      end
+
+      # Stores all view config. Current valid keys:
+      #   :output- contains value of output_config
+      def config=(value)
+        reset_cached_output_config
+        @config = value
+      end
+      
+      def reset_cached_output_config
+        @cached_output_config = nil
+      end
+      
+      # Internal view options built from user-defined ones. Options are built by recursively merging options from oldest
+      # ancestors to the most recent ones.
+      def output_class_options(output_class)
+        @cached_output_config ||= {}
+        @cached_output_config[output_class] ||= 
+          begin
+            output_ancestors_with_config = output_class.ancestors.map {|e| e.to_s}.select {|e| output_config.has_key?(e)}
+            @cached_output_config[output_class] = output_ancestors_with_config.reverse.inject({}) {|h, klass|
+              (klass == output_class.to_s || output_config[klass][:ancestor]) ? h.update(output_config[klass]) : h
+            }
+          end
+        @cached_output_config[output_class]
+      end
+      
+      def cached_output_config; @cached_output_config; end
+
+      def default_render_method
+        lambda {|output| puts output}
+      end
+
+      def default_config
+        conf = Hirb.config[:view] || {}
+        conf[:output] = default_output_config.merge(conf[:output] || {})
+        conf
+      end
+
+      def default_output_config
+        Hirb::Views.constants.inject({}) {|h,e|
+          output_class = e.to_s.gsub("_", "::")
+          if (views_class = Hirb::Views.const_get(e)) && views_class.respond_to?(:render)
+            default_options = views_class.respond_to?(:default_options) ? views_class.default_options : {}
+            h[output_class] = default_options.merge({:class=>"Hirb::Views::#{e}"})
+          end
+          h
+        }
+      end
+      #:startdoc:
+    end
+  end
+  
+  # Namespace for autoloaded views
+  module Views
+  end
+end

data/lib/hirb/views/activerecord_base.rb

@@ -0,0 +1,9 @@
+class Hirb::Views::ActiveRecord_Base #:nodoc:
+  def self.default_options
+    {:ancestor=>true}
+  end
+  
+  def self.render(*args)
+    Hirb::Helpers::ActiveRecordTable.render(*args)
+  end
+end

data/lib/hirb.rb

@@ -0,0 +1,31 @@
+current_dir = File.dirname(__FILE__)
+$:.unshift(current_dir) unless $:.include?(current_dir) || $:.include?(File.expand_path(current_dir))
+require 'hirb/util'
+require 'hirb/hash_struct'
+require 'hirb/helpers'
+require 'hirb/view'
+require 'hirb/views/activerecord_base'
+require 'hirb/console'
+
+# Most of Hirb's functionality currently resides in Hirb::View.
+# Hirb has an optional yaml config file defined by config_file. This config file
+# has the following top level keys:
+# [:view] See Hirb::View for the value of this entry.
+module Hirb
+  class <<self
+    # Default is config/hirb.yml or ~/hirb.yml in that order.
+    def config_file
+      File.exists?('config/hirb.yml') ? 'config/hirb.yml' : File.expand_path(File.join("~",".hirb.yml"))
+    end
+
+    #:stopdoc:
+    def read_config_file(file=config_file)
+      File.exists?(file) ? YAML::load_file(file) : {}
+    end
+
+    def config(reload=false)
+      @config = (@config.nil? || reload) ? read_config_file : @config
+    end
+    #:startdoc:
+  end
+end

data/test/hirb_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class HirbTest < Test::Unit::TestCase
+  before(:each) {Hirb.instance_eval "@config = nil"}
+  
+  test "config converts yaml when config file exists" do
+    yaml_data = {:blah=>'blah'}
+    File.stubs('exists?').returns(true)
+    YAML::expects(:load_file).returns(yaml_data)
+    Hirb.config.should == yaml_data
+  end
+  
+  test "config defaults to hash when no config file" do
+    File.stubs('exists?').returns(false)
+    Hirb.config.should == {}
+  end
+  
+  test "config reloads if given explicit reload" do
+    Hirb.config
+    Hirb.expects(:read_config_file)
+    Hirb.config(true)
+  end
+end

data/test/import_test.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::ImportTest < Test::Unit::TestCase
+  test "require import_object extends Object" do
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(false)
+    require 'hirb/import_object'
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(true)
+  end
+end

data/test/table_test.rb

@@ -0,0 +1,242 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::Helpers::TableTest < Test::Unit::TestCase
+  def table(*args)
+    Hirb::Helpers::Table.render(*args)
+  end
+  
+  context "basic table" do
+    test "renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}]).should == expected_table
+    end
+    
+    test "with no headers renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 1 | 2 |
+      +---+---+
+      1 row in set
+      TABLE
+      table([{:a=>1, :b=>2}], :headers=>nil).should == expected_table
+    end
+
+    test "with string keys renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | a | b |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{'a'=>1, 'b'=>2}, {'a'=>3, 'b'=>4}]).should == expected_table
+    end
+    
+    test "with array only rows renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 0 | 1 |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([[1,2], [3,4]]).should == expected_table
+    end
+    
+    test "with no rows renders" do
+      table([]).should == "0 rows in set"
+    end
+  end
+
+  context "table with" do
+    test "fields option renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | b | a |
+      +---+---+
+      | 2 | 1 |
+      | 4 | 3 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:b, :a]).should == expected_table
+    end
+    
+    test "fields option and array only rows" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 0 | 2 |
+      +---+---+
+      | 1 | 3 |
+      +---+---+
+      1 row in set
+      TABLE
+      table([[1,2,3]], :fields=>[0,2]).should == expected_table
+    end
+  
+    test "invalid fields option renders empty columns" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | b | c |
+      +---+---+
+      | 2 |   |
+      | 4 |   |
+      +---+---+
+      2 rows in set
+  TABLE
+      table([{:a=>1, :b=>2}, {:a=>3, :b=>4}], :fields=>[:b, :c]).should == expected_table
+    end
+  
+    test "invalid fields in field_lengths option renders" do
+      expected_table = <<-TABLE.unindent
+      +------------+---+
+      | a          | b |
+      +------------+---+
+      | AAAAAAA... | 2 |
+      +------------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10,:c=>10}).should == expected_table
+    end
+  
+    test "field_lengths option and field_lengths less than 3 characters renders" do
+      expected_table = <<-TABLE.unindent
+      +----+---+
+      | a  | b |
+      +----+---+
+      | AA | 2 |
+      +----+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>2}).should == expected_table
+    end
+  
+    test "field_lengths option renders" do
+      expected_table = <<-TABLE.unindent
+      +------------+---+
+      | a          | b |
+      +------------+---+
+      | AAAAAAA... | 2 |
+      +------------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2}], :field_lengths=>{:a=>10}).should == expected_table
+    end
+  
+    test "max_width option renders" do
+      expected_table = <<-TABLE.unindent
+      +---------------------+---+------------+
+      | a                   | b | c          |
+      +---------------------+---+------------+
+      | AAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
+      +---------------------+---+------------+
+      1 row in set
+  TABLE
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}], :max_width=>30).should == expected_table
+    end
+  
+    test "global max_width renders" do
+      expected_table = <<-TABLE.unindent
+      +---------------------+---+------------+
+      | a                   | b | c          |
+      +---------------------+---+------------+
+      | AAAAAAAAAAAAAAAA... | 2 | CCCCCCCCCC |
+      +---------------------+---+------------+
+      1 row in set
+  TABLE
+      Hirb::Helpers::Table.max_width = 30
+      table([{:a=> "A" * 50, :b=>2, :c=>"C"*10}]).should == expected_table    
+      Hirb::Helpers::Table.max_width = Hirb::Helpers::Table::DEFAULT_MAX_WIDTH
+    end
+
+    test "headers option and headers longer than fields renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---------+---------+
+      | a | field B | field C |
+      +---+---------+---------+
+      | A | 2       | C       |
+      +---+---------+---------+
+      1 row in set
+  TABLE
+      table([{:a=> "A", :b=>2, :c=>"C"}], :headers=>{:b=>"field B", :c=>"field C"}).should == expected_table
+    end
+  
+    test "headers option and headers shortened by field_lengths renders" do
+      expected_table = <<-TABLE.unindent
+      +-------+---+
+      | fi... | b |
+      +-------+---+
+      | A     | 2 |
+      +-------+---+
+      1 row in set
+  TABLE
+      table([{:a=> "A", :b=>2}], :headers=>{:a=>"field A"}, :field_lengths=>{:a=>5}).should == expected_table
+    end
+    
+    test "with headers option as an array renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | A | B |
+      +---+---+
+      | 1 | 2 |
+      | 3 | 4 |
+      +---+---+
+      2 rows in set
+      TABLE
+      table([[1,2], [3,4]], :headers=>['A', 'B']).should == expected_table
+    end
+    
+  end
+  
+  context "object table" do
+    before(:all) {
+      @pets = [stub(:name=>'rufus', :age=>7), stub(:name=>'alf', :age=>101)]
+    }
+    test "renders" do
+      expected_table = <<-TABLE.unindent
+      +-------+-----+
+      | name  | age |
+      +-------+-----+
+      | rufus | 7   |
+      | alf   | 101 |
+      +-------+-----+
+      2 rows in set
+      TABLE
+      Hirb::Helpers::ObjectTable.render(@pets, :fields=>[:name, :age]).should == expected_table
+    end
+    
+    test "with no options fields raises ArgumentError" do
+      assert_raises(ArgumentError) { Hirb::Helpers::ObjectTable.render(@pets) }
+    end
+  end
+  
+  context "activerecord table" do
+    before(:all) {
+      @pets = [stub(:name=>'rufus', :age=>7, :attribute_names=>['age', 'name']), stub(:name=>'alf', :age=>101)]
+    }
+    test "renders" do
+      expected_table = <<-TABLE.unindent
+      +-----+-------+
+      | age | name  |
+      +-----+-------+
+      | 7   | rufus |
+      | 101 | alf   |
+      +-----+-------+
+      2 rows in set
+      TABLE
+      Hirb::Helpers::ActiveRecordTable.render(@pets).should == expected_table
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'test/unit'
+require 'context' #gem install jeremymcanally-context -s http://gems.github.com
+require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
+require 'mocha'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'hirb'
+
+class Test::Unit::TestCase
+end
+
+class String
+  def unindent
+    gsub(/^\s*/, '').chomp
+  end
+end

data/test/util_test.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::UtilTest < Test::Unit::TestCase
+  test "any_const_get returns nested class" do
+    Hirb::Util.any_const_get("Test::Unit").should == ::Test::Unit
+  end
+  
+  test "any_const_get returns nil for invalid class" do
+    Hirb::Util.any_const_get("Basdfr").should == nil
+  end
+  
+  test "any_const_get returns class when given class" do
+    Hirb::Util.any_const_get(String).should == String
+  end
+end

data/test/view_test.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# mocks IRB for testing
+module ::IRB
+  class Irb
+    def initialize(context)
+      @context = context
+    end
+    def output_value; end
+  end
+end
+
+class Hirb::ViewTest < Test::Unit::TestCase
+  def set_config(value)
+    Hirb::View.output_config = value
+    Hirb::View.reset_cached_output_config
+  end
+  
+  def output_config
+    Hirb::View.config[:output]
+  end
+  
+  test "output_class_options merges ancestor options" do
+    set_config "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output, :ancestor=>true}, "Kernel"=>{:method=>:default_output}
+    expected_result = {:method=>:object_output, :args=>[1, 2], :ancestor=>true}
+    Hirb::View.output_class_options(String).should == expected_result
+  end
+  
+  test "output_class_options doesn't ancestor options" do
+    set_config "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output}, "Kernel"=>{:method=>:default_output}
+    expected_result = {:args=>[1, 2]}
+    Hirb::View.output_class_options(String).should == expected_result
+  end
+  
+  test "output_class_options returns hash when nothing found" do
+    Hirb::View.load_config
+    Hirb::View.output_class_options(String).should == {}
+  end
+
+  context "enable" do
+    before(:each) {Hirb::View.config = {}}
+    after(:each) { Hirb::View.disable }
+    test "redefines irb output_value" do
+      Hirb::View.expects(:render_output).once
+      Hirb::View.enable
+      context_stub = stub(:last_value=>'')
+      ::IRB::Irb.new(context_stub).output_value
+    end
+  
+    test "sets default config" do
+      eval "module ::Hirb::Views::Something_Base; def self.render; end; end"
+      Hirb::View.enable
+      output_config["Something::Base"].should == {:class=>"Hirb::Views::Something_Base"}
+    end
+  
+    test "sets default config with default_options" do
+      eval "module ::Hirb::Views::Blah; def self.render; end; def self.default_options; {:ancestor=>true}; end; end"
+      Hirb::View.enable
+      output_config["Blah"].should == {:class=>"Hirb::Views::Blah", :ancestor=>true}
+    end
+  
+    test "with block sets config" do
+      class_hash = {"Something::Base"=>{:class=>"BlahBlah"}}
+      Hirb::View.enable {|c| c.output = class_hash }
+      output_config['Something::Base'].should == class_hash['Something::Base']
+    end
+  end
+
+  test "reload_config resets config to detect new Hirb::Views" do
+    Hirb::View.load_config
+    output_config.keys.include?('Zzz').should be(false)
+    eval "module ::Hirb::Views::Zzz; def self.render; end; end"
+    Hirb::View.reload_config
+    output_config.keys.include?('Zzz').should be(true)
+  end
+  
+  test "reload_config picks up local changes" do
+    Hirb::View.load_config
+    output_config.keys.include?('Dooda').should be(false)
+    Hirb::View.output_config.merge!('Dooda'=>{:class=>"DoodaView"})
+    Hirb::View.reload_config
+    output_config['Dooda'].should == {:class=>"DoodaView"}
+  end
+  
+  test "disable points output_value back to original output_value" do
+    Hirb::View.expects(:render_output).never
+    Hirb::View.enable
+    Hirb::View.disable
+    context_stub = stub(:last_value=>'')
+    ::IRB::Irb.new(context_stub).output_value
+  end
+
+  context "render_output" do
+    before(:all) { 
+      eval %[module ::Commify
+        def self.render(strings)
+          strings = [strings] unless strings.is_a?(Array)
+          strings.map {|e| e.split('').join(',')}.join("\n")
+        end
+      end]
+      Hirb::View.enable 
+    }
+    after(:all) { Hirb::View.disable }
+    
+    test "formats with config method option" do
+      eval "module ::Kernel; def commify(string); string.split('').join(','); end; end"
+      set_config "String"=>{:method=>:commify}
+      Hirb::View.render_method.expects(:call).with('d,u,d,e')
+      Hirb::View.render_output('dude')
+    end
+    
+    test "formats with config class option" do
+      set_config "String"=>{:class=>"Commify"}
+      Hirb::View.render_method.expects(:call).with('d,u,d,e')
+      Hirb::View.render_output('dude')
+    end
+    
+    test "formats with output array" do
+      set_config "String"=>{:class=>"Commify"}
+      Hirb::View.render_method.expects(:call).with('d,u,d,e')
+      Hirb::View.render_output(['dude'])
+    end
+    
+    test "formats with config options option" do
+      eval "module ::Blahify; def self.render(*args); end; end"
+      set_config "String"=>{:class=>"Blahify", :options=>{:fields=>%w{a b}}}
+      Blahify.expects(:render).with('dude', :fields=>%w{a b})
+      Hirb::View.render_output('dude')
+    end
+    
+    test "doesn't format and returns false when no format method found" do
+      Hirb::View.load_config
+      Hirb::View.render_method.expects(:call).never
+      Hirb::View.render_output(Date.today).should == false
+    end
+    
+    test "formats with explicit class option" do
+      set_config 'String'=>{:class=>"Blahify"}
+      Hirb::View.render_method.expects(:call).with('d,u,d,e')
+      Hirb::View.render_output('dude', :class=>"Commify")
+    end
+    
+    test "formats with block" do
+      Hirb::View.load_config
+      Hirb::View.render_method.expects(:call).with('=dude=')
+      Hirb::View.render_output('dude') {|output|
+        "=#{output}="
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-hirb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A mini view framework for irb that's easy to use, even while under its influence.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+files: 
+- Rakefile
+- VERSION.yml
+- README.rdoc
+- LICENSE.txt
+- lib/hirb
+- lib/hirb/console.rb
+- lib/hirb/hash_struct.rb
+- lib/hirb/helpers
+- lib/hirb/helpers/active_record_table.rb
+- lib/hirb/helpers/auto_table.rb
+- lib/hirb/helpers/object_table.rb
+- lib/hirb/helpers/table.rb
+- lib/hirb/helpers.rb
+- lib/hirb/import_object.rb
+- lib/hirb/util.rb
+- lib/hirb/view.rb
+- lib/hirb/views
+- lib/hirb/views/activerecord_base.rb
+- lib/hirb.rb
+- test/hirb_test.rb
+- test/import_test.rb
+- test/table_test.rb
+- test/test_helper.rb
+- test/util_test.rb
+- test/view_test.rb
+has_rdoc: true
+homepage: http://github.com/cldwalker/hirb
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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.2.0
+signing_key: 
+specification_version: 2
+summary: A mini view framework for irb that's easy to use, even while under its influence.
+test_files: []
+