tableficate 0.2.1 → 0.3.0

data/lib/tableficate/helper.rb

@@ -3,100 +3,97 @@ module Tableficate
     def table_for(rows, options = {})
       t = Tableficate::Table.new(self, rows, options, rows.tableficate_get_data)
       yield(t)
-      t.render
+      t.template.render(partial: Tableficate::Utils::template_path(t.template, 'table_for', t.theme), locals:  {table: t})
+    end
+
+    def tableficate_table_tag(table)
+      render partial: Tableficate::Utils::template_path(table.template, 'table', table.theme), locals: {table: table}
     end
 
     def tableficate_header_tag(column)
-      render partial: Tableficate::Utils::template_path('header', column.table.options[:theme]), locals: {column: column}
+      table = column.table
+      render partial: Tableficate::Utils::template_path(table.template, 'header', table.theme), locals: {column: column}
     end
 
     def tableficate_data_tag(row, column)
-      render partial: Tableficate::Utils::template_path('data', column.table.options[:theme]), locals: {row: row, column: column}
+      table = column.table
+      render partial: Tableficate::Utils::template_path(table.template, 'data', table.theme), locals: {row: row, column: column}
     end
 
     def tableficate_row_tag(row, columns)
-      render partial: Tableficate::Utils::template_path('row', columns.first.table.options[:theme]), locals: {row: row, columns: columns}
+      table = columns.first.table
+      render partial: Tableficate::Utils::template_path(table.template, 'row', table.theme), locals: {row: row, columns: columns}
+    end
+
+    def tableficate_filter_form_tag(table)
+      render partial: Tableficate::Utils::template_path(table.template, 'filters/form', table.theme), locals: {table: table}
     end
 
     def tableficate_filter_tag(filter)
-      render partial: Tableficate::Utils::template_path(filter.template, filter.table.options[:theme]), locals: {filter: filter}
+      table = filter.table
+      render partial: Tableficate::Utils::template_path(table.template, filter.template, table.theme), locals: {filter: filter}
     end
 
     def tableficate_label_tag(filter)
-      label_tag(filter.field_name, filter.label, filter.options[:label_options])
+      label_tag(filter.field_name, filter.label, filter.label_options)
     end
 
     def tableficate_text_field_tag(filter)
-      text_field_tag(filter.field_name, filter.field_value(params[filter.table.as]), filter.options)
+      text_field_tag(filter.field_name, filter.field_value(params[filter.table.as]), filter.attrs)
     end
 
     def tableficate_select_tag(filter)
       field_value = filter.field_value(params[filter.table.as])
 
-      if field_value.present? and filter.options[:collection].is_a?(String)
+      collection = filter.collection
+
+      if field_value.present? and collection.is_a?(String)
         Array.wrap(field_value).each do |fv|
-          if filter.options[:collection].match(/<option[^>]*value\s*=/)
-            filter.options[:collection].gsub!(/(<option[^>]*value\s*=\s*['"]?#{fv}[^>]*)/, '\1 selected="selected"')
+          if collection.match(/<option[^>]*value\s*=/)
+            collection.gsub!(/(<option[^>]*value\s*=\s*['"]?#{fv}[^>]*)/, '\1 selected="selected"')
           else
-            filter.options[:collection].gsub!(/>#{fv}</, " selected=\"selected\">#{fv}<")
+            collection.gsub!(/>#{fv}</, " selected=\"selected\">#{fv}<")
           end
         end
-      elsif not filter.options[:collection].is_a?(String)
-        filter.options[:collection] = Tableficate::Filter::Collection.new(filter.options[:collection], selected: field_value).map {|choice|
-          html_attributes = choice.options.length > 0 ? ' ' + choice.options.map {|k, v| %(#{k.to_s}="#{v}")}.join(' ') : ''
+      elsif not collection.is_a?(String)
+        collection = Tableficate::Filter::Collection.new(collection, selected: field_value).map {|choice|
+          html_attributes = choice.attrs.length > 0 ? ' ' + choice.attrs.map {|k, v| %(#{k.to_s}="#{v}")}.join(' ') : ''
           selected_attribute = choice.selected? ? ' selected="selected"' : ''
 
           %(<option value="#{ERB::Util.html_escape(choice.value)}"#{selected_attribute}#{html_attributes}>#{ERB::Util.html_escape(choice.name)}</option>)
         }.join("\n")
       end
 
-      filter.options[:collection] = filter.options[:collection].html_safe
+      collection = collection.html_safe
 
-      select_tag(filter.field_name, filter.options.delete(:collection), filter.options)
+      select_tag(filter.field_name, collection, filter.attrs)
     end
 
-    def tableficate_radio_tags(filter, &block)
-      field_value = filter.field_value(params[filter.table.as])
-
-      collection = Tableficate::Filter::Collection.new(filter.options[:collection], selected: filter.field_value(params[filter.table.as]))
+    def tableficate_radio_tags(filter)
+      tableficate_collection_of_tags(filter)
+    end
 
-      html = []
-      if block_given?
-        html = collection.map {|choice| capture(choice, &block)}
+    def tableficate_check_box_tags(filter)
+      if filter.collection.empty?
+        check_box_tag(filter.field_name, true, filter.field_value(params[filter.table.as]) == 'true', filter.attrs)
       else
-        collection.each do |choice|
-          html.push(
-            radio_button_tag(filter.field_name, choice.value, choice.checked?, choice.options),
-            label_tag("#{filter.field_name}[#{choice.value}]", choice.name),
-            '<br/>'
-          )
-        end
+        tableficate_collection_of_tags(filter)
       end
-
-      html.join("\n").html_safe
     end
 
-    def tableficate_check_box_tags(filter, &block)
+    def tableficate_collection_of_tags(filter)
+      table       = filter.table
       field_value = filter.field_value(params[filter.table.as])
 
-      collection = Tableficate::Filter::Collection.new(filter.options[:collection], selected: filter.field_value(params[filter.table.as]))
-
       html = []
-      if block_given?
-        html = collection.map {|choice| capture(choice, &block)}
-      else
-        collection.each do |choice|
-          html.push(
-            check_box_tag(
-              "#{filter.field_name}[#{choice.value}]", choice.value, choice.checked?, choice.options.reverse_merge(name: "#{filter.field_name}[]")
-            ),
-            label_tag("#{filter.field_name}[#{choice.value}]", choice.name),
-            '<br/>'
-          )
-        end
+      Tableficate::Filter::Collection.new(filter.collection, selected: field_value).each do |choice|
+        html.push(
+          render(partial: Tableficate::Utils::template_path(table.template, filter.template + '_choice', table.theme), locals: {filter: filter, choice: choice})
+        )
       end
 
       html.join("\n").html_safe
     end
+    private :tableficate_collection_of_tags
   end
 end

data/lib/tableficate/table.rb

@@ -1,32 +1,45 @@
 module Tableficate
   class Table
-    attr_reader :columns, :rows, :current_sort, :filters, :options, :as, :template
+    attr_reader :columns, :rows, :current_sort, :filters, :attrs, :as, :template, :theme
 
     def initialize(template, rows, options, data)
       @template = template
       @rows     = rows
-      @columns  = []
-      @filters  = []
-      @as       = options[:as] || rows.table_name
 
-      @options = {
-        show_sorts: false,
-        theme:      ''
-      }.merge(options)
+      @as         = options.delete(:as) || rows.table_name
+      @theme      = options.delete(:theme) || ''
+      @show_sorts = options.delete(:show_sorts) || false
+      @attrs      = options
+
+      @columns = []
+      @filters = []
 
       @current_sort = data[:current_sort]
+      @field_map    = data[:field_map] || {}
     end
 
-    def column(name, options = {}, &block)
-      options.reverse_merge!(
-        show_sort: @options[:show_sorts]
-      )
+    def empty(*args, &block)
+      if args.empty? and not block_given?
+        @empty
+      else
+        @empty = Empty.new(self, *args, &block)
+      end
+    end
 
-      @columns.push(Column.new(self, name, options, &block))
+    def caption(*args, &block)
+      if args.empty? and not block_given?
+        @caption
+      else
+        @caption = Caption.new(*args, &block)
+      end
     end
 
-    def actions(&block)
-      @columns.push(ActionColumn.new(self, &block))
+    def column(name, options = {}, &block)
+      @columns.push(Column.new(self, name, options.reverse_merge(show_sort: @show_sorts), &block))
+    end
+
+    def actions(options = {}, &block)
+      @columns.push(ActionColumn.new(self, options, &block))
     end
 
     def show_sort?
@@ -54,7 +67,7 @@ module Tableficate
         checkbox: Filter::CheckBox
       }
 
-      as = options.delete(:as) || (options[:collection] ? :select : :text)
+      as = options.delete(:as) || find_as(name, options.has_key?(:collection))
 
       raise Filter::UnknownInputType if as_map[as].nil?
 
@@ -82,7 +95,7 @@ module Tableficate
         select:   Filter::SelectRange
       }
 
-      as = options.delete(:as) || (options[:collection] ? :select : :text)
+      as = options.delete(:as) || find_as(name, options.has_key?(:collection))
 
       raise Filter::UnknownInputType if as_map[as].nil?
 
@@ -91,13 +104,40 @@ module Tableficate
       @filters.push(as_map[as].new(self, name, options))
     end
 
-    def render(options = {})
-      options.reverse_merge!(
-        partial: Tableficate::Utils::template_path('table', @options[:theme]),
-        locals:  {table: self}
-      )
-
-      @template.render options
+    def find_as(name, has_collection)
+      field_name = (@field_map[name] || name).to_s
+      as = :text
+
+      if has_collection
+        as = :select
+      else 
+        case Tableficate::Utils::find_column_type(@rows, field_name)
+        when :integer, :float, :decimal
+          as = :number
+        when :date
+          as = :date
+        when :time
+          as = :time
+        when :datetime, :timestamp
+          as = :datetime
+        when :boolean
+          as = :checkbox
+        end
+      end
+
+      if as == :text
+        case name
+        when /email/
+          as = :email
+        when /url/
+          as = :url
+        when /phone/
+          as = :tel
+        end
+      end
+
+      as
     end
+    private :find_as
   end
 end

data/lib/tableficate/utils.rb

@@ -1,7 +1,32 @@
 module Tableficate
   module Utils
-    def self.template_path(template, theme = '')
-      File.join(['tableficate', theme, template].delete_if(&:blank?))
+    def self.template_path(template, partial, theme = '')
+      file = File.join(['tableficate', theme, partial].delete_if(&:blank?))
+
+      file = File.join(['tableficate', partial]) if not theme.blank? and not template.lookup_context.exists?(file, [], true)
+
+      file
+    end
+
+    def self.find_column_type(scope, name)
+      name = name.to_s
+      column = scope.columns.detect{|column| column.name == name} ||
+      (
+        (scope.respond_to?(:joins_values) ? scope.joins_values : []) +
+        (scope.respond_to?(:includes_values) ? scope.includes_values : [])
+      ).uniq.map{|join|
+        # convert string joins to table names
+        if join.is_a?(String)
+          join.scan(/(?:(?:,|\bjoin\s*)\s*(\w+))/i)
+        else
+          join
+        end
+      }.flatten.map{|table_name|
+        ActiveRecord::Base::connection_pool.columns[table_name.to_s.tableize]
+      }.flatten.detect{|column|
+        column.name == name
+      }
+      column.try(:type)
     end
   end
 end

data/lib/tableficate/version.rb

@@ -1,3 +1,3 @@
 module Tableficate
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/spec/action_column_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Tableficate::ActionColumn do
   before(:all) do
     @action_column = Tableficate::ActionColumn.new(nil) do
-      Actions!
+      'Actions Here!'
     end
   end
 
@@ -18,4 +18,12 @@ describe Tableficate::ActionColumn do
   it 'should have a blank name' do
     @action_column.name.should == ''
   end
+
+  it 'should accept options' do
+    action_column = Tableficate::ActionColumn.new(nil, header: 'Actions') do
+      'Actions Here!'
+    end
+
+    action_column.header.should == 'Actions'
+  end
 end

data/spec/base_spec.rb

@@ -18,6 +18,16 @@ describe Tableficate::Base do
     lambda {NoScope.tableficate({})}.should raise_error(Tableficate::MissingScope)
   end
 
+  it 'should allow for custom column sorting' do
+    class ColumnOrder < Tableficate::Base
+      scope(:nobel_prize_winner)
+      
+      column(:full_name, sort: 'first_name ASC, last_name ASC')
+    end
+
+    ColumnOrder.send(:instance_variable_get, '@sort')[:full_name].should == 'first_name ASC, last_name ASC'
+  end
+
   it 'should allow for a default order' do
     class DefaultOrder < Tableficate::Base
       scope(:nobel_prize_winner)

data/spec/caption_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Tableficate::Caption do
+  it 'should accept plain text in the arguments' do
+    caption = Tableficate::Caption.new('Foo', {class: 'title'})
+
+    caption.attrs[:class].should == 'title'
+    caption.value.should == 'Foo'
+  end
+
+  it 'should take a block in place of the plain text argument' do
+    caption = Tableficate::Caption.new({class: 'title'}) do
+      'Foo'
+    end
+
+    caption.attrs[:class].should == 'title'
+    caption.value.should == 'Foo'
+  end
+  it 'should not escape html in block outputs' do
+    caption = Tableficate::Caption.new do
+      '<b>Foo</b>'
+    end
+
+    ERB::Util::html_escape(caption.value).should == '<b>Foo</b>'
+  end
+  it 'should allow ERB tags in block outputs' do
+    caption = Tableficate::Caption.new do
+      ERB.new("<%= 'Foo'.upcase %>").result(binding)
+    end
+
+    caption.value.should == 'FOO'
+  end
+end

data/spec/column_spec.rb

@@ -9,6 +9,27 @@ describe Tableficate::Column do
     column.header.should == 'Given Name'
   end
 
+  it 'should take all non-specialized options as attrs on the `col` tag' do
+    column = Tableficate::Column.new(nil, :first_name, class: 'attrs')
+    column.attrs.should == {class: 'attrs'}
+
+    column = Tableficate::Column.new(nil, :first_name)
+    column.attrs.should == {}
+  end
+
+  it 'should accept :header_attrs as an option' do
+    column = Tableficate::Column.new(nil, :first_name, header_attrs: {class: 'header'})
+    column.header_attrs.should == {class: 'header'}
+
+    column = Tableficate::Column.new(nil, :first_name)
+    column.header_attrs.should == {}
+  end
+
+  it 'should accept :cell_attrs as an option' do
+    column = Tableficate::Column.new(nil, :first_name, cell_attrs: {class: 'cell'})
+    column.cell_attrs.should == {class: 'cell'}
+  end
+
   it 'should show the value from the database field if no alternative is provided' do
     row = NobelPrizeWinner.find_by_first_name('Norman')
     column = Tableficate::Column.new(nil, :first_name)
@@ -31,6 +52,14 @@ describe Tableficate::Column do
 
     ERB::Util::html_escape(column.value(row)).should == 'Norman<br/>Borlaug'
   end
+  it 'should allow ERB tags in block outputs' do
+    row = NobelPrizeWinner.find_by_first_name_and_last_name('Norman', 'Borlaug')
+    column = Tableficate::Column.new(nil, :first_name) do |row|
+      ERB.new("<%= row.first_name.upcase %>").result(binding)
+    end
+
+    column.value(row).should == 'NORMAN'
+  end
 
   it 'should allow sorting to be turned on and off' do
     column = Tableficate::Column.new(nil, :first_name, show_sort: false)

data/spec/empty_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Tableficate::Empty do
+  before(:each) do
+    @table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {}, {})
+  end
+
+  it 'should add a `colspan` attribute' do
+    @table.column(:first_name)
+    @table.column(:last_name)
+    empty = Tableficate::Empty.new(@table, 'Foo')
+
+    empty.attrs[:colspan].should == 2
+  end
+
+  it 'should accept plain text in the arguments' do
+    empty = Tableficate::Empty.new(@table, 'Foo', {class: 'title'})
+
+    empty.attrs[:class].should == 'title'
+    empty.value.should == 'Foo'
+  end
+
+  it 'should take a block in place of the plain text argument' do
+    empty = Tableficate::Empty.new(@table, {class: 'title'}) do
+      'Foo'
+    end
+
+    empty.attrs[:class].should == 'title'
+    empty.value.should == 'Foo'
+  end
+  it 'should not escape html in block outputs' do
+    empty = Tableficate::Empty.new(@table) do
+      '<b>Foo</b>'
+    end
+
+    ERB::Util::html_escape(empty.value).should == '<b>Foo</b>'
+  end
+  it 'should allow ERB tags in block outputs' do
+    empty = Tableficate::Empty.new(@table) do
+      ERB.new("<%= 'Foo'.upcase %>").result(binding)
+    end
+
+    empty.value.should == 'FOO'
+  end
+end