ar_to_html_table 0.0.1 → 0.1.1

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+.DS_Store

data/README.textile

@@ -0,0 +1,106 @@
+h1. Description
+
+p. ar_to_html_table renders an ActiveRecord result set into an html_table. For example:
+
+bc. Product.all.to_table
+
+p. will produce a table with default characteristics.  These characteristics are primarily driven
+by class names and hence styling is defined in CSS.
+
+h1. Usage
+
+p. ar_to_html_table consists of two parts:
+* Defining column formats in the ActiveRecord model
+* Rendering an ActiveRecord result set
+
+h2. Column definitions
+
+p. Columns in the table are formatted based upon a column definition applied in the Model.  Some examples:
+
+bc. class Product < ActiveRecord::Base
+  column_format :name,      :order => 1
+  column_format :orders,    :total => :sum
+  column_format :revenue,   :total => :sum, :order => 5, :class => 'right'
+  column_format :age, 	    :total => :avg, :order => 20, :class => 'right', :formatter => :number_with_delimiter
+  ....
+end
+
+p. The general form of a column definition is:
+
+bc. column_format :column_name, options
+
+h2. Column names and calculated columns
+
+p. Column names are generally the model attribute name however a limited set of calculated columns can also be derived. For example:
+
+bc. column_format :percentage_of_revenue, :order => 9, :class => 'right'
+
+p. Will define a column that renders the percentage of total revenue that this row's revenue represents.  The regexp used to recognize calculated columns is:
+
+bc. /(percent|percentage|difference|diff)_of_(.*)/
+
+p. Where the match is the name of the column against which the calculation if made.  Therefore percentage and difference (plus their variants) are the two available calculated column types.
+
+h2. Column options
+
+|_. Option|_. Description|
+|:order|Positions a column order relative to other columns.  The number isn't important, just its relative value compared to other columns.  Columns are sorted by order and rendered in that order.  The default order is the order in which the columns are defined.|
+|:total|Renders a table footer with a calculation of all the values in the column.  The available totaling methods are **:sum**, **:count** and **:average** (or :avg or :mean)|
+|:class|The CSS class for this column.  Note that a **colgroup** is defined for each column and each **colgroup** has as CSS class that is the column name|
+|:formatter|Used to format the value of each table cell.  There are several predefined formatters.  This value can also be a lambda for arbitrary formatting.|
+
+h2. Predefined formatters
+
+|_. Formatter|_. Description|
+|:float_with_precision|Calls **#number_with_precision** after **#to_f** on the value.|
+|:integer_with_delimiter|Calls **#integer_with_delimiter** unless **I18n::Backend::Simple.included_modules.include? Cldr::Format** is true in which case **I18n.localize** is called.|
+|:seconds_to_time|Formats an integer as hh:mm:ss, mostly used for durations, not time or datetime columns|
+|:hours_to_time|Formats an integer as hh:00.|
+|:currency_without_sign|Calls **#number_with_precision** with precision 2.|
+|:percentage|An integer rendered as a percentage.  Calls **#number_to_percentage** with a precision of 1.|
+|:bar_and_percentage|Displays a CSS bar and a percentage.|
+|:unknown_on_blank|Displays **(unknown)** when **column.blank?** is true.  This is a localized value.  The key **I18n.t('tables.unknown')** is used.|
+|:not_set_on_blank|Displays **(not set)** when **column.blank?** is true.  This is a localized value.  The key **I18n.t('tables.not_set')** is used.|
+
+p. If no formatter is specified then **#to_s** is called on the value unless the value is a **Fixnumn** in which case **#number_with_delimiter** is called.
+
+h2. Table rendering
+
+To render the html table, call **#to_table(options)** on any ActiveRecord result set.  The default options are:
+
+bc. :exclude      => EXCLUDE_COLUMNS, 
+:exclude_ids  => true, 
+:odd_row      => "odd", 
+:even_row     => "even", 
+:totals       => true,
+:total_one    => 'tables.total_one',
+:total_many   => 'tables.total_many',
+:unknown_key  => 'tables.unknown',
+:not_set_key  => 'tables.not_set'
+
+|_. Option|_. Description|
+|:include|Array of columns that should be rendered|
+|:exclude|Array of columns that should not be rendered|
+|:exclude_ids|Don't render columns that end in **_id**|
+|:sort|A **Proc** that is called to sort the rows.  Called as **results.sort(options[:sort])**.|
+|:heading|A table heading that is placed in the first row of a table|
+|:caption|A table caption applied with <caption> markup|
+|:odd_row|CSS class name for odd rows|
+|:even_row|CSS class name for even rows|
+|:totals|Add a total row at the bottom of the table|
+|:total_one|I18n key for rendering the total row when the total is one|
+|:total_many|I18n key for rendering the total row when the total is not one|
+|:unknown_key|I18n key for rendering **(Unknown)**|
+|:not_set_key|I18n key for rendering **(Not Set)**|
+
+h1. License
+
+(The MIT License)
+
+Copyright © 2010 Kip Cole
+
+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/ar_to_html_table.gemspec

@@ -8,11 +8,11 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Kip Cole"]
   s.email       = ["kipcole9@gmail.com"]
-  s.homepage    = "http://rubygems.org/gems/ar_to_html_table"
+  s.homepage    = "http://github.com/kipcole9/ar_to_html_table"
   s.summary     = %q{Render and ActiveRecord result set as an HTML table}
   s.description = <<-EOF
-    Defines Array#to_table that will accept ActiveRecord result sets
-    and render them as an html table.
+    Defines Array#to_table that will render an ActiveRecord result set
+    as an HTML table.
   EOF
 
   s.rubyforge_project = "ar_to_html_table"
@@ -21,4 +21,5 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+  s.add_dependency('builder')
 end

data/lib/ar_to_html_table/column_formats.rb

@@ -0,0 +1,92 @@
+# Module included into ActiveRecord at gem activation.  Includes methods
+# to define column formats used when rendering an HTML table.
+module ArToHtmlTable
+  module ColumnFormats
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  
+    module InstanceMethods
+
+    end
+  
+    module ClassMethods
+      # Define a column format.
+      #
+      # ====Options
+      #
+      #   :order      Defines the column output order relative to other columns
+      #   :total      Column totaling method
+      #   :class      CSS Class to be added to the table cell
+      #   :formatter  Formatter to be applied.  Default is #to_s.  A symbol or lambda.  Symbol can
+      #               represent any method that accepts a value and options including methods in
+      #               ActionView::Helpers::NumberHelper
+      #
+      # See HtmlTable::ColumnFormatter for formatter options.
+      #
+      # ====Examples
+      #
+      #   class Product < ActiveRecord::Base
+      #     column_format :name,      :order => 1
+      #     column_format :orders,    :total => :sum
+      #     column_format :revenue,   :total => :sum, :order => 5, :class => 'right'
+      #     column_format :age, 	    :total => :avg, :order => 20, :class => 'right', :formatter => :number_with_delimiter
+      #   end
+      def column_format(method, options)
+        @attr_formats = (@attr_formats || default_formats).deep_merge({method.to_s => options})
+      end
+      alias :table_format :column_format
+
+      # Retrieve a column format.
+      #
+      # ====Examples
+      #
+      #   # Given the following class definition
+      #   class Product < ActiveRecord::Base
+      #     column_format :name,      :order => 1
+      #     column_format :orders,    :total => :sum
+      #     column_format :revenue,   :total => :sum, :order => 5, :class => 'right'
+      #     column_format :age, 	    :total => :avg, :order => 20, :class => 'right', :formatter => :number_with_delimiter
+      #   end
+      #
+      #   Product.format_of(:name)
+      #   => { :order => 1 }
+      #
+      #   Product.format_of(:revenue)
+      #   => { :total => :sum, :order => 5, :class => 'right' }
+      def format_of(name)
+        @attr_formats ||= default_formats
+        @attr_formats[name] || {}
+      end
+    
+    private
+      # Default column formats used in to_table for active_record
+      # result arrays
+      #
+      # Hash options are:
+      # => :class => 'class_name' # used to add a CSS class to the <td> element
+      # => :formatter => A symbol denoting a method or a proc to be used to 
+      #    format the data element.  It will be passed the element only.
+      #
+      def default_formats
+        attr_formats = {}
+        columns.each do |column|
+          attr_formats[column.name] = case column.type
+          when :integer, :float
+            {:class => :right, :formatter => :number_with_delimiter}
+          when :text, :string
+            {}
+          when :date, :datetime
+            {}
+          else
+            {}
+          end
+        end
+        attr_formats
+      end
+    end
+  end
+end

data/lib/ar_to_html_table/column_formatter.rb

@@ -0,0 +1,197 @@
+# ==Column Formatters
+#
+# Each cell value (attribute in a row) is formatted on output.  This module
+# defines a series of formatters.  A formatter is any method with a signature
+# of:
+#
+# <tt>def method(cell_value, options)</tt>
+#
+# Hence any method already in scope at the time of formatting is available as well.
+# For example <tt>number_with_delimeter</tt> and friends are valid formatters.
+module ArToHtmlTable
+  module ColumnFormatter
+    
+    def self.included(base) #:nodoc:
+      #base.class_eval do
+      #  extend  ActiveSupport::Memoizable
+      #  memoize :integer_with_delimiter
+      #  memoize :float_with_precision
+      #  memoize :currency_without_sign
+      #end
+    end
+    
+    MIN_PERCENT_BAR_VALUE   = 2.0   # Below which no bar is drawn
+    REDUCTION_FACTOR        = 0.80  # Scale the bar graps so they have room for the percentage number in most cases
+    
+    # If the value is #blank? then display a localized
+    # version of "Not Set".
+    #
+    # ====Examples
+    #
+    #   # Given a value <em>nil</em> the following will be output
+    #   # if the locale is set to "en" and the default translations
+    #   # are not changed:
+    #   (Not Set)
+    #
+    #   val: the value to be formatted
+    #   options: formatter options 
+    def not_set_on_blank(val, options)
+      if options[:cell_type] == :th
+        val
+      else
+        val.blank? ? I18n.t(options[:not_set_key]) : val
+      end
+    end
+
+    def group_not_set_on_blank(val, options) #:nodoc:
+      # Need more context to do this
+    end
+
+    # If the value is #blank? then display a localized
+    # version of "Unknown".
+    #
+    # ====Examples
+    #
+    #   # Given a value _nil_ the following will be output
+    #   # if the locale is set to "en" and the default translations
+    #   # are not changed:
+    #   (Unknown)
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def unknown_on_blank(val, options)
+      if options[:cell_type] == :th
+        val
+      else    
+        val.blank? ? I18n.t(options[:unknown_key]) : val
+      end
+    end
+
+    # Interprets an integer as a duration and outputs the duration
+    # in the format hh:mm:ss
+    #
+    # ====Examples
+    #
+    #   # Given a value of 3600, the formatter will output
+    #   00:05:00
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def seconds_to_time(val, options)
+      hours = val / 3600
+      minutes = (val / 60) - (hours * 60)
+      seconds = val % 60
+      (minutes += 1; seconds = 0) if seconds == 60
+      (hours += 1; minutes = 0) if minutes == 60
+      "#{"%02d" % hours}:#{"%02d" % minutes}:#{"%02d" % seconds}"
+    end
+  
+    # Interprets an integer as a number of hours and outputs the value
+    # in the format hh:00
+    #
+    # ====Examples
+    #
+    #   # Given a value of 11, the formatter will output
+    #   11:00
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def hours_to_time(val, options)
+      "#{"%02d" % val}:00"
+    end
+
+    # Interprets an integer as a percentage with a single
+    # digit of precision. Shim for <tt>#number_to_percentage</tt>
+    #
+    # ====Examples
+    #
+    #   # Given a value of 48, the formatter will output
+    #   48.00%
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def percentage(val, options)
+      number_to_percentage(val ? val.to_f : 0, :precision => 1)
+    end
+  
+    # Formats a number as an integer with a delimiter.  If Cldr::Format
+    # module is included into I18n then the value is localized (recommended
+    # for multilanguage applications).  If not, number_with_delimiter is used
+    # formatting.
+    #
+    # ====Examples
+    #
+    #   # Given a value of 1245 and no Cldr::Format, the formatter will output
+    #   1,345
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    #
+    #-- 
+    # TODO this should be done just once at instantiation but we have a potential
+    # ordering issue  since I18n initializer may not have run yet (needs to be checked)
+    def integer_with_delimiter(val, options = {})
+      if I18n::Backend::Simple.included_modules.include? Cldr::Format 
+        I18n.localize(val.to_i, :format => :short)
+      else 
+        number_with_delimiter(val.to_i)
+      end
+    end
+
+    # Formats a number as an float with a delimiter and precision of 1.
+    #
+    # ====Examples
+    #
+    #   # Given a value of 1245, the formatter will output
+    #   1,345.0
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def float_with_precision(val, options)
+      number_with_precision(val.to_f, :precision => 1)
+    end
+
+    # Formats a number as an float with a delimiter and precision of 2.
+    #
+    # ====Examples
+    #
+    #   # Given a value of 1245, the formatter will output
+    #   1,345.00
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def currency_without_sign(val, options)
+      number_with_precision(val.to_f, :precision => 2)
+    end
+  
+    # Formats a number as a horizontal CSS-based bar followed
+    # by the number formatted as a percentage.
+    #
+    # ====Examples
+    #
+    #   # Given a value of 11, the formatter will output
+    #   <tt><div class="hbar" style="width:#{width}%">&nbsp;</div>
+    #   <div>11%</div></tt>
+    #
+    #   val: the value to be formatted
+    #   options: formatter options
+    def bar_and_percentage(val, options)
+      if options[:cell_type] == :td
+        width = val * bar_reduction_factor(val)
+        bar = (val.to_f > MIN_PERCENT_BAR_VALUE) ? "<div class=\"hbar\" style=\"width:#{width}%\">&nbsp;</div>" : ''
+        bar + "<div>" + percentage(val, :precision => 1) + "</div>"
+      else
+        percentage(val, :precision => 1)
+      end
+    end
+    
+  private
+    def bar_reduction_factor(value)
+      case value
+        when 0..79  then  REDUCTION_FACTOR
+        when 80..99 then  0.6
+        else 0.3
+      end
+    end  
+  end
+end

data/lib/ar_to_html_table/model.rb

@@ -0,0 +1,31 @@
+# Adds method to Array to allow output of html tables - only works
+# if the array is an ActiveRecord result set. See ArToHtmlTable::TableFormatter
+module ArToHtmlTable
+  module Model
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  
+    module InstanceMethods
+      # Renders an ActiveRecord result set into an HTML table
+      #
+      # ====Examples
+      #
+      #   # Render all products as an HTML table
+      #   Product.all.to_table
+      # 
+      # See ArToHtmlTable::TableFormatter for options.
+      def to_table(options = {})
+        @formatter = ArToHtmlTable::TableFormatter.new(self, options)
+        @formatter.to_html
+      end
+    end
+  
+    module ClassMethods
+
+    end
+  end
+end

data/lib/ar_to_html_table/table_formatter.rb

@@ -0,0 +1,286 @@
+module ArToHtmlTable
+  class TableFormatter
+    include                 ArToHtmlTable::ColumnFormatter
+    include                 ::ActionView::Helpers::NumberHelper
+    
+    attr_accessor           :html, :table_columns, :klass, :merged_options, :rows, :totals
+    attr_accessor           :column_cache
+
+    EXCLUDE_COLUMNS         = [:id, :updated_at, :created_at, :updated_on, :created_on]
+    CALCULATED_COLUMNS      = /(percent|percentage|difference|diff)_of_(.*)/
+    DEFAULT_OPTIONS         = {
+        :exclude      => EXCLUDE_COLUMNS, 
+        :exclude_ids  => true, 
+        :odd_row      => "odd", 
+        :even_row     => "even", 
+        :totals       => true,
+        :total_one    => 'tables.total_one',
+        :total_many   => 'tables.total_many',
+        :unknown_key  => 'tables.unknown',
+        :not_set_key  => 'tables.not_set'
+    }
+    
+    # Initialize a table formatter.  Not normally called directly since
+    # Array#to_table takes care of this.
+    #
+    #   results: the value to be formatted
+    #   options: formatter options
+    #
+    # ====Options
+    #
+    #   :include        Array of attributes to include in the table. Default is all attributes excepted :excluded ones.
+    #   :exclude        Array of attributes to exclude from the table. Default is [:id, :updated_at, :created_at, :updated_on, :created_on]
+    #   :exclude_ids    Exclude attributes with names ending in '_id'. Default is _true_
+    #   :sort           A proc invoked to sort the rows before output.  Default is not to sort.
+    #   :heading        Table heading places in the first row of a table
+    #   :caption        Table caption applied with <caption> markup
+    #   :odd_row        CSS Class name of the odd rows in the table.  Default is _odd_
+    #   :even_row       CSS Class name of the even rows.  Default is _even_
+    #   :totals         Include a total row if _true_.  Default is _true_
+    #   :total_one      I18n key for displaying a table footer when there is one row.  Default _tables.total_one_
+    #   :total_many     I18n key for displaying a table footer when there are > 1 rows. Default is _tables.total_many_
+    #   :unknown_key    I18n key for displaying _Unknown_. Default is _tables.unknown_
+    #   :not_set_key    I18n key for displaying _Not Set_.  Default is _tables.no_set_ 
+    def initialize(results, options)
+      raise ArgumentError, "[to_table] First argument must be an array of ActiveRecord rows" \
+        unless  results.try(:first).try(:class).try(:descends_from_active_record?) ||
+                results.is_a?(ActiveRecord::NamedScope::Scope)
+                
+      raise ArgumentError, "[to_table] Sort option must be a Proc" \
+        if options[:sort] && !options[:sort].is_a?(Proc)
+          
+      @klass          = results.first.class
+      @rows           = results
+      @column_order   = 0
+      @merged_options = DEFAULT_OPTIONS.merge(options)
+      @table_columns  = initialise_columns(rows, klass, merged_options)
+      @totals         = initialise_totalling(rows, table_columns)
+      results.sort(options[:sort]) if options[:sort]
+      @merged_options[:rows] = results
+      @html = Builder::XmlMarkup.new(:indent => 2)
+      @column_cache   = {}
+    end
+
+    # Render the result set to an HTML table using the
+    # options set at object instantiation.
+    #
+    # ====Examples
+    #
+    #   products = Product.all
+    #   formatter = ArToHtmlTable::TableFormatter.new(products)
+    #   formatter.to_html
+    def to_html
+      options = merged_options
+      table_options = {}
+      html.table table_options do
+        html.caption(options[:caption]) if options[:caption]
+        output_table_headings(options)
+        output_table_footers(options)
+        html.tbody do
+          rows.each_with_index do |row, index|
+            output_row(row, index, options)
+          end
+        end
+      end 
+    end
+
+  protected
+    # Outputs colgroups and column headings
+    def output_table_headings(options)
+      # Table heading
+      html.colgroup do
+        table_columns.each {|column| html.col :class => column[:name] }
+      end
+    
+      # Column groups
+      html.thead do
+        html.tr(options[:heading], :colspan => columns.length) if options[:heading]
+        html.tr do
+          table_columns.each do |column| 
+            html_options = {}
+            html_options[:class] = column[:class] if column[:class]
+            html.th(column[:label], html_options)
+          end
+        end
+      end
+    end
+
+    # Outputs one row
+    def output_row(row, count, options)
+      html_options = {}
+      html_options[:class] = (count.even? ? options[:even_row] : options[:odd_row])
+      html_options[:id] = row_id(row) if row[klass.primary_key]
+      html.tr html_options  do
+        table_columns.each {|column| output_cell(row, column, options) }
+      end
+    end
+
+    # Outputs table footer
+    def output_table_footers(options)
+      output_table_totals(options) if options[:totals] && rows.length > 1
+    end
+
+    # Output totals row (calculations)
+    def output_table_totals(options)
+      return unless table_has_totals?
+      html.tfoot do
+        html.tr do
+          first_column = true
+          table_columns.each do |column| 
+            value = first_column ? first_column_total(options) : totals[column[:name].to_s]
+            output_cell_value(:th, value, column, options)
+            first_column = false
+          end
+        end
+      end    
+    end
+
+    # Outputs one cell
+    def output_cell(row, column, options = {})
+      output_cell_value(:td, row[column[:name]], column, options)
+    end
+  
+    # Outputs one cells value after invoking its formatter
+    def output_cell_value(cell_type, value, column, options = {})
+      column_name = column[:name].to_sym
+      column_cache[column_name] = {} unless column_cache.has_key?(column_name)
+
+      if column_cache[column_name].has_key?(value)
+        result = column_cache[column_name][value]
+      else
+        result = column[:formatter].call(value, options.reverse_merge({:cell_type => cell_type, :column => column}))
+        result ||= ''
+        column_cache[column_name][value] = result
+      end
+      html.__send__(cell_type, (column[:class] ? {:class => column[:class]} : {})) do
+        html << result
+      end
+    end
+
+  private
+    # Craft a CSS id
+    def row_id(row)
+      "#{klass.name.underscore}_#{row[klass.primary_key]}"
+    end
+  
+    def default_formatter(data, options)
+      case data
+      when Fixnum
+        integer_with_delimiter(data, options)
+      else
+        data.to_s
+      end
+    end
+  
+    def table_has_totals?
+      !totals.empty?
+    end
+  
+    def initialise_columns(rows, model, options)
+      options[:include] = options[:include].map(&:to_s) if options[:include]
+      options[:exclude] = options[:exclude].map(&:to_s) if options[:exclude]
+      add_calculated_columns_to_rows(rows, options)
+      requested_columns = columns_from_row(rows.first)
+      columns = requested_columns.inject([]) do |definitions, column|
+        definitions << column_definition(column) if include_column?(column, options)
+        definitions
+      end
+      columns.sort{|a, b| a[:order] <=> b[:order] }
+    end
+
+    # Return a hash of hashes
+    # :sum => {:column_name_1 => value, :column_name_2 => value}
+    def initialise_totalling(rows, columns)
+      columns.inject({}) do |totals, column|
+        case column[:total]
+          when :sum
+            totals[column[:name]] = rows.make_numeric(column[:name]).sum(column[:name])
+          when :mean, :average, :avg
+            totals[column[:name]] = rows.make_numeric(column[:name]).mean(column[:name])
+          when :count
+            totals[column[:name]] = rows.make_numeric(column[:name]).count(column[:name])
+        end
+        totals
+      end  
+    end
+  
+    def first_column_total(options)
+      if rows.count > 1
+        I18n.t(options[:total_many], :count => rows.count)
+      else
+        I18n.t(options[:total_one], :count => rows.count)
+      end
+    end
+  
+    def column_definition(column)
+      @column_order += 1
+      @default_formatter ||= procify(:default_formatter)
+    
+      css_class, formatter = get_column_formatter(column.to_s)
+      column_order = klass.format_of(column)[:order] || @column_order
+      totals = klass.format_of(column)[:total]
+      return {
+        :name       => column,
+        :label      => klass.human_attribute_name(column),
+        :formatter  => formatter || @default_formatter,
+        :class      => css_class,
+        :order      => column_order,
+        :total      => totals
+      }
+    end
+  
+    def columns_from_row(row)
+      row.attributes.inject([]) {|columns, (k, v)| columns << k.to_s }
+    end
+  
+    def get_column_formatter(column)
+      format = klass.format_of(column)
+      case format
+      when Symbol
+        formatter = procify(format)
+      when Proc
+        formatter = format  
+      when Hash
+        css_class = format[:class] if format[:class]
+        formatter = format[:formatter] if format[:formatter]
+        formatter = procify(formatter) if formatter && formatter.is_a?(Symbol)
+      end
+      return css_class, formatter
+    end
+  
+    # A data formatter can be a symbol or a proc
+    # If its a symbol then we 'procify' it so that
+    # we have on calling interface in the output_cell method
+    # - partially for clarity and partially for performance
+    def procify(sym)
+      proc { |val, options| send(sym, val, options) }
+    end
+
+    # Decide if the given column is to be displayed in the table
+    def include_column?(column, options)
+      return options[:include].include?(column) if options[:include]
+      return false if options[:exclude] && options[:exclude].include?(column)
+      return false if options[:exclude_ids] && column.match(/_id\Z/)  
+      true
+    end
+  
+    def add_calculated_columns_to_rows(rows, options)
+      options.each do |k, v|
+        if match = k.to_s.match(CALCULATED_COLUMNS)
+          raise ArgumentError, "[to_table] Total value must not be 0 for percentage_of" if match[1] =~ /percent/ && v.to_f == 0
+          rows.each do |row|
+            row[k.to_s] = case match[1]
+              when 'percent', 'percentage'
+                row[match[2]].to_f / v.to_f * 100
+              when 'difference', 'diff'
+                row[match[2]].to_f - v.to_f
+              else
+                raise ArgumentError, "[to_table] Invalid calculated column '#{match[1]}' for '#{match[2]}'"
+            end
+          end
+        end
+      end  
+    end
+  
+  end
+end

data/lib/ar_to_html_table/version.rb

@@ -1,3 +1,3 @@
 module ArToHtmlTable
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/lib/ar_to_html_table.rb

@@ -1,3 +1,12 @@
+require File.dirname(__FILE__) + '/ar_to_html_table/column_formatter.rb'
+require File.dirname(__FILE__) + '/ar_to_html_table/table_formatter.rb'
+require File.dirname(__FILE__) + '/ar_to_html_table/column_formats.rb'
+require File.dirname(__FILE__) + '/ar_to_html_table/model.rb'
+
+Array.send :include, ArToHtmlTable::Model
+ActiveRecord::Base.send :include, ArToHtmlTable::ColumnFormats
+I18n.load_path += Dir[ File.join(File.dirname(__FILE__), 'locale', '*.{rb,yml}') ]
+
 module ArToHtmlTable
-  # Your code goes here...
-end
+  
+end

data/lib/locale/cldr_additions.yml

@@ -0,0 +1,12 @@
+# In table_formatter we user the decimal:patterns:short so we need to make sure it's there
+# Some risk it is redefined by someone else too of course - but it's not part of the standard
+# cldr database so should be OK.
+en: 
+  numbers: 
+    formats: 
+      decimal: 
+        patterns: 
+          short:  "#,##0"
+      percent: 
+        patterns:
+          full:  "#,##0.###%"

data/lib/locale/en.yml

@@ -0,0 +1,7 @@
+en:
+    tables:
+        total_many:     "Total (%{count} rows)"
+        total_one:      "Total (one row)"
+        not_set:        (Not Set)
+        unknown:        (Unknown)
+                

data/lib/tasks/html_tables_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :html_tables do
+#   # Task goes here
+# end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar_to_html_table
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Kip Cole
@@ -15,11 +15,24 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-14 00:00:00 +08:00
+date: 2010-10-17 00:00:00 +08:00
 default_executable: 
-dependencies: []
-
-description: "    Defines Array#to_table that will accept ActiveRecord result sets\n    and render them as an html table.\n"
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: "    Defines Array#to_table that will render an ActiveRecord result set\n    as an HTML table.\n"
 email: 
 - kipcole9@gmail.com
 executables: []
@@ -31,12 +44,20 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- README.textile
 - Rakefile
 - ar_to_html_table.gemspec
 - lib/ar_to_html_table.rb
+- lib/ar_to_html_table/column_formats.rb
+- lib/ar_to_html_table/column_formatter.rb
+- lib/ar_to_html_table/model.rb
+- lib/ar_to_html_table/table_formatter.rb
 - lib/ar_to_html_table/version.rb
+- lib/locale/cldr_additions.yml
+- lib/locale/en.yml
+- lib/tasks/html_tables_tasks.rake
 has_rdoc: true
-homepage: http://rubygems.org/gems/ar_to_html_table
+homepage: http://github.com/kipcole9/ar_to_html_table
 licenses: []
 
 post_install_message: