ajax-datatables-rails 1.2.0 → 1.3.0

data/lib/ajax-datatables-rails/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module Error
+    class BaseError < StandardError; end
+    class InvalidSearchColumn < BaseError; end
+    class InvalidSearchCondition < BaseError; end
+  end
+end

data/lib/ajax-datatables-rails/orm.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  module ORM
+  end
+end

data/lib/ajax-datatables-rails/orm/active_record.rb

@@ -4,10 +4,6 @@ module AjaxDatatablesRails
   module ORM
     module ActiveRecord
 
-      def fetch_records
-        get_raw_records
-      end
-
       def filter_records(records)
         records.where(build_conditions)
       end
@@ -30,23 +26,26 @@ module AjaxDatatablesRails
       # ----------------- SEARCH HELPER METHODS --------------------
 
       def build_conditions
-        if datatable.searchable?
-          build_conditions_for_datatable
-        else
-          build_conditions_for_selected_columns
+        @build_conditions ||= begin
+          criteria = [build_conditions_for_selected_columns]
+          criteria << build_conditions_for_datatable if datatable.searchable?
+          criteria.compact.reduce(:and)
         end
       end
 
+      # rubocop:disable Metrics/AbcSize
       def build_conditions_for_datatable
+        columns  = searchable_columns.reject(&:searched?)
         criteria = search_for.inject([]) do |crit, atom|
           search = Datatable::SimpleSearch.new(value: atom, regex: datatable.search.regexp?)
-          crit << searchable_columns.map do |simple_column|
+          crit << columns.map do |simple_column|
             simple_column.search = search
             simple_column.search_query
-          end.reduce(:or)
+          end.compact.reduce(:or)
         end.compact.reduce(:and)
         criteria
       end
+      # rubocop:enable Metrics/AbcSize
 
       def build_conditions_for_selected_columns
         search_columns.map(&:search_query).compact.reduce(:and)

data/lib/ajax-datatables-rails/version.rb

@@ -8,7 +8,7 @@ module AjaxDatatablesRails
 
   module VERSION
     MAJOR = 1
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
     PRE   = nil
 

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

@@ -13,7 +13,7 @@ describe AjaxDatatablesRails::Base do
     end
   end
 
-  context 'Public API' do
+  describe 'User API' do
     describe '#view_columns' do
       it 'raises an error if not defined by the user' do
         datatable = described_class.new(sample_params)
@@ -81,165 +81,122 @@ describe AjaxDatatablesRails::Base do
         end
       end
     end
-
-    describe '#as_json' do
-      let(:datatable) { ComplexDatatable.new(sample_params) }
-
-      it 'should return a hash' do
-        create_list(:user, 5)
-        data = datatable.as_json
-        expect(data[:recordsTotal]).to eq 5
-        expect(data[:recordsFiltered]).to eq 5
-        expect(data[:data]).to be_a(Array)
-        expect(data[:data].size).to eq 5
-      end
-
-      context 'with additional_data' do
-        it 'should return a hash' do
-          create_list(:user, 5)
-          expect(datatable).to receive(:additional_data){ { foo: 'bar' } }
-          data = datatable.as_json
-          expect(data[:recordsTotal]).to eq 5
-          expect(data[:recordsFiltered]).to eq 5
-          expect(data[:data]).to be_a(Array)
-          expect(data[:data].size).to eq 5
-          expect(data[:foo]).to eq 'bar'
-        end
-      end
-    end
-
-    describe '#filter_records' do
-      let(:records) { User.all }
-
-      let(:datatable) do
-        datatable = Class.new(ComplexDatatable) do
-          def filter_records(records)
-            raise NotImplementedError
-          end
-        end
-        datatable.new(sample_params)
-      end
-
-      it 'should allow method override' do
-        expect { datatable.filter_records(records) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    describe '#sort_records' do
-      let(:records) { User.all }
-
-      let(:datatable) do
-        datatable = Class.new(ComplexDatatable) do
-          def sort_records(records)
-            raise NotImplementedError
-          end
-        end
-        datatable.new(sample_params)
-      end
-
-      it 'should allow method override' do
-        expect { datatable.sort_records(records) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    describe '#paginate_records' do
-      let(:records) { User.all }
-
-      let(:datatable) do
-        datatable = Class.new(ComplexDatatable) do
-          def paginate_records(records)
-            raise NotImplementedError
-          end
-        end
-        datatable.new(sample_params)
-      end
-
-      it 'should allow method override' do
-        expect { datatable.paginate_records(records) }.to raise_error(NotImplementedError)
-      end
-    end
   end
 
-
-  context 'Private API' do
-    context 'when orm is not implemented' do
+  describe 'ORM API' do
+    context 'when ORM is not implemented' do
       let(:datatable) { AjaxDatatablesRails::Base.new(sample_params) }
 
       describe '#fetch_records' do
         it 'raises an error if it does not include an ORM module' do
-          expect { datatable.fetch_records }.to raise_error NoMethodError
+          expect { datatable.fetch_records }.to raise_error NotImplementedError
         end
       end
 
       describe '#filter_records' do
         it 'raises an error if it does not include an ORM module' do
-          expect { datatable.filter_records }.to raise_error NoMethodError
+          expect { datatable.filter_records([]) }.to raise_error NotImplementedError
         end
       end
 
       describe '#sort_records' do
         it 'raises an error if it does not include an ORM module' do
-          expect { datatable.sort_records }.to raise_error NoMethodError
+          expect { datatable.sort_records([]) }.to raise_error NotImplementedError
         end
       end
 
       describe '#paginate_records' do
         it 'raises an error if it does not include an ORM module' do
-          expect { datatable.paginate_records }.to raise_error NoMethodError
+          expect { datatable.paginate_records([]) }.to raise_error NotImplementedError
         end
       end
     end
 
-    describe 'helper methods' do
-      describe '#offset' do
-        it 'defaults to 0' do
-          datatable = described_class.new({})
-          expect(datatable.datatable.send(:offset)).to eq(0)
+    context 'when ORM is implemented' do
+      describe 'it allows method override' do
+        let(:datatable) do
+          datatable = Class.new(ComplexDatatable) do
+            def filter_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+
+            def sort_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+
+            def paginate_records(records)
+              raise NotImplementedError.new('FOO')
+            end
+          end
+          datatable.new(sample_params)
         end
 
-        it 'matches the value on view params[:start]' do
-          datatable = described_class.new({ start: '11' })
-          expect(datatable.datatable.send(:offset)).to eq(11)
+        describe '#filter_records' do
+          it {
+            expect { datatable.filter_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
         end
-      end
 
-      describe '#page' do
-        it 'calculates page number from params[:start] and #per_page' do
-          datatable = described_class.new({ start: '11' })
-          expect(datatable.datatable.send(:page)).to eq(2)
+        describe '#sort_records' do
+          it {
+            expect { datatable.sort_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
         end
-      end
 
-      describe '#per_page' do
-        it 'defaults to 10' do
-          datatable = described_class.new(sample_params)
-          expect(datatable.datatable.send(:per_page)).to eq(10)
+        describe '#paginate_records' do
+          it {
+            expect { datatable.paginate_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
         end
+      end
+    end
+  end
+
+  describe 'JSON format' do
+    describe '#as_json' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+
+      it 'should return a hash' do
+        create_list(:user, 5)
+        data = datatable.as_json
+        expect(data[:recordsTotal]).to eq 5
+        expect(data[:recordsFiltered]).to eq 5
+        expect(data[:data]).to be_a(Array)
+        expect(data[:data].size).to eq 5
+      end
 
-        it 'matches the value on view params[:length]' do
-          other_view = { length: 20 }
-          datatable = described_class.new(other_view)
-          expect(datatable.datatable.send(:per_page)).to eq(20)
+      context 'with additional_data' do
+        it 'should return a hash' do
+          create_list(:user, 5)
+          expect(datatable).to receive(:additional_data){ { foo: 'bar' } }
+          data = datatable.as_json
+          expect(data[:recordsTotal]).to eq 5
+          expect(data[:recordsFiltered]).to eq 5
+          expect(data[:data]).to be_a(Array)
+          expect(data[:data].size).to eq 5
+          expect(data[:foo]).to eq 'bar'
         end
       end
+    end
+  end
 
-      describe '#column_id' do
-        let(:datatable) { ComplexDatatable.new(sample_params) }
+  describe 'User helper methods' do
+    describe '#column_id' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
 
-        it 'should return column id from view_columns hash' do
-          expect(datatable.send(:column_id, :username)).to eq(0)
-          expect(datatable.send(:column_id, 'username')).to eq(0)
-        end
+      it 'should return column id from view_columns hash' do
+        expect(datatable.column_id(:username)).to eq(0)
+        expect(datatable.column_id('username')).to eq(0)
       end
+    end
 
-      describe '#column_data' do
-        let(:datatable) { ComplexDatatable.new(sample_params) }
-        before { datatable.params[:columns]['0'][:search][:value] = 'doe' }
+    describe '#column_data' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+      before { datatable.params[:columns]['0'][:search][:value] = 'doe' }
 
-        it 'should return column data from params' do
-          expect(datatable.send(:column_data, :username)).to eq('doe')
-          expect(datatable.send(:column_data, 'username')).to eq('doe')
-        end
+      it 'should return column data from params' do
+        expect(datatable.column_data(:username)).to eq('doe')
+        expect(datatable.column_data('username')).to eq('doe')
       end
     end
   end

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

@@ -153,53 +153,73 @@ describe AjaxDatatablesRails::Datatable::Column do
     let(:column) { datatable.datatable.columns.first }
 
     it 'returns VARCHAR if :db_adapter is :pg' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :pg }
+      expect(datatable).to receive(:db_adapter) { :pg }
       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(datatable).to receive(:db_adapter) { :postgre }
       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(datatable).to receive(:db_adapter) { :postgresql }
       expect(column.send(:type_cast)).to eq('VARCHAR')
     end
 
     it 'returns VARCHAR2(4000) if :db_adapter is :oracle' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracle }
+      expect(datatable).to receive(:db_adapter) { :oracle }
       expect(column.send(:type_cast)).to eq('VARCHAR2(4000)')
     end
 
     it 'returns VARCHAR2(4000) if :db_adapter is :oracleenhanced' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :oracleenhanced }
+      expect(datatable).to receive(:db_adapter) { :oracleenhanced }
       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(datatable).to receive(:db_adapter) { :mysql2 }
       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(datatable).to receive(:db_adapter) { :mysql }
       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(datatable).to receive(:db_adapter) { :sqlite }
       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(datatable).to receive(:db_adapter) { :sqlite3 }
       expect(column.send(:type_cast)).to eq('TEXT')
     end
 
     it 'returns VARCHAR(4000) if :db_adapter is :sqlserver' do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:db_adapter) { :sqlserver }
+      expect(datatable).to receive(:db_adapter) { :sqlserver }
       expect(column.send(:type_cast)).to eq('VARCHAR(4000)')
     end
   end
+
+  describe 'when empty column' do
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
+    end
+
+    it 'raises error' do
+      expect { datatable.to_json }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchColumn).with_message("Unknown column. Check that `data` field is filled on JS side with the column name")
+    end
+  end
+
+  describe 'when unknown column' do
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'foo', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
+    end
+
+    it 'raises error' do
+      expect { datatable.to_json }.to raise_error(AjaxDatatablesRails::Error::InvalidSearchColumn).with_message("Check that column 'foo' exists in view_columns")
+    end
+  end
 end

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

@@ -3,9 +3,11 @@ require 'spec_helper'
 describe AjaxDatatablesRails::Datatable::Datatable do
 
   let(:datatable) { ComplexDatatable.new(sample_params).datatable }
+  let(:datatable_json) { ComplexDatatable.new(sample_params_json).datatable }
   let(:order_option) { {'0'=>{'column'=>'0', 'dir'=>'asc'}, '1'=>{'column'=>'1', 'dir'=>'desc'}} }
+  let(:order_option_json) { [{'column'=>'0', 'dir'=>'asc'}, {'column'=>'1', 'dir'=>'desc'}] }
 
-  describe 'order methods' do
+  shared_examples 'order methods' do
     it 'should be orderable' do
       expect(datatable.orderable?).to eq(true)
     end
@@ -35,6 +37,28 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
   end
 
+  shared_examples 'columns methods' do
+    it 'should have 4 columns' do
+      expect(datatable.columns.count).to eq(6)
+    end
+
+    it 'child class' do
+      expect(datatable.columns.first).to be_a(AjaxDatatablesRails::Datatable::Column)
+    end
+  end
+
+  describe 'with query params' do
+    it_behaves_like 'order methods'
+    it_behaves_like 'columns methods'
+  end
+
+  describe 'with json params' do
+    let(:order_option) { order_option_json }
+    let(:datatable) { datatable_json }
+    it_behaves_like 'order methods'
+    it_behaves_like 'columns methods'
+  end
+
   describe 'search methods' do
     it 'should be searchable' do
       datatable.options[:search][:value] = 'atom'
@@ -51,36 +75,51 @@ describe AjaxDatatablesRails::Datatable::Datatable do
     end
   end
 
-  describe 'columns methods' do
-    it 'should have 4 columns' do
-      expect(datatable.columns.count).to eq(6)
+  describe 'option methods' do
+    describe '#paginate?' do
+      it {
+        expect(datatable.paginate?).to be(true)
+      }
     end
 
-    it 'child class' do
-      expect(datatable.columns.first).to be_a(AjaxDatatablesRails::Datatable::Column)
-    end
-  end
+    describe '#per_page' do
+      context 'when params[:length] is missing' do
+        it 'defaults to 10' do
+          expect(datatable.per_page).to eq(10)
+        end
+      end
 
-  describe 'option methods' do
-    before :each do
-      datatable.options[:start] = '50'
-      datatable.options[:length] = '15'
-    end
+      context 'when params[:length] is passed' do
+        let(:datatable) { ComplexDatatable.new({ length: '20' }).datatable }
 
-    it 'paginate?' do
-      expect(datatable.paginate?).to be(true)
+        it 'matches the value on view params[:length]' do
+          expect(datatable.per_page).to eq(20)
+        end
+      end
     end
 
-    it 'offset' do
-      expect(datatable.offset).to eq(50)
-    end
+    describe '#offset' do
+      context 'when params[:start] is missing' do
+        it 'defaults to 0' do
+          expect(datatable.offset).to eq(0)
+        end
+      end
+
+      context 'when params[:start] is passed' do
+        let(:datatable) { ComplexDatatable.new({ start: '11' }).datatable }
 
-    it 'page' do
-      expect(datatable.page).to eq(4)
+        it 'matches the value on view params[:start]' do
+          expect(datatable.offset).to eq(11)
+        end
+      end
     end
 
-    it 'per_page' do
-      expect(datatable.per_page).to eq(15)
+    describe '#page' do
+      let(:datatable) { ComplexDatatable.new({ start: '11' }).datatable }
+
+      it 'calculates page number from params[:start] and #per_page' do
+        expect(datatable.page).to eq(2)
+      end
     end
   end
 end