ajax-datatables-rails 0.3.1 → 0.4.0

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

@@ -4,9 +4,9 @@ module AjaxDatatablesRails
 
   # configure AjaxDatatablesRails global settings
   #   AjaxDatatablesRails.configure do |config|
-  #     config.db_adapter = :pg
+  #     config.db_adapter = :postgresql
   #   end
-  def self.configure &block
+  def self.configure
     yield @config ||= AjaxDatatablesRails::Configuration.new
   end
 
@@ -15,11 +15,14 @@ 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
 
-    # default db_adapter is pg (postgresql)
-    config_accessor(:db_adapter) { :pg }
-    config_accessor(:paginator) { :simple_paginator }
+    config_accessor(:orm) { :active_record }
+    config_accessor(:db_adapter) { :postgresql }
   end
 end

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

@@ -0,0 +1,169 @@
+require 'ostruct'
+
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+      attr_reader :datatable, :index, :options
+
+      unless AjaxDatatablesRails.old_rails?
+        prepend ColumnDateFilter
+      end
+
+      def initialize(datatable, index, options)
+        @datatable, @index, @options = datatable, index, options
+        @view_column = datatable.view_columns[options["data"].to_sym]
+      end
+
+      def data
+        options[:data].presence || options[:name]
+      end
+
+      def searchable?
+        @view_column.fetch(:searchable, true)
+      end
+
+      def orderable?
+        @view_column.fetch(:orderable, true)
+      end
+
+      def search
+        @search ||= SimpleSearch.new(options[:search])
+      end
+
+      def searched?
+        search.value.present?
+      end
+
+      def search=(value)
+        @search = value
+      end
+
+      def cond
+        @view_column[:cond] || :like
+      end
+
+      def filter(value)
+        @view_column[:cond].call(value)
+      end
+
+      def source
+        @view_column[:source]
+      end
+
+      # Add sort_field option to allow overriding of sort field
+      def sort_field
+        @view_column[:sort_field] || field
+      end
+
+      # Add formater option to allow modification of the value
+      # before passing it to the database
+      def formater
+        @view_column[:formater]
+      end
+
+      # Add use_regex option to allow bypassing of regex search
+      def use_regex?
+        @view_column.fetch(:use_regex, true)
+      end
+
+      # Add delimiter option to handle range search
+      def delimiter
+        @view_column[:delimiter] || '-'
+      end
+
+      def table
+        model = source.split('.').first.constantize
+        model.arel_table rescue model
+      end
+
+      def field
+        source.split('.').last.to_sym
+      end
+
+      def search_query
+        search.regexp? ? regex_search : non_regex_search
+      end
+
+      def sort_query
+        custom_field? ? source : "#{table.name}.#{sort_field}"
+      end
+
+      private
+
+      def custom_field?
+        !source.include?('.')
+      end
+
+      def config
+        @config ||= AjaxDatatablesRails.config
+      end
+
+      def formated_value
+        formater ? formater.call(search.value) : search.value
+      end
+
+      # Using multi-select filters in JQuery Datatable auto-enables regex_search.
+      # Unfortunately regex_search doesn't work when filtering on primary keys with integer.
+      # It generates this kind of query : AND ("regions"."id" ~ '2|3') which throws an error :
+      # operator doesn't exist : integer ~ unknown
+      # 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))
+        else
+          non_regex_search
+        end
+      end
+
+      def non_regex_search
+        case cond
+        when Proc
+          filter(formated_value)
+        when :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in
+          numeric_search
+        when :null_value
+          null_value_search
+        when :start_with
+          casted_column.matches("#{formated_value}%")
+        when :end_with
+          casted_column.matches("%#{formated_value}")
+        when :like
+          casted_column.matches("%#{formated_value}%")
+        else
+          nil
+        end
+      end
+
+      def typecast
+        case config.db_adapter
+        when :oracle, :oracleenhanced then 'VARCHAR2(4000)'
+        when :mysql, :mysql2   then 'CHAR'
+        when :sqlite, :sqlite3 then 'TEXT'
+        else
+          'VARCHAR'
+        end
+      end
+
+      def casted_column
+        ::Arel::Nodes::NamedFunction.new('CAST', [table[field].as(typecast)])
+      end
+
+      def null_value_search
+        if formated_value == '!NULL'
+          table[field].not_eq(nil)
+        else
+          table[field].eq(nil)
+        end
+      end
+
+      def numeric_search
+        if custom_field?
+          ::Arel::Nodes::SqlLiteral.new(field).eq(formated_value)
+        else
+          table[field].send(cond, formated_value)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module AjaxDatatablesRails
+  module Datatable
+    module ColumnDateFilter
+
+      def empty_range_search?
+        (formated_value == delimiter) || (range_start.blank? && range_end.blank?)
+      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]
+      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]
+      end
+
+      # Do a range search
+      def date_range_search
+        return nil if empty_range_search?
+        new_start = range_start.blank? ? DateTime.parse('01/01/1970') : DateTime.parse(range_start)
+        new_end   = range_end.blank?   ? DateTime.current : DateTime.parse("#{range_end} 23:59:59")
+        table[field].between(OpenStruct.new(begin: new_start, end: new_end))
+      end
+
+      private
+
+        def non_regex_search
+          if cond == :date_range
+            date_range_search
+          else
+            super
+          end
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module AjaxDatatablesRails
+  module Datatable
+
+    TRUE_VALUE = 'true'.freeze
+
+    class Datatable
+      attr_reader :datatable, :options
+
+      def initialize(datatable)
+        @datatable = datatable
+        @options   = datatable.params
+      end
+
+      # ----------------- ORDER METHODS --------------------
+
+      def orderable?
+        options[:order].present?
+      end
+
+      def orders
+        @orders ||= get_param(:order).map do |_, order_options|
+          SimpleOrder.new(self, order_options)
+        end
+      end
+
+      def order_by(how, what)
+        orders.find { |simple_order| simple_order.send(how) == what }
+      end
+
+      # ----------------- SEARCH METHODS --------------------
+
+      def searchable?
+        options[:search].present? && options[:search][:value].present?
+      end
+
+      def search
+        @search ||= SimpleSearch.new(options[:search])
+      end
+
+      # ----------------- COLUMN METHODS --------------------
+
+      def columns
+        @columns ||= get_param(:columns).map do |index, column_options|
+          Column.new(datatable, index, column_options)
+        end
+      end
+
+      def column_by(how, what)
+        columns.find { |simple_column| simple_column.send(how) == what }
+      end
+
+      # ----------------- OPTIONS METHODS --------------------
+
+      def paginate?
+        per_page != -1
+      end
+
+      def offset
+        (page - 1) * per_page
+      end
+
+      def page
+        (options[:start].to_i / per_page) + 1
+      end
+
+      def per_page
+        options.fetch(:length, 10).to_i
+      end
+
+      def get_param(param)
+        if AjaxDatatablesRails.old_rails?
+          options[param]
+        else
+          options[param].to_unsafe_h.with_indifferent_access
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module AjaxDatatablesRails
+  module Datatable
+    class SimpleOrder
+
+      DIRECTIONS = %w[DESC ASC].freeze
+
+      def initialize(datatable, options = {})
+        @datatable = datatable
+        @options   = options
+      end
+
+      def query(sort_column)
+        "#{sort_column} #{direction}"
+      end
+
+      def column
+        @datatable.column_by(:index, column_index)
+      end
+
+      def direction
+        DIRECTIONS.find { |dir| dir == @options[:dir].upcase } || 'ASC'
+      end
+
+      private
+
+      def column_index
+        @options[:column]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module AjaxDatatablesRails
+  module Datatable
+    class SimpleSearch
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def value
+        @options[:value]
+      end
+
+      def regexp?
+        @options[:regex] == TRUE_VALUE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module AjaxDatatablesRails
+  module ORM
+    module ActiveRecord
+
+      def fetch_records
+        get_raw_records
+      end
+
+      def filter_records(records)
+        records.where(build_conditions)
+      end
+
+      def sort_records(records)
+        sort_by = datatable.orders.inject([]) do |queries, order|
+          column = order.column
+          queries << order.query(column.sort_query) if column
+        end
+        records.order(sort_by.join(", "))
+      end
+
+      def paginate_records(records)
+        records.offset(datatable.offset).limit(datatable.per_page)
+      end
+
+      # ----------------- SEARCH HELPER METHODS --------------------
+
+      def build_conditions
+        if datatable.searchable?
+          build_conditions_for_datatable
+        else
+          build_conditions_for_selected_columns
+        end
+      end
+
+      def build_conditions_for_datatable
+        search_for = datatable.search.value.split(' ')
+        criteria = search_for.inject([]) do |crit, atom|
+          search = Datatable::SimpleSearch.new({ value: atom, regex: datatable.search.regexp? })
+          crit << searchable_columns.map do |simple_column|
+            simple_column.search = search
+            simple_column.search_query
+          end.reduce(:or)
+        end.reduce(:and)
+        criteria
+      end
+
+      def build_conditions_for_selected_columns
+        search_columns.map(&:search_query).compact.reduce(:and)
+      end
+    end
+  end
+end

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

@@ -1,3 +1,3 @@
 module AjaxDatatablesRails
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'.freeze
 end

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

@@ -1,7 +1,7 @@
 AjaxDatatablesRails.configure do |config|
-  # available options for db_adapter are: :oracle, :pg, :mysql2, :sqlite3
+  # available options for db_adapter are: :pg, :mysql, :mysql2, :sqlite, :sqlite3
   # config.db_adapter = :pg
 
-  # available options for paginator are: :simple_paginator, :kaminari, :will_paginate
-  # config.paginator = :simple_paginator
+  # available options for orm are: :active_record, :mongoid
+  # config.orm = :active_record
 end

data/lib/generators/rails/datatable_generator.rb

@@ -5,35 +5,23 @@ module Rails
     class DatatableGenerator < ::Rails::Generators::Base
       desc 'Creates a *_datatable model in the app/datatables directory.'
       source_root File.expand_path('../templates', __FILE__)
-      argument :name, :type => :string
+      argument :name, type: :string
 
       def generate_datatable
-        file_prefix = set_filename(name)
-        @datatable_name = set_datatable_name(name)
         template 'datatable.rb', File.join(
-          'app/datatables', "#{file_prefix}_datatable.rb"
+          'app/datatables', "#{datatable_path}.rb"
         )
       end
 
-      private
-
-      def set_filename(name)
-        name.include?('_') ? name : name.to_s.underscore
-      end
-
-      def set_datatable_name(name)
-        name.include?('_') ? build_name(name) : capitalize(name)
+      def datatable_name
+        datatable_path.classify
       end
 
-      def build_name(name)
-        pieces = name.split('_')
-        pieces.map(&:titleize).join
+      private
+      def datatable_path
+        "#{name.underscore}_datatable"
       end
 
-      def capitalize(name)
-        return name if name[0] == name[0].upcase
-        name.capitalize
-      end
     end
   end
 end