tabulatr2 0.9.20 → 0.9.21

data/lib/tabulatr/renderer/columns_from_block.rb

@@ -36,7 +36,7 @@ class Tabulatr::Renderer
       if table_data
         @columns << fetch_column_from_table_data(klass.table_name.to_sym, name, opts, &block)
       else
-        @columns << Column.from(opts.merge(klass: klass, table_name: klass.table_name.to_sym, name: name), &block)
+        @columns << Column.from(klass: klass, table_name: klass.table_name.to_sym, name: name, col_options: Tabulatr::ParamsBuilder.new(opts), &block)
       end
     end
 
@@ -45,17 +45,17 @@ class Tabulatr::Renderer
         @columns << fetch_column_from_table_data(table_name, name, opts, &block)
       else
         assoc_klass = klass.reflect_on_association(table_name.to_sym)
-        @columns << Association.from(opts.merge(klass: assoc_klass.try(:klass),
-          name: name, table_name: table_name), &block)
+        @columns << Association.from(klass: assoc_klass.try(:klass),
+          name: name, table_name: table_name, col_options: Tabulatr::ParamsBuilder.new(opts), &block)
       end
     end
 
     def checkbox(opts={})
-      @columns << Checkbox.from(opts.merge(klass: klass, filter: false, sortable: false))
+      @columns << Checkbox.from(klass: klass, col_options: Tabulatr::ParamsBuilder.new(opts.merge(filter: false, sortable: false)))
     end
 
     def action(opts={}, &block)
-      @columns << Action.from(opts.merge(klass: klass, filter: false, sortable: false), &block)
+      @columns << Action.from(klass: klass, col_options: Tabulatr::ParamsBuilder.new(opts.merge(filter: false, sortable: false)), &block)
     end
 
     def buttons(opts={}, &block)
@@ -63,7 +63,8 @@ class Tabulatr::Renderer
         bb = self.instance_exec Tabulatr::Data::ButtonBuilder.new, r, &block
         self.controller.render_to_string partial: '/tabulatr/tabulatr_buttons', locals: {buttons: bb}, formats: [:html]
       }
-      @columns << Buttons.from(opts.merge(klass: klass, filter: false, sortable: false, output: output), &block)
+      opts = {filter: false, sortable: false}.merge(opts)
+      @columns << Buttons.from(klass: klass, col_options: Tabulatr::ParamsBuilder.new(opts), output: output, &block)
     end
 
     def filter(name, partial: nil, &block)
@@ -85,7 +86,9 @@ class Tabulatr::Renderer
 
     def fetch_column_from_table_data table_name, name, opts={}, &block
       column = table_data.table_columns.find{|tc| tc.table_name == table_name && tc.name == name}
-      column.update_options(opts, &block)
+      column.col_options.update(opts)
+      column.output = block if block_given?
+      column
     end
 
     def fetch_filter_from_table_data name

data/lib/tabulatr/renderer/renderer.rb

@@ -58,19 +58,8 @@ class Tabulatr::Renderer
   end
 
   def build_table(columns, filters, tabulatr_data_class, &block)
-    if tabulatr_data_class.present?
-      tdc = tabulatr_data_class.constantize.new(@klass)
-    else
-      tdc = "#{@klass.name}TabulatrData".constantize.new(@klass)
-    end
-    if block_given?
-      @columns = ColumnsFromBlock.process(@klass, tdc, &block).columns
-    elsif columns.any? || filters.any?
-      @columns = get_requested_columns(tdc.table_columns, columns)
-      @filters = get_requested_filters(tdc.filters, filters)
-    else
-      @columns = tdc.table_columns
-    end
+    tdc = get_data_class(tabulatr_data_class)
+    set_columns_and_filters(tdc, columns, filters, &block)
     @view.render(partial: '/tabulatr/tabulatr_table', locals: {
       columns: @columns,
       table_options: @table_options,
@@ -125,11 +114,33 @@ class Tabulatr::Renderer
 
   def get_requested_filters(available_filters, requested_filters)
     requested_filters.collect do |f|
-      result = available_filters.find{|filter| filter.name.to_sym == f.to_sym }
-      result or raise "Can't find filter '#{f}'"
+      available_filters.find("Can't find filter '#{f}'") do |filter|
+        filter.name.to_sym == f.to_sym
+      end
     end.flatten
   end
 
+  def get_data_class(name = '')
+    if name.present?
+      name.constantize.new(@klass)
+    else
+      "#{@klass.name}TabulatrData".constantize.new(@klass)
+    end
+  end
+
+  def set_columns_and_filters(data_class, columns, filters, &block)
+    if block_given?
+      @columns = ColumnsFromBlock.process(@klass, data_class, &block).columns
+    elsif columns.any?
+      @columns = get_requested_columns(data_class.table_columns, columns)
+    else
+      @columns = data_class.table_columns
+    end
+    if filters && filters.any?
+      @filters = get_requested_filters(data_class.filters, filters)
+    end
+  end
+
 end
 
 require_relative './column'

data/lib/tabulatr/version.rb

@@ -22,5 +22,5 @@
 #++
 
 module Tabulatr
-  VERSION = "0.9.20"
+  VERSION = "0.9.21"
 end

data/lib/tabulatr.rb

@@ -37,6 +37,7 @@ require 'tabulatr/engine'
 require 'tabulatr/renderer/renderer'
 require 'tabulatr/data/data'
 require 'tabulatr/json_builder'
+require 'tabulatr/params_builder'
 require 'tabulatr/generators/railtie' if defined?(Rails)
 
 #--

data/spec/dummy/app/controllers/products_controller.rb

@@ -1,12 +1,7 @@
 class ProductsController < ApplicationController
 
   def simple_index
-    begin
-      tabulatr_for Product
-    rescue Exception => e
-      puts e.backtrace
-      raise e
-    end
+    tabulatr_for Product
   end
 
   def one_item_per_page_with_pagination
@@ -58,4 +53,8 @@ class ProductsController < ApplicationController
       raise e
     end
   end
+
+  def without_filters
+    tabulatr_for Product
+  end
 end

data/spec/dummy/app/tabulatr_data/product_tabulatr_data.rb

@@ -9,7 +9,7 @@ class ProductTabulatrData < Tabulatr::Data
   column :title
   column :id
   column :status
-  column :price, table_column_options: {filter: :range} do "#{record.price} EUR" end # <- Block evaluiert im Kontext EINES Records
+  column :price, filter: :range do "#{record.price} EUR" end
   column :edit_link do link_to "edit #{record.title}", product_path(record) end
   # column :name,
   #   sort: "firstname || ' ' || lastname"
@@ -24,8 +24,8 @@ class ProductTabulatrData < Tabulatr::Data
     "#{record.title} from #{record.vendor.try(:name)}"
   end
   column :active, sortable: false
-  column :updated_at, table_column_options: { filter: :date } do "#{record.updated_at.strftime('%H:%M %d.%m.%Y')}" end
-  association :vendor, :name, table_column_options: { filter: :exact }
+  column :updated_at, filter: :date do "#{record.updated_at.strftime('%H:%M %d.%m.%Y')}" end
+  association :vendor, :name, filter: :exact
   association :tags, :title do |r|
     "'#{r.tags.map(&:title).map(&:upcase).join(', ')}'"
   end
@@ -35,10 +35,10 @@ class ProductTabulatrData < Tabulatr::Data
     b.button :eye, product_path(r), class: 'btn-success'
     b.button :pencil, edit_product_path(r), class: 'btn-warning'
     b.submenu do |s|
-      s.button :star, product_path(r), label: 'Dolle Sache'
+      s.button :star, product_path(r), label: 'Great product!'
       s.divider
-      s.button :'trash-o', product_path(r), label: 'Löschen', class: 'btn-danger', method: :delete, data: {confirm: 'echt?'}
+      s.button :'trash-o', product_path(r), label: 'Remove', class: 'btn-danger', method: :delete, data: {confirm: 'are you sure?'}
     end
-    "haha!"
+    "test!"
   end
 end

data/spec/dummy/app/views/products/stupid_array.html.erb

@@ -1,9 +1,15 @@
 <%= static_table_for @products do |t|
   t.column :title
-  t.column :title, format: :foo_me
-  t.column :title, format: ->(a) { bar_me(a) }
+  t.column :title do |a|
+    foo_me(a.title)
+  end
+  t.column :title do |a|
+    bar_me(a.title)
+  end
   t.column :price
-  t.column :price, format: "%08.4f"
+  t.column :price do |b|
+    "%08.4f" % b.price
+  end
   t.column :active
   t.column :updated_at
   t.column :updated_at do |r|
@@ -11,9 +17,17 @@
   end
   t.association :vendor, :name
   t.association :tags, :title
-  t.association :tags, :title, format: :bar_me
-  t.association :tags, :title, format: ->(a) { foo_me(a) }
-  t.association :tags, :count, map: false
+  t.association :tags, :title do |record|
+    record.tags.map(&:title).map do |v|
+      bar_me(v)
+    end
+  end
+  t.association :tags, :title do |record|
+    record.tags.map(&:title).map do |v|
+      foo_me(v)
+    end
+  end
+  t.association :tags, :count
   t.action header: "ACTION!" do |t|
     t.title.upcase
   end

data/spec/dummy/app/views/products/with_styling.html.erb

@@ -1,6 +1,6 @@
 <%= table_for Product, :paginate => true do |t|
   t.checkbox
-  t.column :title, sortable: true, width: '60px', align: 'left', valign: 'top', wrap: 'nowrap', cell_style: {:'background-color' => 'green'}, header_style: {color: 'orange'}
+  t.column :title, sortable: true, width: '60px', align: 'left', wrap: 'nowrap', data_html: {style: 'background-color: green;'}, header_html: {style: 'color: orange;'}
   t.column :price, filter: :range
   t.column :active, sortable: false
   t.column :vendor_product_name, header: 'Product by vendor'

data/spec/dummy/app/views/products/without_filters.html.erb

@@ -0,0 +1 @@
+<%= table_for Product, filter: false %>

data/spec/dummy/config/routes.rb

@@ -10,6 +10,7 @@ Rails.application.routes.draw do
       get :implicit_columns
       get :with_styling
       get :local_storage
+      get :without_filters
     end
   end
 

data/spec/features/tabulatrs_spec.rb

@@ -153,6 +153,11 @@ feature "Tabulatr" do
       expect(page).to have_selector('td[data-tabulatr-column-name="vendor:name"]', text: @vendor2.name)
     end
 
+    scenario "without filters", js: true do
+      visit without_filters_products_path
+      expect(page).to have_no_content('Filter')
+    end
+
     scenario "filters with range", js: true do
       n = names.length
       Product.create!([{title: 'foo', price: 5}, {title: 'bar', price: 17}])
@@ -334,8 +339,8 @@ feature "Tabulatr" do
       header = find(".tabulatr_table thead th[data-tabulatr-column-name='products:title']")
       cell_without_style   = find(".tabulatr_table tbody td[data-tabulatr-column-name='products:price']")
       header_without_style = find(".tabulatr_table thead th[data-tabulatr-column-name='products:price']")
-      expect(cell[:style]).to eql 'text-align:left;width:60px;vertical-align:top;white-space:nowrap;background-color:green'
-      expect(header[:style]).to eql 'text-align:left;width:60px;vertical-align:top;white-space:nowrap;color:orange'
+      expect(cell[:style]).to eql 'background-color: green;text-align: left;width: 60px;white-space: nowrap;'
+      expect(header[:style]).to eql 'color: orange;text-align: left;width: 60px;white-space: nowrap;'
       expect(cell_without_style[:style]).to be_empty
       expect(header_without_style[:style]).to be_empty
     end

data/spec/lib/tabulatr/data/data_spec.rb

@@ -3,12 +3,12 @@ require 'rails_helper'
 describe Tabulatr::Data do
 
   before do
+    col_options = Tabulatr::ParamsBuilder.new(sort_sql: 'products.title', filter_sql: 'products.title')
     column = Tabulatr::Renderer::Column.from(
         name: :title,
         klass: Product,
         table_name: :products,
-        sort_sql: "products.title",
-        filter_sql: "products.title",
+        col_options: col_options,
         output: ->(record){record.send(:title)}
     )
     allow_any_instance_of(Tabulatr::Data).to receive(:table_columns).and_return([column])

data/spec/lib/tabulatr/data/dsl_spec.rb

@@ -9,14 +9,40 @@ describe Tabulatr::Data::DSL do
     DummyDSLClass.instance_variable_set('@table_columns', [])
     DummyDSLClass.instance_variable_set('@filters', [])
     allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+    DummyDSLClass.instance_variable_set('@target_class', nil)
+    DummyDSLClass.instance_variable_set('@target_class_name', nil)
   end
 
   describe '#column' do
     it 'escapes table and column names' do
       DummyDSLClass.column(:active)
       table_column = DummyDSLClass.instance_variable_get('@table_columns').first
-      expect(table_column.filter_sql).to match(/\"products\".\"active\"/)
-      expect(table_column.sort_sql).to match(/\"products\".\"active\"/)
+      expect(table_column.col_options.filter_sql).to match(/\"products\".\"active\"/)
+      expect(table_column.col_options.sort_sql).to match(/\"products\".\"active\"/)
+    end
+
+    it 'uses the sql option as both sort_sql and filter_sql' do
+      allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+      DummyDSLClass.column(:active, sql: 'products.activated')
+      table_column = DummyDSLClass.instance_variable_get('@table_columns').first
+      expect(table_column.col_options.filter_sql).to match(/products\.activated/)
+      expect(table_column.col_options.sort_sql).to match(/products\.activated/)
+    end
+
+    it 'uses the block as output if given' do
+      allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+      output = ->(record){record.title}
+      DummyDSLClass.column(:active, &output)
+      table_column = DummyDSLClass.instance_variable_get('@table_columns').first
+      expect(table_column.output).to eq output
+    end
+
+    it 'uses a standard output if no block is given' do
+      allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+      DummyDSLClass.column(:title)
+      table_column = DummyDSLClass.instance_variable_get('@table_columns').first
+      test_obj = double(title: 'Hello world!')
+      expect(table_column.output.call(test_obj)).to eq(test_obj.title)
     end
   end
 
@@ -24,8 +50,32 @@ describe Tabulatr::Data::DSL do
     it 'escapes table and column names' do
       DummyDSLClass.association(:vendor, :name)
       table_column = DummyDSLClass.instance_variable_get('@table_columns').first
-      expect(table_column.filter_sql).to match(/\"vendors\".\"name\"/)
-      expect(table_column.sort_sql).to match(/\"vendors\".\"name\"/)
+      expect(table_column.col_options.filter_sql).to match(/\"vendors\".\"name\"/)
+      expect(table_column.col_options.sort_sql).to match(/\"vendors\".\"name\"/)
+    end
+
+    it 'uses the block as output if given' do
+      allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+      output = ->(record){ 'test this thing' }
+      DummyDSLClass.association(:vendor, :name, &output)
+      table_column = DummyDSLClass.instance_variable_get('@table_columns').first
+      expect(table_column.output).to eq output
+    end
+
+    it 'uses a standard output if no block is given' do
+      allow(DummyDSLClass).to receive(:main_class).and_return(Product)
+      DummyDSLClass.association(:vendor, :name)
+      table_column = DummyDSLClass.instance_variable_get('@table_columns').first
+      test_obj = double(vendor: double(name: 'Hello world!'))
+      expect(table_column.output.call(test_obj)).to eq(test_obj.vendor.name)
+    end
+  end
+
+  describe '#main_class' do
+    it 'returns the target_class' do
+      DummyDSLClass.instance_variable_set('@target_class', Product)
+      allow(DummyDSLClass).to receive(:target_class_name).and_return('')
+      expect(DummyDSLClass.main_class).to eq(Product)
     end
   end
 

data/spec/lib/tabulatr/data/filtering_spec.rb

@@ -6,6 +6,7 @@ describe Tabulatr::Data::Filtering do
 
     def table_columns; []; end
     def filters; []; end
+    def table_name_for_association(assoc); nil; end
   end
 
   describe '.apply_date_condition' do
@@ -26,7 +27,8 @@ describe Tabulatr::Data::Filtering do
 
 
     it "filters for 'today'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {simple: 'today'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.count).to be 1
@@ -34,7 +36,8 @@ describe Tabulatr::Data::Filtering do
     end
 
     it "filters for 'yesterday'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {simple: 'yesterday'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.count).to be 1
@@ -42,7 +45,8 @@ describe Tabulatr::Data::Filtering do
     end
 
     it "filters for 'this week'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {simple: 'this_week'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.count).to be 4
@@ -50,21 +54,24 @@ describe Tabulatr::Data::Filtering do
     end
 
     it "filters for 'last 7 days'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at' }
       @dummy.apply_date_condition(fake_obj, {simple: 'last_7_days'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.map(&:id).sort).to eq ([@last_seven_days.id, @yesterday.id, @today.id, @week_one.id].sort)
     end
 
     it "filters for 'this month'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {simple: 'this_month'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.map(&:id).sort).to eq ([@today.id, @week_two.id, @this_month.id])
     end
 
     it "filters for 'last 30 days'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {simple: 'last_30_days'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.map(&:id).sort).to eq ([
@@ -73,13 +80,21 @@ describe Tabulatr::Data::Filtering do
     end
 
     it "filters from 'start_date' to 'end_date'" do
-      fake_obj = double(filter_sql: 'publish_at')
+      fake_obj = double()
+      allow(fake_obj).to receive_message_chain('col_options.filter_sql') { 'publish_at'}
       @dummy.apply_date_condition(fake_obj, {
         simple: 'from_to', from: '31.12.2013 15:00',
         to: '15.01.2014 00:00'})
       result = @dummy.instance_variable_get('@relation')
       expect(result.map(&:id)).to eq ([@yesterday.id, @today.id, @week_two.id].sort)
     end
+
+    it "exits early if condition is 'none'" do
+      relation_before = @dummy.instance_variable_get('@relation')
+      @dummy.apply_date_condition(nil, {simple: 'none'})
+      relation_after = @dummy.instance_variable_get('@relation')
+      expect(relation_after).to eq relation_before
+    end
   end
 
   describe '.apply_search' do
@@ -120,6 +135,13 @@ describe Tabulatr::Data::Filtering do
       @dummy.instance_variable_set('@search', ->{'hi'})
       expect{@dummy.apply_search('test')}.to raise_error
     end
+
+    it 'accepts an array of searchable columns' do
+      @dummy.instance_variable_set('@search', ['title', 'vendors:name'])
+      expect{@dummy.apply_search('awesome product')}.to_not raise_error
+      sql = @dummy.instance_variable_get('@relation').to_sql
+      expect(sql).to match(/WHERE \(\(title LIKE '%awesome%product%'\) OR \(vendors:name LIKE '%awesome%product%'\)\)/)
+    end
   end
 
   describe '.apply_filters' do
@@ -146,4 +168,139 @@ describe Tabulatr::Data::Filtering do
       @dummy.apply_filters({'custom' => '10'})
     end
   end
+
+  describe '.apply_condition' do
+    before(:each) do
+      @dummy = DummyFilteringClass.new
+      @dummy.instance_variable_set('@relation', Product.all)
+    end
+
+    it 'handles `:checkbox`' do
+      expect(@dummy).to receive(:apply_boolean_condition)
+      fake_column = double(filter: :checkbox)
+      @dummy.apply_condition(fake_column, true)
+    end
+
+    it 'handles `:decimal`' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: :decimal)
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles `:integer`' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: :integer)
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles `:enum`' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: :enum)
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles `:enum_multiselect`' do
+      expect(@dummy).to receive(:apply_array_condition)
+      fake_column = double(filter: :enum_multiselect)
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles `:exact`' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: :exact)
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles a Hash' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: {})
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles an Array' do
+      expect(@dummy).to receive(:apply_string_condition)
+      fake_column = double(filter: [])
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { ''}
+      @dummy.apply_condition(fake_column, 3)
+    end
+
+    it 'handles `:like`' do
+      expect(@dummy).to receive(:apply_like_condition)
+      fake_column = double(filter: :like)
+      @dummy.apply_condition(fake_column, {like: 'foobar'})
+    end
+
+    it 'handles `:date`' do
+      expect(@dummy).to receive(:apply_date_condition)
+      fake_column = double(filter: :date)
+      @dummy.apply_condition(fake_column, {date: '05/08/2010'})
+    end
+
+    it 'handles `:range`' do
+      expect(@dummy).to receive(:apply_range_condition)
+      fake_column = double(filter: :range)
+      @dummy.apply_condition(fake_column, 2)
+    end
+
+    it 'raises an exception for unknown filter types' do
+      fake_column = double(filter: :foobar, name: 'fake')
+      expect{ @dummy.apply_condition(fake_column, 0) }.to raise_error(/Wrong filter type/)
+    end
+  end
+
+  describe '.apply_boolean_condition' do
+    before(:each) do
+      @dummy = DummyFilteringClass.new
+      @dummy.instance_variable_set('@relation', Product.all)
+    end
+
+    it 'applies a boolean condition to the relation' do
+      fake_column = double()
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { 'products.active'}
+      expect{@dummy.apply_boolean_condition(fake_column, 'true')}.to_not raise_error
+      sql =  @dummy.instance_variable_get('@relation').to_sql
+      expect(sql).to match(/WHERE \(products\.active = 't'\)/)
+    end
+  end
+
+  describe '.apply_like_condition' do
+    before(:each) do
+      @dummy = DummyFilteringClass.new
+      @dummy.instance_variable_set('@relation', Product.all)
+    end
+
+    it 'applies a LIKE condition to the relation' do
+      fake_column = double()
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { 'products.title'}
+      expect{@dummy.apply_like_condition(fake_column, 'hello world')}.to_not raise_error
+      sql = @dummy.instance_variable_get('@relation').to_sql
+      expect(sql).to match(/WHERE \(products.title LIKE '%hello world%'\)/)
+    end
+  end
+
+  describe '.apply_range_condition' do
+    it 'calls `apply_string_condition` twice' do
+      @dummy = DummyFilteringClass.new
+      fake_column = double()
+      allow(fake_column).to receive_message_chain('col_options.filter_sql') { 'products.price'}
+      expect(@dummy).to receive(:apply_string_condition).twice
+      @dummy.apply_range_condition(fake_column, {from: 2, to: 10.5})
+    end
+  end
+
+  describe '.array_condition' do
+    it 'applies an IN condition to the relation' do
+      @dummy = DummyFilteringClass.new
+      @dummy.instance_variable_set('@relation', Product.all)
+      fake_column = double(table_name: 'products', name: 'id')
+      expect{@dummy.apply_array_condition(fake_column, [19, 9])}.to_not raise_error
+      sql = @dummy.instance_variable_get('@relation').to_sql
+      expect(sql).to match(/WHERE \"products\".\"id\" IN \(19, 9\)/)
+    end
+  end
 end

data/spec/lib/tabulatr/data/formatting_spec.rb

@@ -9,12 +9,12 @@ describe Tabulatr::Data::Formatting do
   before(:each) do
     @dummy = DummyFormattingClass.new
     @dummy.instance_variable_set('@relation', Product.all)
+    col_options = Tabulatr::ParamsBuilder.new(sort_sql: 'products.title', filter_sql: 'products.title')
     column = Tabulatr::Renderer::Column.from(
         name: :title,
         klass: Product,
         table_name: :products,
-        sort_sql: "products.title",
-        filter_sql: "products.title"
+        col_options: col_options
     )
     allow(@dummy).to receive(:table_columns).and_return([column])
   end

data/spec/lib/tabulatr/data/sorting_spec.rb

@@ -11,11 +11,11 @@ describe Tabulatr::Data::Sorting do
     @dummy.instance_variable_set('@relation', Product.all)
     @dummy.instance_variable_set('@table_name', 'products')
     @dummy.instance_variable_set('@base', Product)
+    col_options = Tabulatr::ParamsBuilder.new(sort_sql: 'products.title', filter_sql: 'products.title')
     column = Tabulatr::Renderer::Column.from(
         name: :title,
         klass: Product,
-        sort_sql: "products.title",
-        filter_sql: "products.title",
+        col_options: col_options,
         table_name: :products
     )
     allow(@dummy).to receive(:table_columns).and_return([column])
@@ -48,12 +48,12 @@ describe Tabulatr::Data::Sorting do
       context 'sort by association column' do
         it 'sorts by vendor.name' do
           @dummy.instance_variable_set('@includes', [])
+          col_options = Tabulatr::ParamsBuilder.new(sort_sql: 'vendors.name', filter_sql: 'vendors.name')
           assoc = Tabulatr::Renderer::Association.from(
               name: :name,
               table_name: :vendor,
               klass: Product,
-              sort_sql: "vendors.name",
-              filter_sql: "vendors.name"
+              col_options: col_options
           )
           allow(@dummy).to receive(:table_columns).and_return([assoc])
           @dummy.apply_sorting('vendor:name desc')
@@ -65,11 +65,11 @@ describe Tabulatr::Data::Sorting do
       context 'sort by custom sql' do
         it "sorts by products.title || '' || vendors.name" do
           @dummy.instance_variable_set('@includes', [])
+          col_options = Tabulatr::ParamsBuilder.new(sort_sql: "products.title || '' || vendors.name", filter_sql: 'products.title')
           column = Tabulatr::Renderer::Column.from(
               name: :custom_column,
               klass: Product,
-              sort_sql: "products.title || '' || vendors.name",
-              filter_sql: "products.title"
+              col_options: col_options
           )
           allow(@dummy).to receive(:table_columns).and_return([column])
           @dummy.apply_sorting('custom_column asc')