ajax-datatables-rails 0.4.3 → 1.3.1

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

@@ -11,7 +11,7 @@ module AjaxDatatablesRails
 
         # Add sort_field option to allow overriding of sort field
         def sort_field
-          @view_column[:sort_field] || field
+          @view_column.fetch(:sort_field, field)
         end
 
         def sort_query

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

@@ -5,19 +5,21 @@ module AjaxDatatablesRails
     class Column
       module Search
 
-        SMALLEST_PQ_INTEGER = -2147483648
-        LARGEST_PQ_INTEGER = 2147483647
+        SMALLEST_PQ_INTEGER = -2_147_483_648
+        LARGEST_PQ_INTEGER  = 2_147_483_647
+        NOT_NULL_VALUE      = '!NULL'
+        EMPTY_VALUE         = ''
 
         def searchable?
           @view_column.fetch(:searchable, true)
         end
 
         def cond
-          @view_column[:cond] || :like
+          @view_column.fetch(:cond, :like)
         end
 
         def filter
-          @view_column[:cond].call(self, formated_value)
+          @view_column[:cond].call(self, formatted_value)
         end
 
         def search
@@ -46,33 +48,39 @@ module AjaxDatatablesRails
         # The solution is to bypass regex_search and use non_regex_search with :in operator
         def regex_search
           if use_regex?
-            ::Arel::Nodes::Regexp.new((custom_field? ? field : table[field]), ::Arel::Nodes.build_quoted(formated_value))
+            ::Arel::Nodes::Regexp.new((custom_field? ? field : table[field]), ::Arel::Nodes.build_quoted(formatted_value))
           else
             non_regex_search
           end
         end
 
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
         def non_regex_search
           case cond
           when Proc
             filter
           when :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in
-            is_searchable_integer? ? raw_search(cond) : empty_search
-          when :null_value
-            null_value_search
+            searchable_integer? ? raw_search(cond) : empty_search
           when :start_with
-            casted_column.matches("#{formated_value}%")
+            text_search("#{formatted_value}%")
           when :end_with
-            casted_column.matches("%#{formated_value}")
+            text_search("%#{formatted_value}")
           when :like
-            casted_column.matches("%#{formated_value}%")
+            text_search("%#{formatted_value}%")
           when :string_eq
             raw_search(:eq)
+          when :string_in
+            raw_search(:in)
+          when :null_value
+            null_value_search
+          when :date_range
+            date_range_search
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def null_value_search
-          if formated_value == '!NULL'
+          if formatted_value == NOT_NULL_VALUE
             table[field].not_eq(nil)
           else
             table[field].eq(nil)
@@ -81,31 +89,38 @@ module AjaxDatatablesRails
 
         def raw_search(cond)
           if custom_field?
-            ::Arel::Nodes::SqlLiteral.new(field).eq(formated_value)
+            ::Arel::Nodes::SqlLiteral.new(field).eq(formatted_value)
           else
-            table[field].send(cond, formated_value)
+            table[field].send(cond, formatted_value)
           end
         end
 
+        def text_search(value)
+          casted_column.matches(value)
+        end
+
         def empty_search
-          casted_column.matches('')
+          casted_column.matches(EMPTY_VALUE)
         end
 
-        def is_searchable_integer?
-          if formated_value.is_a?(Array)
-            valids = formated_value.map { |v| is_integer?(v) && !is_out_of_range?(v) }
+        def searchable_integer?
+          if formatted_value.is_a?(Array)
+            valids = formatted_value.map { |v| integer?(v) && !out_of_range?(v) }
             !valids.include?(false)
           else
-            is_integer?(formated_value) && !is_out_of_range?(formated_value)
+            integer?(formatted_value) && !out_of_range?(formatted_value)
           end
         end
 
-        def is_out_of_range?(search_value)
+        def out_of_range?(search_value)
           Integer(search_value) > LARGEST_PQ_INTEGER || Integer(search_value) < SMALLEST_PQ_INTEGER
         end
 
-        def is_integer?(string)
-          true if Integer(string) rescue false
+        def integer?(string)
+          Integer(string)
+          true
+        rescue ArgumentError
+          false
         end
 
       end

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

@@ -2,11 +2,8 @@
 
 module AjaxDatatablesRails
   module Datatable
-
-    TRUE_VALUE = 'true'
-
     class Datatable
-      attr_reader :datatable, :options
+      attr_reader :options
 
       def initialize(datatable)
         @datatable = datatable
@@ -43,7 +40,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 +67,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.3'
+
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 3
+    TINY  = 1
+    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

@@ -1,54 +1,58 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe AjaxDatatablesRails::Base do
+RSpec.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)
-        expect { datatable.view_columns }.to raise_error NotImplementedError
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.view_columns }.to raise_error NotImplementedError
+        end
       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
     end
 
     describe '#get_raw_records' do
-      it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
-        expect { datatable.get_raw_records }.to raise_error NotImplementedError
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.get_raw_records }.to raise_error NotImplementedError
+        end
       end
     end
 
     describe '#data' do
-      it 'raises an error if not defined by the user' do
-        datatable = described_class.new(view)
-        expect { datatable.data }.to raise_error NotImplementedError
+      context 'when method is not defined by the user' do
+        it 'raises an error' do
+          datatable = described_class.new(sample_params)
+          expect { datatable.data }.to raise_error NotImplementedError
+        end
       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
+        it 'returns an array of hashes' do
           create_list(:user, 5)
           expect(datatable.data).to be_a(Array)
           expect(datatable.data.size).to eq 5
@@ -56,9 +60,9 @@ describe AjaxDatatablesRails::Base do
           expect(item).to be_a(Hash)
         end
 
-        it 'should html escape data' do
+        it 'htmls 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,9 +70,9 @@ 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
+        it 'returns an array of arrays' do
           create_list(:user, 5)
           expect(datatable.data).to be_a(Array)
           expect(datatable.data.size).to eq 5
@@ -76,20 +80,103 @@ describe AjaxDatatablesRails::Base do
           expect(item).to be_a(Array)
         end
 
-        it 'should html escape data' do
+        it 'htmls 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 '#fetch_records' do
+          it 'calls #get_raw_records' do
+            expect(datatable).to receive(:get_raw_records) { User.all }
+            datatable.fetch_records
+          end
+
+          it 'returns a collection of records' do
+            expect(datatable).to receive(:get_raw_records) { User.all }
+            expect(datatable.fetch_records).to be_a(ActiveRecord::Relation)
+          end
+        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
+      it 'returns a hash' do
         create_list(:user, 5)
         data = datatable.as_json
         expect(data[:recordsTotal]).to eq 5
@@ -99,9 +186,9 @@ describe AjaxDatatablesRails::Base do
       end
 
       context 'with additional_data' do
-        it 'should return a hash' do
+        it 'returns a hash' do
           create_list(:user, 5)
-          expect(datatable).to receive(:additional_data){ { 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
@@ -113,74 +200,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 'returns 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 'returns column data from params' do
+        expect(datatable.column_data(:username)).to eq('doe')
+        expect(datatable.column_data('username')).to eq('doe')
       end
     end
   end