ajax-datatables-rails 0.4.2 → 1.3.0

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

@@ -2,23 +2,21 @@
 
 module AjaxDatatablesRails
   class Base
-    extend Forwardable
 
-    attr_reader :view, :options
-    def_delegator :@view, :params
+    class_attribute :db_adapter, default: ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+    class_attribute :nulls_last, default: false
 
-    GLOBAL_SEARCH_DELIMITER = ' '
+    attr_reader :params, :options, :datatable
 
-    def initialize(view, options = {})
-      @view    = view
-      @options = options
-      load_orm_extension
-    end
+    GLOBAL_SEARCH_DELIMITER = ' '
 
-    def datatable
-      @datatable ||= Datatable::Datatable.new(self)
+    def initialize(params, options = {})
+      @params    = params
+      @options   = options
+      @datatable = Datatable::Datatable.new(self)
     end
 
+    # User defined methods
     def view_columns
       raise(NotImplementedError, view_columns_error_text)
     end
@@ -31,22 +29,49 @@ module AjaxDatatablesRails
       raise(NotImplementedError, data_error_text)
     end
 
+    # ORM defined methods
+    def fetch_records
+      get_raw_records
+    end
+
+    def filter_records(records)
+      raise(NotImplementedError)
+    end
+
+    def sort_records(records)
+      raise(NotImplementedError)
+    end
+
+    def paginate_records(records)
+      raise(NotImplementedError)
+    end
+
+    # User overides
     def additional_data
       {}
     end
 
+    # JSON structure sent to jQuery DataTables
     def as_json(*)
       {
-        recordsTotal: records_total_count,
+        recordsTotal:    records_total_count,
         recordsFiltered: records_filtered_count,
-        data: sanitize(data)
-      }.merge(get_additional_data)
+        data:            sanitize_data(data),
+      }.merge(additional_data)
     end
 
-    def records
-      @records ||= retrieve_records
+    # User helper methods
+    def column_id(name)
+      view_columns.keys.index(name.to_sym)
+    end
+
+    def column_data(column)
+      id = column_id(column)
+      params.dig('columns', id.to_s, 'search', 'value')
     end
 
+    private
+
     # helper methods
     def connected_columns
       @connected_columns ||= begin
@@ -68,26 +93,7 @@ module AjaxDatatablesRails
       end
     end
 
-    private
-
-    # This method is necessary for smooth transition from
-    # `additinonal_datas` method to `additional_data`
-    # without breaking change.
-    def get_additional_data
-      if respond_to?(:additional_datas)
-        puts <<-WARNING
-          `additional_datas` has been deprecated and
-          will be removed in next major version update!
-          Please use `additional_data` instead.
-        WARNING
-
-        additional_datas
-      else
-        additional_data
-      end
-    end
-
-    def sanitize(data)
+    def sanitize_data(data)
       data.map do |record|
         if record.is_a?(Array)
           record.map { |td| ERB::Util.html_escape(td) }
@@ -97,6 +103,11 @@ module AjaxDatatablesRails
       end
     end
 
+    # called from within #data
+    def records
+      @records ||= retrieve_records
+    end
+
     def retrieve_records
       records = fetch_records
       records = filter_records(records)
@@ -113,16 +124,6 @@ module AjaxDatatablesRails
       filter_records(fetch_records).count(:all)
     end
 
-    # Private helper methods
-    def load_orm_extension
-      case AjaxDatatablesRails.config.orm
-      when :active_record
-        extend ORM::ActiveRecord
-      when :mongoid
-        nil
-      end
-    end
-
     def global_search_delimiter
       GLOBAL_SEARCH_DELIMITER
     end

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

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

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

@@ -4,28 +4,23 @@ module AjaxDatatablesRails
   module Datatable
     class Column
 
-      DB_ADAPTER_TYPE_CAST = {
-        mysql:          'CHAR',
-        mysql2:         'CHAR',
-        sqlite:         'TEXT',
-        sqlite3:        'TEXT',
-        oracle:         'VARCHAR2(4000)',
-        oracleenhanced: 'VARCHAR2(4000)'
-      }.freeze
-
-      attr_reader :datatable, :index, :options
-      attr_writer :search
-
       include Search
       include Order
-      prepend DateFilter unless AjaxDatatablesRails.old_rails?
+      include DateFilter
 
+      attr_reader :datatable, :index, :options
+      attr_writer :search
 
       def initialize(datatable, index, options)
         @datatable   = datatable
         @index       = index
         @options     = options
-        @view_column = datatable.view_columns[options[:data].to_sym]
+        @view_column = datatable.view_columns[column_name]
+        validate_settings!
+      end
+
+      def column_name
+        @column_name ||= options[:data]&.to_sym
       end
 
       def data
@@ -52,26 +47,76 @@ module AjaxDatatablesRails
         !source.include?('.')
       end
 
-      # Add formater option to allow modification of the value
+      # Add formatter option to allow modification of the value
       # before passing it to the database
-      def formater
-        @view_column[:formater]
+      def formatter
+        @view_column[:formatter]
       end
 
-      def formated_value
-        formater ? formater.call(search.value) : search.value
+      def formatted_value
+        formatter ? formatter.call(search.value) : search.value
       end
 
       private
 
+      TYPE_CAST_DEFAULT   = 'VARCHAR'
+      TYPE_CAST_MYSQL     = 'CHAR'
+      TYPE_CAST_SQLITE    = 'TEXT'
+      TYPE_CAST_ORACLE    = 'VARCHAR2(4000)'
+      TYPE_CAST_SQLSERVER = 'VARCHAR(4000)'
+
+      DB_ADAPTER_TYPE_CAST = {
+        mysql:          TYPE_CAST_MYSQL,
+        mysql2:         TYPE_CAST_MYSQL,
+        sqlite:         TYPE_CAST_SQLITE,
+        sqlite3:        TYPE_CAST_SQLITE,
+        oracle:         TYPE_CAST_ORACLE,
+        oracleenhanced: TYPE_CAST_ORACLE,
+        sqlserver:      TYPE_CAST_SQLSERVER,
+      }.freeze
+
+      private_constant :TYPE_CAST_DEFAULT
+      private_constant :TYPE_CAST_MYSQL
+      private_constant :TYPE_CAST_SQLITE
+      private_constant :TYPE_CAST_ORACLE
+      private_constant :TYPE_CAST_SQLSERVER
+      private_constant :DB_ADAPTER_TYPE_CAST
+
       def type_cast
-        @type_cast ||= (DB_ADAPTER_TYPE_CAST[AjaxDatatablesRails.config.db_adapter] || 'VARCHAR')
+        @type_cast ||= DB_ADAPTER_TYPE_CAST.fetch(datatable.db_adapter, TYPE_CAST_DEFAULT)
       end
 
       def casted_column
         @casted_column ||= ::Arel::Nodes::NamedFunction.new('CAST', [table[field].as(type_cast)])
       end
 
+      def validate_settings!
+        raise AjaxDatatablesRails::Error::InvalidSearchColumn, "Unknown column. Check that `data` field is filled on JS side with the column name" if column_name.empty?
+        raise AjaxDatatablesRails::Error::InvalidSearchColumn, "Check that column '#{column_name}' exists in view_columns" unless valid_search_column?(column_name)
+        raise AjaxDatatablesRails::Error::InvalidSearchCondition, cond unless valid_search_condition?(cond)
+      end
+
+      def valid_search_column?(column_name)
+        !datatable.view_columns[column_name].nil?
+      end
+
+      VALID_SEARCH_CONDITIONS = [
+        # String condition
+        :start_with, :end_with, :like, :string_eq, :string_in, :null_value,
+        # Numeric condition
+        :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in,
+        # Date condition
+        :date_range
+      ].freeze
+
+      private_constant :VALID_SEARCH_CONDITIONS
+
+      def valid_search_condition?(cond)
+        return true if cond.is_a?(Proc)
+
+        VALID_SEARCH_CONDITIONS.include?(cond)
+      end
+
     end
   end
 end

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

@@ -5,6 +5,8 @@ module AjaxDatatablesRails
     class Column
       module DateFilter
 
+        RANGE_DELIMITER = '-'
+
         class DateRange
           attr_reader :begin, :end
 
@@ -20,55 +22,44 @@ module AjaxDatatablesRails
 
         # Add delimiter option to handle range search
         def delimiter
-          @view_column[:delimiter] || '-'
-        end
-
-        def empty_range_search?
-          (formated_value == delimiter) || (range_start.blank? && range_end.blank?)
+          @delimiter ||= @view_column.fetch(:delimiter, RANGE_DELIMITER)
         end
 
         # A range value is in form '<range_start><delimiter><range_end>'
         # This returns <range_start>
         def range_start
-          @range_start ||= formated_value.split(delimiter)[0]
+          @range_start ||= formatted_value.split(delimiter)[0]
         end
 
         # A range value is in form '<range_start><delimiter><range_end>'
         # This returns <range_end>
         def range_end
-          @range_end ||= formated_value.split(delimiter)[1]
+          @range_end ||= formatted_value.split(delimiter)[1]
+        end
+
+        def empty_range_search?
+          (formatted_value == delimiter) || (range_start.blank? && range_end.blank?)
         end
 
         # Do a range search
         def date_range_search
           return nil if empty_range_search?
+
           table[field].between(DateRange.new(range_start_casted, range_end_casted))
         end
 
         private
 
-        def non_regex_search
-          if cond == :date_range
-            date_range_search
-          else
-            super
-          end
-        end
-
         def range_start_casted
           range_start.blank? ? parse_date('01/01/1970') : parse_date(range_start)
         end
 
         def range_end_casted
-          range_end.blank? ? Time.current : parse_date("#{range_end} 23:59:59")
+          range_end.blank? ? parse_date('9999-12-31 23:59:59') : parse_date("#{range_end} 23:59:59")
         end
 
         def parse_date(date)
-          if Time.zone
-            Time.zone.parse(date)
-          else
-            Time.parse(date)
-          end
+          Time.zone ? Time.zone.parse(date) : Time.parse(date)
         end
 
       end

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,64 +48,75 @@ 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? ? numeric_search : empty_search
-          when :null_value
-            null_value_search
+            searchable_integer? ? raw_search(cond) : empty_search
           when :start_with
-            casted_column.matches("#{formated_value}%")
+            casted_column.matches("#{formatted_value}%")
           when :end_with
-            casted_column.matches("%#{formated_value}")
+            casted_column.matches("%#{formatted_value}")
           when :like
-            casted_column.matches("%#{formated_value}%")
+            casted_column.matches("%#{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)
           end
         end
 
-        def numeric_search
+        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 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