ajax-datatables-rails 0.4.3 → 1.0.0

data/doc/migrate.md

@@ -0,0 +1,53 @@
+## To migrate from `v0.4.x` to `v1.0.0`
+
+1) To mitigate the first change (Datatables no longer inherits from `AjaxDatatablesRails::Base` but from `AjaxDatatablesRails::ActiveRecord`)
+
+Create a new `ApplicationDatatable` class and make all your classes inherits from it :
+
+```ruby
+class ApplicationDatatable < AjaxDatatablesRails::ActiveRecord
+end
+
+class PostDatatable < ApplicationDatatable
+end
+```
+
+**Note :** This is now in the [ProTips™](https://github.com/jbox-web/ajax-datatables-rails#protips) section of the documentation.
+
+2) To mitigate the second change (The `view_context` is no longer injected in Datatables)
+
+Update the `ApplicationDatatable` class :
+
+```ruby
+class ApplicationDatatable < AjaxDatatablesRails::ActiveRecord
+  extend Forwardable
+  attr_reader :view
+  def initialize(params, opts = {})
+    @view = opts[:view_context]
+    super
+  end
+end
+```
+
+and update your controllers :
+
+```ruby
+# before
+respond_to do |format|
+  format.json { render json: UserDatatable.new(view_context) }
+end
+
+# after
+respond_to do |format|
+  format.json { render json: UserDatatable.new(params, view_context: view_context) }
+end
+
+# if you need to inject some options
+respond_to do |format|
+  format.json { render json: UserDatatable.new(params, view_context: view_context, my: 'options') }
+end
+```
+
+This way, you can still use `def_delegators` in your datatables [as in the documentation](https://github.com/jbox-web/ajax-datatables-rails#using-view-helpers).
+
+Note that the recommanded way is to use [Draper gem](https://github.com/drapergem/draper) to separate filtering logic from view/presentation logic [as in the documentation](https://github.com/jbox-web/ajax-datatables-rails#using-view-decorators).

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AjaxDatatablesRails
+  class ActiveRecord < AjaxDatatablesRails::Base
+    include AjaxDatatablesRails::ORM::ActiveRecord
+  end
+end

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

@@ -2,21 +2,15 @@
 
 module AjaxDatatablesRails
   class Base
-    extend Forwardable
 
-    attr_reader :view, :options
-    def_delegator :@view, :params
+    attr_reader :params, :options, :datatable
 
     GLOBAL_SEARCH_DELIMITER = ' '
 
-    def initialize(view, options = {})
-      @view    = view
-      @options = options
-      load_orm_extension
-    end
-
-    def datatable
-      @datatable ||= Datatable::Datatable.new(self)
+    def initialize(params, options = {})
+      @params    = params
+      @options   = options
+      @datatable = Datatable::Datatable.new(self)
     end
 
     def view_columns
@@ -37,9 +31,9 @@ module AjaxDatatablesRails
 
     def as_json(*)
       {
-        recordsTotal: records_total_count,
+        recordsTotal:    records_total_count,
         recordsFiltered: records_filtered_count,
-        data: sanitize(data)
+        data:            sanitize(data)
       }.merge(get_additional_data)
     end
 
@@ -113,16 +107,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/config.rb

@@ -4,10 +4,12 @@ require 'active_support/configurable'
 
 module AjaxDatatablesRails
 
-  # configure AjaxDatatablesRails global settings
+  # Configure AjaxDatatablesRails global settings
+  #
   #   AjaxDatatablesRails.configure do |config|
   #     config.db_adapter = :postgresql
   #   end
+
   def self.configure
     yield @config ||= AjaxDatatablesRails::Configuration.new
   end
@@ -17,14 +19,9 @@ module AjaxDatatablesRails
     @config ||= AjaxDatatablesRails::Configuration.new
   end
 
-  def self.old_rails?
-    Rails::VERSION::MAJOR == 4 && (Rails::VERSION::MINOR == 1 || Rails::VERSION::MINOR == 0)
-  end
-
   class Configuration
     include ActiveSupport::Configurable
 
-    config_accessor(:orm) { :active_record }
     config_accessor(:db_adapter) { :postgresql }
     config_accessor(:nulls_last) { false }
   end

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

@@ -4,13 +4,18 @@ module AjaxDatatablesRails
   module Datatable
     class Column
 
+      TYPE_CAST_DEFAULT = 'VARCHAR'
+      TYPE_CAST_MYSQL   = 'CHAR'
+      TYPE_CAST_SQLITE  = 'TEXT'
+      TYPE_CAST_ORACLE  = 'VARCHAR2(4000)'
+
       DB_ADAPTER_TYPE_CAST = {
-        mysql:          'CHAR',
-        mysql2:         'CHAR',
-        sqlite:         'TEXT',
-        sqlite3:        'TEXT',
-        oracle:         'VARCHAR2(4000)',
-        oracleenhanced: 'VARCHAR2(4000)'
+        mysql:          TYPE_CAST_MYSQL,
+        mysql2:         TYPE_CAST_MYSQL,
+        sqlite:         TYPE_CAST_SQLITE,
+        sqlite3:        TYPE_CAST_SQLITE,
+        oracle:         TYPE_CAST_ORACLE,
+        oracleenhanced: TYPE_CAST_ORACLE
       }.freeze
 
       attr_reader :datatable, :index, :options
@@ -18,7 +23,7 @@ module AjaxDatatablesRails
 
       include Search
       include Order
-      prepend DateFilter unless AjaxDatatablesRails.old_rails?
+      include DateFilter
 
 
       def initialize(datatable, index, options)
@@ -52,20 +57,20 @@ 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
 
       def type_cast
-        @type_cast ||= (DB_ADAPTER_TYPE_CAST[AjaxDatatablesRails.config.db_adapter] || 'VARCHAR')
+        @type_cast ||= DB_ADAPTER_TYPE_CAST.fetch(AjaxDatatablesRails.config.db_adapter, TYPE_CAST_DEFAULT)
       end
 
       def casted_column

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,23 +22,23 @@ 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
@@ -47,14 +49,6 @@ module AjaxDatatablesRails
 
         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
@@ -64,11 +58,7 @@ module AjaxDatatablesRails
         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,33 +48,37 @@ 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
+            searchable_integer? ? raw_search(cond) : empty_search
           when :null_value
             null_value_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 :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 +87,34 @@ 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 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

@@ -3,8 +3,6 @@
 module AjaxDatatablesRails
   module Datatable
 
-    TRUE_VALUE = 'true'
-
     class Datatable
       attr_reader :datatable, :options
 
@@ -70,11 +68,7 @@ module AjaxDatatablesRails
       end
 
       def get_param(param)
-        if AjaxDatatablesRails.old_rails?
-          options[param]
-        else
-          options[param].to_unsafe_h.with_indifferent_access
-        end
+        options[param].to_unsafe_h.with_indifferent_access
       end
 
     end

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

@@ -4,7 +4,9 @@ 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
@@ -24,7 +26,7 @@ module AjaxDatatablesRails
       end
 
       def direction
-        DIRECTIONS.find { |dir| dir == column_direction } || 'ASC'
+        DIRECTIONS.find { |dir| dir == column_direction } || DIRECTION_ASC
       end
 
       private

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