tabulatr2 0.9.20 → 0.9.21

data/lib/tabulatr/data/dsl.rb

@@ -23,127 +23,78 @@
 
 module Tabulatr::Data::DSL
 
-  def target_class(name)
-    s = name.to_s
-    @target_class = s.camelize.constantize rescue "There's no class `#{s.camelize}' for `#{self.name}'"
-    @target_class_name = s.underscore
-  end
-
   def main_class
     target_class_name # to get auto setting @target_class
     @target_class
   end
 
-  def target_class_name
-    return @target_class_name if @target_class_name.present?
-    if (s = /(.+)TabulatrData\Z/.match(self.name))
-      # try whether it's a class
-      target_class s[1].underscore
-    else
-      raise "Don't know which class should be target_class for `#{self.name}'."
-    end
-  end
-
-  def column(name, header: nil, sort_sql: nil, filter_sql: nil, sql: nil, table_column_options: {},
-    classes: nil, width: false, align: false, valign: false, wrap: nil, th_html: false,
-    filter_html: false, filter_label: nil, filter: true, sortable: true, format: nil, map: true, cell_style: {},
-    header_style: {},
-    &block)
+  def column(name, opts = {}, &block)
     @table_columns ||= []
-    table_column_options = {classes: classes, width: width, align: align, valign: valign, wrap: wrap,
-      th_html: th_html, filter_html: filter_html, filter_label: filter_label, filter: filter, sortable: sortable,
-      format: format, map: map, cell_style: cell_style, header_style: header_style,
-      header: header
-    }.merge(table_column_options)
-    table_name = main_class.table_name
+    sql_options = determine_sql(opts, main_class.quoted_table_name, name)
+    opts = {
+            sort_sql: sql_options[:sort_sql],
+            filter: true,
+            sortable: true,
+            filter_sql: sql_options[:filter_sql]}.merge(opts)
     table_column = Tabulatr::Renderer::Column.from(
-      table_column_options.merge(name: name,
+        name: name,
         klass: @base,
-        sort_sql: sort_sql || sql || "#{main_class.quoted_table_name}.#{ActiveRecord::Base.connection.quote_column_name(name)}",
-        filter_sql: filter_sql || sql || "#{main_class.quoted_table_name}.#{ActiveRecord::Base.connection.quote_column_name(name)}",
-        table_name: table_name.to_sym,
-        output: block_given? ? block : ->(record){record.send(name)}))
+        col_options: Tabulatr::ParamsBuilder.new(opts),
+        table_name: main_class.table_name.to_sym,
+        output: block_given? ? block : ->(record){record.send(name)})
     @table_columns << table_column
   end
 
-  def association(assoc, name, header: nil, sort_sql: nil, filter_sql: nil, sql: nil, table_column_options: {},
-    classes: nil, width: false, align: false, valign: false, wrap: nil, th_html: false,
-    filter_html: false, filter_label: nil, filter: true, sortable: true, format: nil, map: true, cell_style: {},
-    header_style: {},
-    &block)
+  def association(assoc, name, opts = {}, &block)
     @table_columns ||= []
-    table_column_options = {classes: classes, width: width, align: align, valign: valign, wrap: wrap,
-      th_html: th_html, filter_html: filter_html, filter_label: filter_label, filter: filter, sortable: sortable,
-      format: format, map: map, cell_style: cell_style, header_style: header_style,
-      header: header
-    }.merge(table_column_options)
     assoc_klass = main_class.reflect_on_association(assoc.to_sym)
-    t_name = assoc_klass.try(:quoted_table_name)
+    sql_options = determine_sql(opts, assoc_klass.try(:quoted_table_name), name)
+    opts = {
+        sort_sql: sql_options[:sort_sql],
+        filter_sql: sql_options[:filter_sql]}.merge(opts)
     table_column = Tabulatr::Renderer::Association.from(
-      table_column_options.merge(name: name, table_name: assoc,
+        name: name,
         klass: assoc_klass.try(:klass),
-        sort_sql: sort_sql || sql || "#{t_name}.#{ActiveRecord::Base.connection.quote_column_name(name)}",
-        filter_sql: filter_sql || sql || "#{t_name}.#{ActiveRecord::Base.connection.quote_column_name(name)}",
-        output: block_given? ? block : ->(record){a=record.send(assoc); a.try(:read_attribute, name) || a.try(name)}))
+        col_options: Tabulatr::ParamsBuilder.new(opts),
+        table_name: assoc,
+        output: block_given? ? block : ->(record){a=record.send(assoc); a.try(:read_attribute, name) || a.try(name)})
     @table_columns << table_column
   end
 
-  def actions(header: nil, name: nil, table_column_options: {},
-    classes: nil, width: false, align: false, valign: false, wrap: nil, th_html: false,
-    filter_html: false, filter_label: nil, filter: true, sortable: true, format: nil, map: true, cell_style: {},
-    header_style: {},
-    &block)
+  def actions(opts = {}, &block)
     raise 'give a block to action column' unless block_given?
     @table_columns ||= []
-    table_column_options = {classes: classes, width: width, align: align, valign: valign, wrap: wrap,
-      th_html: th_html, filter_html: filter_html, filter_label: filter_label, filter: filter, sortable: sortable,
-      format: format, map: map, cell_style: cell_style, header_style: header_style
-    }.merge(table_column_options)
     table_column = Tabulatr::Renderer::Action.from(
-      table_column_options.merge(
-        name: (name || '_actions'), table_name: main_class.table_name.to_sym,
-        klass: @base, header: header || '',
-        filter: false, sortable: false,
-        output: block))
+      name: '_actions',
+      table_name: main_class.table_name.to_sym,
+      klass: @base,
+      col_options: Tabulatr::ParamsBuilder.new({header: (opts[:header] || ''), filter: false, sortable: false}),
+      output: block)
     @table_columns << table_column
   end
 
-  def buttons(header: nil, name: nil, table_column_options: {},
-    classes: nil, width: false, align: false, valign: false, wrap: nil, th_html: false,
-    filter_html: false, filter: true, sortable: true, format: nil, map: true, cell_style: {},
-    header_style: {},
-    &block)
+  def buttons(opts = {}, &block)
     raise 'give a block to action column' unless block_given?
     @table_columns ||= []
-    table_column_options = {classes: classes, width: width, align: align, valign: valign, wrap: wrap,
-      th_html: th_html, filter_html: filter_html, filter: filter, sortable: sortable,
-      format: format, map: map, cell_style: cell_style, header_style: header_style
-    }.merge(table_column_options)
     output = ->(r) {
       tdbb = Tabulatr::Data::ButtonBuilder.new
       self.instance_exec tdbb, r, &block
-      bb = tdbb.val
-      self.controller.render_to_string partial: '/tabulatr/tabulatr_buttons', locals: {buttons: bb}, formats: [:html]
+      self.controller.render_to_string partial: '/tabulatr/tabulatr_buttons', locals: {buttons: tdbb.val}, formats: [:html]
     }
+    opts = {header: opts[:header] || '', filter: false, sortable: false}.merge(opts)
     table_column = Tabulatr::Renderer::Buttons.from(
-      table_column_options = table_column_options.merge(
-        name: (name || '_buttons'), table_name: main_class.table_name.to_sym,
-        klass: @base, header: header || '',
-        filter: false, sortable: false,
-        output: output))
+      name: (opts[:name] || '_buttons'),
+      table_name: main_class.table_name.to_sym,
+      klass: @base,
+      col_options: Tabulatr::ParamsBuilder.new(opts),
+      output: output)
     @table_columns << table_column
   end
 
-  def checkbox(table_column_options: {},
-    classes: nil, width: false, align: false, valign: false, wrap: nil, th_html: false,
-    filter_html: false, filter: true, sortable: true, format: nil, map: true, cell_style: {},
-    header_style: {})
+  def checkbox(opts = {})
     @table_columns ||= []
-    table_column_options = {classes: classes, width: width, align: align, valign: valign, wrap: wrap,
-      th_html: th_html, filter_html: filter_html, filter: filter, sortable: sortable,
-      format: format, map: map, cell_style: cell_style, header_style: header_style
-    }.merge(table_column_options)
-    box = Tabulatr::Renderer::Checkbox.from(table_column_options = table_column_options.merge(klass: @base, filter: false, sortable: false))
+    box = Tabulatr::Renderer::Checkbox.from(klass: @base,
+            col_options: Tabulatr::ParamsBuilder.new(opts.merge(filter: false, sortable: false)))
     @table_columns << box
   end
 
@@ -162,6 +113,31 @@ module Tabulatr::Data::DSL
     @filters << Tabulatr::Renderer::Filter.new(name, partial: partial, &block)
   end
 
+  private
+
+  def target_class(name)
+    s = name.to_s
+    @target_class = s.camelize.constantize rescue "There's no class `#{s.camelize}' for `#{self.name}'"
+    @target_class_name = s.underscore
+  end
+
+  def target_class_name
+    return @target_class_name if @target_class_name.present?
+    if (s = /(.+)TabulatrData\Z/.match(self.name))
+      # try whether it's a class
+      target_class s[1].underscore
+    else
+      raise "Don't know which class should be target_class for `#{self.name}'."
+    end
+  end
+
+  def determine_sql(options, table_name, column_name)
+    options_hash = {}
+    [:sort_sql, :filter_sql].each do |sym|
+      options_hash[sym] = options[sym] || options[:sql] || "#{table_name}.#{ActiveRecord::Base.connection.quote_column_name(column_name)}"
+    end
+    options_hash
+  end
 end
 
 Tabulatr::Data.send :extend, Tabulatr::Data::DSL

data/lib/tabulatr/data/filtering.rb

@@ -43,39 +43,21 @@ module Tabulatr::Data::Filtering
 
   def apply_filters(filter_params)
     return unless filter_params
-    assoc_filters = filter_params.delete :__association
-    apply_association_filters(assoc_filters) if assoc_filters.present?
     filter_params.each do |param|
       name, value = param
       next unless value.present?
 
-      table_name, method_name = name.split(':').map(&:to_sym)
-      column = table_columns.find{|c| c.table_name == table_name && c.name == method_name}
-      column = filters.find{|f| f.name.to_sym == name.to_sym} if column.nil?
-      apply_condition(column, value)
-    end
-  end
-
-  def apply_association_filters(assoc_filters)
-    assoc_filters.each do |assoc_filter|
-      name, value = assoc_filter
-      assoc, att = name.split(".").map(&:to_sym)
-      table_name = table_name_for_association(assoc)
-      column = table_columns.find{|c| c.table_name = table_name && name == name}
-      apply_condition(column, value)
+      apply_condition(find_column(name), value)
     end
   end
 
   def apply_condition(n,v)
     case n.filter
     when :checkbox then apply_boolean_condition(n, v)
-    when :decimal  then apply_string_condition("#{n.filter_sql} = ?", v.to_f)
-    when :integer  then apply_string_condition("#{n.filter_sql} = ?", v.to_i)
-    when :enum     then apply_string_condition("#{n.filter_sql} = ?", v.to_i)
+    when :decimal  then apply_string_condition("#{n.col_options.filter_sql} = ?", v.to_f)
+    when :integer, :enum  then apply_string_condition("#{n.col_options.filter_sql} = ?", v.to_i)
     when :enum_multiselect then apply_array_condition(n, v)
-    when :exact    then apply_string_condition("#{n.filter_sql} = ?", v)
-    when Hash      then apply_string_condition("#{n.filter_sql} = ?", v)
-    when Array     then apply_string_condition("#{n.filter_sql} = ?", v)
+    when :exact, Hash, Array then apply_string_condition("#{n.col_options.filter_sql} = ?", v)
     when :like     then apply_like_condition(n, v[:like])
     when :date     then apply_date_condition(n, v[:date])
     when :range    then apply_range_condition(n, v)
@@ -84,52 +66,39 @@ module Tabulatr::Data::Filtering
     end
   end
 
-  def apply_boolean_condition(n, value)
-    @relation = @relation.where("#{n.filter_sql} = ?", Tabulatr::Utility.string_to_boolean(value))
+  def apply_boolean_condition(column, value)
+    @relation = @relation.where("#{column.col_options.filter_sql} = ?", Tabulatr::Utility.string_to_boolean(value))
   end
 
   def apply_date_condition(n, cond)
     today = Date.today
+    yesterday = today - 1.day
     case cond[:simple]
     when 'none' then return
-    when 'today'
-      since = today
-      to = today.at_end_of_day
-    when 'yesterday'
-      since = today - 1.day
-      to = since.at_end_of_day
-    when 'this_week'
-      since = today.at_beginning_of_week.beginning_of_day
-      to = today.at_end_of_week.end_of_day
-    when 'last_7_days'
-      since = (today - 6.day).beginning_of_day
-      to = today.at_end_of_day
-    when 'this_month'
-      since = today.at_beginning_of_month.beginning_of_day
-      to = today.at_end_of_month.end_of_day
-    when 'last_30_days'
-      since = (today - 29.day).beginning_of_day
-      to = today.at_end_of_day
-    when 'from_to'
-      since = (Date.parse(cond[:from]) rescue nil) if cond[:from].present?
-      to = (Date.parse(cond[:to]) rescue nil) if cond[:to].present?
+    when 'today' then date_in_between(today, today.at_end_of_day, n)
+    when 'yesterday' then date_in_between(yesterday, yesterday.at_end_of_day, n)
+    when 'this_week' then date_in_between(today.at_beginning_of_week.beginning_of_day,
+                            today.at_end_of_week.end_of_day, n)
+    when 'last_7_days' then date_in_between((today - 6.day).beginning_of_day, today.at_end_of_day, n)
+    when 'this_month' then date_in_between(today.at_beginning_of_month.beginning_of_day,
+                              today.at_end_of_month.end_of_day, n)
+    when 'last_30_days' then date_in_between((today - 29.day).beginning_of_day, today.at_end_of_day, n)
+    when 'from_to' then date_in_between((Date.parse(cond[:from]) rescue nil), (Date.parse(cond[:to]) rescue nil), n)
     end
-    @relation = @relation.where("#{n.filter_sql} >= ?", since) if since.present?
-    @relation = @relation.where("#{n.filter_sql} <= ?", to) if to.present?
   end
 
   def apply_string_condition(replacement_string, value)
      @relation = @relation.where(replacement_string, value) if value.present?
   end
 
-  def apply_like_condition(column_name, value)
+  def apply_like_condition(column, value)
     like ||= Tabulatr::Utility.like_statement
-    apply_string_condition("#{column_name.filter_sql} #{like} ?", "%#{value}%") if value.present?
+    apply_string_condition("#{column.col_options.filter_sql} #{like} ?", "%#{value}%") if value.present?
   end
 
-  def apply_range_condition(column_name, hash)
-    apply_string_condition("#{column_name.filter_sql} >= ?", "#{hash[:from]}")
-    apply_string_condition("#{column_name.filter_sql} <= ?", "#{hash[:to]}")
+  def apply_range_condition(column, hash)
+    apply_string_condition("#{column.col_options.filter_sql} >= ?", "#{hash[:from]}")
+    apply_string_condition("#{column.col_options.filter_sql} <= ?", "#{hash[:to]}")
   end
 
   def apply_array_condition(column, value)
@@ -165,6 +134,17 @@ module Tabulatr::Data::Filtering
     end
   end
 
+  def date_in_between(from, to, column)
+    @relation = @relation.where("#{column.col_options.filter_sql} >= ?", from) if from.present?
+    @relation = @relation.where("#{column.col_options.filter_sql} <= ?", to) if to.present?
+  end
+
+  def find_column(name)
+    table_name, method_name = name.split(':').map(&:to_sym)
+    table_columns.find { |c| c.table_name == table_name && c.name == method_name } ||
+      filters.find { |f| f.name.to_sym == name.to_sym }
+  end
+
 end
 
 Tabulatr::Data.send :include, Tabulatr::Data::Filtering

data/lib/tabulatr/data/sorting.rb

@@ -46,7 +46,7 @@ module Tabulatr::Data::Sorting
   end
 
   def sort_by(column, orientation)
-      sort_sql = column.sort_sql
+      sort_sql = column.col_options.sort_sql
       if sort_sql.respond_to? :call
         @relation = sort_sql.call(@relation, orientation, "#{@table_name}.#{@base.primary_key}", @base)
       else

data/lib/tabulatr/params_builder.rb

@@ -0,0 +1,50 @@
+module Tabulatr
+  class ParamsBuilder
+    ALLOWED_PARAMS    = [:header, :filter, :sortable, :data_html,
+                         :header_html, :filter_sql, :sort_sql, :sql, :width,
+                         :align, :wrap, :format, :filter_label, :name, :classes]
+    DEPRECATED_PARAMS = []
+
+    attr_accessor *ALLOWED_PARAMS
+
+    def initialize(params = {})
+      apply_params(params)
+    end
+
+    def update(params = {})
+      apply_params(params)
+    end
+
+    private
+
+    def style_options
+      self.data_html ||= {}
+      self.header_html ||= {}
+      self.data_html[:style] ||= ''
+      self.header_html[:style] ||= ''
+      apply_style_option('text-align', align)
+      apply_style_option('width', width)
+      apply_style_option('white-space', wrap)
+    end
+
+    def apply_params(params)
+      params.each do |k, v|
+        if DEPRECATED_PARAMS.include?(k.to_sym)
+          self.public_send(k)
+        elsif ALLOWED_PARAMS.exclude?(k.to_sym)
+          raise ArgumentError, "`#{k}` is not allowed as a parameter"
+        else
+          self.public_send("#{k}=", v)
+        end
+      end
+      style_options
+    end
+
+    def apply_style_option(attribute, value)
+      if value.present?
+        self.header_html[:style].concat("#{attribute}: #{value};")
+        self.data_html[:style].concat("#{attribute}: #{value};")
+      end
+    end
+  end
+end

data/lib/tabulatr/rails/action_view.rb

@@ -23,9 +23,9 @@
 
 class ActionView::Base
   # render the table in a view
-  def table_for(klass, columns: [], filter: [], tabulatr_data_class: nil, **opts, &block)
+  def table_for(klass, columns: [], filters: [], tabulatr_data_class: nil, **opts, &block)
     @_tabulatr_table_index += 1
-    Tabulatr::Renderer.build_table(klass, self, opts, columns, filter, tabulatr_data_class, &block)
+    Tabulatr::Renderer.build_table(klass, self, opts, columns, filters, tabulatr_data_class, &block)
   end
 
   def static_table_for(records, opts={}, &block)

data/lib/tabulatr/rails/active_record.rb

@@ -23,17 +23,12 @@
 
 # We monkey patch ActiveRecord::Base to add a function for finding using
 # the information of the params hash as created by a Tabulatr table
+
 if Object.const_defined? "ActiveRecord"
   class ActiveRecord::Base
     def self.tabulatr(relation, tabulatr_data_class = nil)
-      tabulatr_data_class = "#{self.name}TabulatrData".constantize unless tabulatr_data_class
-      begin
-        td = tabulatr_data_class.new(relation)
-      rescue NameError => e
-        puts e.message
-        # TODO: Better message
-        raise "No class `#{self.name}TabulatrData' defined. Explanation here."
-      end
+      tabulatr_data_class ||= "#{self.name}TabulatrData".constantize
+      td = tabulatr_data_class.new(relation)
     end
   end
 end

data/lib/tabulatr/renderer/action.rb

@@ -23,7 +23,7 @@
 
 class Tabulatr::Renderer::Action < Tabulatr::Renderer::Column
   def human_name
-    header
+    col_options.header
   end
 
   def coltype() 'action' end

data/lib/tabulatr/renderer/association.rb

@@ -23,7 +23,7 @@
 
 class Tabulatr::Renderer::Association < Tabulatr::Renderer::Column
   def human_name
-    header || klass.model_name.human + ' ' + klass.human_attribute_name(name)
+    col_options.header || klass.model_name.human + ' ' + klass.human_attribute_name(name)
   end
 
   def coltype() 'association' end
@@ -31,9 +31,9 @@ class Tabulatr::Renderer::Association < Tabulatr::Renderer::Column
   def association?() true end
 
   def principal_value(record, view)
-    return super if output
+    return super if output || block
     v = record.send(table_name)
-    if v && v.respond_to?(:to_a) && map && name != :count
+    if v && v.respond_to?(:to_a) && name != :count
       v.map(&:"#{name}")
     else
       v.try(name)

data/lib/tabulatr/renderer/buttons.rb

@@ -23,7 +23,7 @@
 
 class Tabulatr::Renderer::Buttons < Tabulatr::Renderer::Action
   def human_name
-    header
+    col_options.header
   end
 
   def coltype() 'buttons' end

data/lib/tabulatr/renderer/column.rb

@@ -24,91 +24,29 @@
 class Tabulatr::Renderer::Column
   include ActiveModel::Model
 
-  attr_accessor *%i{name header width align valign wrap type th_html filter_html
-    filter_label filter filter_width range_filter_symbol
-    sortable table_name block klass format map classes cell_style header_style
-    sort_sql filter_sql output}
+  attr_accessor *%i{name klass table_name col_options output block}
+
+  delegate :filter, to: :col_options
 
   def self.from(
     name: nil,
     table_name: nil,
-    header: nil,
-    classes: nil,
-    width: false,
-    align: false,
-    valign: false,
-    wrap: nil,
-    th_html: false,
-    filter_html: false,
-    filter_label: nil,
-    filter: true,
-    sortable: true,
-    format: nil,
-    map: true,
+    col_options: nil,
     klass: nil,
-    cell_style: {},
-    header_style: {},
-    sort_sql: nil,
-    filter_sql: nil,
     output: nil,
     &block)
     self.new(
       name: name,
       table_name: table_name,
-      header: header,
-      classes: classes,
-      width: width,
-      align: align,
-      valign: valign,
-      wrap: wrap,
-      th_html: th_html,
-      filter_html: filter_html,
-      filter_label: filter_label,
-      filter: filter,
-      sortable: sortable,
-      format: format,
-      map: map,
+      col_options: col_options,
       klass: klass,
-      block: block,
-      cell_style: cell_style,
-      header_style: header_style,
-      sort_sql: sort_sql,
-      filter_sql: filter_sql,
-      output: output
-    ).apply_styles!
-  end
-
-  def update_options(hash = {}, &block)
-    self.header = hash[:header] || self.header
-    self.classes = hash[:classes] || self.classes
-    self.width = hash[:width] || self.width
-    self.align = hash[:align] || self.align
-    self.valign = hash[:valign] || self.valign
-    self.wrap = hash[:wrap] || self.wrap
-    self.th_html = hash[:th_html] || self.th_html
-    self.filter_html = hash[:filter_html] || self.filter_html
-    self.filter_label = hash[:filter_label] || self.filter_label
-    self.filter = hash[:filter] || self.filter
-    self.sortable = hash[:sortable] || self.sortable
-    self.format = hash[:format] || self.format
-    self.map = hash[:map] || self.map
-    self.th_html = hash[:th_html] || self.th_html
-    self.output = block if block_given?
-    self.filter_sql = hash[:filter_sql] || self.filter_sql
-    self.sort_sql = hash[:sort_sql] || self.sort_sql
-    if self.cell_style == ''
-      self.cell_style = {}
-    end
-    self.cell_style = hash[:cell_style] || self.cell_style
-    if self.header_style == ''
-      self.header_style = {}
-    end
-    self.header_style = hash[:header_style] || self.header_style
-    self.apply_styles!
+      output: output,
+      block: block
+    )
   end
 
   def klassname() @_klassname ||= @klass.name.underscore end
-  def human_name() header || klass.human_attribute_name(name) end
+  def human_name() col_options.header || klass.human_attribute_name(name) end
   def sort_param() "#{klassname}_sort" end
   def full_name() [table_name, name].compact.join(":") end
   def coltype() 'column' end
@@ -118,49 +56,11 @@ class Tabulatr::Renderer::Column
   def checkbox?() false end
   def action?() false end
 
-  def apply_styles!
-    # raise cell_style.inspect
-    self.cell_style = style_options.merge(self.cell_style)
-    self.header_style = style_options.merge(self.header_style)
-    self
-  end
-
-  def html_cell_style
-    cell_style.map{|e| e.join(':')}.join(';')
-  end
-
-  def html_header_style
-    header_style.map{|e| e.join(':')}.join(';')
-  end
-
-  def style_options
-    default_style_attributes = {
-      :'text-align' => align,
-      width: width,
-      :'vertical-align' => valign,
-      :'white-space' => wrap
-    }.select{|k,v| v}
-
-    default_style_attributes || {}
-  end
-
   def value_for(record, view)
     val = principal_value(record, view)
-    if format.present? && val.respond_to?(:to_ary)
-      val.map do |v|
-        case format
-        when Symbol then view.send(format, v)
-        when String then format % v
-        when Proc   then format.(v)
-        else val
-        end
-      end
-    elsif format.present?
-      case format
-      when Symbol then view.send(format, val)
-      when String then format % val
-      when Proc   then format.(val)
-      else val
+    if self.col_options.format.present?
+      Array(val).map do |v|
+        format_value(v)
       end
     else
       val
@@ -180,22 +80,37 @@ class Tabulatr::Renderer::Column
   end
 
   def determine_appropriate_filter!
-    typ = self.klass.columns_hash[self.name.to_s].try(:type).try(:to_sym)
+    typ = self.klass.columns_hash[self.name.to_s].type.to_sym rescue nil
     case typ
-    when :integer
-      if self.klass.respond_to?(:defined_enums) && self.klass.defined_enums.keys.include?(self.name.to_s)
-        self.filter = :enum
-      else
-        self.filter = :integer
-      end
-    when :enum then self.filter = :enum
-    when :float, :decimal then self.filter = :decimal
-    when :string, :text then self.filter = :like
-    when :date, :time, :datetime, :timestamp then self.filter = :date
-    when :boolean then self.filter = :checkbox
-    when nil then self.filter = :exact
+    when :integer then self.col_options.filter = filter_type_for_integer
+    when :enum then self.col_options.filter = :enum
+    when :float, :decimal then self.col_options.filter = :decimal
+    when :string, :text then self.col_options.filter = :like
+    when :date, :time, :datetime, :timestamp then self.col_options.filter = :date
+    when :boolean then self.col_options.filter = :checkbox
+    when nil then self.col_options.filter = :exact
     else raise "Unknown filter type for #{self.name}: »#{typ}«"
     end
   end
 
+
+  private
+
+  def filter_type_for_integer
+    if self.klass.respond_to?(:defined_enums) && self.klass.defined_enums.keys.include?(self.name.to_s)
+      :enum
+    else
+      :integer
+    end
+  end
+
+  def format_value(value)
+    case self.col_options.format
+    when Symbol then view.send(col_options.format, value)
+    when String then col_options.format % value
+    when Proc   then col_options.format.(value)
+    else value
+    end
+  end
+
 end