bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/console.rb

@@ -1,43 +0,0 @@
-module Hirb
-  # This module is meant to be extended to provide methods for use in a console/irb shell.
-  # For example:
-  #    >> 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
-      # the helper except for the formatter options. Formatter options are :class, :method and :output_method.
-      # Examples:
-      #   render_output output, :class=>:tree :type=>:directory
-      #   # is the same as:
-      #   render_output output, :class=>:tree, :options=> {:type=>:directory}
-      #
-      def render_output(output, options={})
-        View.load_config unless View.config_loaded?
-        View.render_output(output, options.merge(:console=>true))
-      end
-
-      # Takes same arguments and options as render_output() but returns formatted output instead of rendering it.
-      def format_output(output, options={}, &block)
-        View.load_config unless View.config_loaded?
-        View.formatter.format_output(output, options.merge(:console=>true), &block)
-      end
-    end
-
-    # Renders a table for the given object. Takes same options as Hirb::Helpers::Table.render.
-    def table(output, options={})
-      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(output, options={})
-      Console.render_output(output, options)
-    end
-
-    # Renders a menu given an array using Hirb::Menu.render.
-    def menu(output, options={}, &block)
-      Console.format_output(output, options.merge(:class=>"Hirb::Menu"), &block)
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/dynamic_view.rb

@@ -1,113 +0,0 @@
-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:
-      meth = class_to_method output_mod.to_s
-      view_mod = meth.capitalize
-      Views::Single.send(:remove_const, view_mod) if Views::Single.const_defined?(view_mod)
-      mod = Views::Single.const_set(view_mod, Module.new)
-      mod.send(:define_method, meth, block)
-      mod
-    end
-
-    def self.class_to_method(mod) #:nodoc:
-      mod.gsub(/(?!^)([A-Z])/) {|e| '_'+e }.gsub('::_', '__').downcase + '_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/bbcloud/vendor/hirb-0.3.4/lib/hirb/formatter.rb

@@ -1,116 +0,0 @@
-module Hirb
-  # 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
-    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 = additional_config || {}
-    end
-
-    # 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
-
-    # 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] = view_config
-      true
-    end
-
-    # 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)
-      _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]
-        send(options[:method],*args)
-      elsif options[:class] && (helper_class = Helpers.helper_class(options[:class]))
-        helper_class.render(*args, &block)
-      elsif options[:output_method]
-        output
-      end
-    end
-
-    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
-    end
-
-    def determine_output_class(output)
-      output.respond_to?(:to_a) ? Array(output)[0].class : output.class
-    end
-
-    def call_output_method(output_method, output)
-      output_method.is_a?(Proc) ? output_method.call(output) : output.send(output_method)
-    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 klass_config(output_class)
-      @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
-    #:startdoc:
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers.rb

@@ -1,17 +0,0 @@
-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 auto_table tree parent_child_tree vertical_table}.each do |e|
-  require "hirb/helpers/#{e}"
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/auto_table.rb

@@ -1,24 +0,0 @@
-# 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={})
-    output = Array(output)
-    (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

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/object_table.rb

@@ -1,14 +0,0 @@
-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].
-  def self.render(rows, options ={})
-    options[:fields] ||= [:to_s]
-    options[:headers] ||= {:to_s=>'value'} if options[:fields] == [:to_s]
-    item_hashes = options[:fields].empty? ? [] : Array(rows).inject([]) {|t,item|
-      t << options[:fields].inject({}) {|h,f| h[f] = item.__send__(f); h}
-    }
-    super(item_hashes, options)
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/parent_child_tree.rb

@@ -1,24 +0,0 @@
-class Hirb::Helpers::ParentChildTree < Hirb::Helpers::Tree
-  class <<self
-    # Starting with the given node, this builds a tree by recursively calling a children method.
-    # Takes same options as Hirb::Helper::Table.render with some additional ones below.
-    # ==== Options:
-    # [:value_method] Method or proc to call to display as a node's value. If not given, uses :name if node
-    #                 responds to :name or defaults to :object_id.
-    # [:children_method] Method or proc to call to obtain a node's children. Default is :children.
-    def render(root_node, options={})
-      value_method = options[:value_method] || (root_node.respond_to?(:name) ? :name : :object_id)
-      @value_method = value_method.is_a?(Proc) ? value_method : lambda {|n| n.send(value_method) }
-      children_method = options[:children_method] || :children
-      @children_method = children_method.is_a?(Proc) ? children_method : lambda {|n| n.send(children_method)}
-      @nodes = []
-      build_node(root_node, 0)
-      super(@nodes, options)
-    end
-
-    def build_node(node, level) #:nodoc:
-      @nodes << {:value=>@value_method.call(node), :level=>level}
-      @children_method.call(node).each {|e| build_node(e, level + 1)}
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb-0.3.4/lib/hirb/helpers/table.rb

@@ -1,323 +0,0 @@
-require 'hirb/helpers/table/filters'
-require 'hirb/helpers/table/resizer'
-
-module Hirb
-# 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 the max_width option or Hirb::View.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.
-#
-# === Custom Callbacks
-# Callback methods can be defined to add your own options that modify rows right before they are rendered.
-# Here's an example that allows for searching with a :query option:
-#   module Query
-#     # Searches fields given a query hash
-#     def query_callback(rows, options)
-#       return rows unless options[:query]
-#       options[:query].map {|field,query|
-#         rows.select {|e| e[field].to_s =~ /#{query}/i }
-#       }.flatten.uniq
-#     end
-#   end
-#   Hirb::Helpers::Table.send :include, Query
-#
-#   >> puts Hirb::Helpers::Table.render [{:name=>'batman'}, {:name=>'robin'}], :query=>{:name=>'rob'}
-#   +-------+
-#   | name  |
-#   +-------+
-#   | robin |
-#   +-------+
-#   1 row in set
-#
-# Callback methods:
-# * must be defined in Helpers::Table and end in '_callback'.
-# * should expect rows and a hash of render options. Rows will be an array of hashes.
-# * are expected to return an array of hashes.
-# * are invoked in alphabetical order.
-# For a thorough example, see {Boson::Pipe}[http://github.com/cldwalker/boson/blob/master/lib/boson/pipe.rb].
-#--
-# derived from http://gist.github.com/72234
- class Helpers::Table
-  BORDER_LENGTH = 3 # " | " and "-+-" are the borders
-  MIN_FIELD_LENGTH = 3
-  class TooManyFieldsForWidthError < StandardError; end
-
-  class << self
-    
-    # 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.
-    #              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.
-    # [*:max_width*] The maximum allowed width of all fields put together including field borders. Only valid when :resize is true.
-    #                Default is Hirb::View.width.
-    # [*:resize*] Resizes table to display all columns in allowed :max_width. Default is true. Setting this false will display the full
-    #             length of each field.
-    # [*:number*] When set to true, numbers rows by adding a :hirb_number column as the first column. Default is false.
-    # [*:change_fields*] A hash to change old field names to new field names. This can also be an array of new names but only for array rows.
-    #                    This is useful when wanting to change auto-generated keys to more user-friendly names i.e. for array rows.
-    # [*:filters*] A hash of fields and their filters, applied to every row in a field. A filter can be a proc, an instance method
-    #              applied to the field value or a Filters method. Also see the filter_classes attribute below.
-    # [*:header_filter*] A filter, like one in :filters, that is applied to all headers after the :headers option.
-    # [*:filter_any*] When set to true, any cell defaults to being filtered by its class in :filter_classes.
-    #                 Default Hirb::Helpers::Table.filter_any().
-    # [*:filter_classes*] Hash which maps classes to filters. Default is Hirb::Helpers::Table.filter_classes().
-    # [*:vertical*] When set to true, renders a vertical table using Hirb::Helpers::VerticalTable. Default is false.
-    # [*:all_fields*] When set to true, renders fields in all rows. Valid only in rows that are hashes. Default is false.
-    # [*: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.
-    # Examples:
-    #    Hirb::Helpers::Table.render [[1,2], [2,3]]
-    #    Hirb::Helpers::Table.render [[1,2], [2,3]], :max_fields=>{0=>10}, :header_filter=>:capitalize
-    #    Hirb::Helpers::Table.render [['a',1], ['b',2]], :change_fields=>%w{letters numbers}, :max_fields=>{'numbers'=>0.4}
-    #    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)"}
-    #    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) :
-      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. **"
-      Helpers::VerticalTable.render(rows, options)
-    end
-
-    # A hash which maps a cell value's class to a filter. This serves to set a default filter per field if all of its
-    # values are a class in this hash. By default, Array values are comma joined and Hashes are inspected.
-    # See the :filter_any option to apply this filter per value.
-    attr_accessor :filter_classes
-    # Boolean which sets the default for :filter_any option.
-    attr_accessor :filter_any
-    # Holds last table object created
-    attr_accessor :last_table
-  end
-  self.filter_classes = { Array=>:comma_join, Hash=>:inspect }
-
-  #: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)
-    @rows = set_rows(rows)
-    @headers = set_headers
-    if @options[:number]
-      @headers[:hirb_number] = "number"
-      @fields.unshift :hirb_number
-    end
-    Helpers::Table.last_table = self
-  end
-
-  def set_fields(rows)
-    @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
-      rows[0].is_a?(Array) ? (0..rows[0].length - 1).to_a : []
-    end
-
-    @options[:change_fields].each do |oldf, newf|
-      (index = fields.index(oldf)) && fields[index] = newf
-    end
-    fields
-  end
-
-  def set_rows(rows)
-    rows = Array(rows)
-    if rows[0].is_a?(Array)
-      rows = rows.inject([]) {|new_rows, row|
-        new_rows << array_to_indices_hash(row)
-      }
-    end
-    @options[:change_fields].each do |oldf, newf|
-      rows.each {|e| e[newf] = e.delete(oldf) if e.key?(oldf) }
-    end
-    rows = filter_values(rows)
-    rows.each_with_index {|e,i| e[:hirb_number] = (i + 1).to_s} if @options[:number]
-    deleted_callbacks = Array(@options[:delete_callbacks]).map {|e| "#{e}_callback" }
-    (methods.grep(/_callback$/).map {|e| e.to_s} - deleted_callbacks).sort.each do |meth|
-      rows = send(meth, rows, @options.dup)
-    end
-    validate_values(rows)
-    rows
-  end
-
-  def set_headers
-    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
-    if @options[:header_filter]
-      headers.each {|k,v|
-        headers[k] = call_filter(@options[:header_filter], v)
-      }
-    end
-    headers
-  end
-
-  def render
-    body = []
-    unless @rows.length == 0
-      setup_field_lengths
-      body += render_header
-      body += render_rows
-      body += render_footer
-    end
-    body << render_table_description if @options[:description]
-    body.join("\n")
-  end
-
-  def render_header
-    @headers ? render_table_header : [render_border]
-  end
-
-  def render_footer
-    [render_border]
-  end
-
-  def render_table_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 = String.size(value) > cell_width ?
-      (
-      (cell_width < 5) ? String.slice(value, 0, cell_width) : String.slice(value, 0, cell_width - 3) + '...'
-      ) : value
-    String.ljust(text, cell_width)
-  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[:resize]
-      raise TooManyFieldsForWidthError if @fields.size > self.actual_width.to_f / MIN_FIELD_LENGTH
-      Resizer.resize!(self)
-    else
-      enforce_field_constraints
-    end
-  end
-
-  def enforce_field_constraints
-    max_fields.each {|k,max| @field_lengths[k] = max if @field_lengths[k].to_i > max }
-  end
-
-  def max_fields
-    @max_fields ||= (@options[:max_fields] ||= {}).each {|k,v|
-      @options[:max_fields][k] = (actual_width * v.to_f.abs).floor if v.to_f.abs < 1
-    }
-  end
-
-  def actual_width
-    @actual_width ||= self.width - (@fields.size * BORDER_LENGTH + 1)
-  end
-
-  def width
-    @width ||= @options[:max_width] || View.width
-  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] = 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])
-        field_lengths[field] = len if len > field_lengths[field].to_i
-      end
-    end
-    field_lengths
-  end
-
-  def set_filter_defaults(rows)
-    @filter_classes.each do |klass, filter|
-      @fields.each {|field|
-        if rows.all? {|r| r[field].class == klass }
-          @options[:filters][field] ||= filter
-        end
-      }
-    end
-  end
-
-  def filter_values(rows)
-    @filter_classes = Helpers::Table.filter_classes.merge @options[:filter_classes] || {}
-    set_filter_defaults(rows) unless @options[:filter_any]
-    rows.map {|row|
-      @fields.inject({}) {|new_row,f|
-        (filter = @options[:filters][f]) || (@options[:filter_any] && (filter = @filter_classes[row[f].class]))
-        new_row[f] = filter ? call_filter(filter, row[f]) : row[f]
-        new_row
-      }
-    }
-  end
-
-  def call_filter(filter, val)
-    filter.is_a?(Proc) ? filter.call(val) :
-      val.respond_to?(Array(filter)[0]) ? val.send(*filter) : Filters.send(filter, val)
-  end
-
-  def validate_values(rows)
-    rows.each {|row|
-      @fields.each {|f|
-        row[f] = row[f].to_s || ''
-        row[f] = row[f].gsub(/(\t|\r|\n)/) {|e| e.dump.gsub('"','') } if @options[:escape_special_chars]
-      }
-    }
-  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
-end