ajax-datatables-rails 0.4.3 → 1.3.1

data/doc/webpack.md

@@ -5,7 +5,9 @@ We assume here that Bootstrap and FontAwesome are already installed with Webpack
 Inspired by https://datatables.net/download and completed :
 
 Add npm packages :
-
+```sh
+$ yarn add imports-loader
+```
 ```sh
 $ yarn add datatables.net
 $ yarn add datatables.net-bs
@@ -22,7 +24,10 @@ In `config/webpack/loaders/datatables.js` :
 ```js
 module.exports = {
   test: /datatables\.net.*/,
-  loader: 'imports-loader?define=>false'
+  loader: 'imports-loader',
+  options: {
+    additionalCode: 'var define = false;'
+  }
 }
 ```
 

data/gemfiles/{rails_5.2.0.gemfile → rails_5.2.4.gemfile}

@@ -2,12 +2,10 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.2.0"
+gem "rails", "5.2.4"
 gem "activerecord-oracle_enhanced-adapter", "~> 5.2.0"
+gem "sqlite3", "~> 1.3.0"
+gem "mysql2"
 gem "ruby-oci8" if ENV["DB_ADAPTER"] == "oracle_enhanced"
 
-group :test do
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
 gemspec path: "../"

data/gemfiles/{rails_5.0.7.gemfile → rails_6.0.3.gemfile}

@@ -2,12 +2,10 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.0.7"
-gem "activerecord-oracle_enhanced-adapter", "~> 1.7.0"
+gem "rails", "6.0.3"
+gem "activerecord-oracle_enhanced-adapter", "~> 6.0.0"
+gem "sqlite3", "~> 1.4.0"
+gem "mysql2"
 gem "ruby-oci8" if ENV["DB_ADAPTER"] == "oracle_enhanced"
 
-group :test do
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
 gemspec path: "../"

data/gemfiles/{rails_5.1.6.gemfile → rails_6.1.0.gemfile}

@@ -2,12 +2,10 @@
 
 source "https://rubygems.org"
 
-gem "rails", "5.1.6"
-gem "activerecord-oracle_enhanced-adapter", "~> 1.8.0"
+gem "rails", "6.1.0"
+gem "activerecord-oracle_enhanced-adapter", "~> 6.1.0"
+gem "sqlite3", "~> 1.4.0"
+gem "mysql2"
 gem "ruby-oci8" if ENV["DB_ADAPTER"] == "oracle_enhanced"
 
-group :test do
-  gem "codeclimate-test-reporter", "~> 1.0.0"
-end
-
 gemspec path: "../"

data/lib/ajax-datatables-rails.rb

@@ -1,3 +1,14 @@
 # frozen_string_literal: true
 
-require 'ajax_datatables_rails'
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+generators = "#{__dir__}/generators"
+loader.ignore(generators)
+loader.inflector.inflect(
+  'orm'                   => 'ORM',
+  'ajax-datatables-rails' => 'AjaxDatatablesRails'
+)
+loader.setup
+
+module AjaxDatatablesRails
+end

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,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