effective_datatables 2.3.8 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8497b5523a489dc7a7b27a161203782080c6c95a
-  data.tar.gz: edfd807e2a1032d6bf3724200ba37fdc37626937
+  metadata.gz: 5356cff7e6d831538a222820ad35adde6b9c28a8
+  data.tar.gz: 273bea0ced295a05ef825e2cfa009670c1a0f682
 SHA512:
-  metadata.gz: 9a9f16f1d2248b4f8b80003427a6a6a44bd4c48e5fa2084ae664158d60dd9df55cda4a6642bff2ee33c04a4f54f6dde092987a2ea164eee0b9d1a75c225e6399
-  data.tar.gz: c000ddce0633521ea5cb132af6a8a8e6a15a098bf7f5948d65f7bcc782fbe7ab18251889c5da1e17d7e7d411a006316bc722c35e5c70f81a29a7b48874750c59
+  metadata.gz: 8c0af0da24feda9e04408d4150fd874818d7bf08ecb29f445797e4a06362cb4d9ec454f65163d77a551bfc5af2efb96e23ed0eebb99125a5224fc6883aaafd5d
+  data.tar.gz: 3f6e5cd755c9d9c773ed9c32e9096fc2c5b496a7dfc5ff0c8aec14519e5b2719db57f09c332617566bc2b2f3f8a8968f6854326e073d75d5635a9e8fbea8e36a

data/README.md

@@ -136,7 +136,7 @@ module Effective
 
         table_column :user
 
-        table_column :post_category_id, :filter => {:type => :select, :values => Proc.new { PostCategory.all } } do |post|
+        table_column :post_category_id, :filter => {:as => :select, :collection => Proc.new { PostCategory.all } } do |post|
           post.post_category.name.titleize
         end
 
@@ -267,7 +267,7 @@ table_column :user
 # Will have the same behaviour as declaring
 datatable do
   if attributes[:user_id].blank?
-    table_column :user_id, :filter => {:type => :select, :values => Proc.new { User.all.map { |user| [user.id, user.to_s] }.sort { |x, y| x[1] <=> y[1] } } } do |post|
+    table_column :user_id, :filter => {:as => :select, :collection => Proc.new { User.all.map { |user| [user.id, user.to_s] }.sort { |x, y| x[1] <=> y[1] } } } do |post|
       post.user.to_s
     end
   end
@@ -284,7 +284,7 @@ The difference occurs with sorting and filtering:
 
 array_columns perform searching and sorting on the computed results after all columns have been rendered.
 
-With a `table_column`, the frontend sends some search terms to the server, the raw database table is searched & sorted using standard ActiveRecord .where(), the appropriate rows returned, and then each row is rendered as per the rendering options.
+With a `table_column`, the frontend sends some search terms to the server, the raw database table is searched & sorted using standard ActiveRecord .where() and .order(), the appropriate rows returned, and then each row is rendered as per the rendering options.
 
 With an `array_column`, the front end sends some search terms to the server, all rows are returned and rendered, and then the rendered output is searched & sorted.
 
@@ -292,6 +292,18 @@ This allows the output of an `array_column` to be anything complex that cannot b
 
 When searching & sorting with a mix of table_columns and array_columns, all the table_columns are processed first so the most work is put on the database, the least on rails.
 
+If you're overriding the `search_column` or `order_column` behaviour of an `array_column`, keep in mind that all values will be strings.
+
+This has the side effect of ordering an `array_column` of numbers, as if they were strings.  To keep them ordered as numbers, call:
+
+```ruby
+array_column :price, type: :number do |product|
+  number_to_currency(product.price)
+end
+```
+
+The above code will output the price as a currency, but still sort the values as numbers rather than as strings.
+
 
 ### General Options
 
@@ -299,7 +311,7 @@ The following options control the general behaviour of the column:
 
 ```ruby
 :column => 'users.id'     # Set this if you're doing something tricky with the database.  Used internally for .order() and .where() clauses
-:type => :string          # Derived from the ActiveRecord attribute default datatype.  Controls searching behaviour.  Valid options include :string, :text, :datetime, :integer, :boolean, :year
+:type => :string          # Derived from the ActiveRecord attribute default datatype.  Controls searching behaviour.  Valid options include :string, :text, :datetime, :date, :integer, :boolean, :year
 ```
 
 ### Display Options
@@ -325,17 +337,16 @@ The following options control the filtering behaviour of the column:
 table_column :created_at, :filter => false    # Disable filtering on this column entirely
 table_column :created_at, :filter => {...}    # Enable filtering with these options
 
-:filter => {:type => :number}
-:filter => {:type => :text}
-
-:filter => {:type => :select, :values => ['One', 'Two'], :selected => 'Two'}
-:filter => {:type => :select, :values => [*2010..(Time.zone.now.year+6)]}
-:filter => {:type => :select, :values => Proc.new { PostCategory.all } }
-:filter => {:type => :select, :values => Proc.new { User.all.order(:email).map { |obj| [obj.id, obj.email] } } }
+:filter => {:as => :number}
+:filter => {:as => :text}
 
-:filter => {:type => :grouped_select, :values => {'Active' => Events.active, 'Past' => Events.past }}
-:filter => {:type => :grouped_select, :values => {'Active' => [['Event A', 1], ['Event B', 2]], 'Past' => [['Event C', 3], ['Event D', 4]]} }
+:filter => {:as => :select, :collection => ['One', 'Two'], :selected => 'Two'}
+:filter => {:as => :select, :collection => [*2010..(Time.zone.now.year+6)]}
+:filter => {:as => :select, :collection => Proc.new { PostCategory.all } }
+:filter => {:as => :select, :collection => Proc.new { User.all.order(:email).map { |obj| [obj.id, obj.email] } } }
 
+:filter => {:as => :grouped_select, :collection => {'Active' => Events.active, 'Past' => Events.past }}
+:filter => {:as => :grouped_select, :collection => {'Active' => [['Event A', 1], ['Event B', 2]], 'Past' => [['Event C', 3], ['Event D', 4]]} }
 ```
 
 Some additional, lesser used options include:
@@ -537,22 +548,63 @@ This gem does its best to provide "just works" filtering of both raw SQL (table_
 
 It's also very easy to override the filter behaviour on a per-column basis.
 
-Keep in mind, the filter terms on hidden columns will still be considered in filter results.
+Keep in mind, that filter terms applied to hidden columns will still be considered in filter results.
 
-For custom filter behaviour, specify a `def search_column` method in the datatables model file:
+To customize filter behaviour, specify a `def search_column` method in the datatables model file.
+
+If the table column being customized is a table_column:
 
 ```ruby
-def collection
-  User.unscoped.uniq
-    .joins('LEFT JOIN customers ON customers.user_id = users.id')
-    .select('users.*')
-    .select('customers.stripe_customer_id AS stripe_customer_id')
-    .includes(:addresses)
+def search_column(collection, table_column, search_term, sql_column)
+  if table_column[:name] == 'subscription_types'
+    collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%")
+  else
+    super
+  end
 end
+```
+
+And if the table column being customized is an array_column:
 
-def search_column(collection, table_column, search_term)
+```ruby
+def search_column(collection, table_column, search_term, index)
+  if table_column[:name] == 'price'
+    collection.select! { |row| row[index].include?(search_term) }
+  else
+    super
+  end
+end
+```
+
+### Customize Order Behaviour
+
+The order behaviour can be overridden on a per-column basis.
+
+To custom order behaviour, specify a `def order_column` method in the datatables model file.
+
+If the table column being customized is a table_column:
+
+```ruby
+def order_column(collection, table_column, direction, sql_column)
   if table_column[:name] == 'subscription_types'
-    collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%")
+    sql_direction = (direction == :desc ? 'DESC' : 'ASC')
+    collection.joins(:subscriptions).order("subscriptions.stripe_plan_id #{sql_direction}")
+  else
+    super
+  end
+end
+```
+
+And if the table column being customized is an array_column:
+
+```ruby
+def order_column(collection, table_column, direction, index)
+  if table_column[:name] == 'price'
+    if direction == :asc
+      collection.sort! { |a, b| a[index].gsub(/\D/, '').to_i <=> b[index].gsub(/\D/, '').to_i }
+    else
+      collection.sort! { |a, b| b[index].gsub(/\D/, '').to_i <=> a[index].gsub(/\D/, '').to_i }
+    end
   else
     super
   end
@@ -679,7 +731,7 @@ the filters and sorting will be automatically configured.
 
 Just define `table_column :roles`
 
-The `EffectiveRoles.roles` collection will be used for the filter values, and sorting will be done by roles_mask.
+The `EffectiveRoles.roles` collection will be used for the filter collection, and sorting will be done by roles_mask.
 
 
 ## Get access to the raw results

data/app/helpers/effective_datatables_helper.rb

@@ -54,7 +54,7 @@ module EffectiveDatatablesHelper
   def datatable_header_filter(form, name, value, opts)
     return render(partial: opts[:header_partial], locals: {form: form, name: (opts[:label] || name), column: opts}) if opts[:header_partial].present?
 
-    case opts[:filter][:type]
+    case opts[:filter][:as]
     when :string, :text, :number
       form.input name, label: false, required: false, value: value,
         as: :string,
@@ -77,7 +77,7 @@ module EffectiveDatatablesHelper
     when :select, :boolean
       form.input name, label: false, required: false, value: value,
         as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_select) ? :effective_select : :select),
-        collection: opts[:filter][:values],
+        collection: opts[:filter][:collection],
         selected: opts[:filter][:selected],
         multiple: opts[:filter][:multiple] == true,
         include_blank: (opts[:label] || name.titleize),
@@ -86,7 +86,7 @@ module EffectiveDatatablesHelper
     when :grouped_select
       form.input name, label: false, required: false, value: value,
         as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_select) ? :effective_select : :grouped_select),
-        collection: opts[:filter][:values],
+        collection: opts[:filter][:collection],
         selected: opts[:filter][:selected],
         multiple: opts[:filter][:multiple] == true,
         include_blank: (opts[:label] || name.titleize),

data/app/models/effective/active_record_datatable_tool.rb

@@ -2,7 +2,7 @@ module Effective
   class ActiveRecordDatatableTool
     attr_accessor :table_columns
 
-    delegate :order_name, :order_direction, :page, :per_page, :search_column, :collection_class, :quote_sql, :to => :@datatable
+    delegate :page, :per_page, :search_column, :order_column, :collection_class, :quote_sql, :to => :@datatable
 
     def initialize(datatable, table_columns)
       @datatable = datatable
@@ -13,67 +13,72 @@ module Effective
       @search_terms ||= @datatable.search_terms.select { |name, search_term| table_columns.key?(name) }
     end
 
-    def order_column
-      @order_column ||= table_columns[order_name]
+    def order_by_column
+      @order_by_column ||= table_columns[@datatable.order_name]
     end
 
     def order(collection)
-      return collection if order_column.blank?
+      return collection unless order_by_column.present?
 
-      column = order_column[:column]
+      column_order = order_column(collection, order_by_column, @datatable.order_direction, order_by_column[:column])
+      raise 'order_column must return an ActiveRecord::Relation object' unless column_order.kind_of?(ActiveRecord::Relation)
+      column_order
+    end
+
+    def order_column_with_defaults(collection, table_column, direction, sql_column)
       before = ''; after = ''
+      sql_direction = (direction == :desc ? 'DESC' : 'ASC')
 
       if postgres?
-        after = if order_column[:nulls] == :first
+        after = if table_column[:nulls] == :first
           ' NULLS FIRST'
-        elsif order_column[:nulls] == :last
+        elsif table_column[:nulls] == :last
           ' NULLS LAST'
         else
-          " NULLS #{order_direction == 'DESC' ? 'FIRST' : 'LAST' }"
+          " NULLS #{direction == :desc ? 'FIRST' : 'LAST' }"
         end
       elsif mysql?
-        before = "ISNULL(#{column}), "
+        before = "ISNULL(#{sql_column}), "
       end
 
-      if order_column[:type] == :belongs_to_polymorphic
-        collection.order("#{before}#{column.sub('_id', '_type')} #{order_direction}, #{column} #{order_direction}#{after}")
-      elsif order_column[:sql_as_column] == true
-        collection.order("#{column} #{order_direction}")
+      if table_column[:type] == :belongs_to_polymorphic
+        collection.order("#{before}#{sql_column.sub('_id', '_type')} #{sql_direction}, #{sql_column} #{sql_direction}#{after}")
+      elsif table_column[:sql_as_column] == true
+        collection.order("#{sql_column} #{sql_direction}")
       else
-        collection.order("#{before}#{column} #{order_direction}#{after}")
+        collection.order("#{before}#{sql_column} #{sql_direction}#{after}")
       end
     end
 
     def search(collection)
       search_terms.each do |name, search_term|
-        column_search = search_column(collection, table_columns[name], search_term)
+        column_search = search_column(collection, table_columns[name], search_term, table_columns[name][:column])
         raise 'search_column must return an ActiveRecord::Relation object' unless column_search.kind_of?(ActiveRecord::Relation)
         collection = column_search
       end
       collection
     end
 
-    def search_column_with_defaults(collection, table_column, term)
-      column = table_column[:column]
+    def search_column_with_defaults(collection, table_column, term, sql_column)
       sql_op = table_column[:filter][:sql_operation] || :where # only other option is :having
 
       case table_column[:type]
       when :string, :text
-        if (table_column[:filter][:type] == :select && table_column[:filter][:fuzzy] != true) || sql_op != :where
-          if ['null', 'nil', nil].include?(term)
-            collection.public_send(sql_op, "#{column} = :term OR #{column} IS NULL", term: term)
-          else
-            collection.public_send(sql_op, "#{column} = :term", term: term)
-          end
+        if sql_op != :where
+          collection.public_send(sql_op, "#{sql_column} = :term", term: term)
+        elsif ['null', 'nil', nil].include?(term)
+          collection.public_send(sql_op, "#{sql_column} = :term OR #{sql_column} IS NULL", term: '')
+        elsif table_column[:filter][:fuzzy] != true
+          collection.public_send(sql_op, "#{sql_column} = :term", term: term)
         else
-          collection.public_send(sql_op, "#{column} #{ilike} :term", term: "%#{term}%")
+          collection.public_send(sql_op, "#{sql_column} #{ilike} :term", term: "%#{term}%")
         end
       when :belongs_to_polymorphic
         # our key will be something like Post_15, or Event_1
         (type, id) = term.split('_')
 
         if type.present? && id.present?
-          collection.public_send(sql_op, "#{column} = :id AND #{column.sub('_id', '_type')} = :type", id: id, type: type)
+          collection.public_send(sql_op, "#{sql_column} = :id AND #{sql_column.sub('_id', '_type')} = :type", id: id, type: type)
         else
           collection
         end
@@ -87,7 +92,7 @@ module Effective
         inverse = reflection.inverse_of || klass.reflect_on_association(collection.table_name) || obj.class.reflect_on_association(collection.table_name.singularize)
         raise "unable to find #{klass.name} has_many :#{collection.table_name} or belongs_to :#{collection.table_name.singularize} associations" unless inverse
 
-        ids = if [:select, :grouped_select].include?(table_column[:filter][:type])
+        ids = if [:select, :grouped_select].include?(table_column[:filter][:as])
           # Treat the search term as one or more IDs
           inverse_ids = term.split(',').map { |term| (term = term.to_i) == 0 ? nil : term }.compact
           return collection unless inverse_ids.present?
@@ -95,10 +100,10 @@ module Effective
           klass.where(id: inverse_ids).joins(inverse.name).pluck(inverse.foreign_key)
         else
           # Treat the search term as a string.
-          klass_columns = if (table_column[:column] == klass.table_name) # No custom column has been defined
+          klass_columns = if (sql_column == klass.table_name) # No custom column has been defined
             klass.columns.map { |col| col.name if col.text? }.compact  # Search all database text? columns
           else
-            [table_column[:column].gsub("#{klass.table_name}.", '')] # table_column :order_items, column: 'order_items.title'
+            [sql_column.gsub("#{klass.table_name}.", '')] # table_column :order_items, column: 'order_items.title'
           end
 
           conditions = klass_columns.map { |col_name| "#{klass.table_name}.#{col_name} #{ilike} :term" }
@@ -118,7 +123,7 @@ module Effective
         inverse = reflection.inverse_of || klass.reflect_on_association(collection.table_name) || obj.class.reflect_on_association(collection.table_name.singularize)
         raise "unable to find #{klass.name} has_and_belongs_to_many :#{collection.table_name} or belongs_to :#{collection.table_name.singularize} associations" unless inverse
 
-        ids = if [:select, :grouped_select].include?(table_column[:filter][:type])
+        ids = if [:select, :grouped_select].include?(table_column[:filter][:as])
           # Treat the search term as one or more IDs
           inverse_ids = term.split(',').map { |term| (term = term.to_i) == 0 ? nil : term }.compact
           return collection unless inverse_ids.present?
@@ -127,10 +132,10 @@ module Effective
         else
           # Treat the search term as a string.
 
-          klass_columns = if (table_column[:column] == klass.table_name) # No custom column has been defined
+          klass_columns = if (sql_column == klass.table_name) # No custom column has been defined
             klass.columns.map { |col| col.name if col.text? }.compact  # Search all database text? columns
           else
-            [table_column[:column].gsub("#{klass.table_name}.", '')] # table_column :order_items, column: 'order_items.title'
+            [sql_column.gsub("#{klass.table_name}.", '')] # table_column :order_items, column: 'order_items.title'
           end
 
           conditions = klass_columns.map { |col_name| "#{klass.table_name}.#{col_name} #{ilike} :term" }
@@ -141,9 +146,9 @@ module Effective
         collection.public_send(sql_op, id: ids)
       when :obfuscated_id
         if (deobfuscated_id = collection.deobfuscate(term)) == term # We weren't able to deobfuscate it, so this is an Invalid ID
-          collection.public_send(sql_op, "#{column} = :term", term: 0)
+          collection.public_send(sql_op, "#{sql_column} = :term", term: 0)
         else
-          collection.public_send(sql_op, "#{column} = :term", term: deobfuscated_id)
+          collection.public_send(sql_op, "#{sql_column} = :term", term: deobfuscated_id)
         end
       when :effective_address
         ids = Effective::Address
@@ -156,7 +161,7 @@ module Effective
         collection.with_role(term)
       when :datetime, :date
         begin
-          digits = term.scan(/(\d+)/).flatten.map(&:to_i)
+          digits = term.scan(/(\d+)/).flatten.map { |digit| digit.to_i }
           start_at = Time.zone.local(*digits)
 
           case digits.length
@@ -176,23 +181,23 @@ module Effective
             end_at = start_at
           end
 
-          collection.public_send(sql_op, "#{column} >= :start_at AND #{column} <= :end_at", start_at: start_at, end_at: end_at)
+          collection.public_send(sql_op, "#{sql_column} >= :start_at AND #{sql_column} <= :end_at", start_at: start_at, end_at: end_at)
         rescue => e
           collection
         end
       when :boolean
-        collection.public_send(sql_op, "#{column} = :term", term: [1, 'true', 'yes'].include?(term.to_s.downcase))
+        collection.public_send(sql_op, "#{sql_column} = :term", term: [1, 'true', 'yes'].include?(term.to_s.downcase))
       when :integer
-        collection.public_send(sql_op, "#{column} = :term", term: term.gsub(/\D/, '').to_i)
+        collection.public_send(sql_op, "#{sql_column} = :term", term: term.gsub(/\D/, '').to_i)
       when :year
-        collection.public_send(sql_op, "EXTRACT(YEAR FROM #{column}) = :term", term: term.to_i)
+        collection.public_send(sql_op, "EXTRACT(YEAR FROM #{sql_column}) = :term", term: term.to_i)
       when :price
         price_in_cents = (term.gsub(/[^0-9|\.]/, '').to_f * 100.0).to_i
-        collection.public_send(sql_op, "#{column} = :term", term: price_in_cents)
-      when :currency, :decimal
-        collection.public_send(sql_op, "#{column} = :term", term: term.gsub(/[^0-9|\.]/, '').to_f)
+        collection.public_send(sql_op, "#{sql_column} = :term", term: price_in_cents)
+      when :currency, :decimal, :number
+        collection.public_send(sql_op, "#{sql_column} = :term", term: term.gsub(/[^0-9|\.]/, '').to_f)
       else
-        collection.public_send(sql_op, "#{column} = :term", term: term)
+        collection.public_send(sql_op, "#{sql_column} = :term", term: term)
       end
     end
 

data/app/models/effective/array_datatable_tool.rb

@@ -3,7 +3,7 @@ module Effective
   class ArrayDatatableTool
     attr_accessor :table_columns
 
-    delegate :order_name, :order_direction, :page, :per_page, :search_column, :display_table_columns, :to => :@datatable
+    delegate :page, :per_page, :search_column, :order_column, :display_table_columns, :to => :@datatable
 
     def initialize(datatable, table_columns)
       @datatable = datatable
@@ -14,37 +14,41 @@ module Effective
       @search_terms ||= @datatable.search_terms.select { |name, search_term| table_columns.key?(name) }
     end
 
-    def order_column
-      @order_column ||= table_columns[order_name]
+    def order_by_column
+      @order_by_column ||= table_columns[@datatable.order_name]
     end
 
     def order(collection)
-      if order_column.present?
-        index = display_index(order_column)
-
-        if order_direction == 'ASC'
-          collection.sort! do |x, y|
-            if (x[index] && y[index])
-              x[index] <=> y[index]
-            elsif x[index]
-              -1
-            elsif y[index]
-              1
-            else
-              0
-            end
+      return collection unless order_by_column.present?
+
+      column_order = order_column(collection, order_by_column, @datatable.order_direction, display_index(order_by_column))
+      raise 'order_column must return an Array' unless column_order.kind_of?(Array)
+      column_order
+    end
+
+    def order_column_with_defaults(collection, table_column, direction, index)
+      if direction == :asc
+        collection.sort! do |x, y|
+          if (x[index] && y[index])
+            cast_array_column_value(table_column, x[index]) <=> cast_array_column_value(table_column, y[index])
+          elsif x[index]
+            -1
+          elsif y[index]
+            1
+          else
+            0
           end
-        else
-          collection.sort! do |x, y|
-            if (x[index] && y[index])
-              y[index] <=> x[index]
-            elsif x[index]
-              1
-            elsif y[index]
-              -1
-            else
-              0
-            end
+        end
+      else
+        collection.sort! do |x, y|
+          if (x[index] && y[index])
+            cast_array_column_value(table_column, y[index]) <=> cast_array_column_value(table_column, x[index])
+          elsif x[index]
+            1
+          elsif y[index]
+            -1
+          else
+            0
           end
         end
       end
@@ -54,21 +58,20 @@ module Effective
 
     def search(collection)
       search_terms.each do |name, search_term|
-        column_search = search_column(collection, table_columns[name], search_term)
+        column_search = search_column(collection, table_columns[name], search_term, display_index(table_columns[name]))
         raise 'search_column must return an Array object' unless column_search.kind_of?(Array)
         collection = column_search
       end
       collection
     end
 
-    def search_column_with_defaults(collection, table_column, search_term)
+    def search_column_with_defaults(collection, table_column, search_term, index)
       search_term = search_term.downcase
-      index = display_index(table_column)
 
       collection.select! do |row|
         value = row[index].to_s.downcase
 
-        if table_column[:filter][:type] == :select && table_column[:filter][:fuzzy] != true
+        if table_column[:filter][:fuzzy] != true
           value == search_term
         else
           value.include?(search_term)
@@ -86,6 +89,19 @@ module Effective
       display_table_columns.present? ? display_table_columns.keys.index(column[:name]) : column[:array_index]
     end
 
+    # When we order by Array, it's already a string.
+    # This gives us a mechanism to sort numbers as numbers
+    def cast_array_column_value(table_column, value)
+      case table_column[:type]
+      when :number, :price, :decimal, :float
+        (value.to_s.gsub(/[^0-9|\.]/, '').to_f rescue 0.00)
+      when :integer
+        (value.to_s.gsub(/\D/, '').to_i rescue 0)
+      else
+        value
+      end
+    end
+
   end
 end
 

data/app/models/effective/datatable.rb

@@ -11,6 +11,7 @@ module Effective
     extend Effective::EffectiveDatatable::Dsl::ClassMethods
 
     include Effective::EffectiveDatatable::Ajax
+    include Effective::EffectiveDatatable::Hooks
     include Effective::EffectiveDatatable::Options
     include Effective::EffectiveDatatable::Rendering
 
@@ -111,7 +112,7 @@ module Effective
       @view.class.send(:attr_accessor, :effective_datatable)
       @view.effective_datatable = self
 
-      (self.class.instance_methods(false) - [:collection, :search_column]).each do |view_method|
+      (self.class.instance_methods(false) - [:collection, :search_column, :order_column]).each do |view_method|
         @view.class_eval { delegate view_method, :to => :@effective_datatable }
       end
 

data/app/models/effective/effective_datatable/ajax.rb

@@ -19,8 +19,8 @@ module Effective
       def order_name
         @order_name ||= begin
           if params[:order] && params[:columns]
-            order_column_index = (params[:order].first[1][:column] rescue '0')
-            (params[:columns][order_column_index] || {})[:name]
+            order_by_column_index = (params[:order].first[1][:column] rescue '0')
+            (params[:columns][order_by_column_index] || {})[:name]
           elsif @default_order.present?
             @default_order.keys.first
           end || table_columns.find { |col, opts| opts[:type] != :bulk_actions_column }.first
@@ -33,11 +33,11 @@ module Effective
 
       def order_direction
         @order_direction ||= if params[:order].present?
-          params[:order].first[1][:dir] == 'desc' ? 'DESC' : 'ASC'
+          params[:order].first[1][:dir] == 'desc' ? :desc : :asc
         elsif @default_order.present?
-          @default_order.values.first.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
+          @default_order.values.first.to_s.downcase == 'desc' ? :desc : :asc
         else
-          'ASC'
+          :asc
         end
       end
 
@@ -65,15 +65,6 @@ module Effective
         end
       end
 
-      # This is here so classes that inherit from Datatables can can override the specific where clauses on a search column
-      def search_column(collection, table_column, search_term)
-        if table_column[:array_column]
-          array_tool.search_column_with_defaults(collection, table_column, search_term)
-        else
-          table_tool.search_column_with_defaults(collection, table_column, search_term)
-        end
-      end
-
       def per_page
         return 9999999 if simple?
 

data/app/models/effective/effective_datatable/hooks.rb

@@ -0,0 +1,30 @@
+module Effective
+  module EffectiveDatatable
+    module Hooks
+
+      # Called on the final collection after searching, ordering, arrayizing and formatting have been completed
+      def finalize(collection) # Override me if you like
+        collection
+      end
+
+      # Override this function to perform custom searching on a column
+      def search_column(collection, table_column, search_term, sql_column_or_array_index)
+        if table_column[:array_column]
+          array_tool.search_column_with_defaults(collection, table_column, search_term, sql_column_or_array_index)
+        else
+          table_tool.search_column_with_defaults(collection, table_column, search_term, sql_column_or_array_index)
+        end
+      end
+
+      # Override this function to perform custom ordering on a column
+      # direction will be :asc or :desc
+      def order_column(collection, table_column, direction, sql_column_or_array_index)
+        if table_column[:array_column]
+          array_tool.order_column_with_defaults(collection, table_column, direction, sql_column_or_array_index)
+        else
+          table_tool.order_column_with_defaults(collection, table_column, direction, sql_column_or_array_index)
+        end
+      end
+    end
+  end
+end

data/app/models/effective/effective_datatable/options.rb

@@ -141,22 +141,27 @@ module Effective
         col_type = column[:type]
         sql_column = column[:column].to_s.upcase
 
-        return {type: :null} if filter == false
+        return {as: :null} if filter == false
 
-        filter = {type: filter.to_sym} if filter.kind_of?(String)
+        filter = {as: filter.to_sym} if filter.kind_of?(String)
         filter = {} unless filter.kind_of?(Hash)
 
         # This is a fix for passing filter[:selected] == false, it needs to be 'false'
         filter[:selected] = filter[:selected].to_s unless filter[:selected].nil?
 
-        # Allow values or collection to be used interchangeably
-        if filter.key?(:collection)
-          filter[:values] ||= filter[:collection]
+        # Allow :values or :collection to be used interchangeably
+        if filter.key?(:values)
+          filter[:collection] ||= filter[:values]
         end
 
-        # If you pass values, just assume it's a select
-        if filter.key?(:values) && col_type != :belongs_to_polymorphic
-          filter[:type] ||= :select
+        # Allow :as or :type to be used interchangeably
+        if filter.key?(:type)
+          filter[:as] ||= filter[:type]
+        end
+
+        # If you pass a collection, just assume it's a select
+        if filter.key?(:collection) && col_type != :belongs_to_polymorphic
+          filter[:as] ||= :select
         end
 
         # Check if this is an aggregate column
@@ -167,8 +172,8 @@ module Effective
         case col_type
         when :belongs_to
           {
-            type: :select,
-            values: (
+            as: :select,
+            collection: (
               if belongs_to[:klass].respond_to?(:datatables_filter)
                 Proc.new { belongs_to[:klass].datatables_filter }
               else
@@ -177,12 +182,12 @@ module Effective
             )
           }
         when :belongs_to_polymorphic
-          {type: :grouped_select, polymorphic: true, values: {}}
+          {as: :grouped_select, polymorphic: true, collection: {}}
         when :has_many
           {
-            type: :select,
+            as: :select,
             multiple: true,
-            values: (
+            collection: (
               if has_many[:klass].respond_to?(:datatables_filter)
                 Proc.new { has_many[:klass].datatables_filter }
               else
@@ -192,9 +197,9 @@ module Effective
           }
         when :has_and_belongs_to_many
           {
-            type: :select,
+            as: :select,
             multiple: true,
-            values: (
+            collection: (
               if has_and_belongs_to_manys[:klass].respond_to?(:datatables_filter)
                 Proc.new { has_and_belongs_to_manys[:klass].datatables_filter }
               else
@@ -203,25 +208,25 @@ module Effective
             )
           }
         when :effective_address
-          {type: :string}
+          {as: :string}
         when :effective_roles
-          {type: :select, values: EffectiveRoles.roles}
+          {as: :select, collection: EffectiveRoles.roles}
         when :integer
-          {type: :number}
+          {as: :number}
         when :boolean
           if EffectiveDatatables.boolean_format == :yes_no
-            {type: :boolean, values: [['Yes', true], ['No', false]] }
+            {as: :boolean, collection: [['Yes', true], ['No', false]] }
           else
-            {type: :boolean, values: [['true', true], ['false', false]] }
+            {as: :boolean, collection: [['true', true], ['false', false]] }
           end
         when :datetime
-          {type: :datetime}
+          {as: :datetime}
         when :date
-          {type: :date}
+          {as: :date}
         when :bulk_actions_column
-          {type: :bulk_actions_column}
+          {as: :bulk_actions_column}
         else
-          {type: :string}
+          {as: :string}
         end.merge(filter.symbolize_keys)
       end
 

data/app/models/effective/effective_datatable/rendering.rb

@@ -5,10 +5,6 @@ module Effective
     module Rendering
       BLANK = ''.freeze
 
-      def finalize(collection) # Override me if you like
-        collection
-      end
-
       protected
 
       # So the idea here is that we want to do as much as possible on the database in ActiveRecord
@@ -37,7 +33,7 @@ module Effective
           self.display_records = col.size
         end
 
-        if array_tool.order_column.present?
+        if array_tool.order_by_column.present?
           col = self.arrayize(col)
           col = array_tool.order(col)
         end

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.3.8'.freeze
+  VERSION = '2.4.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.3.8
+  version: 2.4.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-29 00:00:00.000000000 Z
+date: 2016-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -142,6 +142,7 @@ files:
 - app/models/effective/datatable.rb
 - app/models/effective/effective_datatable/ajax.rb
 - app/models/effective/effective_datatable/dsl.rb
+- app/models/effective/effective_datatable/hooks.rb
 - app/models/effective/effective_datatable/options.rb
 - app/models/effective/effective_datatable/rendering.rb
 - app/views/effective/datatables/_actions_column.html.haml