ajax-datatables-rails 0.4.2 → 1.3.0

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

@@ -3,10 +3,8 @@
 module AjaxDatatablesRails
   module Datatable
 
-    TRUE_VALUE = 'true'
-
     class Datatable
-      attr_reader :datatable, :options
+      attr_reader :options
 
       def initialize(datatable)
         @datatable = datatable
@@ -43,7 +41,7 @@ module AjaxDatatablesRails
 
       def columns
         @columns ||= get_param(:columns).map do |index, column_options|
-          Column.new(datatable, index, column_options)
+          Column.new(@datatable, index, column_options)
         end
       end
 
@@ -70,13 +68,25 @@ module AjaxDatatablesRails
       end
 
       def get_param(param)
-        if AjaxDatatablesRails.old_rails?
-          options[param]
+        return {} if options[param].nil?
+
+        if options[param].is_a? Array
+          hash = {}
+          options[param].each_with_index { |value, index| hash[index] = value }
+          hash
         else
           options[param].to_unsafe_h.with_indifferent_access
         end
       end
 
+      def db_adapter
+        @datatable.db_adapter
+      end
+
+      def nulls_last
+        @datatable.nulls_last
+      end
+
     end
   end
 end

data/lib/ajax-datatables-rails/datatable/simple_order.rb

@@ -4,19 +4,19 @@ module AjaxDatatablesRails
   module Datatable
     class SimpleOrder
 
-      DIRECTIONS = %w[DESC ASC].freeze
+      DIRECTION_ASC  = 'ASC'
+      DIRECTION_DESC = 'DESC'
+      DIRECTIONS     = [DIRECTION_ASC, DIRECTION_DESC].freeze
 
       def initialize(datatable, options = {})
-        @datatable = datatable
-        @options   = options
+        @datatable  = datatable
+        @options    = options
+        @adapter    = datatable.db_adapter
+        @nulls_last = datatable.nulls_last
       end
 
       def query(sort_column)
-        if sort_nulls_last?
-          "CASE WHEN #{sort_column} IS NULL THEN 1 ELSE 0 END, #{sort_column} #{direction}"
-        else
-          "#{sort_column} #{direction}"
-        end
+        [sort_column, direction, nulls_last_sql].compact.join(' ')
       end
 
       def column
@@ -24,7 +24,7 @@ module AjaxDatatablesRails
       end
 
       def direction
-        DIRECTIONS.find { |dir| dir == column_direction } || 'ASC'
+        DIRECTIONS.find { |dir| dir == column_direction } || DIRECTION_ASC
       end
 
       private
@@ -38,7 +38,20 @@ module AjaxDatatablesRails
       end
 
       def sort_nulls_last?
-        column.nulls_last? || AjaxDatatablesRails.config.nulls_last == true
+        column.nulls_last? || @nulls_last == true
+      end
+
+      def nulls_last_sql
+        return unless sort_nulls_last?
+
+        case @adapter
+        when :pg, :postgresql, :postgres, :oracle
+          'NULLS LAST'
+        when :mysql, :mysql2, :sqlite, :sqlite3
+          'IS NULL'
+        else
+          raise "unsupported database adapter: #{@adapter}"
+        end
       end
 
     end

data/lib/ajax-datatables-rails/datatable/simple_search.rb

@@ -4,6 +4,8 @@ module AjaxDatatablesRails
   module Datatable
     class SimpleSearch
 
+      TRUE_VALUE = 'true'
+
       def initialize(options = {})
         @options = options
       end

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,15 +4,11 @@ module AjaxDatatablesRails
   module ORM
     module ActiveRecord
 
-      def fetch_records
-        get_raw_records
-      end
-
       def filter_records(records)
         records.where(build_conditions)
       end
 
-      # rubocop:disable Style/EachWithObject
+      # rubocop:disable Style/EachWithObject, Style/SafeNavigation
       def sort_records(records)
         sort_by = datatable.orders.inject([]) do |queries, order|
           column = order.column
@@ -21,7 +17,7 @@ module AjaxDatatablesRails
         end
         records.order(Arel.sql(sort_by.join(', ')))
       end
-      # rubocop:enable Style/EachWithObject
+      # rubocop:enable Style/EachWithObject, Style/SafeNavigation
 
       def paginate_records(records)
         records.offset(datatable.offset).limit(datatable.per_page)
@@ -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

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 
 module AjaxDatatablesRails
-  VERSION = '0.4.2'
+
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 3
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
 end

data/lib/generators/rails/templates/datatable.rb

@@ -1,4 +1,4 @@
-class <%= datatable_name %> < AjaxDatatablesRails::Base
+class <%= datatable_name %> < AjaxDatatablesRails::ActiveRecord
 
   def view_columns
     # Declare strings in this format: ModelName.column_name

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

@@ -3,30 +3,26 @@ require 'spec_helper'
 describe AjaxDatatablesRails::Base do
 
   describe 'an instance' do
-    let(:view) { double('view', params: sample_params) }
-
-    it 'requires a view_context' do
+    it 'requires a hash of params' do
       expect { described_class.new }.to raise_error ArgumentError
     end
 
     it 'accepts an options hash' do
-      datatable = described_class.new(view, foo: 'bar')
+      datatable = described_class.new(sample_params, foo: 'bar')
       expect(datatable.options).to eq(foo: 'bar')
     end
   end
 
-  context 'Public API' do
-    let(:view) { double('view', params: sample_params) }
-
+  describe 'User API' do
     describe '#view_columns' do
       it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         expect { datatable.view_columns }.to raise_error NotImplementedError
       end
 
       context 'child class implements view_columns' do
         it 'expects a hash based defining columns' do
-          datatable = ComplexDatatable.new(view)
+          datatable = ComplexDatatable.new(sample_params)
           expect(datatable.view_columns).to be_a(Hash)
         end
       end
@@ -34,19 +30,19 @@ describe AjaxDatatablesRails::Base do
 
     describe '#get_raw_records' do
       it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         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
-        datatable = described_class.new(view)
+        datatable = described_class.new(sample_params)
         expect { datatable.data }.to raise_error NotImplementedError
       end
 
       context 'when data is defined as a hash' do
-        let(:datatable) { ComplexDatatable.new(view) }
+        let(:datatable) { ComplexDatatable.new(sample_params) }
 
         it 'should return an array of hashes' do
           create_list(:user, 5)
@@ -58,7 +54,7 @@ describe AjaxDatatablesRails::Base do
 
         it 'should html escape data' do
           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)
+          data = datatable.send(:sanitize_data, datatable.data)
           item = data.first
           expect(item[:first_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
           expect(item[:last_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
@@ -66,7 +62,7 @@ describe AjaxDatatablesRails::Base do
       end
 
       context 'when data is defined as a array' do
-        let(:datatable) { ComplexDatatableArray.new(view) }
+        let(:datatable) { ComplexDatatableArray.new(sample_params) }
 
         it 'should return an array of arrays' do
           create_list(:user, 5)
@@ -78,16 +74,87 @@ describe AjaxDatatablesRails::Base do
 
         it 'should html escape data' do
           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)
+          data = datatable.send(:sanitize_data, datatable.data)
           item = data.first
           expect(item[2]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
           expect(item[3]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
         end
       end
     end
+  end
+
+  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 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 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 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 NotImplementedError
+        end
+      end
+    end
 
+    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
+
+        describe '#filter_records' do
+          it {
+            expect { datatable.filter_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
+        end
+
+        describe '#sort_records' do
+          it {
+            expect { datatable.sort_records([]) }.to raise_error(NotImplementedError).with_message('FOO')
+          }
+        end
+
+        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(view) }
+      let(:datatable) { ComplexDatatable.new(sample_params) }
 
       it 'should return a hash' do
         create_list(:user, 5)
@@ -113,74 +180,23 @@ describe AjaxDatatablesRails::Base do
     end
   end
 
+  describe 'User helper methods' do
+    describe '#column_id' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
 
-  context 'Private API' do
-
-    let(:view) { double('view', params: sample_params) }
-    let(:datatable) { ComplexDatatable.new(view) }
-
-    before(:each) do
-      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:orm) { nil }
-    end
-
-    describe '#fetch_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:fetch_records) }.to raise_error NoMethodError
+      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 '#filter_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:filter_records) }.to raise_error NoMethodError
-      end
-    end
-
-    describe '#sort_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:sort_records) }.to raise_error NoMethodError
-      end
-    end
+    describe '#column_data' do
+      let(:datatable) { ComplexDatatable.new(sample_params) }
+      before { datatable.params[:columns]['0'][:search][:value] = 'doe' }
 
-    describe '#paginate_records' do
-      it 'raises an error if it does not include an ORM module' do
-        expect { datatable.send(:paginate_records) }.to raise_error NoMethodError
-      end
-    end
-
-    describe 'helper methods' do
-      describe '#offset' do
-        it 'defaults to 0' do
-          default_view = double('view', params: {})
-          datatable = described_class.new(default_view)
-          expect(datatable.datatable.send(:offset)).to eq(0)
-        end
-
-        it 'matches the value on view params[:start]' do
-          paginated_view = double('view', params: { start: '11' })
-          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 = 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 = 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 = described_class.new(other_view)
-          expect(datatable.datatable.send(:per_page)).to eq(20)
-        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