hirb 0.2.10 → 0.3.0

data/lib/hirb/helpers.rb

@@ -1,7 +1,17 @@
 module Hirb
   module Helpers #:nodoc:
+    @helper_classes ||= {}
+    def self.helper_class(klass)
+      @helper_classes[klass.to_s] ||= begin
+        if (helper_class = constants.find {|e| e.to_s == Util.camelize(klass.to_s)})
+          klass = "Hirb::Helpers::#{helper_class}"
+        end
+        Util.any_const_get(klass)
+      end
+    end
   end
 end
-%w{table object_table active_record_table auto_table tree parent_child_tree vertical_table}.each do |e|
+
+%w{table object_table auto_table tree parent_child_tree vertical_table}.each do |e|
   require "hirb/helpers/#{e}"
 end

data/lib/hirb/helpers/auto_table.rb

@@ -1,16 +1,24 @@
-# Detects the table class the output should use and delegates rendering to it.
-class Hirb::Helpers::AutoTable
-  # Same options as Hirb::Helpers::Table.render.
+# This helper wraps around the other table helpers i.e. Hirb::Helpers::Table while
+# providing default helper options via Hirb::DynamicView. Using these default options, this
+# helper supports views for the following modules/classes:
+# ActiveRecord::Base, CouchFoo::Base, CouchPotato::Persistence, CouchRest::ExtendedDocument,
+# DBI::Row, DataMapper::Resource, Friendly::Document, MongoMapper::Document, MongoMapper::EmbeddedDocument,
+# Mongoid::Document, Ripple::Document, Sequel::Model.
+class Hirb::Helpers::AutoTable < Hirb::Helpers::Table
+  extend Hirb::DynamicView
+
+  # Takes same options as Hirb::Helpers::Table.render except as noted below.
+  #
+  # ==== Options:
+  # [:table_class] Explicit table class to use for rendering. Defaults to
+  #                Hirb::Helpers::ObjectTable if output is not an Array or Hash. Otherwise
+  #                defaults to Hirb::Helpers::Table.
   def self.render(output, options={})
-    options[:_original_class] = output.class
     output = Array(output)
-    klass = if (output[0].is_a?(ActiveRecord::Base) rescue false)
-      Hirb::Helpers::ActiveRecordTable
-    elsif !(output[0].is_a?(Hash) || output[0].is_a?(Array))
-      Hirb::Helpers::ObjectTable
-    else
-      Hirb::Helpers::Table
-    end
+    (defaults = dynamic_options(output[0])) && (options = defaults.merge(options))
+    klass = options.delete(:table_class) || (
+      !(output[0].is_a?(Hash) || output[0].is_a?(Array)) ?
+      Hirb::Helpers::ObjectTable : Hirb::Helpers::Table)
     klass.render(output, options)
   end
-end
+end

data/lib/hirb/helpers/object_table.rb

@@ -1,8 +1,8 @@
 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 to represent as columns. Defaults to [:to_s].
+  # ==== Options:
+  # [:fields] Methods of the object to represent as columns. Defaults to [:to_s].
   def self.render(rows, options ={})
     options[:fields] ||= [:to_s]
     options[:headers] ||= {:to_s=>'value'} if options[:fields] == [:to_s]

data/lib/hirb/helpers/table.rb

@@ -68,7 +68,7 @@ module Hirb
     # ==== 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.
+    #              When set to false, headers are hidden. Can also be an array but only for array rows.
     # [*:max_fields*] A hash of fields and their maximum allowed lengths. Maximum length can also be a percentage of the total width
     #                 (decimal less than one). When a field exceeds it's maximum then it's
     #                 truncated and has a ... appended to it. Fields that aren't specified have no maximum.
@@ -90,7 +90,6 @@ module Hirb
     # [*:description*] When set to true, renders row count description at bottom. Default is true.
     # [*:escape_special_chars*] When set to true, escapes special characters \n,\t,\r so they don't disrupt tables. Default is false for
     #                           vertical tables and true for anything else.
-    # [*:return_rows*] When set to true, returns rows that have been initialized but not rendered. Default is false.
     # Examples:
     #    Hirb::Helpers::Table.render [[1,2], [2,3]]
     #    Hirb::Helpers::Table.render [[1,2], [2,3]], :max_fields=>{0=>10}, :header_filter=>:capitalize
@@ -100,7 +99,7 @@ module Hirb
     #    Hirb::Helpers::Table.render [{:age=>10, :weight=>100}, {:age=>80, :weight=>500}], :filters=>{:age=>[:to_f]}
     def render(rows, options={})
       options[:vertical] ? Helpers::VerticalTable.render(rows, options) :
-      options[:return_rows] ? new(rows, options).instance_variable_get("@rows") : new(rows, options).render
+      new(rows, options).render
     rescue TooManyFieldsForWidthError
       $stderr.puts "", "** Error: Too many fields for the current width. Configure your width " +
         "and/or fields to avoid this error. Defaulting to a vertical table. **"
@@ -121,6 +120,8 @@ module Hirb
   #:stopdoc:
   attr_accessor :width, :max_fields, :field_lengths, :fields
   def initialize(rows, options={})
+    raise ArgumentError, "Table must be an array of hashes or array of arrays" unless rows.is_a?(Array) &&
+      (rows[0].is_a?(Hash) or rows[0].is_a?(Array) or rows.empty?)
     @options = {:description=>true, :filters=>{}, :change_fields=>{}, :escape_special_chars=>true,
       :filter_any=>Helpers::Table.filter_any, :resize=>true}.merge(options)
     @fields = set_fields(rows)
@@ -134,19 +135,18 @@ module Hirb
   end
 
   def set_fields(rows)
-    fields = if @options[:fields]
-      @options[:fields].dup
+    @options[:change_fields] = array_to_indices_hash(@options[:change_fields]) if @options[:change_fields].is_a?(Array)
+    return @options[:fields].dup if @options[:fields]
+
+    fields = if rows[0].is_a?(Hash)
+      keys = @options[:all_fields] ? rows.map {|e| e.keys}.flatten.uniq : rows[0].keys
+      keys.sort {|a,b| a.to_s <=> b.to_s}
     else
-      if rows[0].is_a?(Hash)
-        keys = @options[:all_fields] ? rows.map {|e| e.keys}.flatten.uniq : rows[0].keys
-        keys.sort {|a,b| a.to_s <=> b.to_s}
-      else
-        rows[0].is_a?(Array) ? (0..rows[0].length - 1).to_a : []
-      end
+      rows[0].is_a?(Array) ? (0..rows[0].length - 1).to_a : []
     end
-    @options[:change_fields] = array_to_indices_hash(@options[:change_fields]) if @options[:change_fields].is_a?(Array)
+
     @options[:change_fields].each do |oldf, newf|
-      (index = fields.index(oldf)) ? fields[index] = newf : fields << newf
+      (index = fields.index(oldf)) && fields[index] = newf
     end
     fields
   end
@@ -267,7 +267,8 @@ module Hirb
 
   # find max length for each field; start with the headers
   def default_field_lengths
-    field_lengths = @headers ? @headers.inject({}) {|h,(k,v)| h[k] = String.size(v); h} : {}
+    field_lengths = @headers ? @headers.inject({}) {|h,(k,v)| h[k] = String.size(v); h} :
+      @fields.inject({}) {|h,e| h[e] = 1; h }
     @rows.each do |row|
       @fields.each do |field|
         len = String.size(row[field])

data/lib/hirb/helpers/tree.rb

@@ -43,6 +43,7 @@ class Hirb::Helpers::Tree
     # [:indent] Number of spaces to indent between levels for basic + number trees. Default is 4.
     # [:limit] Limits the level or depth of a tree that is displayed. Root node is level 0.
     # [:description] Displays brief description about tree ie how many nodes it has.
+    # [:multi_line_nodes] Handles multi-lined nodes by indenting their newlines. Default is false.
     #  Examples:
     #     Hirb::Helpers::Tree.render([[0, 'root'], [1, 'child']], :type=>:directory)
     def render(nodes, options={})
@@ -81,28 +82,27 @@ class Hirb::Helpers::Tree
     @indent = ' ' * (@options[:indent] || 4 )
     @nodes = @nodes.select {|e| e[:level] <= @options[:limit] } if @options[:limit]
     case @type.to_s
-    when 'directory'
-      render_directory
-    when 'number'
-      render_number
-    else
-      render_basic
+    when 'directory' then render_directory
+    when 'number'    then render_number
+    else render_basic
     end
   end
 
+  def render_nodes
+    value_indent = @options[:multi_line_nodes] ? @indent : nil
+    @nodes.map {|e| yield(e) + e.value(value_indent) }.join("\n")
+  end
+
   def render_directory
     mark_last_nodes_per_level
-    new_nodes = []
-    @nodes.each_with_index {|e, i|
+    render_nodes {|e|
       value = ''
       unless e.root?
         value << e.render_parent_characters
         value << (e[:last_node] ? "`-- " : "|-- ")
       end
-      value << e[:value]
-      new_nodes << value
+      value
     }
-    new_nodes.join("\n")
   end
   
   def render_number
@@ -113,13 +113,13 @@ class Hirb::Helpers::Tree
       counter[parent_level_key] += 1
       e[:pre_value] = "#{counter[parent_level_key]}. "
     }
-    @nodes.map {|e| @indent * e[:level] + e[:pre_value] + e[:value]}.join("\n")
+    render_nodes {|e| @indent * e[:level] + e[:pre_value] }
   end
-  
+
   def render_basic
-    @nodes.map {|e| @indent * e[:level] + e[:value]}.join("\n")
+    render_nodes {|e| @indent * e[:level] }
   end
-  
+
   def validate_nodes
     @nodes.each do |e|
       raise ParentlessNodeError if (e[:level] > e.previous[:level]) && (e[:level] - e.previous[:level]) > 1
@@ -146,6 +146,10 @@ class Hirb::Helpers::Tree
       replace(hash)
     end
 
+    def value(indent=nil)
+      indent ? self[:value].gsub("\n", "\n#{indent * self[:level]}") : self[:value]
+    end
+
     def parent
       self[:tree].nodes.slice(0 .. self[:index]).reverse.detect {|e| e[:level] < self[:level]}
     end

data/lib/hirb/import_object.rb

@@ -2,7 +2,7 @@ module Hirb
   module ObjectMethods
     # Takes same options as Hirb::View.render_output.
     def view(*args)
-      Hirb::View.console_render_output(*(args.unshift(self)))
+      Hirb::Console.render_output(*(args.unshift(self)))
     end
   end
 end

data/lib/hirb/menu.rb

@@ -197,7 +197,7 @@ module Hirb
     end
 
     def table_helper_class?
-      @options[:helper_class].is_a?(Class) && (@options[:helper_class] < Helpers::Table || @options[:helper_class] == Helpers::AutoTable)
+      @options[:helper_class].is_a?(Class) && @options[:helper_class] < Helpers::Table
     end
 
     def unalias_field(field)

data/lib/hirb/util.rb

@@ -16,7 +16,7 @@ module Hirb
          nil
       end
     end
-    
+
     # Recursively merge hash1 with hash2.
     def recursive_hash_merge(hash1, hash2)
       hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}

data/lib/hirb/version.rb

@@ -0,0 +1,3 @@
+module Hirb
+  VERSION = '0.3.0'
+end

data/lib/hirb/view.rb

@@ -1,6 +1,64 @@
 module Hirb
-  # This class is responsible for managing all view-related functionality. Its functionality is determined by setting up a configuration file
-  # as explained in Hirb and/or passed configuration directly to Hirb.enable. Most of the functionality in this class is dormant until enabled.
+  # This class is responsible for managing all view-related functionality.
+  #
+  # == Create a View
+  # Let's create a simple view for Hash objects:
+  #   $ irb -rubygems
+  #   >> require 'hirb'
+  #   =>true
+  #   >> Hirb.enable
+  #   =>nil
+  #   >> require 'yaml'
+  #   =>true
+  #
+  #   # A view method is the smallest view
+  #   >> def yaml(output); output.to_yaml; end
+  #   => nil
+  #   # Add the view
+  #   >> Hirb.add_view Hash, :method=>:yaml
+  #   => true
+  #
+  #   # Hashes now appear as yaml
+  #   >> {:a=>1, :b=>{:c=>3}}
+  #   ---
+  #   :a : 1
+  #   :b : 
+  #     :c : 3
+  #   => true
+  #
+  # Another way of creating a view is a Helper class:
+  #
+  #   # Create yaml view class
+  #   >> class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
+  #   =>nil
+  #   # Add the view
+  #   >> Hirb.add_view Hash, :class=>Hirb::Helpers::Yaml
+  #   =>true
+  #
+  #   # Hashes appear as yaml like above ...
+  #
+  # == Configure a View
+  # To configure the above Helper class as a view, either pass Hirb.enable a hash:
+  #   # In .irbrc
+  #   require 'hirb'
+  #   # View class needs to come before enable()
+  #   class Hirb::Helpers::Yaml; def self.render(output, options={}); output.to_yaml; end ;end
+  #   Hirb.enable :output=>{"Hash"=>{:class=>"Hirb::Helpers::Yaml"}}
+  #
+  # Or create a config file at config/hirb.yml or ~/.hirb.yml:
+  #   # The config file for the yaml example would look like:
+  #   # ---
+  #   # :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, options={}); output.to_yaml; end ;end
+  #   Hirb.enable
+  #
+  # For more about configuring Hirb, see the Config Files section in Hirb.
   module View
     DEFAULT_WIDTH = 120
     DEFAULT_HEIGHT = 40
@@ -10,26 +68,23 @@ module Hirb
 
       # This activates view functionality i.e. the formatter, pager and size detection. If irb exists, it overrides irb's output
       # method with Hirb::View.view_output. When called multiple times, new configs are merged into the existing config.
-      # If using Wirble, you should call this after it. The view configuration
-      # can be specified in a hash via a config file, as options to this method, as this method's block or any combination of these three.
-      # In addition to the config keys mentioned in Hirb, the options also take the following keys:
+      # If using Wirble, you should call this after it. The view configuration can be specified in a hash via a config file,
+      # or as options to this method. In addition to the config keys mentioned in Hirb, options also take the following keys:
       # ==== Options:
       # * config_file: Name of config file(s) that are merged into existing config
       # * output_method: Specify an object's class and instance method (separated by a period) to be realiased with
       #   hirb's view system. The instance method should take a string to be output. Default is IRB::Irb.output_value
       #   if using irb.
       # Examples:
-      #   Hirb::View.enable
-      #   Hirb::View.enable :formatter=>false, :output_method=>"Mini.output"
-      #   Hirb::View.enable {|c| c.output = {'String'=>{:class=>'Hirb::Helpers::Table'}} }
+      #   Hirb.enable
+      #   Hirb.enable :formatter=>false, :output_method=>"Mini.output"
       def enable(options={}, &block)
         Array(options.delete(:config_file)).each {|e|
           @new_config_file = true
           Hirb.config_files << e
         }
         enable_output_method(options.delete(:output_method))
-        puts "Using a block with View.enable will be *deprecated* in the next release" if block_given?
-        merge_or_load_config(Util.recursive_hash_merge(options, HashStruct.block_to_hash(block)))
+        merge_or_load_config options
         resize(config[:width], config[:height])
         @enabled = true
       end
@@ -102,14 +157,18 @@ module Hirb
         config ? config[:height] : DEFAULT_HEIGHT
       end
 
-      # Current formatter config
+      # Current formatter config, storing a hash of all static views
       def formatter_config
         formatter.config
       end
 
-      # Sets the helper config for the given output class.
-      def format_class(klass, helper_config)
-        formatter.format_class(klass, helper_config)
+      # Adds a view when View is enabled. See Formatter.add_view for more details.
+      def add(klass, view_config)
+        if enabled?
+          formatter.add_view(klass, view_config)
+        else
+          puts "View must be enabled to add a view"
+        end
       end
 
       #:stopdoc:
@@ -217,8 +276,4 @@ module Hirb
       #:startdoc:
     end
   end
-  
-  # Namespace for autoloaded views
-  module Views
-  end
-end
+end

data/lib/hirb/views.rb

@@ -0,0 +1,8 @@
+module Hirb
+  # Namespace for Helpers defining multiple views in a module i.e. via DynamicView.
+  module Views
+    module Single #:nodoc:
+    end
+  end
+end
+%w{rails orm mongo_db couch_db misc_db}.each {|e| require "hirb/views/#{e}" }

data/lib/hirb/views/couch_db.rb

@@ -0,0 +1,11 @@
+module Hirb::Views::CouchDb #:nodoc:
+  def default_couch(obj)
+    {:fields=>([:_id] + obj.class.properties.map {|e| e.name }) }
+  end
+
+  alias_method :couch_rest__extended_document_view, :default_couch
+  alias_method :couch_foo__base_view, :default_couch
+  alias_method :couch_potato__persistence_view, :default_couch
+end
+
+Hirb::DynamicView.add Hirb::Views::CouchDb, :helper=>:auto_table

data/lib/hirb/views/misc_db.rb

@@ -0,0 +1,15 @@
+module Hirb::Views::MiscDb #:nodoc:
+  def friendly__document_view(obj)
+    {:fields=>obj.class.attributes.keys - [:id]}
+  end
+
+  def ripple__document_view(obj)
+    {:fields=>obj.class.properties.keys}
+  end
+
+  def d_b_i__row_view(obj)
+    {:fields=>obj.column_names, :table_class=>Hirb::Helpers::Table}
+  end
+end
+
+Hirb::DynamicView.add Hirb::Views::MiscDb, :helper=>:auto_table

data/lib/hirb/views/mongo_db.rb

@@ -0,0 +1,15 @@
+module Hirb::Views::MongoDb #:nodoc:
+  def mongoid__document_view(obj)
+    {:fields=>['_id'] + obj.class.fields.keys}
+  end
+
+  def mongo_mapper__document_view(obj)
+    {:fields=>obj.class.column_names}
+  end
+
+  def mongo_mapper__embedded_document_view(obj)
+    {:fields=>obj.class.column_names}
+  end
+end
+
+Hirb::DynamicView.add Hirb::Views::MongoDb, :helper=>:auto_table

data/lib/hirb/views/orm.rb

@@ -0,0 +1,11 @@
+module Hirb::Views::ORM #:nodoc:
+  def data_mapper__resource_view(obj)
+    {:fields=>obj.class.properties.map {|e| e.name }}
+  end
+
+  def sequel__model_view(obj)
+    {:fields=>obj.class.columns}
+  end
+end
+
+Hirb::DynamicView.add Hirb::Views::ORM, :helper=>:auto_table