ajax-datatables-rails 0.4.0 → 0.4.1

data/spec/ajax-datatables-rails/base_spec.rb

@@ -6,30 +6,25 @@ describe AjaxDatatablesRails::Base do
     let(:view) { double('view', params: sample_params) }
 
     it 'requires a view_context' do
-      expect { AjaxDatatablesRails::Base.new }.to raise_error ArgumentError
+      expect { described_class.new }.to raise_error ArgumentError
     end
 
     it 'accepts an options hash' do
-      datatable = AjaxDatatablesRails::Base.new(view, foo: 'bar')
+      datatable = described_class.new(view, foo: 'bar')
       expect(datatable.options).to eq(foo: 'bar')
     end
   end
 
   context 'Public API' do
     let(:view) { double('view', params: sample_params) }
-    let(:datatable) { AjaxDatatablesRails::Base.new(view) }
 
     describe '#view_columns' do
       it 'raises an error if not defined by the user' do
-        expect { datatable.view_columns }.to raise_error AjaxDatatablesRails::NotImplemented
+        datatable = described_class.new(view)
+        expect { datatable.view_columns }.to raise_error NotImplementedError
       end
 
       context 'child class implements view_columns' do
-        it 'expects an array based defining columns' do
-          datatable = SampleDatatable.new(view)
-          expect(datatable.view_columns).to be_a(Array)
-        end
-
         it 'expects a hash based defining columns' do
           datatable = ComplexDatatable.new(view)
           expect(datatable.view_columns).to be_a(Hash)
@@ -39,18 +34,21 @@ describe AjaxDatatablesRails::Base do
 
     describe '#get_raw_records' do
       it 'raises an error if not defined by the user' do
-        expect { datatable.get_raw_records }.to raise_error AjaxDatatablesRails::NotImplemented
+        datatable = described_class.new(view)
+        expect { datatable.get_raw_records }.to raise_error NotImplementedError
       end
     end
 
     describe '#data' do
       it 'raises an error if not defined by the user' do
-        expect { datatable.data }.to raise_error AjaxDatatablesRails::NotImplemented
+        datatable = described_class.new(view)
+        expect { datatable.data }.to raise_error NotImplementedError
       end
 
       context 'when data is defined as a hash' do
+        let(:datatable) { ComplexDatatable.new(view) }
+
         it 'should return an array of hashes' do
-          datatable = ComplexDatatableHash.new(view)
           create_list(:user, 5)
           expect(datatable.data).to be_a(Array)
           expect(datatable.data.size).to eq 5
@@ -59,7 +57,6 @@ describe AjaxDatatablesRails::Base do
         end
 
         it 'should html escape data' do
-          datatable = ComplexDatatableHash.new(view)
           create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
           data = datatable.send(:sanitize, datatable.data)
           item = data.first
@@ -69,8 +66,9 @@ describe AjaxDatatablesRails::Base do
       end
 
       context 'when data is defined as a array' do
+        let(:datatable) { ComplexDatatableArray.new(view) }
+
         it 'should return an array of arrays' do
-          datatable = ComplexDatatableArray.new(view)
           create_list(:user, 5)
           expect(datatable.data).to be_a(Array)
           expect(datatable.data.size).to eq 5
@@ -79,7 +77,6 @@ describe AjaxDatatablesRails::Base do
         end
 
         it 'should html escape data' do
-          datatable = ComplexDatatableArray.new(view)
           create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
           data = datatable.send(:sanitize, datatable.data)
           item = data.first
@@ -90,8 +87,9 @@ describe AjaxDatatablesRails::Base do
     end
 
     describe '#as_json' do
+      let(:datatable) { ComplexDatatable.new(view) }
+
       it 'should return a hash' do
-        datatable = ComplexDatatableHash.new(view)
         create_list(:user, 5)
         data = datatable.as_json
         expect(data[:recordsTotal]).to eq 5
@@ -100,11 +98,10 @@ describe AjaxDatatablesRails::Base do
         expect(data[:data].size).to eq 5
       end
 
-      context 'with additional_datas' do
+      context 'with additional_data' do
         it 'should return a hash' do
-          datatable = ComplexDatatableHash.new(view)
           create_list(:user, 5)
-          expect(datatable).to receive(:additional_datas){ { foo: 'bar' } }
+          expect(datatable).to receive(:additional_data){ { foo: 'bar' } }
           data = datatable.as_json
           expect(data[:recordsTotal]).to eq 5
           expect(data[:recordsFiltered]).to eq 5
@@ -154,34 +151,34 @@ describe AjaxDatatablesRails::Base do
       describe '#offset' do
         it 'defaults to 0' do
           default_view = double('view', params: {})
-          datatable = AjaxDatatablesRails::Base.new(default_view)
+          datatable = described_class.new(default_view)
           expect(datatable.datatable.send(:offset)).to eq(0)
         end
 
-        it 'matches the value on view params[:start] minus 1' do
+        it 'matches the value on view params[:start]' do
           paginated_view = double('view', params: { start: '11' })
-          datatable = AjaxDatatablesRails::Base.new(paginated_view)
-          expect(datatable.datatable.send(:offset)).to eq(10)
+          datatable = described_class.new(paginated_view)
+          expect(datatable.datatable.send(:offset)).to eq(11)
         end
       end
 
       describe '#page' do
         it 'calculates page number from params[:start] and #per_page' do
           paginated_view = double('view', params: { start: '11' })
-          datatable = AjaxDatatablesRails::Base.new(paginated_view)
+          datatable = described_class.new(paginated_view)
           expect(datatable.datatable.send(:page)).to eq(2)
         end
       end
 
       describe '#per_page' do
         it 'defaults to 10' do
-          datatable = AjaxDatatablesRails::Base.new(view)
+          datatable = described_class.new(view)
           expect(datatable.datatable.send(:per_page)).to eq(10)
         end
 
         it 'matches the value on view params[:length]' do
           other_view = double('view', params: { length: 20 })
-          datatable = AjaxDatatablesRails::Base.new(other_view)
+          datatable = described_class.new(other_view)
           expect(datatable.datatable.send(:per_page)).to eq(20)
         end
       end

data/spec/ajax-datatables-rails/datatable/column_spec.rb

@@ -17,6 +17,10 @@ describe AjaxDatatablesRails::Datatable::Column do
       expect(column.orderable?).to eq(true)
     end
 
+    it 'should sort nulls last' do
+      expect(column.nulls_last?).to eq(false)
+    end
+
     it 'should be searchable' do
       expect(column.searchable?).to eq(true)
     end
@@ -29,6 +33,50 @@ describe AjaxDatatablesRails::Datatable::Column do
       expect(column.data).to eq('username')
     end
 
+    describe '#data' do
+      it 'should return the data from params' do
+        expect(column.data).to eq 'username'
+      end
+    end
+
+    describe '#source' do
+      it 'should return the data source from view_column' do
+        expect(column.source).to eq 'User.username'
+      end
+    end
+
+    describe '#table' do
+      context 'with ActiveRecord ORM' do
+        it 'should return the corresponding AR table' do
+          expect(column.table).to eq User.arel_table
+        end
+      end
+      context 'with other ORM' do
+        it 'should return the corresponding model' do
+          expect(User).to receive(:respond_to?).with(:arel_table).and_return(false)
+          expect(column.table).to eq User
+        end
+      end
+    end
+
+    describe '#model' do
+      it 'should return the corresponding AR model' do
+        expect(column.model).to eq User
+      end
+    end
+
+    describe '#field' do
+      it 'should return the corresponding field in DB' do
+        expect(column.field).to eq :username
+      end
+    end
+
+    describe '#custom_field?' do
+      it 'should return false if field is bound to an AR field' do
+        expect(column.custom_field?).to be false
+      end
+    end
+
     describe '#search' do
       it 'child class' do
         expect(column.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
@@ -73,37 +121,34 @@ describe AjaxDatatablesRails::Datatable::Column do
       end
     end
 
-    describe '#delimiter' do
-      it 'should be - by default' do
-        expect(column.delimiter).to eq('-')
+    unless AjaxDatatablesRails.old_rails?
+      describe '#delimiter' do
+        it 'should be - by default' do
+          expect(column.delimiter).to eq('-')
+        end
       end
     end
   end
 
-  describe 'last_name column' do
-    let(:column) { datatable.datatable.columns.last }
-
-    before do
-      datatable.params[:columns] = {'0'=>{'data'=>'last_name', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'', 'regex'=>'false'}}}
-    end
-
-    it 'should be orderable' do
-      expect(column.orderable?).to eq(true)
-    end
+  describe '#formater' do
+    let(:datatable) { DatatableWithFormater.new(view) }
+    let(:column) { datatable.datatable.columns.find { |c| c.data == 'last_name' } }
 
-    it 'should be searchable' do
-      expect(column.searchable?).to eq(true)
+    it 'should be a proc' do
+      expect(column.formater).to be_a(Proc)
     end
+  end
 
-    it 'should have connected to id column' do
-      expect(column.data).to eq('last_name')
-    end
+  describe '#filter' do
+    let(:datatable) { DatatableCondProc.new(view) }
+    let(:column) { datatable.datatable.columns.find { |c| c.data == 'username' } }
 
-    describe '#formater' do
-      it 'should be a proc' do
-        expect(column.formater).to be_a(Proc)
-      end
+    it 'should be a proc' do
+      config = column.instance_variable_get('@view_column')
+      filter = config[:cond]
+      expect(filter).to be_a(Proc)
+      expect(filter).to receive(:call).with(column, column.formated_value)
+      column.filter
     end
   end
-
 end

data/spec/ajax-datatables-rails/datatable/datatable_spec.rb

@@ -73,7 +73,7 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
 
     it 'offset' do
-      expect(datatable.offset).to eq(45)
+      expect(datatable.offset).to eq(50)
     end
 
     it 'page' do

data/spec/ajax-datatables-rails/datatable/simple_order_spec.rb

@@ -2,12 +2,39 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::SimpleOrder do
 
-  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'column'=>'1', 'dir'=>'desc'}) }
-  let(:simple_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(nil, options) }
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view).datatable }
+  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'column' => '1', 'dir' => 'desc'}) }
+  let(:simple_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(datatable, options) }
 
   describe 'option methods' do
     it 'sql query' do
       expect(simple_order.query('firstname')).to eq('firstname DESC')
     end
   end
+
+  describe 'option methods with nulls last' do
+    describe 'using global option' do
+      before { AjaxDatatablesRails.config.nulls_last = true }
+      after  { AjaxDatatablesRails.config.nulls_last = false }
+
+      it 'sql query' do
+        expect(simple_order.query('email')).to eq(
+          'CASE WHEN email IS NULL THEN 1 ELSE 0 END, email DESC'
+        )
+      end
+    end
+
+    describe 'using column option' do
+      let(:sorted_datatable) { DatatableOrderNullsLast.new(view).datatable }
+      let(:nulls_last_order) { AjaxDatatablesRails::Datatable::SimpleOrder.new(sorted_datatable, options) }
+
+      it 'sql query' do
+        expect(nulls_last_order.query('email')).to eq(
+          'CASE WHEN email IS NULL THEN 1 ELSE 0 END, email DESC'
+        )
+      end
+    end
+  end
+
 end

data/spec/ajax-datatables-rails/datatable/simple_search_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe AjaxDatatablesRails::Datatable::SimpleSearch do
 
-  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'value'=>'search value', 'regex'=>'true'}) }
+  let(:options) { ActiveSupport::HashWithIndifferentAccess.new({'value' => 'search value', 'regex' => 'true'}) }
   let(:simple_search) { AjaxDatatablesRails::Datatable::SimpleSearch.new(options) }
 
   describe 'option methods' do

data/spec/ajax-datatables-rails/extended_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 describe AjaxDatatablesRails::Base do
-  let(:view) { double('view', params: sample_params) }
-  let(:datatable) { ReallyComplexDatatable.new(view) }
-
   describe 'it can transform search value before asking the database' do
+    let(:view) { double('view', params: sample_params) }
+    let(:datatable) { DatatableWithFormater.new(view) }
+
     before(:each) do
       create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'DOE')
       create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'SMITH')

data/spec/ajax-datatables-rails/orm/active_record_filter_records_spec.rb

@@ -43,27 +43,69 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
       end
     end
 
-    context 'none of columns are connected' do
+    context 'when none of columns are connected' do
       before(:each) do
         allow(datatable).to receive(:searchable_columns) { [] }
       end
 
-      it 'returns empty query result' do
-        datatable.params[:search] = { value: 'msmith' }
-        expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+      context 'when search value is a string' do
+        before(:each) do
+          datatable.params[:search] = { value: 'msmith' }
+        end
+
+        it 'returns empty query result' do
+          expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+        end
+
+        it 'returns filtered results' do
+          query = datatable.send(:build_conditions_for_datatable)
+          results = records.where(query).map(&:username)
+          expect(results).to eq ['johndoe', 'msmith']
+        end
+      end
+
+      context 'when search value is space-separated string' do
+        before(:each) do
+          datatable.params[:search] = { value: 'foo bar' }
+        end
+
+        it 'returns empty query result' do
+          expect(datatable.send(:build_conditions_for_datatable)).to be_blank
+        end
+
+        it 'returns filtered results' do
+          query = datatable.send(:build_conditions_for_datatable)
+          results = records.where(query).map(&:username)
+          expect(results).to eq ['johndoe', 'msmith']
+        end
       end
     end
 
     context 'with search query' do
-      before(:each) do
-        datatable.params[:search] = { value: "john", regex: "false" }
+      context 'when search value is a string' do
+        before(:each) do
+          datatable.params[:search] = { value: 'john', regex: 'false' }
+        end
+
+        it 'returns a filtering query' do
+          query = datatable.send(:build_conditions_for_datatable)
+          results = records.where(query).map(&:username)
+          expect(results).to include('johndoe')
+          expect(results).not_to include('msmith')
+        end
       end
 
-      it 'returns a filtering query' do
-        query = datatable.send(:build_conditions_for_datatable)
-        results = records.where(query).map(&:username)
-        expect(results).to include('johndoe')
-        expect(results).not_to include('msmith')
+      context 'when search value is space-separated string' do
+        before(:each) do
+          datatable.params[:search] = { value: 'john doe', regex: 'false' }
+        end
+
+        it 'returns a filtering query' do
+          query = datatable.send(:build_conditions_for_datatable)
+          results = records.where(query).map(&:username)
+          expect(results).to eq ['johndoe']
+          expect(results).not_to include('msmith')
+        end
       end
     end
   end
@@ -141,61 +183,61 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
   end
 
-  describe '#typecast helper method' do
+  describe '#type_cast helper method' do
     let(:view) { double('view', params: sample_params) }
     let(:column) { ComplexDatatable.new(view).datatable.columns.first }
 
     it 'returns VARCHAR if :db_adapter is :pg' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :pg }
-      expect(column.send(:typecast)).to eq('VARCHAR')
+      expect(column.send(:type_cast)).to eq('VARCHAR')
     end
 
     it 'returns VARCHAR if :db_adapter is :postgre' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgre }
-      expect(column.send(:typecast)).to eq('VARCHAR')
+      expect(column.send(:type_cast)).to eq('VARCHAR')
     end
 
     it 'returns VARCHAR if :db_adapter is :postgresql' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :postgresql }
-      expect(column.send(:typecast)).to eq('VARCHAR')
+      expect(column.send(:type_cast)).to eq('VARCHAR')
     end
 
     it 'returns VARCHAR if :db_adapter is :oracle' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracle }
-      expect(column.send(:typecast)).to eq('VARCHAR2(4000)')
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
     end
 
     it 'returns VARCHAR if :db_adapter is :oracleenhanced' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracleenhanced }
-      expect(column.send(:typecast)).to eq('VARCHAR2(4000)')
+      expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
     end
 
     it 'returns CHAR if :db_adapter is :mysql2' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql2 }
-      expect(column.send(:typecast)).to eq('CHAR')
+      expect(column.send(:type_cast)).to eq('CHAR')
     end
 
     it 'returns CHAR if :db_adapter is :mysql' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :mysql }
-      expect(column.send(:typecast)).to eq('CHAR')
+      expect(column.send(:type_cast)).to eq('CHAR')
     end
 
     it 'returns TEXT if :db_adapter is :sqlite' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite }
-      expect(column.send(:typecast)).to eq('TEXT')
+      expect(column.send(:type_cast)).to eq('TEXT')
     end
 
     it 'returns TEXT if :db_adapter is :sqlite3' do
       allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlite3 }
-      expect(column.send(:typecast)).to eq('TEXT')
+      expect(column.send(:type_cast)).to eq('TEXT')
     end
   end
 
   describe 'filter conditions' do
-    let(:datatable) { ReallyComplexDatatable.new(view) }
-
     unless AjaxDatatablesRails.old_rails?
       describe 'it can filter records with condition :date_range' do
+        let(:datatable) { DatatableCondDate.new(view) }
+
         before(:each) do
           create(:user, username: 'johndoe', email: 'johndoe@example.com', last_name: 'Doe', created_at: '01/01/2000')
           create(:user, username: 'msmith', email: 'mary.smith@example.com', last_name: 'Smith', created_at: '01/02/2000')
@@ -276,6 +318,8 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :start_with' do
+      let(:datatable) { DatatableCondStartWith.new(view) }
+
       before(:each) do
         create(:user, first_name: 'John')
         create(:user, first_name: 'Mary')
@@ -290,20 +334,35 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :end_with' do
+      let(:datatable) { DatatableCondEndWith.new(view) }
+
       before(:each) do
         create(:user, last_name: 'JOHN')
         create(:user, last_name: 'MARY')
       end
 
-      it 'should filter records matching' do
-        datatable.params[:columns]['3'][:search][:value] = 'ry'
-        expect(datatable.data.size).to eq 1
-        item = datatable.data.first
-        expect(item[:last_name]).to eq 'MARY'
+      if AjaxDatatablesRails.config.db_adapter == :oracleenhanced
+        context 'when db_adapter is oracleenhanced' do
+          it 'should filter records matching' do
+            datatable.params[:columns]['3'][:search][:value] = 'RY'
+            expect(datatable.data.size).to eq 1
+            item = datatable.data.first
+            expect(item[:last_name]).to eq 'MARY'
+          end
+        end
+      else
+        it 'should filter records matching' do
+          datatable.params[:columns]['3'][:search][:value] = 'ry'
+          expect(datatable.data.size).to eq 1
+          item = datatable.data.first
+          expect(item[:last_name]).to eq 'MARY'
+        end
       end
     end
 
     describe 'it can filter records with condition :null_value' do
+      let(:datatable) { DatatableCondNullValue.new(view) }
+
       before(:each) do
         create(:user, first_name: 'john', email: 'foo@bar.com')
         create(:user, first_name: 'mary', email: nil)
@@ -329,7 +388,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :eq' do
-      let(:datatable) { ReallyComplexDatatableEq.new(view) }
+      let(:datatable) { DatatableCondEq.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -345,7 +404,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :not_eq' do
-      let(:datatable) { ReallyComplexDatatableNotEq.new(view) }
+      let(:datatable) { DatatableCondNotEq.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -361,7 +420,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :lt' do
-      let(:datatable) { ReallyComplexDatatableLt.new(view) }
+      let(:datatable) { DatatableCondLt.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -377,7 +436,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :gt' do
-      let(:datatable) { ReallyComplexDatatableGt.new(view) }
+      let(:datatable) { DatatableCondGt.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -393,7 +452,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :lteq' do
-      let(:datatable) { ReallyComplexDatatableLteq.new(view) }
+      let(:datatable) { DatatableCondLteq.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -407,7 +466,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :gteq' do
-      let(:datatable) { ReallyComplexDatatableGteq.new(view) }
+      let(:datatable) { DatatableCondGteq.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)
@@ -421,7 +480,7 @@ describe AjaxDatatablesRails::ORM::ActiveRecord do
     end
 
     describe 'it can filter records with condition :in' do
-      let(:datatable) { ReallyComplexDatatableIn.new(view) }
+      let(:datatable) { DatatableCondIn.new(view) }
 
       before(:each) do
         create(:user, first_name: 'john', post_id: 1)