tabulatr2 0.9.4 → 0.9.6

data/app/views/tabulatr/_tabulatr_static_table.html.slim

@@ -19,15 +19,15 @@
 /  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 /  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-table.table.tabulatr_table.tabulatr_static_table
+table class="#{table_options[:html_class]} tabulatr_static_table"
   thead
     tr
      - columns.each do |column|
-       th data-tabulatr-column-name=column.full_name style=column.header_style
+       th data-tabulatr-column-name=column.full_name style=column.html_header_style
          = column.human_name
   tbody
     - records.each do |record|
       tr data-id=record.try(:id)
         - columns.each do |column|
-          td data-tabulatr-column-name=column.full_name data-tabulatr-type=column.coltype style=column.cell_style
+          td data-tabulatr-column-name=column.full_name data-tabulatr-type=column.coltype style=column.html_cell_style
             = column.value_for(record, self)

data/app/views/tabulatr/_tabulatr_table.html.slim

@@ -23,24 +23,29 @@
     klass: klass, classname: classname, table_id: table_id,
     formatted_name: formatted_name }
 
-.tabulatr-table-controls-wrapper data-table-id=table_id
-  .tabulatr-filter-menu-wrapper data-table-id=table_id
+.tabulatr-table-controls-wrapper.row data-table-id=table_id
+  .tabulatr-filter-menu-wrapper.col-xs-3.col-sm-1 data-table-id=table_id
     = render '/tabulatr/tabulatr_filter_menu', opts
 
-  .tabulatr-batch-actions-menu-wrapper data-table-id=table_id
+  .tabulatr-batch-actions-menu-wrapper.col-xs-3.col-sm-1 data-table-id=table_id
     = render '/tabulatr/tabulatr_batch_actions_menu', opts
 
-  .tabulatr-paginator-wrapper data-table-id=table_id
-    = render '/tabulatr/tabulatr_paginator', opts
-
-  .tabulatr-info-string-wrapper data-table-id=table_id
-    = render '/tabulatr/tabulatr_info_string', opts
-
   - if tabulatr_data.search?
-    .tabulatr-fuzzy-search-field-wrapper data-table-id=table_id
+    .tabulatr-fuzzy-search-field-wrapper.col-xs-6.col-sm-2 data-table-id=table_id
       = render '/tabulatr/tabulatr_fuzzy_search_field', opts
 
-  .tabulatr-filter-dialog-wrapper data-table-id=table_id
-    = render '/tabulatr/tabulatr_filter_dialog', opts
+  - if table_options[:pagination_position].in?([:top, :both])
+    .tabulatr-paginator-wrapper.col-xs-12.col-sm-8 data-table-id=table_id
+      = render '/tabulatr/tabulatr_paginator', opts
+
+
+.tabulatr-filter-dialog-wrapper data-table-id=table_id
+  = render '/tabulatr/tabulatr_filter_dialog', opts
+
+.tabulatr-info-string-wrapper data-table-id=table_id
+  = render '/tabulatr/tabulatr_info_string', opts
 
 = render '/tabulatr/tabulatr_actual_table', opts
+- if table_options[:pagination_position].in?([:bottom, :both])
+  .tabulatr-paginator-wrapper.col-xs-12 data-table-id=table_id
+    = render '/tabulatr/tabulatr_paginator', opts

data/lib/tabulatr/data/data.rb

@@ -27,9 +27,7 @@ class Tabulatr::Data
     @relation   = relation
     @base       = relation.respond_to?(:klass) ? relation.klass : relation
     @table_name = @base.table_name
-    @assocs     = self.class.instance_variable_get('@assocs') || HashWithIndifferentAccess.new
-    @columns    = self.class.instance_variable_get('@columns') || HashWithIndifferentAccess.new
-    @search     = self.class.instance_variable_get('@search') || HashWithIndifferentAccess.new
+    @search     = self.class.instance_variable_get('@search')     || HashWithIndifferentAccess.new
     @includes   = Set.new()
     @cname      = @base.name.downcase
     @batch_actions = nil
@@ -56,7 +54,7 @@ class Tabulatr::Data
     join_required_tables(params)
 
     pagination = compute_pagination(params[:page], params[:pagesize])
-    apply_pagination(pagination)
+    apply_pagination(pagination.slice(:offset, :pagesize))
 
     # TODO: batch actions and checked ids
 
@@ -104,10 +102,10 @@ class Tabulatr::Data
   # Params
   #++
 
-  def filter_params(params) params["#{@cname}_filter"] end
-  def search_param(params)  params["#{@cname}_search"] end
-  def sort_params(params)   params["#{@cname}_sort"] end
-  def batch_params(params)  params["#{@cname}_batch"] end
+  def filter_params(params) params["#{Tabulatr::Utility.formatted_name(@base.name)}_filter"] end
+  def search_param(params)  params["#{Tabulatr::Utility.formatted_name(@base.name)}_search"] end
+  def sort_params(params)   params["#{Tabulatr::Utility.formatted_name(@base.name)}_sort"] end
+  def batch_params(params)  params["#{Tabulatr::Utility.formatted_name(@base.name)}_batch"] end
   def check_params(params)
     tabulatr_checked = params["tabulatr_checked"]
     if tabulatr_checked.present?
@@ -119,6 +117,7 @@ class Tabulatr::Data
     tt = (params[:arguments].split(",").select{|s| s[':']}.map do |s|
           s.split(':').first
         end.uniq.map(&:to_sym))
+    tt.delete(@table_name.to_sym)
     @includes = @includes + tt
     # @relation = @relation.includes(@includes.map(&:to_sym)).references(@includes.map(&:to_sym))
     @relation = @relation.eager_load(@includes.map(&:to_sym))
@@ -132,7 +131,6 @@ class Tabulatr::Data
 
 end
 
-require_relative './column_name_builder'
 require_relative './dsl'
 require_relative './filtering'
 require_relative './invoker'

data/lib/tabulatr/data/dsl.rb

@@ -23,35 +23,50 @@
 
 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, sort_sql: nil, filter_sql: nil, sql: nil, table_column_options: {}, &block)
-    @columns ||= HashWithIndifferentAccess.new
-    table_column = Tabulatr::Renderer::Column.from(table_column_options.merge(name: name, klass: @base))
     @table_columns ||= []
+    table_name = main_class.table_name
+    table_column = Tabulatr::Renderer::Column.from(
+      table_column_options.merge(name: name,
+        klass: @base, sort_sql: sort_sql || sql || "#{table_name}.#{name}",
+        filter_sql: filter_sql || sql || "#{table_name}.#{name}",
+        table_name: table_name.to_sym,
+        output: block_given? ? block : ->(record){record.send(name)}))
     @table_columns << table_column
-
-    @columns[name.to_sym] = {
-      name: name,
-      sort_sql: sort_sql || sql,
-      filter_sql: filter_sql || sql,
-      output: block,
-      table_column: table_column
-    }
   end
 
   def association(assoc, name, sort_sql: nil, filter_sql: nil, sql: nil, table_column_options: {}, &block)
-    @assocs ||= HashWithIndifferentAccess.new
-    @assocs[assoc.to_sym] ||= {}
     @table_columns ||= []
-    table_column = Tabulatr::Renderer::Association.from(table_column_options.merge(name: name, table_name: assoc, klass: @base))
+    assoc_klass = main_class.reflect_on_association(assoc.to_sym)
+    t_name = assoc_klass.try(:table_name)
+    table_column = Tabulatr::Renderer::Association.from(
+      table_column_options.merge(name: name, table_name: assoc,
+        klass: assoc_klass.try(:klass),
+        sort_sql: sort_sql || sql || "#{t_name}.#{name}",
+        filter_sql: filter_sql || sql || "#{t_name}.#{name}",
+        output: block_given? ? block : ->(record){record.send(assoc).try(name)}))
     @table_columns << table_column
-
-    @assocs[assoc.to_sym][name.to_sym] = {
-      name: name,
-      sort_sql: sort_sql || sql,
-      filter_sql: filter_sql || sql,
-      output: block,
-      table_column: table_column
-    }
   end
 
   def search(*args, &block)

data/lib/tabulatr/data/filtering.rb

@@ -29,13 +29,15 @@ module Tabulatr::Data::Filtering
     if @search.is_a? Array
       query = query.strip.gsub(/['*%\s]+/, '%')
       a = @search.map do |name|
-        nn = build_column_name name, use_for: :filter
+        column = table_columns.find{|c| c.name == name}
+        nn = column ? column.filter_sql : name
+        # nn = build_column_name name, use_for: :filter
         "(#{nn} #{like} '%#{query}%')"
       end
       a = a.join(' OR ')
       @relation = @relation.where(a)
     else # search is a proc
-      @relation = @relation.where(@search.(query))
+      execute_provided_search_block!(query)
     end
   end
 
@@ -46,8 +48,10 @@ module Tabulatr::Data::Filtering
     filter_params.each do |filter|
       name, value = filter
       next unless value.present?
-      nn = build_column_name name, use_for: :filter
-      apply_condition(nn, value)
+
+      table_name, method_name = name.split(':').map(&:to_sym)
+      column = table_columns.find{|c| c.table_name == table_name && c.name == method_name}
+      apply_condition(column, value)
     end
   end
 
@@ -56,16 +60,16 @@ module Tabulatr::Data::Filtering
       name, value = assoc_filter
       assoc, att = name.split(".").map(&:to_sym)
       table_name = table_name_for_association(assoc)
-      nn = build_column_name(att, table_name: table_name, assoc_name: assoc, use_for: :filter)
-      apply_condition(nn, value)
+      column = table_columns.find{|c| c.table_name = table_name && name == name}
+      apply_condition(column, value)
     end
   end
 
   def apply_condition(n,v)
     if ['true', 'false'].include?(v)
-      @relation = @relation.where(:"#{n}" => Tabulatr::Utility.string_to_boolean(v))
+      @relation = @relation.where(:"#{n.filter_sql}" => Tabulatr::Utility.string_to_boolean(v))
     elsif v.is_a?(String)
-      apply_string_condition("#{n} = ?", v)
+      apply_string_condition("#{n.filter_sql} = ?", v)
     elsif v.is_a?(Hash)
       apply_hash_condition(n, v)
     else
@@ -100,8 +104,8 @@ module Tabulatr::Data::Filtering
       since = Date.parse(cond[:from]) if cond[:from].present?
       to = Date.parse(cond[:to]) if cond[:to].present?
     end
-    @relation = @relation.where("#{n} >= ?", since) if since.present?
-    @relation = @relation.where("#{n} <= ?", to) if to.present?
+    @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)
@@ -110,10 +114,34 @@ module Tabulatr::Data::Filtering
 
   def apply_hash_condition(column_name, hash)
     like ||= Tabulatr::Utility.like_statement
-    apply_string_condition("#{column_name} #{like} ?", "%#{hash[:like]}%") if hash[:like].present?
+    apply_string_condition("#{column_name.filter_sql} #{like} ?", "%#{hash[:like]}%") if hash[:like].present?
     apply_date_condition(column_name, hash[:date])
-    apply_string_condition("#{column_name} >= ?", "#{hash[:from]}")
-    apply_string_condition("#{column_name} <= ?", "#{hash[:to]}")
+    apply_string_condition("#{column_name.filter_sql} >= ?", "#{hash[:from]}")
+    apply_string_condition("#{column_name.filter_sql} <= ?", "#{hash[:to]}")
+  end
+
+  private
+
+  def execute_provided_search_block!(query)
+    if @search.arity == 1
+      search_result = @search.(query)
+    elsif @search.arity == 2
+      search_result = @search.(query, @relation)
+    else
+      raise 'Search block needs either `query` or both `query` and `relation` block variables'
+    end
+    handle_search_result(search_result)
+  end
+
+  def handle_search_result(search_result)
+    return if search_result.nil?
+    if search_result.is_a?(ActiveRecord::Relation)
+      @relation = search_result
+    elsif search_result.is_a?(String) || search_result.is_a?(Hash) || search_result.is_a?(Array)
+      @relation = @relation.where(search_result)
+    else
+      Tabulatr::UnexpectedSearchResultError.raise_error(search_result.class)
+    end
   end
 
 end

data/lib/tabulatr/data/formatting.rb

@@ -28,31 +28,18 @@ module Tabulatr::Data::Formatting
     return @relation.map do |record|
       view.record = record
       h = HashWithIndifferentAccess.new
-      @columns.each do |name, opts|
-        h[name] = format_column(record, name, opts, view)
-      end # @columns each
-      @assocs.each do |table_name, columns|
-        h[table_name] ||= {}
-        columns.each do |name, opts|
-          h[table_name][name] = format_association(record, table_name, name, opts, view)
-        end
-      end # @assocs each
+      table_columns.each do |tc|
+        h[tc.table_name] ||= HashWithIndifferentAccess.new
+        h[tc.table_name][tc.name] = format_column(record, tc.output, view)
+      end
       h[:_row_config] = format_row(view, @row)
+      h[:id] = record.id
       h
     end # @relation map
   end # apply_formats
 
-  def format_column(record, name, opts, view)
-    if opts[:output]
-      view.instance_exec(record, &opts[:output])
-    else
-      opts[:table_column].value_for(record, view)
-    end
-  end
-
-  def format_association(record, table_name, name, opts, view)
-    return view.instance_exec(record, &opts[:output]) if opts[:output]
-    opts[:table_column].value_for(record, view)
+  def format_column(record, output, view)
+      view.instance_exec(record, &output) if output.present?
   end
 
   def format_row(view, row)

data/lib/tabulatr/data/pagination.rb

@@ -23,7 +23,7 @@
 
 module Tabulatr::Data::Pagination
 
-  def apply_pagination(offset: 0, pagesize: nil, pages: nil, page: 1, count: nil)
+  def apply_pagination(offset: 0, pagesize: nil)
     @relation = @relation.limit(pagesize).offset(offset)
   end
 
@@ -33,7 +33,6 @@ module Tabulatr::Data::Pagination
     pagesize, page = pagesize.to_i, page.to_i
 
     pages = (count/pagesize.to_f).ceil
-
     {
       offset: [0,((page-1)*pagesize).to_i].max,
       pagesize: pagesize,

data/lib/tabulatr/data/proxy.rb

@@ -27,6 +27,7 @@ class Data::Proxy < ActionView::Base
 
   def initialize(record=nil, locals: {})
     self.class._init
+    Rails.application.routes.mounted_helpers.instance_methods.each{|f| self.send(f).instance_variable_set('@scope', self)}
     @record = record
     locals.each do |nam, val|
       raise "cowardly refusing to override `#{nam}'" if respond_to? nam
@@ -40,6 +41,7 @@ class Data::Proxy < ActionView::Base
     include ActionView::Helpers
     include Rails.application.helpers
     include Rails.application.routes.url_helpers
+    include Rails.application.routes.mounted_helpers
   end
 
 end

data/lib/tabulatr/data/sorting.rb

@@ -23,26 +23,37 @@
 
 module Tabulatr::Data::Sorting
 
-  def apply_sorting(sortparam, default_order=nil)
+  def apply_sorting(sortparam)
     if sortparam.present?
-      sort_by, orientation = sortparam.split(' ')
-      klass = sort_by.split('.').first
-      col_name = sort_by.split('.').last
-      assoc_name = nil
-      if klass == @cname
-        table_name = @base.table_name
+      clname, orientation = sortparam.split(' ')
+      if clname[':']
+        splitted = clname.split(':')
       else
-        assoc_name = @base.reflect_on_association(klass.to_sym).try(:name)
-        table_name = @base.reflect_on_association(klass.to_sym).try(:table_name)
+        splitted = clname.split('.')
       end
-      nn = build_column_name(col_name, table_name: table_name, assoc_name: assoc_name, use_for: :sort)
-      raise "Invalid sorting orientation" unless ['asc', 'desc'].member?(orientation.downcase)
-      @relation = @relation.order("#{nn} #{orientation}")
+      if splitted.count == 2
+        assoc_name = splitted[0].to_sym
+        name = splitted[1].to_sym
+        column = table_columns.find{|c| c.table_name == assoc_name && c.name == name}
+      else
+        name = splitted[0].to_sym
+        column = table_columns.find{|c| c.name == name}
+      end
+      sort_by(column, orientation)
     else
-      @relation = @relation.order(default_order || "#{@table_name}.#{@base.primary_key} desc")
+      @relation = @relation.reorder("#{@table_name}.#{@base.primary_key} desc")
     end
   end
 
+  def sort_by(column, orientation)
+      sort_sql = column.sort_sql
+      if sort_sql.respond_to? :call
+        @relation = sort_sql.call(@relation, orientation, "#{@table_name}.#{@base.primary_key}", @base)
+      else
+        @relation = @relation.reorder("#{sort_sql} #{orientation}")
+      end
+  end
+
 end
 
 Tabulatr::Data.send :include, Tabulatr::Data::Sorting

data/lib/tabulatr/engine.rb

@@ -21,6 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'slim'
 class Tabulatr::Engine < Rails::Engine
 
 end

data/lib/tabulatr/generators/tabulatr/templates/tabulatr.yml

@@ -5,7 +5,7 @@ en:
     batch_actions: 'Batch actions'
     count: 'Showing: %{current} of total %{total}. %{per_page} items per page.'
     apply_filters: 'Apply'
-    search: 'Search'
+    search: 'Search...'
     date_filter:
       none: ''
       today: "Today"
@@ -27,7 +27,7 @@ de:
     batch_actions: 'Batch-Aktionen'
     count: 'Zeige %{current} von insgesamt %{total}. %{per_page} pro Seite.'
     apply_filters: 'Anwenden'
-    search: 'Suche'
+    search: 'Suche...'
     date_filter:
       none: ''
       today: "Heute"

data/lib/tabulatr/json_builder.rb

@@ -62,34 +62,32 @@ module Tabulatr::JsonBuilder
   end
 
   def self.insert_attribute_in_hash at, f, r={}
+    action = at[:action].to_sym
+    relation = at[:relation].try(:to_sym)
     if at.has_key? :relation
-      rel = at[:relation].to_sym
-      action = at[:action].to_sym
-      # if f.class.reflect_on_association(at[:relation].to_sym).collection?
-      #   if at[:action].to_sym == :count
-      #     r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).count
-      #   else
-      #     r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).map(&at[:action].to_sym).join(', ')
-      #   end
-      # else
-      #   r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).try(at[:action])
-      # end
-      begin
-        raise Tabulatr::RequestDataNotIncludedError.raise_error(rel, f) if !f.has_key?(rel)
-        raise Tabulatr::RequestDataNotIncludedError.raise_error(action, rel) if !f[rel].has_key?(action) && action != :id
-        r["#{at[:relation]}:#{at[:action]}"] = f[rel][action]
-      rescue TypeError, NoMethodError => e
-        Tabulatr::RequestDataNotIncludedError.raise_error(at[:action], at[:relation])
-      end
+      check_if_attribute_is_in_hash(f, relation)
+      check_if_attribute_is_in_hash(f[relation], action) if action != :id
+      set_value_at_key(r, f[relation][action], "#{at[:relation]}:#{at[:action]}")
     else
-      begin
-        action = at[:action].to_sym
-        raise Tabulatr::RequestDataNotIncludedError.raise_error(action, f) if !f.has_key?(action) && [:checkbox, :id].exclude?(action)
-        r[at[:action]] = f[action]
-      rescue TypeError, NoMethodError => e
-        raise Tabulatr::RequestDataNotIncludedError.raise_error(action, f)
-      end
+      check_if_attribute_is_in_hash(f, action) if [:checkbox, :id].exclude?(action)
+      set_value_at_key(r, f[action], at[:action])
     end
     r
   end
+
+  private
+
+  def self.check_if_attribute_is_in_hash hash, key
+    if !hash.has_key?(key)
+      raise Tabulatr::RequestDataNotIncludedError.raise_error(key, hash)
+    end
+  end
+
+  def self.set_value_at_key hash, value, key
+    begin
+      hash[key] = value
+    rescue TypeError, NoMethodError => e
+      raise Tabulatr::RequestDataNotIncludedError.raise_error(key, value)
+    end
+  end
 end

data/lib/tabulatr/rails/action_controller.rb

@@ -22,6 +22,10 @@
 #++
 
 class ActionController::Base
+  before_filter do
+    @_tabulatr_table_index = 0
+  end
+
   def tabulatr_for(relation, tabulatr_data_class: nil, serializer: nil, render_action: nil, locals: {}, &block)
     klass = relation.respond_to?(:klass) ? relation.klass : relation
     respond_to do |format|

data/lib/tabulatr/rails/action_view.rb

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

data/lib/tabulatr/renderer/checkbox.rb

@@ -22,8 +22,10 @@
 #++
 
 class Tabulatr::Renderer::Checkbox < Tabulatr::Renderer::Column
+  include ActionView::Helpers::FormTagHelper
+
   def human_name
-    nil
+    check_box_tag('mark_all', '1', false, class: 'tabulatr_mark_all').html_safe
   end
 
   def coltype() 'checkbox' end

data/lib/tabulatr/renderer/column.rb

@@ -26,7 +26,8 @@ class Tabulatr::Renderer::Column
 
   attr_accessor *%i{name header width align valign wrap type th_html filter_html
     filter filter_width range_filter_symbol
-    sortable table_name block klass format map classes cell_style header_style}
+    sortable table_name block klass format map classes cell_style header_style
+    sort_sql filter_sql output}
 
   def self.from(
     name: nil,
@@ -46,6 +47,9 @@ class Tabulatr::Renderer::Column
     klass: nil,
     cell_style: {},
     header_style: {},
+    sort_sql: nil,
+    filter_sql: nil,
+    output: nil,
     &block)
     b = block_given? ? block : nil
     self.new(
@@ -66,10 +70,41 @@ class Tabulatr::Renderer::Column
       klass: klass,
       block: b,
       cell_style: cell_style,
-      header_style: header_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 = 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!
+  end
+
   def klassname() @_klassname ||= @klass.name.underscore end
   def human_name() header || klass.human_attribute_name(name) end
   def sort_param() "#{klassname}_sort" end
@@ -83,11 +118,19 @@ class Tabulatr::Renderer::Column
 
   def apply_styles!
     # raise cell_style.inspect
-    self.cell_style = style_options.merge(self.cell_style).map{|e| e.join(':')}.join(';')
-    self.header_style = style_options.merge(self.header_style).map{|e| e.join(':')}.join(';')
+    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,
@@ -106,7 +149,6 @@ class Tabulatr::Renderer::Column
       return r
     end
     val = principal_value(record) or return ''
-
     if format.present? && val.respond_to?(:to_ary)
       val.map do |v|
         case format