hirb 0.2.10 → 0.3.0

data/CHANGELOG.rdoc

@@ -1,3 +1,17 @@
+== 0.3.0
+* Added dynamic views.
+* Added default table views for the following database classes/modules:
+  CouchFoo::Base, CouchPotato::Persistence, CouchRest::ExtendedDocument,
+  DBI::Row, DataMapper::Resource, Friendly::Document, MongoMapper::Document, MongoMapper::EmbeddedDocument,
+  Mongoid::Document, Ripple::Document and Sequel::Model.
+* Added Hirb.add_view and Hirb.add_dynamic_view for easier view manipulation.
+* Added :multi_line_nodes option for Tree.
+* Fixed :change_fields option bug in Table.
+* Fixed no headers and nil fields bug in Table.
+* Removed deprecations in Hirb.config_file + View.enable.
+* Removed Views classes and View.format_class.
+* Removed :return_rows option for Table.
+
 == 0.2.10
 * Added multiple options to Menu, most importantly :two_d and :action.
 * Improved table resizing algorithm.

data/README.rdoc

@@ -1,12 +1,14 @@
 == Description
 
-Hirb currently provides a mini view framework for console applications, designed to improve irb's default output.
-Hirb improves console output by providing a smart pager and auto-formatting output. The smart pager detects when an output exceeds
-a screenful and thus only pages output as needed. Auto-formatting adds a view to an output's class. This is helpful in separating
-views from content (MVC anyone?). The framework encourages reusing views by letting you
-package them in classes and associate them with any number of output classes.  Hirb comes with tree views (see
-Hirb::Helpers::Tree) and table views (see Hirb::Helpers::Table). By default Hirb displays Rails'
-model classes as tables. Hirb also sports a nice selection menu, Hirb::Menu.
+Hirb provides a mini view framework for console applications and uses it to improve irb's default inspect output.
+Given an object or array of objects, hirb renders a view based on the object's class and/or ancestry. Hirb offers reusable
+views in the form of helper classes. The two main helpers, Hirb::Helpers::Table and Hirb::Helpers::Tree, provide several options
+for generating ascii tables and trees. Using Hirb::Helpers::AutoTable, hirb has useful default views for at least ten popular database gems
+i.e. Rails' ActiveRecord::Base. Other than views, hirb offers a smart pager and a console menu. The smart pager
+only pages when the output exceeds the current screen size. The menu is used in conjunction with tables to offer
+{two dimensional menus}[http://tagaholic.me/2010/02/16/two-dimensional-console-menus-with-hirb.html].
+
+Note: To read a linked version of this README, {click here}[http://tagaholic.me/hirb/doc/].
 
 == Install
 
@@ -14,40 +16,28 @@ Install the gem with:
 
     sudo gem install hirb
 
-== Pager
-
-Hirb has both pager and formatter functionality enabled by default.
-If you want to turn off the functionality of either you can pass that in at startup:
+== View Tutorials
 
-  Hirb.enable :pager=>false
-  Hirb.enable :formatter=>false
+* To create and configure views, see Hirb::View or {here if on the web}[http://tagaholic.me/hirb/doc/classes/Hirb/View.html].
+* To create dynamic views, see Hirb::DynamicView or {here if on the web}[http://tagaholic.me/hirb/doc/classes/Hirb/DynamicView.html].
 
-or toggle their state at runtime:
-
-  Hirb::View.toggle_pager
-  Hirb::View.toggle_formatter
-
-== Create and Configure Views
-
-If you'd like to learn how to create and configure views, {read the docs}[http://tagaholic.me/hirb/doc/classes/Hirb/Formatter.html].
-
-== Rails Formatter Example
+== Rails Example
 
 Let's load and enable the view framework:
-  bash> script/console
-  Loading local environment (Rails 2.2.2)
-  irb>> require 'hirb'
+  $ script/console
+  Loading local environment (Rails 2.3.5)
+  >> require 'hirb'
   => true
-  irb>> Hirb.enable
+  >> Hirb.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.formatter_config
-  => {"ActiveRecord::Base"=>{:class=>"Hirb::Views::ActiveRecord_Base", :ancestor=>true}}
+  >> Hirb::Formatter.dynamic_config['ActiveRecord::Base']
+  => {:class=>Hirb::Helpers::AutoTable, :ancestor=>true}
 
   # Tag is a model class and descendant of ActiveRecord::Base
-  irb>> Tag.last
+  >> Tag.last
   +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
   | id  | created_at              | description | name          | namespace | predicate | value |
   +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
@@ -55,19 +45,22 @@ If a class isn't configured, Hirb reverts to irb's default echo mode.
   +-----+-------------------------+-------------+---------------+-----------+-----------+-------+
   1 row in set
 
-  irb>> 'plain ol irb'
+  >> Hirb::Formatter.dynamic_config['String']
+  => nil
+  >> 'plain ol irb'
   => 'plain ol irb'
-  irb>> :blah
+  >> Hirb::Formatter.dynamic_config['Symbol']
+  => nil
+  >> :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.
+From above you can see there are no views configured for a String or a Symbol so Hirb defaults to
+irb's echo mode. On the other hand, Tag has a view thanks to being a descendant of ActiveRecord::Base
+and there being 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:
+Having seen hirb display views based on an output object's class, let's see it handle an array of objects:
 
-  irb>> Tag.all :limit=>3, :order=>"id DESC"
+  >> Tag.all :limit=>3, :order=>"id DESC"
   +-----+-------------------------+-------------+-------------------+-----------+-----------+----------+
   | id  | created_at              | description | name              | namespace | predicate | value    |
   +-----+-------------------------+-------------+-------------------+-----------+-----------+----------+
@@ -78,9 +71,9 @@ you may appreciate it also detects configured output objects in an array:
   3 rows in set
 
 At any time you can disable Hirb if you really like irb's lovely echo mode:
-  irb>> Hirb.disable
+  >> Hirb.disable
   => nil
-  irb>> Tag.all :limit=>3, :order=>"id DESC"
+  >> 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:
@@ -92,15 +85,15 @@ While preconfigured tables are great for database records, sometimes you just wa
 tables/views for any output object:
   
   #These examples don't need to have Hirb::View enabled.
-  irb>>Hirb.disable
-  =>nil
+  >> Hirb.disable
+  => nil
 
   # Imports table() and view()
-  irb>>extend Hirb::Console
-  =>main
+  >> 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]
+  >> table [Date.today, Date.today.next_month], :fields=>[:to_s, :ld, :ajd, :amjd, :asctime]
   +------------+--------+-----------+-------+--------------------------+
   | to_s       | ld     | ajd       | amjd  | asctime                  |
   +------------+--------+-----------+-------+--------------------------+
@@ -110,44 +103,56 @@ tables/views for any output object:
   2 rows in set
 
   # Same table as the previous method. However view() will be able to call any helper.
-  irb>> view [Date.today, Date.today.next_month], :class=>:object_table,
+  >> view [Date.today, Date.today.next_month], :class=>:object_table,
     :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'
+  >> require 'hirb/import_object'
   =>true
   # Yields same table as above examples.
-  irb>> [Date.today, Date.today.next_month].view :class=>:object_table,
+  >> [Date.today, Date.today.next_month].view :class=>:object_table,
     :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) } }
+  >> 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=>:object_table,
+  >> view [Date.today, Date.today.next_month], :class=>:object_table,
     :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
+  # Doesn't write to file because Symbol doesn't have a view and thus defaults to irb's echo mode.
+  >> :blah
   =>:blah
 
   # Go back to printing Hirb views to STDOUT.
-  irb>> Hirb::View.reset_render_method
+  >> Hirb::View.reset_render_method
+
+== Pager
+
+Hirb has both pager and formatter functionality enabled by default.
+If you want to turn off the functionality of either you can pass that in at startup:
+
+  Hirb.enable :pager=>false
+  Hirb.enable :formatter=>false
+
+or toggle their state at runtime:
+
+  Hirb::View.toggle_pager
+  Hirb::View.toggle_formatter
 
-== Sharing Views
-If you have tested views you'd like to share, fork Hirb and put your views under
-the lib/hirb/views/ and/or helpers files under lib/hirb/helpers/. If not tested, feel free to share
-them on the wiki.
+== Sharing Helpers and Views
+If you have tested helpers you'd like to share, fork Hirb and put them under lib/hirb/helpers. To share
+views for certain classes, put them under lib/hirb/views. Please submit views for gems that have a nontrivial
+number of users.
 
 == Limitations
 If using Wirble, you should call Hirb after it since they both override irb's default output.
 
 == Motivation
-Table code from http://gist.github.com/72234 and {my console
-app's needs}[http://github.com/cldwalker/tag-tree].
+Table code from http://gist.github.com/72234 and {my console app's needs}[http://github.com/cldwalker/tag-tree].
 
 == Credits
 * Chrononaut for vertical table helper.
@@ -162,7 +167,6 @@ Please report them {on github}[http://github.com/cldwalker/hirb/issues].
 * http://tagaholic.me/2009/06/19/page-irb-output-and-improve-ri-with-hirb.html
 
 == Todo
-* Consider applying multiple views/filters to output.
-* Consider mapping a class' methods to their own views.
-* Provides helper methods to all view classes.
-* Consider adding a template system as needed.
+* Consider generating views based on methods an object responds to.
+* Provide helper methods to all views.
+* Consider adding a template helper.

data/Rakefile

@@ -16,8 +16,11 @@ end
 
 begin
   require 'jeweler'
+  require File.dirname(__FILE__) + "/lib/hirb/version"
+
   Jeweler::Tasks.new do |s|
     s.name = "hirb"
+    s.version = Hirb::VERSION
     s.summary = "A mini view framework for console/irb that's easy to use, even while under its influence."
     s.description = "Hirb currently provides a mini view framework for console applications, designed to improve irb's default output.  Hirb improves console output by providing a smart pager and auto-formatting output. The smart pager detects when an output exceeds a screenful and thus only pages output as needed. Auto-formatting adds a view to an output's class. This is helpful in separating views from content (MVC anyone?). The framework encourages reusing views by letting you package them in classes and associate them with any number of output classes."
     s.email = "gabriel.horner@gmail.com"

data/lib/hirb.rb

@@ -6,28 +6,29 @@ $KCODE = 'u' if RUBY_VERSION < '1.9'
 
 require 'hirb/util'
 require 'hirb/string'
-require 'hirb/hash_struct'
+require 'hirb/formatter' # must come before helpers/auto_table
+require 'hirb/dynamic_view'
 require 'hirb/helpers'
+require 'hirb/views'
 require 'hirb/view'
-require 'hirb/views/activerecord_base'
 require 'hirb/console'
-require 'hirb/formatter'
 require 'hirb/pager'
 require 'hirb/menu'
+require 'hirb/version'
 
-# Most of Hirb's functionality currently resides in Hirb::View.
-# For an in-depth tutorial on creating and configuring views see Hirb::Formatter.
+# Most of Hirb's functionality is in Hirb::View.
+# For a tutorial  on configuring and creating views see Hirb::View. For a tutorial on dynamic views see Hirb::DynamicView.
+#
+# == Config Files
 # Hirb can have multiple config files defined by config_files(). These config files
 # have the following top level keys:
-# [:output] This hash is used by the formatter object. See Hirb::Formatter.config for its format.
-# [:width]  Width of the terminal/console. Defaults to DEFAULT_WIDTH or possibly autodetected when Hirb is enabled.
-# [:height]  Height of the terminal/console. Defaults to DEFAULT_HEIGHT or possibly autodetected when Hirb is enabled.
-# [:formatter] Boolean which determines if the formatter is enabled. Defaults to true.
-# [:pager] Boolean which determines if the pager is enabled. Defaults to true.
-# [:pager_command] Command to be used for paging. Command can have options after it i.e. 'less -r'.
-#                  Defaults to common pagers i.e. less and more if detected.
-#
-
+# [*:output*] This hash is used by the formatter object. See Hirb::Formatter.config for its format.
+# [*:width*]  Width of the terminal/console. Defaults to Hirb::View::DEFAULT_WIDTH or possibly autodetected when Hirb is enabled.
+# [*:height*]  Height of the terminal/console. Defaults to Hirb::View::DEFAULT_HEIGHT or possibly autodetected when Hirb is enabled.
+# [*:formatter*] Boolean which determines if the formatter is enabled. Defaults to true.
+# [*:pager*] Boolean which determines if the pager is enabled. Defaults to true.
+# [*:pager_command*] Command to be used for paging. Command can have options after it i.e. 'less -r'.
+#                    Defaults to common pagers i.e. less and more if detected.
 module Hirb
   class <<self
     attr_accessor :config_files, :config
@@ -42,6 +43,16 @@ module Hirb
       View.disable
     end
 
+    # Adds views. See Hirb::View.add for details.
+    def add_view(view, options, &block)
+      View.add(view, options, &block)
+    end
+
+    # Adds views. See Hirb::DynamicView.add for details.
+    def add_dynamic_view(view, options, &block)
+      DynamicView.add(view, options, &block)
+    end
+
     # Array of config files which are merged sequentially to produce config.
     # Defaults to config/hirb.yml and ~/.hirb_yml
     def config_files
@@ -49,10 +60,6 @@ module Hirb
     end
 
     #:stopdoc:
-    def config_file
-      puts "Hirb.config_file is *deprecated*. Use Hirb.config_files"
-    end
-
     def default_config_files
       [File.join(Util.find_home, ".hirb.yml")] +
         (File.exists?('config/hirb.yml') ? ['config/hirb.yml'] : [])

data/lib/hirb/console.rb

@@ -1,9 +1,9 @@
 module Hirb
   # This module 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]]
+  #    >> extend Hirb::Console
+  #    >> view 'some string', :class=>Some::String::Formatter
+  #    >> table [[:row1], [:row2]]
   module Console
     class<<self
       # A console version of render_output() which takes its same options but allows for shorthand. All options are passed to

data/lib/hirb/dynamic_view.rb

@@ -0,0 +1,112 @@
+module Hirb
+  # This module extends a Helper with the ability to have dynamic views for configured output classes.
+  # After a Helper has extended this module, it can use it within a render() by calling
+  # dynamic_options() to get dynamically generated options for the object it's rendering. See Hirb::Helpers::AutoTable as an example.
+  #
+  # == Dynamic Views
+  # Whereas normal views are generated from helpers with static helper options, dynamic views are generated from helpers and
+  # dynamically generated helper options. Let's look at an example for Rails' ActiveRecord classes:
+  #
+  #   Hirb.add_dynamic_view("ActiveRecord::Base", :helper=>:auto_table) {|obj|
+  #    {:fields=>obj.class.column_names} }
+  #
+  # From this dynamic view definition, _any_ ActiveRecord model class will render a table with the correct fields, since the fields
+  # are extracted from the output object's class at runtime. Note that dynamic view definitions should return a hash of helper options.
+  #
+  # To define multiple dynamic views, create a Views module where each method ending in '\_view' maps to a class/module:
+  #
+  #   module Hirb::Views::ORM
+  #     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.add_dynamic_view Hirb::Views::ORM, :helper=>:auto_table
+  #
+  # In this example, 'data_mapper__resource_view' maps to DataMapper::Resource and 'sequel__model_view' maps to Sequel::Model.
+  # Note that when mapping method names to class names, '__' maps to '::' and '_' signals the next letter to be capitalized.
+  module DynamicView
+    # Add dynamic views to output class(es) for a given helper. If defining one view, the first argument is the output class
+    # and a block defines the dynamic view. If defining multiple views, the first argument should be a Views::* module where
+    # each method in the module ending in _view defines a view for an output class. To map output classes to method names in
+    # a Views module, translate'::' to '__' and a capital letter translates to a '_' and a lowercase letter.
+    # ==== Options:
+    # [*:helper*] Required option. Helper class that view(s) use to format. Hirb::Helpers::AutoTable is the only valid
+    #             helper among default helpers. Can be given in aliased form i.e. :auto_table -> Hirb::Helpers::AutoTable.
+    #
+    # Examples:
+    #    Hirb.add_dynamic_view Hirb::Views::ORM, :helper=>:auto_table
+    #    Hirb.add_dynamic_view("ActiveRecord::Base", :helper=>:auto_table) {|obj| {:fields=>obj.class.column_names} }
+    def self.add(view, options, &block)
+      raise ArgumentError, ":helper option is required" unless options[:helper]
+      helper = Helpers.helper_class options[:helper]
+      unless helper.is_a?(Module) && class << helper; self.ancestors; end.include?(self)
+        raise ArgumentError, ":helper option must be a helper that has extended DynamicView"
+      end
+      mod = block ? generate_single_view_module(view, &block) : view
+      raise ArgumentError, "'#{mod}' must be a module" unless mod.is_a?(Module)
+      helper.add_module mod
+    end
+
+    def self.generate_single_view_module(output_mod, &block) #:nodoc:
+      mod_name = class_to_method output_mod.to_s
+      Views::Single.send(:remove_const, mod_name) if Views::Single.const_defined?(mod_name)
+      mod = Views::Single.const_set(mod_name, Module.new)
+      mod.send(:define_method, mod_name.downcase, block)
+      mod
+    end
+
+    def self.class_to_method(mod) #:nodoc:
+      mod.gsub("::","__").gsub(/([A-Z])/, '_\1').gsub(/(^|::)_/,'\1') + '_view'
+    end
+
+    # Returns a hash of options based on dynamic views defined for the object's ancestry. If no config is found returns nil.
+    def dynamic_options(obj)
+      view_methods.each do |meth|
+        if obj.class.ancestors.map {|e| e.to_s }.include?(method_to_class(meth))
+          begin
+            return send(meth, obj)
+          rescue
+            raise "View failed to generate for '#{method_to_class(meth)}' "+
+              "while in '#{meth}' with error:\n#{$!.message}"
+          end
+        end
+      end
+      nil
+    end
+
+    #:stopdoc:
+    def add_module(mod)
+      new_methods = mod.instance_methods.select {|e| e.to_s =~ /_view$/ }.map {|e| e.to_s}
+      return if new_methods.empty?
+      extend mod
+      view_methods.replace(view_methods + new_methods).uniq!
+      update_config(new_methods)
+    end
+
+    def update_config(meths)
+      output_config = meths.inject({}) {|t,e|
+        t[method_to_class(e)] = {:class=>self, :ancestor=>true}; t
+      }
+      Formatter.dynamic_config.merge! output_config
+    end
+
+    def method_to_class(meth)
+      view_method_classes[meth] ||= Util.camelize meth.sub(/_view$/, '').gsub('__', '/')
+    end
+
+    def view_method_classes
+      @view_method_classes ||= {}
+    end
+    #:startdoc:
+
+    # Stores view methods that a Helper has been given via DynamicView.add
+    def view_methods
+      @view_methods ||= []
+    end
+  end
+end

data/lib/hirb/formatter.rb

@@ -1,160 +1,77 @@
 module Hirb
-=begin rdoc
-  This class is format an output into a string using Hirb::Helpers::*, Hirb::Views::* or any user-created views.
-  The formatter object looks for an output's class config in Hirb::Formatter.config and if found applies a helper to the output.
-
-  == 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.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
-    irb>>Hirb::View.format_class Hash, :method=>:yaml
-    =>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, options={}); output.to_yaml; end ;end
-    =>nil
-    # Just reload since no configuration is necessary
-    irb>>Hirb::View.formatter.reload
-
-    # 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, options={}); output.to_yaml; end ;end
-    =>nil
-
-    # Configure view and reload it
-    irb>>Hirb::View.format_class Hash, :class=>"Hirb::Helpers::Yaml"
-    =>true
-
-    # 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.enable an options 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 by creating 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
-=end 
-  
+  # A Formatter object formats an output object (using Formatter.format_output) into a string based on the views defined
+  # for its class and/or ancestry.
   class Formatter
-    def initialize(additional_config={})
+    class<<self
+      # This config is used by Formatter.format_output to lazily load dynamic views defined with Hirb::DynamicView.
+      # This hash has the same format as Formatter.config.
+      attr_accessor :dynamic_config
+    end
+    self.dynamic_config = {}
+
+    def initialize(additional_config={}) #:nodoc:
       @klass_config = {}
-      @config = Util.recursive_hash_merge default_config, additional_config || {}
+      @config = additional_config || {}
     end
 
-    # A hash of Ruby class strings mapped to helper config hashes. A helper config hash must have at least a :method, :output_method
-    # or :class option for a helper to be applied to an output. A helper config hash has the following keys:
-    # [:method] Specifies a global (Kernel) method to do the formatting.
-    # [:class] Specifies a class to do the formatting, using its render() class method. If a symbol it's converted to a corresponding
-    #          Hirb::Helpers::* class if it exists.
-    # [:output_method] Specifies a method or proc to call on output before passing it to a helper. If the output is an array, it's applied
-    #                  to every element in the array.
-    # [:options] Options to pass the helper method or class.
-    # [:ancestor] Boolean which when true causes subclasses of the output class to inherit its config. This doesn't effect the current 
-    #             output class. Defaults to false. This is used by ActiveRecord classes.
+    # A hash of Ruby class strings mapped to view hashes. A view hash must have at least a :method, :output_method
+    # or :class option for a view to be applied to an output. A view hash has the following keys:
+    # [*:method*] Specifies a global (Kernel) method to do the formatting.
+    # [*:class*] Specifies a class to do the formatting, using its render() class method. If a symbol it's converted to a corresponding
+    #            Hirb::Helpers::* class if it exists.
+    # [*:output_method*] Specifies a method or proc to call on output before passing it to a helper. If the output is an array, it's applied
+    #                    to every element in the array.
+    # [*:options*] Options to pass the helper method or class.
+    # [*:ancestor*] Boolean which when true causes subclasses of the output class to inherit its config. This doesn't effect the current
+    #               output class. Defaults to false. This is used by ActiveRecord classes.
     # 
     #   Examples:
     #     {'WWW::Delicious::Element'=>{:class=>'Hirb::Helpers::ObjectTable', :ancestor=>true, :options=>{:max_width=>180}}}
     #     {'Date'=>{:class=>:auto_table, :ancestor=>true}}
+    #     {'Hash'=>{:method=>:puts}}
     def config
       @config
     end
 
-    # Sets the helper config for the given output class.
-    def format_class(klass, helper_config)
+    # Adds the view for the given class and view hash config. See Formatter.config for valid keys for view hash.
+    def add_view(klass, view_config)
       @klass_config.delete(klass)
-      @config[klass.to_s] = helper_config
+      @config[klass.to_s] = view_config
       true
     end
 
-    # Reloads autodetected Hirb::Views
-    def reload
-      @config = Util.recursive_hash_merge default_config, @config
-    end
-
-    # This is the main method of this class. The formatter looks for the first helper in its config for the given output class.
-    # If a helper is found, the output is converted by the helper into a string and returned. If not, nil is returned. The options
-    # this class takes are a helper config hash as described in config. These options will be merged with any existing helper config hash
-    # an output class has in config. Any block given is passed along to a helper class.
+    # This method looks for an output object's view in Formatter.config and then Formatter.dynamic_config.
+    # If a view is found, a stringified view is returned based on the object. If no view is found, nil is returned. The options this
+    # class takes are a view hash as described in Formatter.config. These options will be merged with any existing helper
+    # config hash an output class has in Formatter.config. Any block given is passed along to a helper class.
     def format_output(output, options={}, &block)
       output_class = determine_output_class(output)
       options = parse_console_options(options) if options.delete(:console)
       options = Util.recursive_hash_merge(klass_config(output_class), options)
-      output = options[:output_method] ? (output.is_a?(Array) ? output.map {|e| call_output_method(options[:output_method], e) } : 
+      _format_output(output, options, &block)
+    end
+
+    #:stopdoc:
+    def _format_output(output, options, &block)
+      output = options[:output_method] ? (output.is_a?(Array) ?
+        output.map {|e| call_output_method(options[:output_method], e) } :
         call_output_method(options[:output_method], output) ) : output
       args = [output]
       args << options[:options] if options[:options] && !options[:options].empty?
       if options[:method]
-        new_output = send(options[:method],*args)
-      elsif options[:class] && (helper_class = determine_helper_class(options[:class]))
-        new_output = helper_class.render(*args, &block)
+        send(options[:method],*args)
+      elsif options[:class] && (helper_class = Helpers.helper_class(options[:class]))
+        helper_class.render(*args, &block)
       elsif options[:output_method]
-        new_output = output
+        output
       end
-      new_output
     end
 
-    #:stopdoc:
     def parse_console_options(options) #:nodoc:
       real_options = [:method, :class, :output_method].inject({}) do |h, e|
         h[e] = options.delete(e) if options[e]; h
       end
       real_options.merge! :options=>options
-      real_options
-    end
-
-    def determine_helper_class(klass)
-      if (helper_class = Helpers.constants.find {|e| e.to_s == Util.camelize(klass.to_s)})
-        klass = "Hirb::Helpers::#{helper_class}"
-      end
-      Util.any_const_get(klass)
     end
 
     def determine_output_class(output)
@@ -168,28 +85,32 @@ module Hirb
     # Internal view options built from user-defined ones. Options are built by recursively merging options from oldest
     # ancestors to the most recent ones.
     def klass_config(output_class)
-      @klass_config[output_class] ||= begin
-        output_ancestors_with_config = output_class.ancestors.map {|e| e.to_s}.select {|e| @config.has_key?(e)}
-        @klass_config[output_class] = output_ancestors_with_config.reverse.inject({}) {|h, klass|
-          (klass == output_class.to_s || @config[klass][:ancestor]) ? Util.recursive_hash_merge(h, @config[klass]) : h
-        }
+      @klass_config[output_class] ||= build_klass_config(output_class)
+    end
+
+    def build_klass_config(output_class)
+      output_ancestors = output_class.ancestors.map {|e| e.to_s}.reverse
+      output_ancestors.pop
+      hash = output_ancestors.inject({}) {|h, klass|
+        add_klass_config_if_true(h, klass) {|c,klass| c[klass] && c[klass][:ancestor] }
+      }
+      add_klass_config_if_true(hash, output_class.to_s) {|c,klass| c[klass] }
+    end
+
+    def add_klass_config_if_true(hash, klass)
+      if yield(@config, klass)
+        Util.recursive_hash_merge hash, @config[klass]
+      elsif yield(self.class.dynamic_config, klass)
+        @config[klass] = self.class.dynamic_config[klass].dup # copy to local
+        Util.recursive_hash_merge hash, self.class.dynamic_config[klass]
+      else
+        hash
       end
     end
 
     def reset_klass_config
       @klass_config = {}
     end
-
-    def default_config
-      Views.constants.inject({}) {|h,e|
-        output_class = e.to_s.gsub("_", "::")
-        if (views_class = 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
+end