dining-table 0.2.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 67ee845d370a9b92ee759acdb3fff4fbfccdbd12
-  data.tar.gz: 88e0481f7a7d2218cb709e36d94ccf22d22add8b
+SHA256:
+  metadata.gz: e3d53dc971fea99ed47e6793a2cdf74aa9c1f02b96726e56947ce9b264e5b688
+  data.tar.gz: 60cb9fdb7f239528b13aea9eab65ec9185038162c8ee4b4506f54e3e607614ff
 SHA512:
-  metadata.gz: adfc7a39866c15e9da27a68b262a24695a72d46951abe91658e2e71917541407cac95c9a7afdb0ede4e825dbaa4e9fee4c5f765a7bb8207d8efd1878a1bec440
-  data.tar.gz: 382b77586358e8505d819ed50a8d999abc53f451b2b083a85ea3cc0af7c2709f92f6a8ae0f323d1100b5bf94b589411ef45cab9b35b811de5f35f620214fa927
+  metadata.gz: 33ba0f66b71201b5adde87aee1237e8616fe371a17fa4651a4b006ca8b6a1f3780c69e8e71cf4d34ec93371f9598d20938491f039a520548c37b45467ec45466
+  data.tar.gz: 7eb66dae080a8efd67c3b5705f697a3d217c49c109c7d7eff7983e367ebfbb49e72bc2630558e149506e2c9935a789e3ec9eed652bb80cbe23f6a29da8f25680

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 rvm:
-  - 2.2.0
-  - 2.3.0
-  - jruby-9.1.5.0
+  - 2.3.8
+  - 2.6.3
+  - 2.7.1
+  - jruby-9.1.9.0
 script: bundle exec rake
 before_install:
 - gem install bundler

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 1.1.3 (22/06/2020)
+
+* Fix ruby 2.7 deprecation warning
+
+## 1.1.2 (28/11/2019)
+
+* Bugfix - fix html escaping issue
+
+## 1.1.1 (12/10/2019)
+
+* Bugfix - call per-cell configuration block with correct index for footer row
+
+## 1.1.0 (28/11/2018)
+
+* Allow passing in class of object to avoid header edge case when the collection is empty
+
+## 1.0.0 (17/06/2018)
+
+* New configuration mechanism for HTML presenter
+* Described new configuration mechanism in readme
+* Documented skip_header and added and documented skip_footer
+
 ## 0.2.1 (26/05/2018)
 
 * Removed Gemfile.lock file

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 
 group :development do
-  gem "bundler", "~> 1.0"
+  gem "bundler"
   gem "juwelier", "~> 2.1.0"
 end
 

data/README.md

@@ -1,10 +1,12 @@
 # dining-table
 [![Build Status](https://travis-ci.org/mvdamme/dining-table.png)](https://travis-ci.org/mvdamme/dining-table)
 
+dining-table allows you to write clean Ruby classes instead of messy view code to generate HTML tables. You can re-use the same classes to 
+generate csv or xlsx output as well.
+
 dining-table was inspired by the (now unfortunately unmaintained) [table_cloth](https://github.com/bobbytables/table_cloth) gem. 
-This gem is definitely not a drop-in replacement for [table-cloth](https://github.com/bobbytables/table_cloth), it aims to be less dependent on Rails 
-(no Rails required to use `dining-table`) and more flexible.
-In addition, it not only supports HTML output but you can output tabular data in csv or xlsx formats as well.
+This gem is definitely not a drop-in replacement for [table_cloth](https://github.com/bobbytables/table_cloth), it aims to be less dependent on Rails 
+(no Rails required to use `dining-table`, in fact it has no dependencies (except if you chose to generate xlsx output)) and more flexible.
 
 ## Installation
 
@@ -71,6 +73,17 @@ end
 
 The custom header can be a string, but also a lambda or a proc.
 
+If for some reason you don't want a header, call `skip_header`:
+
+```ruby
+class CarTable < DiningTable::Table
+  def define
+    skip_header
+    column :brand
+  end
+end
+```
+
 By default, `dining-table` doesn't add a footer to the table, except when at least one column explicitly specifies a footer:
 
 ```ruby
@@ -82,7 +95,27 @@ class CarTable < DiningTable::Table
 end
 ```
 
-Please note how the collection passed in when creating the table obect (`@cars` in `CarTable.new(@cars, self)`) is available as `collection`.
+Please note how the collection passed in when creating the table object (`@cars` in `CarTable.new(@cars, self)`) is available as `collection`.
+
+Similarly to `skip_header`, if for some reason you don't want a footer (even though at least one column defines one), call `skip_footer`:
+
+```ruby
+class CarTable < DiningTable::Table
+  def define
+    skip_footer
+    column :brand, footer: 'Footer'
+  end
+end
+```
+#### Empty collection
+
+Note that when the collection to be presented in the table is empty, `dining-table` can't determine table headers 
+that aren't explicitly specified as there are no objects to use with `human_attribute_name`. In order to avoid this 
+edge case, you can pass in the class of the objects normally present in the collection when creating the table:
+
+```ruby
+<%= CarTable.new(@cars, self, class: Car).render %>
+```
 
 ### Links and view helpers
 
@@ -185,6 +218,8 @@ end
 
 ### HTML
 
+#### Introduction
+
 The default presenter is HTML (i.e. `DiningTable::Presenters::HTMLPresenter`), so `CarTable.new(@cars, self).render` will generate a table in HTML.
 When defining columns, you can specify options that apply only when using a certain presenter. For example, here we provide css classes for `td` and `th` 
 elements for some columns in the html table:
@@ -193,29 +228,126 @@ elements for some columns in the html table:
 class CarTable < DiningTable::Table
   def define
     column :brand
-    column :number_of_doors, html: { td_options: { class: 'center' }, th_options: { class: :center } }
-    column :stock, html: { td_options: { class: 'center' }, th_options: { class: :center } }
+    column :number_of_doors, html: { td: { class: 'center' }, th: { class: 'center' } }
+    column :stock, html: { td: { class: 'center' }, th: { class: 'center' } }
   end
 end
 ```
 
 The same table class can also be used with other presenters (csv, xlsx or a custom presenter), but the options will only be in effect when using the HTML presenter.
 
-By instantiating the presenter yourself it is possible to specify options. For example:
+#### Presenter configuration
+
+By instantiating the presenter yourself it is possible to specify options for a specific table. Using the `:tags` key you can specify
+options for all HTML tags used in the table. Example:
 
 ```ruby
-<%= CarTable.new(@cars, self, presenter: DiningTable::Presenters::HTMLPresenter.new( class: 'table table-bordered' )).render %>
+<%= CarTable.new(@cars, self, 
+                 presenter: DiningTable::Presenters::HTMLPresenter.new( 
+                   tags: { table: { class: 'table table-bordered', id: 'car_table' }, 
+                           tr: { class: 'car_table_row' } } )).render %>
 ```
+In the above example, we specify the CSS class and HTML id for the table, and the CSS class to be used for all rows in the table.
+The supported HTML tags are: `table`, `thead`, `tbody`, `tfoot`, `tr`, `th`, `td`.
 
-It is also possible to wrap the table in another tag (a div for instance):
+It is also possible to wrap the table in another tag (a div for instance), and specify options for this tag:
 
 ```ruby
 <%= CarTable.new(@cars, self, 
-                 presenter: DiningTable::Presenters::HTMLPresenter.new( class: 'table table-bordered',
-                                                                        wrap: { tag: :div, class: 'table-responsive' } )).render %>
+                 presenter: DiningTable::Presenters::HTMLPresenter.new( 
+                   tags: { table: { class: 'table table-bordered', id: 'car_table' }, 
+                   wrap: { tag: :div, class: 'table-responsive' } )).render %>
 ```
 
-Both of these html options are usually best set as defaults, see [Configuration](#configuration) 
+Most of the html options are usually best set as defaults, see [Configuration](#configuration).
+
+Note that configuration information provided to the presenter constructor is added to the default configuration,
+it doesn't replace it. This means you can have the default configuration define the CSS class for the
+table tag, for instance, and add the html id attribute when initializing the presenter, or from inside the
+table definition.
+
+#### Configuration inside the table definition
+
+It is possible to specify or modify the configuration from within the table definition. This allows you to use custom
+CSS classes, ids, etc. per row or even per cell. Example:
+
+```ruby
+class CarTableWithConfigBlocks < DiningTable::Table
+  def define
+    table_id = options[:table_id]  # custom option, see 'Options' above
+
+    presenter.table_config do |config|
+      config.table.class = 'table-class'
+      config.table.id    = table_id || 'table-id'
+      config.thead.class = 'thead-class'
+    end if presenter.type?(:html)
+
+    presenter.row_config do |config, index, object|
+      if index == :header
+        config.tr.class = 'header-tr'
+        config.th.class = 'header-th'
+      elsif index == :footer
+        config.tr.class = 'footer-tr'
+      else  # normal row
+        config.tr.class = index.odd? ? 'odd' : 'even'
+        config.tr.class += ' lowstock' if object.stock < 10
+      end
+    end if presenter.type?(:html)
+
+    column :brand
+    column :stock, footer: 'Footer text'
+  end
+end
+```
+This example shows how to use `presenter.table_config` to set the configuration for (in this case) the `table` and `thead`tags. The block you use with `table_config`
+is called once, when the table is being rendered. A configuration object is passed in that allows you to set any HTML attribute of the
+seven supported tags. 
+
+Note that the configuration object already contains the pre-existing configuration information (coming
+from either the presenter initialisation and/or from the global configuration), so you can refine the configuration in the block
+instead of having to re-specify it in full. This means you can easily add CSS classes without knowledge of previously existing
+configuration:
+```ruby
+presenter.table_config do |config|
+  config.table.class += ' my-table-class'
+end if presenter.type?(:html)
+```
+Per row configuration can be specified with `presenter.row_config`. The block used with this method is called once for each row being
+rendered, and receives three parameters: the configuration object (identical as with `table_config`), an index value, and the object 
+containing the data being rendered in this row. 
+The index value is equal to the row number of the row being rendered (starting at zero), except for the header and footer rows, in which case it
+is equal to `:header` and `:footer`, respectively. `object` is the current object being rendered (`nil` for the header and footer rows). 
+As above, the passed in configuration object already contains the configuration which is in effect before calling the block.
+
+#### Per cell configuration
+
+As shown above, you can specify per column configuration using a hash:
+
+```ruby
+class CarTable < DiningTable::Table
+  def define
+    column :number_of_doors, html: { td: { class: 'center' }, th: { class: 'center' } }
+  end
+end
+```
+For each column, the per column configuration is merged with the row configuration (see `presenter.row_config` above) before
+cells from the column are rendered.
+
+Sometimes, you might want to specify the configuration per cell, for instance to add a CSS class for cells with a certain content.
+This is possible by supplying a lamba or proc instead of a hash: 
+
+```ruby
+class CarTable < DiningTable::Table
+  def define
+    number_of_doors_options = ->( config, index, object ) do
+      config.td.class = 'center'
+      config.td.class += ' five_doors' if object && object.number_of_doors == 5
+    end
+    column :number_of_doors, html: number_of_doors_options
+  end
+end
+```
+The arguments provided to the lambda or proc are the same as in the case of `presenter.row_config`.
 
 ### CSV
 
@@ -271,14 +403,14 @@ end
 
 ### Excel (xlsx)
 
-The Excel presenter depends on [axlsx](https://github.com/randym/axlsx). Note that `dining-table` doesn't require `axlsx`, you have to add it to 
+The Excel presenter depends on [xlsxtream](https://github.com/felixbuenemann/xlsxtream) or [axlsx](https://github.com/randym/axlsx). Note that `dining-table` doesn't require either `xlsxtream` or `axlsx`, you have to add one of them to 
 your Gemfile yourself if you want to use the Excel presenter.
 
-In order to use the Excel presenter, pass it in as a presenter and provide an axlsx worksheet:
+In order to use the Excel presenter, pass it in as a presenter and provide a xlsxtream or axlsx worksheet:
 
 ```ruby
 collection = Car.order(:brand)
-# sheet is the axlsx worksheet in which the table will be rendered
+# sheet is the xlsxtream or axlsx worksheet in which the table will be rendered
 CarTable.new( collection, nil, presenter: DiningTable::Presenters::ExcelPresenter.new( sheet ) ).render
 ```
 
@@ -315,7 +447,8 @@ You can set default options for the different presenters in an initializer (e.g.
 
 ```ruby
 DiningTable.configure do |config|
-  config.html_presenter.default_options = { class: 'table table-bordered table-hover',
+  config.html_presenter.default_options = { tags: { table: { class: 'table table-bordered' }, 
+                                                    thead: { class: 'header' } },
                                             wrap: { tag: :div, class: 'table-responsive' } }
   config.csv_presenter.default_options  = { csv: { col_sep: ';' } }
 end
@@ -323,4 +456,4 @@ end
 
 ## Copyright
 
-Copyright (c) 2016 Michaël Van Damme. See LICENSE.txt for further details.
+Copyright (c) 2018 Michaël Van Damme. See LICENSE.txt for further details.

data/VERSION

@@ -1 +1 @@
-0.2.1
+1.1.3

data/dining-table.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: dining-table 0.2.1 ruby lib
+# stub: dining-table 1.1.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "dining-table".freeze
-  s.version = "0.2.1"
+  s.version = "1.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
-  s.authors = ["Micha\u{eb}l Van Damme".freeze]
-  s.date = "2018-05-26"
+  s.authors = ["Micha\u00EBl Van Damme".freeze]
+  s.date = "2020-06-22"
   s.description = "Easily output tabular data, be it in HTML, CSV or XLSX. Create clean table classes instead of messing with views to create nice tables.".freeze
   s.email = "michael.vandamme@vub.ac.be".freeze
   s.extra_rdoc_files = [
@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
     "lib/dining-table/presenters/csv_presenter.rb",
     "lib/dining-table/presenters/excel_presenter.rb",
     "lib/dining-table/presenters/html_presenter.rb",
+    "lib/dining-table/presenters/html_presenter_configuration.rb",
     "lib/dining-table/presenters/presenter.rb",
     "lib/dining-table/presenters/spreadsheet_presenter.rb",
     "lib/dining-table/table.rb",
@@ -44,27 +45,27 @@ Gem::Specification.new do |s|
     "spec/spec_helper.rb",
     "spec/tables/car_table.rb",
     "spec/tables/car_table_with_actions.rb",
+    "spec/tables/car_table_with_config_blocks.rb",
     "spec/tables/car_table_with_footer.rb",
     "spec/tables/car_table_with_header.rb",
-    "spec/tables/car_table_with_options.rb"
+    "spec/tables/car_table_with_options.rb",
+    "spec/tables/car_table_with_options_old_syntax.rb",
+    "spec/tables/car_table_without_header.rb"
   ]
   s.homepage = "http://github.com/mvdamme/dining-table".freeze
   s.licenses = ["MIT".freeze]
-  s.rubygems_version = "2.6.11".freeze
+  s.rubygems_version = "3.1.2".freeze
   s.summary = "Create tables easily. Supports html, csv and xlsx.".freeze
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
+  end
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
-      s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
-    else
-      s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
-      s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
-    end
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
+    s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
   else
-    s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
+    s.add_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
   end
 end

data/lib/dining-table.rb

@@ -6,6 +6,7 @@ require 'dining-table/columns/column'
 require 'dining-table/columns/actions_column'
 
 require 'dining-table/presenters/presenter'
+require 'dining-table/presenters/html_presenter_configuration'
 require 'dining-table/presenters/html_presenter'
 require 'dining-table/presenters/spreadsheet_presenter'
 require 'dining-table/presenters/csv_presenter'

data/lib/dining-table/columns/actions_column.rb

@@ -6,7 +6,7 @@ module DiningTable
       
       def value(object)
         if block
-          @incremental_value = ''
+          @incremental_value = ''.html_safe
           @current_object = object
           self.instance_eval(&block)
           @incremental_value
@@ -16,11 +16,11 @@ module DiningTable
       private
       
         def action(&block)
-          action_value = yield(@current_object)
+          action_value = table.instance_exec(@current_object, &block)
           @incremental_value += action_value.to_s if action_value && action_value.respond_to?(:to_s)
         end
 
-        # offer methods normally available on Table that could be used by the action blocks
+        # offer methods normally available on Table that could be used by the action-column block
         [ :h, :helpers, :collection, :index, :presenter ].each do |method|
           self.class_eval <<-eos, __FILE__, __LINE__+1
             def #{method}(*args)
@@ -28,7 +28,7 @@ module DiningTable
             end
           eos
         end
-      
+
     end
 
   end

data/lib/dining-table/columns/column.rb

@@ -26,6 +26,7 @@ module DiningTable
           label = determine_label(:header)
           return label if label
           object_class = table.collection.first.class if table.collection.first
+          object_class ||= table.object_class if !object_class
           object_class.human_attribute_name( name ) if object_class && object_class.respond_to?( :human_attribute_name )
         end
       end

data/lib/dining-table/presenters/csv_presenter.rb

@@ -5,7 +5,11 @@ module DiningTable
   module Presenters
 
     class CSVPresenter < SpreadsheetPresenter
-      
+
+      attr_writer :output
+      attr_accessor :stringio
+      private :output, :stringio, :output=, :stringio=
+
       def initialize( *args )
         super
         self.output = ''
@@ -21,14 +25,11 @@ module DiningTable
       
       private
       
-        attr_writer :output
-        attr_accessor :stringio
-        
         def csv
           @csv ||= begin
             self.stringio = StringIO.new
             csv_options = options[:csv] || { }
-            CSV.new(stringio, csv_options)
+            CSV.new(stringio, **csv_options)
           end
         end
         

data/lib/dining-table/presenters/excel_presenter.rb

@@ -3,7 +3,10 @@ module DiningTable
   module Presenters
 
     class ExcelPresenter < SpreadsheetPresenter
-      
+
+      attr_accessor :worksheet
+      private :worksheet, :worksheet=
+
       def initialize( worksheet, *args )
         super( *args )
         self.worksheet = worksheet
@@ -15,8 +18,6 @@ module DiningTable
       
       private
       
-        attr_accessor :worksheet
-        
         def add_row(array)
           worksheet.add_row( array )
         end

data/lib/dining-table/presenters/html_presenter.rb

@@ -3,10 +3,17 @@ module DiningTable
   module Presenters
 
     class HTMLPresenter < Presenter
-      
-      def initialize( *args )
+
+      attr_accessor :tags_configuration, :table_tags_configuration, :base_tags_configuration, :table_config_block, :row_config_block
+
+      attr_writer :output
+      private :output, :output=
+
+      def initialize( options = {} )
         super
-        self.output  = ''
+        self.base_tags_configuration = HTMLPresenterConfiguration::TagsConfiguration.from_hash( default_options )
+        base_tags_configuration.merge_hash( options )
+        self.output = ''.html_safe
       end
       
       def identifier
@@ -14,10 +21,11 @@ module DiningTable
       end
       
       def start_table
+        set_up_configuration
         if options[:wrap]
           add_tag(:start, wrap_tag, wrap_options )
         end
-        add_tag(:start, :table, options )
+        add_tag(:start, :table, table_options )
       end
       
       def end_table
@@ -28,7 +36,7 @@ module DiningTable
       end
       
       def start_body
-        add_tag(:start, :tbody)
+        add_tag(:start, :tbody, tag_options(:tbody))
       end
       
       def end_body
@@ -36,33 +44,39 @@ module DiningTable
       end
       
       def render_row( object )
-        add_tag(:start, :tr)
+        set_up_row_configuration( table.index, object )
+        add_tag(:start, :tr, row_options)
         columns.each do |column|
           value = column.value( object )
-          render_cell( value, column.options_for( identifier ) )
+          configuration = cell_configuration( tags_configuration, column, table.index, object )
+          render_cell( value, configuration )
         end
         add_tag(:end,   :tr)
       end
 
       def render_header
-        add_tag(:start, :thead)
-        add_tag(:start, :tr)
+        set_up_row_configuration( :header, nil )
+        add_tag(:start, :thead, tag_options(:thead))
+        add_tag(:start, :tr, row_options)
         columns.each do |column|
           value = column.header
-          render_header_cell( value, column.options_for( identifier )  )
+          configuration = cell_configuration( tags_configuration, column, :header, nil )
+          render_header_cell( value, configuration )
         end
         add_tag(:end,   :tr)
         add_tag(:end,   :thead)
       end
       
       def render_footer
+        set_up_row_configuration( :footer, nil )
         footers = columns.each.map(&:footer)
         if footers.map { |s| blank?(s) }.uniq != [ true ]
-          add_tag(:start, :tfoot)
-          add_tag(:start, :tr)
+          add_tag(:start, :tfoot, tag_options(:tfoot))
+          add_tag(:start, :tr, row_options)
           columns.each_with_index do |column, index|
             value = footers[index]
-            render_footer_cell( value, column.options_for( identifier )  )
+            configuration = cell_configuration( tags_configuration, column, :footer, nil )
+            render_footer_cell( value, configuration )
           end
           add_tag(:end,   :tr)
           add_tag(:end,   :tfoot)
@@ -70,13 +84,19 @@ module DiningTable
       end
 
       def output
-        @output.respond_to?(:html_safe) ? @output.html_safe : @output
+        @output
       end
-      
+
+      def table_config(&block)
+        self.table_config_block = block
+      end
+
+      def row_config(&block)
+        self.row_config_block = block
+      end
+
       private
       
-        attr_writer :output
-        
         def output_
           @output
         end
@@ -87,27 +107,27 @@ module DiningTable
         end
       
         def start_tag(tag, options = {})
-          "<#{ tag.to_s }#{ options_string(options) }>"
+          "<#{ tag.to_s }#{ options_string(options) }>".html_safe
         end
       
         def end_tag(tag, options = {})
-          "</#{ tag.to_s }>"
+          "</#{ tag.to_s }>".html_safe
         end
-        
-        def render_cell( string, options )
-          render_general_cell( string, options, :td, :td_options )
+
+        def render_cell( string, configuration )
+          render_general_cell( string, configuration, :td)
         end
 
-        def render_header_cell( string, options )
-          render_general_cell( string, options, :th, :th_options )
+        def render_header_cell( string, configuration )
+          render_general_cell( string, configuration, :th)
         end
-        
-        def render_footer_cell( string, options )
-          render_general_cell( string, options, :td, :footer_options )
+
+        def render_footer_cell( string, configuration )
+          render_cell( string, configuration )
         end
-        
-        def render_general_cell( string, options, cell_tag, options_identifier )
-          add_tag(:start, cell_tag, options[ options_identifier ] )
+
+        def render_general_cell( string, configuration, cell_tag )
+          add_tag(:start, cell_tag, tag_options(cell_tag, configuration) )
           output_ << string.to_s
           add_tag(:end,   cell_tag)
         end
@@ -134,7 +154,67 @@ module DiningTable
           options_.delete(:tag)
           options_
         end
-        
+
+        def table_options
+          options_ = tag_options(:table)
+          return options_ unless options_.empty?
+          if options[:class]
+            warn "[DEPRECATION] dining-table: option \"class\" is deprecated, please use \"tags: { table: { class: 'my_class' } }\" instead."
+            { :class => options[:class] }
+          else
+            { }
+          end
+        end
+
+        def row_options
+          tag_options(:tr)
+        end
+
+        def column_options_cache( column )
+          @column_options_cache ||= { }
+          @column_options_cache[ column ] ||= begin
+            column_options = column.options_for( identifier )
+            if column_options.is_a?(Hash)
+              if column_options[:th_options] || column_options[:td_options]
+                warn "[DEPRECATION] dining-table: options \"th_options\" and \"td_options\" are deprecated, please use \"th\" and \"td\" instead. Example: \"{ td: { class: 'my_class' } }\"."
+                column_options[:th] = column_options.delete(:th_options)
+                column_options[:td] = column_options.delete(:td_options)
+              end
+              column_options[:tags] ? column_options : { :tags => column_options }
+            elsif column_options.respond_to?(:call)
+              column_options
+            end
+          end
+        end
+
+        def cell_configuration( start_configuration, column, index, object )
+          column_options = column_options_cache( column )
+          return start_configuration if !column_options
+          new_configuration = start_configuration.dup
+          if column_options.is_a?(Hash)
+            new_configuration.merge_hash( column_options )
+          else # callable
+            column_options.call( new_configuration, index, object )
+            new_configuration
+          end
+        end
+
+        def tag_options( tag, configuration = nil )
+          configuration ||= tags_configuration
+          configuration.send( tag ).to_h
+        end
+
+        def set_up_configuration
+          self.table_tags_configuration = base_tags_configuration.dup
+          table_config_block.call( table_tags_configuration ) if table_config_block
+          self.tags_configuration = table_tags_configuration.dup
+        end
+
+        def set_up_row_configuration( index, object )
+          self.tags_configuration = table_tags_configuration.dup
+          row_config_block.call( tags_configuration, index, object ) if row_config_block
+        end
+
     end
 
   end

data/lib/dining-table/presenters/html_presenter_configuration.rb

@@ -0,0 +1,103 @@
+module DiningTable
+
+  module Presenters
+
+    module HTMLPresenterConfiguration
+
+      # configuration classes that allow us to avoid implementing a deep-merge for the config hash,
+      # and are more user friendly for use in config blocks in the table definition
+      class TagConfiguration
+
+        attr_accessor :__data_hash
+
+        def initialize
+          self.__data_hash = {}
+        end
+
+        def method_missing(name, *args, &block)
+          if name.to_s[-1] == '='
+            key = name.to_s[0..-2]   # strip away '='
+            __data_hash[ key.to_sym ] = args.first
+          else
+            __data_hash.key?( name ) ? __data_hash[ name ] : super
+          end
+        end
+
+        def respond_to_missing?(method_name, *args)
+          return true if method_name.to_s[-1] == '='
+          __data_hash.key?( method_name ) ? true : super
+        end
+
+        # override class method (since it is a very common html attribute), and the method missing approach doesn't
+        # work here, as it returns the Ruby class by default.
+        def class
+          __data_hash.key?( :class ) ? __data_hash[ :class ] : super
+        end
+
+        def to_h
+          __data_hash
+        end
+
+        def merge_hash( hash )
+          return self if !hash
+          hash.each do |key, value|
+            self.send("#{ key }=", value)
+          end
+          self
+        end
+
+        def self.from_hash( hash )
+          new.merge_hash( hash )
+        end
+
+        # for deep dup
+        def initialize_copy( source )
+          self.__data_hash = source.__data_hash.dup
+        end
+
+      end
+
+      class TagsConfiguration
+        TAGS = [ :table, :thead, :tbody, :tfoot, :tr, :th, :td ]
+        attr_accessor(*TAGS)
+
+        def initialize
+          TAGS.each do |tag|
+            self.send("#{ tag }=", TagConfiguration.new)
+          end
+        end
+
+        def to_h
+          hashes = TAGS.map do |identifier|
+            self.send(identifier).to_h
+          end
+          { :tags => Hash[ TAGS.zip( hashes ) ] }
+        end
+
+        def merge_hash( hash )
+          return self if !hash
+          tags = hash[ :tags ]
+          TAGS.each do |tag|
+            self.send("#{ tag }").merge_hash( tags[ tag ] )
+          end if tags
+          self
+        end
+
+        def self.from_hash( hash )
+          new.merge_hash( hash )
+        end
+
+        # for deep dup
+        def initialize_copy( source )
+          TAGS.each do |tag|
+            self.send("#{ tag }=", source.send( tag ).dup)
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/dining-table/presenters/presenter.rb

@@ -22,7 +22,7 @@ module DiningTable
         identifier == identifier_
       end
       
-      [ :start_table, :end_table, :render_header, :start_body, :end_body, :row, :render_footer, :output ].each do |method|
+      [ :start_table, :end_table, :render_header, :start_body, :end_body, :render_row, :render_footer, :output ].each do |method|
         self.class_eval <<-eos, __FILE__, __LINE__+1
           def #{method}(*args)
           end

data/lib/dining-table/table.rb

@@ -3,7 +3,10 @@ module DiningTable
   class Table
     
     attr_accessor :collection, :presenter, :options, :index, :columns, :action_columns, :view_context
-    
+
+    attr_accessor :no_header, :no_footer
+    private :no_header, :no_footer, :no_header=, :no_footer=
+
     def initialize( collection, view_context, options = {} )
       self.collection = collection
       self.view_context = view_context
@@ -27,7 +30,7 @@ module DiningTable
         presenter.render_row( object )
       end
       presenter.end_body
-      presenter.render_footer
+      presenter.render_footer unless no_footer
       presenter.end_table
       presenter.output
     end
@@ -36,11 +39,21 @@ module DiningTable
       view_context
     end
     alias_method :h, :helpers
-    
+
+    def skip_header
+      self.no_header = true
+    end
+
+    def skip_footer
+      self.no_footer = true
+    end
+
+    def object_class
+      options[:class]
+    end
+
     private
     
-      attr_accessor :no_header
-    
       # auxiliary function
       def column(name, options = {}, &block)
         klass = options[:class]
@@ -62,10 +75,6 @@ module DiningTable
         Presenters::HTMLPresenter
       end
       
-      def skip_header
-        self.no_header = true
-      end
-      
   end
 
 end

data/spec/html_table_spec.rb

@@ -36,7 +36,19 @@ describe 'HTMLTableSpec' do
       end
     end
   end
-  
+
+  it "correctly renders a table's header when the table body is empty and a class is provided" do
+    html = CarTable.new([], nil, :class => CarWithHumanAttributeName).render
+    doc = document( html )
+    [ 'Brand', 'Number of doors', 'Stock' ].each_with_index do |header, col_index|
+      xpath = "/table/thead/tr[1]/th[#{ col_index + 1 }]"
+      check_not_empty(doc.elements, xpath)
+      doc.elements.each(xpath) do |element|
+        element.text.must_equal header
+      end
+    end
+  end
+
   it "correctly renders a table's header when explicit headers are defined" do
     @cars = CarWithHumanAttributeName.collection
     html = CarTableWithHeader.new(@cars, @view_context).render
@@ -55,6 +67,23 @@ describe 'HTMLTableSpec' do
     end
   end
 
+  it "correctly renders a table's header when explicit headers are defined and the table body is empty" do
+    html = CarTableWithHeader.new([], @view_context).render
+    doc = document( html )
+    [ 'The brand', 'The number of doors' ].each_with_index do |header, col_index|
+      xpath = "/table/thead/tr[1]/th[#{ col_index + 1 }]"
+      check_not_empty(doc.elements, xpath)
+      doc.elements.each(xpath) do |element|
+        element.text.must_equal header
+      end
+    end
+    # last header has link
+    doc.elements.each("/table/thead/tr[1]/th[3]/a") do |element|
+      element.text.must_equal 'Stock'
+      element.attributes.get_attribute('href').value.must_equal "http://www.google.com"
+    end
+  end
+
   it "correctly renders a table's footer when footers are defined" do
     @cars = CarWithHumanAttributeName.collection
     html = CarTableWithFooter.new(@cars, @view_context).render
@@ -63,7 +92,8 @@ describe 'HTMLTableSpec' do
       xpath = "/table/tfoot/tr[1]/td[#{ col_index + 1 }]"
       check_not_empty(doc.elements, xpath)
       doc.elements.each(xpath) do |element|
-        element.text.must_equal footer
+        element.text.must_equal footer if footer
+        element.text.must_be_nil if !footer  # avoid minitest deprecation warning
       end
     end
     # last footer has link
@@ -73,6 +103,15 @@ describe 'HTMLTableSpec' do
     end
   end
 
+  it "allows skipping header and footer" do
+    @cars = CarWithHumanAttributeName.collection
+    html = CarTableWithoutHeader.new(@cars, @view_context).render
+    doc = REXML::Document.new( html )
+    table = doc.elements.first
+    table.elements.size.must_equal 1  # only body
+    table.elements.first.name.must_equal 'tbody'
+  end
+
   it "correctly renders a table with column options and column blocks" do
     html = CarTableWithOptions.new(@cars, nil).render
     doc = document( html )
@@ -96,6 +135,28 @@ describe 'HTMLTableSpec' do
     end
   end
 
+  it "still supports deprecated syntax for html column options" do
+    html = CarTableWithOptionsOldSyntax.new(@cars, nil).render
+    doc = document( html )
+    @cars.each_with_index do |car, index|
+      [ :brand, :stock ].each_with_index do |column, col_index|
+        xpath = "/table/tbody/tr[#{ index + 1 }]/td[#{ col_index + 1 }]"
+        check_not_empty(doc.elements, xpath)
+        doc.elements.each(xpath) do |element|
+          class_ = col_index == 0 ? 'center' : 'left'
+          element.attributes.get_attribute('class').value.must_equal class_
+        end
+      end
+    end
+    # also check header
+    [ 1, 2 ].each do |index|
+      doc.elements.each("/table/thead/tr[1]/th[#{ index }]") do |element|
+        class_ = index == 1 ? 'center' : 'left'
+        element.attributes.get_attribute('class').value.must_equal class_
+      end
+    end
+  end
+
   it "correctly renders a table with actions" do
     html = CarTableWithActions.new(@cars, @view_context).render
     doc = document( html )
@@ -140,6 +201,38 @@ describe 'HTMLTableSpec' do
   end
 
   it "respects presenter options" do
+    html = CarTableWithFooter.new(@cars, @view_context,
+                            :presenter => DiningTable::Presenters::HTMLPresenter.new(
+                            :tags => { :table => { :class => 'table table-bordered', :id => 'my_table_id', :'data-custom' => 'custom1!' },
+                                       :thead => { :class => 'mythead', :id => 'my_thead_id', :'data-custom' => 'custom2!' },
+                                       :tbody => { :class => 'mytbody', :id => 'my_tbody_id', :'data-custom' => 'custom3!' },
+                                       :tfoot => { :class => 'mytfoot', :id => 'my_tfoot_id', :'data-custom' => 'custom4!' },
+                                       :tr => { :class => 'mytr', :'data-custom' => 'custom5!' },
+                                       :th => { :class => 'myth', :'data-custom' => 'custom6!' },
+                                       :td => { :class => 'mytd', :'data-custom' => 'custom7!' }
+                                       } ) ).render
+    doc = document( html )
+    table = doc.elements.first
+    check_attributes( table, ['class', 'id', 'data-custom'], ['table table-bordered', 'my_table_id', 'custom1!'])
+    header = table.elements[1] # 1 = first element (not second) in REXML
+    check_attributes( header, ['class', 'id', 'data-custom'], ['mythead', 'my_thead_id', 'custom2!'])
+    body = table.elements[2]   # 2 = second element (not third) in REXML
+    check_attributes( body, ['class', 'id', 'data-custom'], ['mytbody', 'my_tbody_id', 'custom3!'])
+    footer = table.elements[3] # 3 = third element (not fourth) in REXML
+    check_attributes( footer, ['class', 'id', 'data-custom'], ['mytfoot', 'my_tfoot_id', 'custom4!'])
+    row = header.elements.first
+    check_attributes( row, ['class', 'data-custom'], ['mytr', 'custom5!'])
+    row.elements.each do |header_cell|
+      check_attributes( header_cell, ['class', 'data-custom'], ['myth', 'custom6!'])
+    end
+    body.elements.each do |row_|
+      check_attributes( row_, ['class', 'data-custom'], ['mytr', 'custom5!'])
+    end
+    row = footer.elements.first
+    check_attributes( row, ['class', 'data-custom'], ['mytr', 'custom5!'])
+  end
+
+  it "still supports old (deprecated) way of specifying the table class" do
     html = CarTable.new(@cars, nil,
                         :presenter => DiningTable::Presenters::HTMLPresenter.new( :class => 'table table-bordered' ) ).render
     doc = document( html )
@@ -156,7 +249,7 @@ describe 'HTMLTableSpec' do
 
   it "respects global html options" do
     DiningTable.configure do |config|
-      config.html_presenter.default_options = { :class => 'table-hover',
+      config.html_presenter.default_options = { :tags => { :table => { :class => 'table-hover' }, :tr => { :class => 'rowrow' } },
                                                 :wrap => { :tag => :div, :class => 'table-responsive' } }
     end
     html = CarTable.new(@cars, nil).render
@@ -165,12 +258,56 @@ describe 'HTMLTableSpec' do
     doc.elements.first.attributes.get_attribute('class').value.must_equal 'table-responsive'
     table = doc.elements.first.elements.first
     table.attributes.get_attribute('class').value.must_equal 'table-hover'
+    body = table.elements[2]
+    body.elements.each do |row|
+      row.attributes.get_attribute('class').value.must_equal 'rowrow'
+    end
     # reset configuration for other specs
     DiningTable.configure do |config|
       config.html_presenter.default_options = {  }
     end
   end
 
+  it "respects in-table presenter config blocks" do
+    html = CarTableWithConfigBlocks.new(@cars, @view_context).render
+    doc = REXML::Document.new( html )
+    table = doc.elements.first
+    table.attributes.get_attribute('class').value.must_equal 'my-table-class'
+    header = table.elements.first
+    header.attributes.get_attribute('class').value.must_equal 'my-thead-class'
+    row = header.elements.first
+    row.attributes.get_attribute('class').value.must_equal 'header-tr'
+    row.elements.each do |cell|
+      cell.attributes.get_attribute('class').value.must_equal 'header-th'
+    end
+    body = table.elements[2]
+    body.elements.each_with_index do |row_, index|
+      row_.attributes.get_attribute('class').value.must_match( index.odd? ? /odd/ : /even/ )
+      row_.attributes.get_attribute('class').value.must_match( /lowstock/ ) if @cars[index].stock < 10
+      row_.elements.each_with_index do |td, td_index|
+        if td_index == 0
+          td.attributes.get_attribute('class').value.must_equal 'left'
+        elsif td_index == 1
+          td.attributes.get_attribute('class').value.must_match( /center/ )
+          td.attributes.get_attribute('class').value.must_match( /five_doors/ ) if @cars[index].number_of_doors == 5
+        else
+          td.attributes.get_attribute('class').must_be_nil if td_index != 1
+        end
+      end
+    end
+    footer = table.elements[3]
+    footer.attributes.get_attribute('class').value.must_equal 'my-tfoot-class'
+    row = footer.elements.first
+    row.attributes.get_attribute('class').value.must_equal 'footer-tr'
+    row.elements.each_with_index do |cell, index|
+      if index == 0
+        cell.attributes.get_attribute('class').value.must_equal 'left'  # brand column
+      else
+        cell.attributes.get_attribute('class').value.must_equal 'footer-td'
+      end
+    end
+  end
+
   def document( html )
     doc = REXML::Document.new( html )
     check_table_structure( doc )
@@ -203,6 +340,13 @@ describe 'HTMLTableSpec' do
     not_empty?(node, xpath).must_equal true
   end
 
+  def check_attributes( element, attributes, values )
+    attributes.each_with_index do |attribute, index|
+      value = values[ index ]
+      element.attributes.get_attribute( attribute ).value.must_equal value
+    end
+  end
+
   class ViewContext
     def link_to(text, url)
       "<a href=\"#{ url }\">#{ text }</a>"

data/spec/spec_helper.rb

@@ -1,2 +1,8 @@
 require 'dining-table'
-require 'minitest/autorun'
+require 'minitest/autorun'
+
+class String
+  def html_safe
+    self
+  end
+end

data/spec/tables/car_table_with_actions.rb

@@ -2,9 +2,10 @@ class CarTableWithActions < DiningTable::Table
   def define
     column :brand
     column :number_of_doors
-    actions :header => 'Action', :html => { :td_options => { class: 'left' }, :th_options => { class: :left } } do |object|
-      action { |object| h.link_to( 'Show', '#show' ) }
-      action { |object| h.link_to( 'Edit', '#edit' ) }
+    actions :header => 'Action', :html => { :td => { class: 'left' }, :th => { class: :left } } do |object|
+      h.link_to( 'Show', '#show' )  # doesn't do anything, simply verify that h helper is available
+      action { |object_| h.link_to( 'Show', '#show' ) }
+      action { |object_| h.link_to( 'Edit', '#edit' ) }
     end
   end
 end

data/spec/tables/car_table_with_config_blocks.rb

@@ -0,0 +1,33 @@
+class CarTableWithConfigBlocks < DiningTable::Table
+  def define
+
+    presenter.table_config do |config|
+      config.table.class = 'my-table-class'
+      config.thead.class = 'my-thead-class'
+      config.tfoot.class = 'my-tfoot-class'
+    end if presenter.type?(:html)
+
+    presenter.row_config do |config, index, object|
+      if index == :header
+        config.tr.class = 'header-tr'
+        config.th.class = 'header-th'
+      elsif index == :footer
+        config.tr.class = 'footer-tr'
+        config.td.class = 'footer-td'
+      else
+        config.tr.class = index.odd? ? 'odd' : 'even'
+        config.tr.class += ' lowstock' if object.stock < 10
+      end
+    end if presenter.type?(:html)
+
+    column :brand, :html => { :td => { :class => 'left' } }
+
+    number_of_doors_options = ->( config, index, object ) do
+      config.td.class = 'center' unless index == :footer
+      config.td.class += ' five_doors' if object && object.number_of_doors == 5
+    end
+    column :number_of_doors, :footer => 'Total', :html => number_of_doors_options
+
+    column :stock, :footer => lambda { h.link_to("Total: #{ collection.map(&:stock).inject(&:+) }", '#') }
+  end
+end

data/spec/tables/car_table_with_options.rb

@@ -1,9 +1,9 @@
 class CarTableWithOptions < DiningTable::Table
   def define
-    column :brand, :html => { :td_options => { class: 'center' }, :th_options => { class: :center } } do |object|
+    column :brand, :html => { :td => { class: 'center' }, :th => { class: :center } } do |object|
       object.brand.upcase
     end
-    column :stock, :html => { :td_options => { class: 'left' }, :th_options => { class: :left } }
+    column :stock, :html => { :td => { class: 'left' }, :th => { class: :left } }
     column :launch_date if options[:with_normal_launch_date]
     column :launch_date, :class => DateColumn if options[:with_date_column_launch_date]
   end

data/spec/tables/car_table_with_options_old_syntax.rb

@@ -0,0 +1,10 @@
+class CarTableWithOptionsOldSyntax < DiningTable::Table
+  def define
+    column :brand, :html => { :td => { class: 'center' }, :th => { class: :center } } do |object|
+      object.brand.upcase
+    end
+    column :stock, :html => { :td_options => { class: 'left' }, :th_options => { class: :left } }  # deprecated options syntax
+    column :launch_date if options[:with_normal_launch_date]
+    column :launch_date, :class => DateColumn if options[:with_date_column_launch_date]
+  end
+end

data/spec/tables/car_table_without_header.rb

@@ -0,0 +1,9 @@
+class CarTableWithoutHeader < DiningTable::Table
+  def define
+    skip_header
+    skip_footer
+
+    column :brand
+    column :number_of_doors, :footer => 'Total'
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dining-table
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Michaël Van Damme
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-26 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: juwelier
   requirement: !ruby/object:Gem::Requirement
@@ -62,6 +62,7 @@ files:
 - lib/dining-table/presenters/csv_presenter.rb
 - lib/dining-table/presenters/excel_presenter.rb
 - lib/dining-table/presenters/html_presenter.rb
+- lib/dining-table/presenters/html_presenter_configuration.rb
 - lib/dining-table/presenters/presenter.rb
 - lib/dining-table/presenters/spreadsheet_presenter.rb
 - lib/dining-table/table.rb
@@ -72,9 +73,12 @@ files:
 - spec/spec_helper.rb
 - spec/tables/car_table.rb
 - spec/tables/car_table_with_actions.rb
+- spec/tables/car_table_with_config_blocks.rb
 - spec/tables/car_table_with_footer.rb
 - spec/tables/car_table_with_header.rb
 - spec/tables/car_table_with_options.rb
+- spec/tables/car_table_with_options_old_syntax.rb
+- spec/tables/car_table_without_header.rb
 homepage: http://github.com/mvdamme/dining-table
 licenses:
 - MIT
@@ -94,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Create tables easily. Supports html, csv and xlsx.