tableficate 0.2.1 → 0.3.0

data/spec/filters/base_spec.rb

@@ -4,24 +4,25 @@ describe Tableficate::Filter::Base do
   before(:all) do
     @table = Tableficate::Table.new(nil, NobelPrizeWinner.limit(1), {}, {})
     @table.column(:first_name, header: 'Given Name')
+    @first_name_filter = Tableficate::Filter::Base.new(@table, :first_name)
   end
 
   it 'should find the correct template type' do
-    Tableficate::Filter::Base.new(@table, :first_name).template.should == 'filters/base'
+    @first_name_filter.template.should == 'filters/base'
   end
 
   it 'should use the provided label or default to the column header' do
-    Tableficate::Filter::Base.new(@table, :first_name).label.should == 'Given Name'
+    @first_name_filter.label.should == 'Given Name'
     Tableficate::Filter::Base.new(@table, :first_name, label: 'First').label.should == 'First'
   end
 
   it 'should provide a field name' do
-    Tableficate::Filter::Base.new(@table, :first_name).field_name.should == "#{@table.as}[filter][first_name]"
+    @first_name_filter.field_name.should == "#{@table.as}[filter][first_name]"
   end
 
   it 'should provide a field value when given params or a blank value' do
-    Tableficate::Filter::Base.new(@table, :first_name).field_value({filter: {first_name: 'Aaron'}}).should == 'Aaron'
-    Tableficate::Filter::Base.new(@table, :first_name).field_value({}).should == ''
+    @first_name_filter.field_value({filter: {first_name: 'Aaron'}}).should == 'Aaron'
+    @first_name_filter.field_value({}).should == ''
   end
 
   it 'should allow for filters that do not match a particular field' do

data/spec/filters/choice_spec.rb

@@ -4,10 +4,13 @@ describe Tableficate::Filter::Choice do
   it 'should mark a choice as selected if it has a :selected or :checked option' do
     choice = Tableficate::Filter::Choice.new('foo', 'bar', {selected: 'selected'})
     choice.selected?.should be true
-    choice.options[:selected].should be nil
+    choice.attrs[:selected].should be nil
+
+    choice = Tableficate::Filter::Choice.new('foo', 'bar')
+    choice.selected?.should be false
 
     choice = Tableficate::Filter::Choice.new('foo', 'bar', {checked: 'checked'})
     choice.checked?.should be true
-    choice.options[:checked].should be nil
+    choice.attrs[:checked].should be nil
   end
 end

data/spec/filters/collection_spec.rb

@@ -75,9 +75,9 @@ describe Tableficate::Filter::Collection do
 
     1.upto(3) do |i|
       if i == 2
-        collection[i - 1].options[:disabled].should == 'disabled'
+        collection[i - 1].attrs[:disabled].should == 'disabled'
       else
-        collection[i - 1].options.has_key?(:disabled).should be false
+        collection[i - 1].attrs.has_key?(:disabled).should be false
       end
     end
 
@@ -85,9 +85,9 @@ describe Tableficate::Filter::Collection do
 
     1.upto(3) do |i|
       if i == 2 or i == 3
-        collection[i - 1].options[:disabled].should == 'disabled'
+        collection[i - 1].attrs[:disabled].should == 'disabled'
       else
-        collection[i - 1].options.has_key?(:disabled).should be false
+        collection[i - 1].attrs.has_key?(:disabled).should be false
       end
     end
   end

data/spec/filters/input_range_spec.rb

@@ -7,19 +7,20 @@ describe Tableficate::Filter::InputStart do
     template.lookup_context.stub!(:exists?).and_return(true)
     @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
     @table.column(:year)
+    @input_start_filter = Tableficate::Filter::InputStart.new(@table, :year)
   end
 
   it 'should append "[start]" to field_name' do
-    Tableficate::Filter::InputStart.new(@table, :year).field_name == "#{@table.as}[filter][year][start]"
+    @input_start_filter.field_name == "#{@table.as}[filter][year][start]"
   end
 
   it 'should append "_start" to the name' do
-    Tableficate::Filter::InputStart.new(@table, :year).name == :year_start
+    @input_start_filter.name == :year_start
   end
 
   it 'should provide a field value when given params or a blank value' do
-    Tableficate::Filter::InputStart.new(@table, :year).field_value({filter: {year: {start: '2011'}}}).should == '2011'
-    Tableficate::Filter::InputStart.new(@table, :year).field_value({}).should == ''
+    @input_start_filter.field_value({filter: {year: {start: '2011'}}}).should == '2011'
+    @input_start_filter.field_value({}).should == ''
   end
 end
 
@@ -30,19 +31,20 @@ describe Tableficate::Filter::InputStop do
     template.lookup_context.stub!(:exists?).and_return(true)
     @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
     @table.column(:year)
+    @input_stop_filter = Tableficate::Filter::InputStop.new(@table, :year)
   end
 
   it 'should append "[stop]" to field_name' do
-    Tableficate::Filter::InputStop.new(@table, :year).field_name == "#{@table.as}[filter][year][stop]"
+    @input_stop_filter.field_name == "#{@table.as}[filter][year][stop]"
   end
 
   it 'should append "_stop" to the name' do
-    Tableficate::Filter::InputStop.new(@table, :year).name == :year_stop
+    @input_stop_filter.name == :year_stop
   end
 
   it 'should provide a field value when given params or a blank value' do
-    Tableficate::Filter::InputStop.new(@table, :year).field_value({filter: {year: {stop: '2011'}}}).should == '2011'
-    Tableficate::Filter::InputStop.new(@table, :year).field_value({}).should == ''
+    @input_stop_filter.field_value({filter: {year: {stop: '2011'}}}).should == '2011'
+    @input_stop_filter.field_value({}).should == ''
   end
 end
 

data/spec/filters/select_range_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Tableficate::Filter::SelectStart do
+  before(:each) do
+    template = mock('Template')
+    template.stub!(:lookup_context).and_return(ActionView::LookupContext.new([]))
+    template.lookup_context.stub!(:exists?).and_return(true)
+    @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+    @select_start_filter = Tableficate::Filter::SelectStart.new(@table, :year, collection: 1900..2000)
+  end
+
+  it 'should append "[start]" to field_name' do
+    @select_start_filter.field_name == "#{@table.as}[filter][year][start]"
+  end
+
+  it 'should append "_start" to the name' do
+    @select_start_filter.name == :year_start
+  end
+
+  it 'should provide a field value when given params or a blank value' do
+    @select_start_filter.field_value({filter: {year: {start: '1911'}}}).should == '1911'
+    @select_start_filter.field_value({}).should == ''
+  end
+end
+
+describe Tableficate::Filter::SelectStop do
+  before(:each) do
+    template = mock('Template')
+    template.stub!(:lookup_context).and_return(ActionView::LookupContext.new([]))
+    template.lookup_context.stub!(:exists?).and_return(true)
+    @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+    @select_stop_filter = Tableficate::Filter::SelectStop.new(@table, :year, collection: 1900..2000)
+  end
+
+  it 'should append "[stop]" to field_name' do
+    @select_stop_filter.field_name == "#{@table.as}[filter][year][stop]"
+  end
+
+  it 'should append "_stop" to the name' do
+    @select_stop_filter.name == :year_stop
+  end
+
+  it 'should provide a field value when given params or a blank value' do
+    @select_stop_filter.field_value({filter: {year: {stop: '1911'}}}).should == '1911'
+    @select_stop_filter.field_value({}).should == ''
+  end
+end
+
+describe Tableficate::Filter::SelectRange do
+  before(:each) do
+    template = mock('Template')
+    template.stub!(:lookup_context).and_return(ActionView::LookupContext.new([]))
+    @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {})
+    @table.column(:year)
+  end
+
+  it 'should create a start and stop select' do
+    @table.template.lookup_context.stub!(:exists?).and_return(true)
+
+    filter = Tableficate::Filter::SelectRange.new(@table, :year, collection: 1900..2000)
+
+    filter.start.is_a?(Tableficate::Filter::SelectStart).should be true
+    filter.stop.is_a?(Tableficate::Filter::SelectStop).should be true
+  end
+
+  it 'should use the :start and :stop option hashes for the individual filters and default any values not passed to the range options provided' do
+    @table.template.lookup_context.stub!(:exists?).and_return(true)
+
+    filter = Tableficate::Filter::SelectRange.new(@table, :year, label: 'Nobel Prize Won In', collection: 1900..2000)
+    filter.start.label.should == 'Nobel Prize Won In'
+    filter.stop.label.should == 'Nobel Prize Won In'
+
+    filter = Tableficate::Filter::SelectRange.new(@table, :year, label: 'Nobel Prize Won In', start: {label: 'Nobel Prize Won Between'}, stop: {label: 'and'}, collection: 1900..2000)
+    filter.start.label.should == 'Nobel Prize Won Between'
+    filter.stop.label.should == 'and'
+  end
+end

data/spec/finder_spec.rb

@@ -2,21 +2,43 @@ require 'spec_helper'
 
 describe Tableficate::Finder do
   it 'should filter based on single input passed in' do
-    # exact input
+    # exact match
     npw = NobelPrizeWinner.tableficate({filter: {first_name: 'Albert'}})
     npw.size.should == 1
     npw.first.first_name.should == 'Albert'
     npw = NobelPrizeWinner.tableficate({filter: {first_name: 'Al'}})
     npw.size.should == 0
+
+    # contains match
+    class ContainsNobelPrizeWinner < Tableficate::Base
+      scope :nobel_prize_winner
+
+      filter(:first_name, match: 'contains')
+    end
+    npw = ContainsNobelPrizeWinner.tableficate({filter: {first_name: 'Al'}})
+    npw.size.should == 1
+    npw.first.first_name.should == 'Albert'
   end
 
   it 'should filter based on multiple inputs passed in' do
+    # exact match
     npw = NobelPrizeWinner.tableficate({filter: {first_name: ['Albert', 'Marie']}})
     npw.size.should == 2
     npw.first.first_name.should == 'Albert'
     npw.last.first_name.should == 'Marie'
     npw = NobelPrizeWinner.tableficate({filter: {first_name: ['Al', 'Mar']}})
     npw.size.should == 0
+
+    # contains match
+    class ContainsNobelPrizeWinner < Tableficate::Base
+      scope :nobel_prize_winner
+
+      filter(:first_name, match: 'contains')
+    end
+    npw = ContainsNobelPrizeWinner.tableficate({filter: {first_name: ['Al', 'Mar']}})
+    npw.size.should == 2
+    npw.first.first_name.should == 'Albert'
+    npw.last.first_name.should == 'Marie'
   end
 
   it 'should attach the table name to the fields from the primary table to avoid ambiguity' do
@@ -32,4 +54,29 @@ describe Tableficate::Finder do
     np = NobelPrize.tableficate({filter: {year: {start: 1900, stop: 1930}}})
     np.size.should == 4
   end
+
+  it 'should remove harmful characters from the param name' do
+    np = NobelPrize.tableficate({filter: {"ye'ar" =>  {start: 1900, stop: 1930}}})
+    np.size.should == 4
+  end
+
+  it 'should handle a date string being used against a datetime or timestamp column' do
+    np = NobelPrizeWinner.tableficate({filter: {created_at: '20110101'}})
+    np.size.should == 1
+  end
+
+  it 'should handle a date range being used against a datetime or timestamp column' do
+    np = NobelPrizeWinner.tableficate({filter: {created_at: {start: '20110101', stop: '20110105'}}})
+    np.size.should == 5
+  end
+
+  it 'should match an exact datetime and account for the timezone setting' do
+    np = NobelPrizeWinner.tableficate({filter: {created_at: '20110101050112'}})
+    np.size.should == 1
+  end
+
+  it 'should match an exact datetime range and account for the timezone setting' do
+    np = NobelPrizeWinner.tableficate({filter: {created_at: {start: '20110101050112', stop: '20110102050212'}}})
+    np.size.should == 2
+  end
 end

data/spec/generators/tableficate_theme_spec.rb

@@ -8,4 +8,18 @@ describe 'tableficate:theme' do
       subject.should generate('app/views/tableficate/foo/_table.html.erb')
     end
   end
+
+  with_args :foo, 'table_for' do
+    it 'should generate a single file in app/views/tableficate/foo/' do
+      subject.should generate('app/views/tableficate/foo')
+      subject.should generate('app/views/tableficate/foo/_table_for.html.erb')
+    end
+  end
+
+  with_args :foo, 'filters/form' do
+    it 'should generate a single file in app/views/tableficate/foo/filters' do
+      subject.should generate('app/views/tableficate/foo/filters')
+      subject.should generate('app/views/tableficate/foo/filters/_form.html.erb')
+    end
+  end
 end

data/spec/table_spec.rb

@@ -5,7 +5,7 @@ describe Tableficate::Table do
     template = mock('Template')
     template.stub!(:lookup_context).and_return(ActionView::LookupContext.new([]))
     template.lookup_context.stub!(:exists?).and_return(true)
-    @table = Tableficate::Table.new(template, NobelPrizeWinner.limit(1), {}, {current_sort: {column: :first_name, dir: 'asc'}})
+    @table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {current_sort: {column: :first_name, dir: 'asc'}})
   end
 
   it 'should have the current sort if provided' do
@@ -17,6 +17,28 @@ describe Tableficate::Table do
     @table.as.should == 'nobel_prize_winners'
   end
 
+  it 'should add a empty' do
+    @table.empty('There is no data.')
+    @table.empty.is_a?(Tableficate::Empty).should be true
+    @table.empty.value.should == 'There is no data.'
+
+    @table.empty do
+      'No data.'
+    end
+    @table.empty.value.should == 'No data.'
+  end
+
+  it 'should add a caption' do
+    @table.caption('Nobel Prize Winners')
+    @table.caption.is_a?(Tableficate::Caption).should be true
+    @table.caption.value.should == 'Nobel Prize Winners'
+
+    @table.caption do
+      'Nobel Winners'
+    end
+    @table.caption.value.should == 'Nobel Winners'
+  end
+
   it 'should add a Column' do
     @table.column(:first_name)
     @table.column(:last_name)
@@ -85,7 +107,96 @@ describe Tableficate::Table do
     @table.filter(:first_name, as: :search)
 
     @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
-    @table.filters.first.options[:type].should == 'search'
+    @table.filters.first.attrs[:type].should == 'search'
+  end
+
+  it 'should default the type to "checkbox" for boolean fields' do
+    @table.filter(:shared)
+
+    @table.filters.first.is_a?(Tableficate::Filter::CheckBox).should be true
+    @table.filters.first.attrs[:type].should == 'checkbox'
+  end
+
+  it 'should default the type to "email" for string fields with "email" somewhere in the name' do
+    @table.filter(:email)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'email'
+  end
+
+  it 'should default the type to "url" for string fields with "url" somewhere in the name' do
+    @table.filter(:url)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'url'
+  end
+
+  it 'should default the type to "tel" for string fields with "phone" somewhere in the name' do
+    @table.filter(:home_phone)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'tel'
+  end
+
+  it 'should default the type to "number" for integer fields' do
+    @table.filter(:year)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'number'
+  end
+
+  it 'should default the type to "number" for float fields' do
+    @table.filter(:meaningless_float)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'number'
+  end
+
+  it 'should default the type to "number" for decimal fields' do
+    @table.filter(:meaningless_decimal)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'number'
+  end
+
+  it 'should default the type to "date" for date fields' do
+    @table.filter(:birthdate)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'date'
+  end
+
+  it 'should default the type to "time" for time fields' do
+    @table.filter(:meaningless_time)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'time'
+  end
+
+  it 'should default the type to "datetime" for datetime fields' do
+    @table.filter(:created_at)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'datetime'
+  end
+
+  it 'should default the type to "datetime" for timestamp fields' do
+    @table.filter(:updated_at)
+
+    @table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    @table.filters.first.attrs[:type].should == 'datetime'
+  end
+
+  it 'should default the type based on the actual field, not the label' do
+    template = mock('Template')
+    template.stub!(:lookup_context).and_return(ActionView::LookupContext.new([]))
+    template.lookup_context.stub!(:exists?).and_return(true)
+    table = Tableficate::Table.new(template, NobelPrizeWinner.joins(:nobel_prizes).limit(1), {}, {field_map: {foo: 'year'}})
+
+    table.filter(:foo)
+
+    table.filters.first.is_a?(Tableficate::Filter::Input).should be true
+    table.filters.first.attrs[:type].should == 'number'
   end
 
   it 'should add a InputRange filter' do
@@ -105,7 +216,7 @@ describe Tableficate::Table do
     @table.filter_range(:first_name, as: :search)
 
     @table.filters.first.is_a?(Tableficate::Filter::InputRange).should be true
-    @table.filters.first.options[:type].should == 'search'
+    @table.filters.first.attrs[:type].should == 'search'
   end
 
   it 'should add a Select filter' do

data/spec/test_app/app/controllers/filters_controller.rb

@@ -2,6 +2,6 @@ class FiltersController < ApplicationController
   before_filter :get_npw
 
   def get_npw
-    @npw = NobelPrizeWinner.select('nobel_prize_winners.*, nobel_prizes.category, nobel_prizes.year').joins(:nobel_prizes).tableficate(params[:nobel_prize_winners])
+    @npw = NobelPrizeWinner.select('nobel_prize_winners.*, nobel_prizes.*').joins(:nobel_prizes).tableficate(params[:nobel_prize_winners])
   end
 end