effective_datatables 1.8.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51442e1874c5619504602bba266af6ebdd589a2a
-  data.tar.gz: 51f2e7929b20e801d9b6b30b70fd4c0c028503d6
+  metadata.gz: 42cbf488b1f1cf5d77c3ffd2dc352b06eee67d9c
+  data.tar.gz: d94cd33a3001743a072162855700dcdbf97e6dd2
 SHA512:
-  metadata.gz: 06f07d33e9eaf67ea873f21650b505338e1928a31ce5138264aa5eed6cb1715b8c84c0916a2ea2c7ba0d08443e22cbd0c6acbaf4a9bcfde8cfa1bc320b09d166
-  data.tar.gz: 055b33ce39c9b1745c74f73d105f4d16134e0bdea5c1e5e7587ccda73bbfa815826499c8166a3144b2f9acc548718df71117af048bac4b56f99a042162c42e90
+  metadata.gz: 69dab91b291914705aa7e9903b706772d73ec708b9a5c0ebdb0bb9494481fccdb0f0c8d124de634b3dbf952287fe99d62e5f5f48f43e718a38d2e7f85f3a5b44
+  data.tar.gz: 4b44b67e3385891730e63cea4c236967792d34959a4c65662cc7c9d4243eae39d5df61be52194b74f8eb49f84be2db522b052eafddf3d02ca7e8b34a8c08b7c9

data/README.md

@@ -67,10 +67,12 @@ This model exists at `/app/models/effective/datatables/posts.rb`:
 module Effective
   module Datatables
     class Posts < Effective::Datatable
-      table_column :id
-      table_column :user    # if Post belongs_to :user
-      table_column :title
-      table_column :created_at
+      datatable do
+        table_column :id
+        table_column :user    # if Post belongs_to :user
+        table_column :title
+        table_column :created_at
+      end
 
       def collection
         Post.all
@@ -88,7 +90,7 @@ We're going to display this DataTable on the posts#index action
 ```ruby
 class PostsController < ApplicationController
   def index
-    @datatable = Effective::Datatables::Posts.new()
+    @datatable = Effective::Datatables::Posts.new
   end
 end
 ```
@@ -128,31 +130,33 @@ For example: `/app/models/effective/datatables/posts.rb`:
 module Effective
   module Datatables
     class Posts < Effective::Datatable
-      default_order :created_at, :desc
-      default_entries 25
+      datatable do
+        default_order :created_at, :desc
+        default_entries 25
 
-      table_column :id, :visible => false
+        table_column :id, :visible => false
 
-      table_column :created_at, :width => '25%'
+        table_column :created_at, :width => '25%'
 
-      table_column :updated_at, :proc => Proc.new { |post| nicetime(post.updated_at) } # just a standard helper as defined in helpers/application_helper.rb
+        table_column :updated_at, :proc => Proc.new { |post| nicetime(post.updated_at) } # just a standard helper as defined in helpers/application_helper.rb
 
-      table_column :user
+        table_column :user
 
-      table_column :post_category_id, :filter => {:type => :select, :values => Proc.new { PostCategory.all } } do |post|
-        post.post_category.name.titleize
-      end
+        table_column :post_category_id, :filter => {:type => :select, :values => Proc.new { PostCategory.all } } do |post|
+          post.post_category.name.titleize
+        end
 
-      array_column :comments do |post|
-        content_tag(:ul) do
-          post.comments.where(:archived => false).map do |comment|
-            content_tag(:li, comment.title)
-          end.join('').html_safe
+        array_column :comments do |post|
+          content_tag(:ul) do
+            post.comments.where(:archived => false).map do |comment|
+              content_tag(:li, comment.title)
+            end.join('').html_safe
+          end
         end
-      end
 
-      table_column :title, :label => 'Post Title', :class => 'col-title'
-      table_column :actions, :sortable => false, :filter => false, :partial => '/posts/actions'
+        table_column :title, :label => 'Post Title', :class => 'col-title'
+        table_column :actions, :sortable => false, :filter => false, :partial => '/posts/actions'
+      end
 
       def collection
         Post.where(:archived => false).includes(:post_category)
@@ -211,10 +215,12 @@ Define your collection as an Array of Arrays, declare only array_columns, and ev
 module Effective
   module Datatables
     class ArrayBackedDataTable < Effective::Datatable
-      array_column :id
-      array_column :first_name
-      array_column :last_name
-      array_column :email
+      datatable do
+        array_column :id
+        array_column :first_name
+        array_column :last_name
+        array_column :email
+      end
 
       def collection
         [
@@ -268,8 +274,12 @@ table_column :created_at
 table_column :user
 
 # Will have the same behaviour as declaring
-table_column :user_id, :if => Proc.new { attributes[:user_id].blank? }, :filter => {:type => :select, :values => Proc.new { User.all.map { |user| [user.id, user.to_s] }.sort { |x, y| x[1] <=> y[1] } } } do |post|
-  post.user.to_s
+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|
+      post.user.to_s
+    end
+  end
 end
 ```
 
@@ -299,7 +309,6 @@ 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
-:if => Proc.new { attributes[:user_id].blank? }  # Excludes this table_column entirely if false. See "Initialize with attributes" section of this README below
 ```
 
 ### Display Options
@@ -503,23 +512,28 @@ class PostsController < ApplicationController
 end
 ```
 
-Scope the query to the passed user in in your collection method:
+And then in your datatable:
 
 ```ruby
-def collection
-  if attributes[:user_id]
-    Post.where(:user_id => attributes[:user_id])
-  else
-    Post.all
-  end
-end
-```
+module Effective
+  module Datatables
+    class Posts < Effective::Datatable
+      datatable do
+        if attributes[:user_id].blank?
+          table_column :user_id { |post| post.user.email }
+        end
+      end
 
-and remove the table_column when a user_id is present:
+      def collection
+        if attributes[:user_id]
+          Post.where(user_id: attributes[:user_id])
+        else
+          Post.all
+        end
+      end
 
-```ruby
-table_column :user_id, :if => Proc.new { attributes[:user_id].blank? } do |post|
-  post.user.email
+    end
+  end
 end
 ```
 
@@ -531,14 +545,6 @@ Any non-private methods defined in the datatable model will be available to your
 module Effective
   module Datatables
     class Posts < Effective::Datatable
-      table_column :title do |post|
-        format_post_title(post)
-      end
-
-      def collection
-        Post.all
-      end
-
       def format_post_title(post)
         if post.title.start_with?('important')
           link_to(post.title.upcase, post_path(post))
@@ -547,6 +553,15 @@ module Effective
         end
       end
 
+      datatable do
+        table_column :title do |post|
+          format_post_title(post)
+        end
+      end
+
+      def collection
+        Post.all
+      end
     end
   end
 end
@@ -577,7 +592,7 @@ end
 When working with an ActiveRecord collection that implements [effective_obfuscation](https://github.com/code-and-effect/effective_obfuscation) for the ID column,
 that column's filters and sorting will be automatically configured.
 
-Just define `table_column :id`.
+Just define `table_column :id`
 
 Unfortunately, due to the effective_obfuscation algorithm, sorting and filtering by partial values is not supported.
 
@@ -588,7 +603,7 @@ So the column may not be sorted, and may only be filtered by typing the entire 1
 When working with an ActiveRecord collection that implements [effective_roles](https://github.com/code-and-effect/effective_roles),
 the filters and sorting will be automatically configured.
 
-Just define `table_column :roles`.
+Just define `table_column :roles`
 
 The `EffectiveRoles.roles` collection will be used for the filter values, and sorting will be done by roles_mask.
 
@@ -680,10 +695,12 @@ In this example, a User belongs_to an Applicant.  But instead of using the built
 module Effective
   module Datatables
     class Applicants < Effective::Datatable
-      table_column :id, visible: true
+      datatable do
+        table_column :id, visible: true
 
-      table_column :user, :type => :string, :column => 'users.email' do |applicant|
-        link_to applicant.user.try(:email), edit_admin_user_path(applicant.user)
+        table_column :user, :type => :string, :column => 'users.email' do |applicant|
+          link_to applicant.user.try(:email), edit_admin_user_path(applicant.user)
+        end
       end
 
       def collection

data/app/assets/javascripts/effective_datatables/initialize.js.coffee.erb

@@ -14,7 +14,7 @@ initializeDataTables = ->
         pagingType: 'simple_numbers'
         language: { 'lengthMenu': 'Show _MENU_ per page'}
         lengthMenu: [[10, 25, 50, 100, 250, 1000, -1], ['10', '25', '50', '100', '250', '1000', 'All']]
-        iDisplayLength: datatable.data('default-entries')
+        iDisplayLength: datatable.data('display-entries')
         columnDefs: [
           { visible: false, targets: datatable.data('non-visible') },
           { sortable: false, targets: datatable.data('non-sortable') }

data/app/controllers/effective/datatables_controller.rb

@@ -4,7 +4,7 @@ module Effective
 
     # This will respond to both a GET and a POST
     def show
-      @datatable = Effective::Datatable.find(params[:id], params[:attributes])
+      @datatable = find_datatable(params[:id]).try(:new, params[:attributes])
       @datatable.view = view_context if !@datatable.nil?
 
       EffectiveDatatables.authorized?(self, :index, @datatable.try(:collection_class) || Effective::Datatable)
@@ -24,6 +24,10 @@ module Effective
 
     private
 
+    def find_datatable(id)
+      "effective/datatables/#{id}".classify.tap { |klass| klass << 's' if id.to_s.end_with?('s') }.safe_constantize
+    end
+
     def error_json
       {
         :draw => params[:draw].to_i,

data/app/helpers/effective_datatables_helper.rb

@@ -54,12 +54,7 @@ module EffectiveDatatablesHelper
   end
 
   def datatable_default_order(datatable)
-    [
-      if datatable.default_order.present?
-        index = (datatable.table_columns.values.find { |options| options[:name] == datatable.default_order.keys.first.to_s }[:index] rescue nil)
-        [index, datatable.default_order.values.first] if index.present?
-      end || [0, 'asc']
-    ].to_json()
+    [datatable.order_index, datatable.order_direction.downcase].to_json()
   end
 
   def datatable_widths(datatable)

data/app/models/effective/datatable.rb

@@ -4,77 +4,23 @@ module Effective
 
     delegate :render, :link_to, :mail_to, :to => :@view
 
-    class << self
-      def all
-        EffectiveDatatables.datatables.map { |klass| klass.new() }
-      end
-
-      def find(obj, attributes = nil)
-        obj = obj.respond_to?(:to_param) ? obj.to_param : obj
-        EffectiveDatatables.datatables.find { |klass| klass.name.underscore.parameterize == obj }.try(:new, attributes.presence || {})
-      end
-
-      def table_column(name, options = {}, proc = nil, &block)
-        if block_given?
-          raise "You cannot use :partial => '' with the block syntax" if options[:partial]
-          raise "You cannot use :proc => ... with the block syntax" if options[:proc]
-          options[:block] = block
-        end
-        raise "You cannot use both :partial => '' and proc => ..." if options[:partial] && options[:proc]
-
-        send(:attr_accessor, name)
-        (@table_columns ||= HashWithIndifferentAccess.new())[name] = options
-      end
-
-      def table_columns(*names)
-        names.each { |name| table_column(name) }
-      end
-
-      def array_column(name, options = {}, proc = nil, &block)
-        table_column(name, options.merge!({:array_column => true}), proc, &block)
-      end
-
-      def actions_column(options = {}, proc = nil, &block)
-        show = options.fetch(:show, false)
-        edit = options.fetch(:edit, true)
-        destroy = options.fetch(:destroy, true)
-        name = options.fetch(:name, 'actions')
-
-        opts = {
-          sortable: false,
-          filter: false,
-          partial_local: :resource,
-          partial_locals: { show_action: show, edit_action: edit, destroy_action: destroy }
-        }
-        opts[:partial] = '/effective/datatables/actions_column' unless (block_given? || proc.present?)
-
-        table_column(name, opts, proc, &block)
-      end
-
-      def array_columns(*names)
-        names.each { |name| array_column(name) }
-      end
-
-      def default_order(name, direction = :asc)
-        @default_order = {name => direction}
-      end
-
-      def default_entries(entries)
-        @default_entries = entries
-      end
+    include Effective::EffectiveDatatable::Dsl
+    extend Effective::EffectiveDatatable::Dsl::ClassMethods
 
-      def model_name # Searching & Filters
-        @model_name ||= ActiveModel::Name.new(self)
-      end
-    end
+    include Effective::EffectiveDatatable::Ajax
+    include Effective::EffectiveDatatable::Options
+    include Effective::EffectiveDatatable::Rendering
 
     def initialize(*args)
-      if args.present?
-        raise 'Effective::Datatable.new() can only be called with a Hash like arguments' unless args.first.kind_of?(Hash)
+      if args.present? && args.first != nil
+        raise "#{self.class.name}.new() can only be initialized with a Hash like arguments" unless args.first.kind_of?(Hash)
         args.first.each { |k, v| self.attributes[k] = v }
       end
 
-      unless active_record_collection? || (collection.kind_of?(Array) && collection.first.kind_of?(Array))
+      initialize_datatable  # This creates @table_columns based on the DSL datatable do .. end block
+      initialize_options    # This normalizes all the options
+
+      unless active_record_collection? || array_collection?
         raise "Unsupported collection type. Should be ActiveRecord class, ActiveRecord relation, or an Array of Arrays [[1, 'something'], [2, 'something else']]"
       end
 
@@ -82,6 +28,10 @@ module Effective
       search_terms.each { |column, term| self.send("#{column}=", term) }
     end
 
+    def table_columns
+      @table_columns
+    end
+
     # Any attributes set on initialize will be echoed back and available to the class
     def attributes
       @attributes ||= HashWithIndifferentAccess.new()
@@ -94,8 +44,12 @@ module Effective
       @model_name ||= ActiveModel::Name.new(self.class)
     end
 
+    def self.model_name # Searching & Filters
+      @model_name ||= ActiveModel::Name.new(self)
+    end
+
     def to_param
-      self.class.name.underscore.parameterize
+      @to_param ||= self.class.name.underscore.sub('effective/datatables/', '')
     end
 
     def collection
@@ -106,30 +60,6 @@ module Effective
       collection.respond_to?(:klass) ? collection.klass : self.class
     end
 
-    def finalize(collection) # Override me if you like
-      collection
-    end
-
-    # Select only col[:if] == true columns, and then set the col[:index] accordingly
-    def table_columns
-      @table_columns ||= table_columns_with_defaults().select do |_, col|
-        col[:if] == nil || (col[:if].respond_to?(:call) ? (view || self).instance_exec(&col[:if]) : col[:if])
-      end.each_with_index { |(_, col), index| col[:index] = index }
-    end
-
-    # This is for the ColReorder plugin
-    # It sends us a list of columns that are different than our table_columns order
-    # So this method just returns an array of column names, as per ColReorder
-    def display_table_columns
-      if params[:columns].present?
-        HashWithIndifferentAccess.new().tap do |display_columns|
-          params[:columns].each do |_, values|
-            display_columns[values[:name]] = table_columns[values[:name]]
-          end
-        end
-      end
-    end
-
     def to_json
       raise 'Effective::Datatable to_json called with a nil view.  Please call render_datatable(@datatable) or @datatable.view = view before this method' unless view.present?
 
@@ -149,97 +79,16 @@ module Effective
       total_records.to_i == 0
     end
 
-    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]
-        elsif default_order.present?
-          default_order.keys.first
-        end || table_columns.keys.first
-      end
-    end
-
-    def order_direction
-      @order_direction ||= if params[:order].present?
-        params[:order].first[1][:dir] == 'desc' ? 'DESC' : 'ASC'
-      elsif default_order.present?
-        default_order.values.first.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
-      else
-        'ASC'
-      end
-    end
-
-    def default_order
-      self.class.instance_variable_get(:@default_order)
-    end
-
-    def default_entries
-      @default_entries ||= begin
-        entries = (self.class.instance_variable_get(:@default_entries).presence || EffectiveDatatables.default_entries)
-        entries = -1 if entries.to_s.downcase == 'all'
-        [10, 25, 50, 100, 250, 1000, -1].include?(entries) ? entries : 25
-      end
-    end
-
-    def search_terms
-      @search_terms ||= HashWithIndifferentAccess.new().tap do |terms|
-        if params[:columns].present? # This is an AJAX request from the DataTable
-          (params[:columns] || {}).each do |_, column|
-            next if table_columns[column[:name]].blank? || (column[:search] || {})[:value].blank?
-
-            terms[column[:name]] = column[:search][:value]
-          end
-        else # This is the initial render, and we have to apply default search terms only
-          table_columns.each do |name, values|
-            terms[name] = values[:filter][:selected] if values[:filter][:selected].present?
-          end
-        end
-      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
-      length = (params[:length].presence || default_entries).to_i
-
-      if length == -1
-        9999999
-      elsif length > 0
-        length
-      else
-        25
-      end
-    end
-
-    def per_page=(length)
-      case length
-      when Integer
-        params[:length] = length
-      when :all
-        params[:length] = -1
-      end
-    end
-
-    def page
-      params[:start].to_i / per_page + 1
-    end
-
     def total_records
       @total_records ||= (
-        if active_record_collection? && collection_class.connection.respond_to?(:unprepared_statement)
+        if active_record_collection?
           # https://github.com/rails/rails/issues/15331
-          collection_sql = collection_class.connection.unprepared_statement { collection.to_sql }
-          (collection_class.connection.execute("SELECT COUNT(*) FROM (#{collection_sql}) AS datatables_total_count").first['count'] rescue 1).to_i
-        elsif active_record_collection?
-          (collection_class.connection.execute("SELECT COUNT(*) FROM (#{collection.to_sql}) AS datatables_total_count").first['count'] rescue 1).to_i
+          if collection_class.connection.respond_to?(:unprepared_statement)
+            collection_sql = collection_class.connection.unprepared_statement { collection.to_sql }
+            (collection_class.connection.execute("SELECT COUNT(*) FROM (#{collection_sql}) AS datatables_total_count").first['count'] rescue 1).to_i
+          else
+            (collection_class.connection.execute("SELECT COUNT(*) FROM (#{collection.to_sql}) AS datatables_total_count").first['count'] rescue 1).to_i
+          end
         else
           collection.size
         end
@@ -268,116 +117,8 @@ module Effective
       @order_direction = nil
     end
 
-
     protected
 
-    # So the idea here is that we want to do as much as possible on the database in ActiveRecord
-    # And then run any array_columns through in post-processed results
-    def table_data
-      col = collection
-
-      if active_record_collection?
-        col = table_tool.order(col)
-        col = table_tool.search(col)
-
-        if table_tool.search_terms.present? && array_tool.search_terms.blank?
-          if collection_class.connection.respond_to?(:unprepared_statement)
-            # https://github.com/rails/rails/issues/15331
-            col_sql = collection_class.connection.unprepared_statement { col.to_sql }
-            self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col_sql}) AS datatables_filtered_count").first['count'] rescue 1).to_i
-          else
-            self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_filtered_count").first['count'] rescue 1).to_i
-          end
-        end
-      end
-
-      if array_tool.search_terms.present?
-        col = self.arrayize(col)
-        col = array_tool.search(col)
-        self.display_records = col.size
-      end
-
-      if array_tool.order_column.present?
-        col = self.arrayize(col)
-        col = array_tool.order(col)
-      end
-
-      self.display_records ||= total_records
-
-      if col.kind_of?(Array)
-        col = array_tool.paginate(col)
-      else
-        col = table_tool.paginate(col)
-        col = self.arrayize(col)
-      end
-
-      col = self.finalize(col)
-    end
-
-    def arrayize(collection)
-      return collection if @arrayized  # Prevent the collection from being arrayized more than once
-      @arrayized = true
-
-      # We want to use the render :collection for each column that renders partials
-      rendered = {}
-      table_columns.each do |name, opts|
-        if opts[:partial]
-          locals = {
-            datatable: self,
-            table_column: table_columns[name],
-            controller_namespace: view.controller_path.split('/')[0...-1].map { |path| path.downcase.to_sym if path.present? }.compact,
-            show_action: (opts[:partial_locals] || {})[:show_action],
-            edit_action: (opts[:partial_locals] || {})[:edit_action],
-            destroy_action: (opts[:partial_locals] || {})[:destroy_action]
-          }
-          locals.merge!(opts[:partial_locals]) if opts[:partial_locals]
-
-          rendered[name] = (render(
-            :partial => opts[:partial],
-            :as => opts[:partial_local],
-            :collection => collection,
-            :formats => :html,
-            :locals => locals,
-            :spacer_template => '/effective/datatables/spacer_template',
-          ) || '').split('EFFECTIVEDATATABLESSPACER')
-        end
-      end
-
-      collection.each_with_index.map do |obj, index|
-        (display_table_columns || table_columns).map do |name, opts|
-          value = if opts[:partial]
-            rendered[name][index]
-          elsif opts[:block]
-            view.instance_exec(obj, collection, self, &opts[:block])
-          elsif opts[:proc]
-            view.instance_exec(obj, collection, self, &opts[:proc])
-          elsif opts[:type] == :belongs_to
-            val = (obj.send(name) rescue nil).to_s
-          elsif opts[:type] == :obfuscated_id
-            (obj.send(:to_param) rescue nil).to_s
-          elsif opts[:type] == :effective_roles
-            (obj.send(:roles) rescue []).join(', ')
-          else
-            val = (obj.send(name) rescue nil)
-            val = (obj[opts[:array_index]] rescue nil) if val == nil
-            val
-          end
-
-          # Last minute formatting of dates
-          case value
-          when Date
-            value.strftime(EffectiveDatatables.date_format)
-          when Time, DateTime
-            value.strftime(EffectiveDatatables.datetime_format)
-          else
-            value.to_s
-          end
-        end
-      end
-    end
-
-    private
-
     def params
       view.try(:params) || HashWithIndifferentAccess.new()
     end
@@ -391,110 +132,11 @@ module Effective
     end
 
     def active_record_collection?
-      if @active_record_collection.nil?
-        @active_record_collection = (collection.ancestors.include?(ActiveRecord::Base) rescue false)
-      else
-        @active_record_collection
-      end
-    end
-
-    def table_columns_with_defaults
-      unless self.class.instance_variable_get(:@table_columns_initialized)
-        self.class.instance_variable_set(:@table_columns_initialized, true)
-        initalize_table_columns(self.class.instance_variable_get(:@table_columns))
-      end
-
-      self.class.instance_variable_get(:@table_columns)
-    end
-
-    def initalize_table_columns(cols)
-      sql_table = (collection.table rescue nil)
-
-      # Here we identify all belongs_to associations and build up a Hash like:
-      # {:user => {:foreign_key => 'user_id', :klass => User}, :order => {:foreign_key => 'order_id', :klass => Effective::Order}}
-      belong_tos = (collection.ancestors.first.reflect_on_all_associations(:belongs_to) rescue []).inject(HashWithIndifferentAccess.new()) do |retval, bt|
-        unless bt.options[:polymorphic]
-          begin
-            klass = bt.klass || bt.foreign_type.sub('_type', '').classify.constantize
-          rescue => e
-            klass = nil
-          end
-
-          retval[bt.name] = {:foreign_key => bt.foreign_key, :klass => klass} if bt.foreign_key.present? && klass.present?
-        end
-
-        retval
-      end
-
-      cols.each_with_index do |(name, _), index|
-        # If this is a belongs_to, add an :if clause specifying a collection scope if
-        if belong_tos.key?(name)
-          cols[name][:if] ||= Proc.new { attributes[belong_tos[name][:foreign_key]].blank? }
-        end
-
-        sql_column = (collection.columns rescue []).find do |column|
-          column.name == name.to_s || (belong_tos.key?(name) && column.name == belong_tos[name][:foreign_key])
-        end
-
-        cols[name][:array_column] ||= false
-        cols[name][:array_index] = index # The index of this column in the collection, regardless of hidden table_columns
-        cols[name][:name] ||= name
-        cols[name][:label] ||= name.titleize
-        cols[name][:column] ||= (sql_table && sql_column) ? "\"#{sql_table.name}\".\"#{sql_column.name}\"" : name
-        cols[name][:width] ||= nil
-        cols[name][:sortable] = true if cols[name][:sortable] == nil
-        cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : sql_column.try(:type).presence) || :string
-        cols[name][:class] = "col-#{cols[name][:type]} col-#{name} #{cols[name][:class]}".strip
-
-        # EffectiveObfuscation
-        if name == 'id' && defined?(EffectiveObfuscation) && collection.respond_to?(:deobfuscate)
-          cols[name][:sortable] = false
-          cols[name][:type] = :obfuscated_id
-        end
-
-        # EffectiveRoles, if you do table_column :roles, everything just works
-        if name == 'roles' && defined?(EffectiveRoles) && collection.respond_to?(:with_role)
-          cols[name][:sortable] = true
-          cols[name][:column] = sql_table.present? ? "\"#{sql_table.name}\".\"roles_mask\"" : name
-          cols[name][:type] = :effective_roles
-        end
-
-        if sql_table.present? && sql_column.blank? # This is a SELECT AS column
-          cols[name][:sql_as_column] = true
-        end
-
-        cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type], belong_tos[name])
-
-        if cols[name][:partial]
-          cols[name][:partial_local] ||= (sql_table.try(:name) || cols[name][:partial].split('/').last(2).first.presence || 'obj').singularize.to_sym
-        end
-      end
+      collection.ancestors.include?(ActiveRecord::Base) rescue false
     end
 
-    def initialize_table_column_filter(filter, col_type, belongs_to)
-      return {type: :null} if filter == false
-
-      filter = {type: 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?
-
-      case col_type
-      when :belongs_to
-        {
-          type: :select,
-          values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
-        }
-      when :effective_roles
-        {type: :select, values: EffectiveRoles.roles}
-      when :integer
-        {type: :number}
-      when :boolean
-        {type: :boolean, values: [true, false]}
-      else
-        {type: :string}
-      end.merge(filter.symbolize_keys)
+    def array_collection?
+      collection.kind_of?(Array) && collection.first.kind_of?(Array)
     end
 
   end

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

@@ -0,0 +1,105 @@
+# This is extended as class level into Datatable
+
+module Effective
+  module EffectiveDatatable
+    module Ajax
+
+      # This is for the ColReorder plugin
+      # It sends us a list of columns that are different than our table_columns order
+      # So this method just returns an array of column names, as per ColReorder
+      def display_table_columns
+        if params[:columns].present?
+          HashWithIndifferentAccess.new().tap do |display_columns|
+            params[:columns].each do |_, values|
+              display_columns[values[:name]] = table_columns[values[:name]]
+            end
+          end
+        end
+      end
+
+      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]
+          elsif @default_order.present?
+            @default_order.keys.first
+          end || table_columns.keys.first
+        end
+      end
+
+      def order_index
+        (table_columns[order_name][:index] || 0) rescue 0
+      end
+
+      def order_direction
+        @order_direction ||= if params[:order].present?
+          params[:order].first[1][:dir] == 'desc' ? 'DESC' : 'ASC'
+        elsif @default_order.present?
+          @default_order.values.first.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
+        else
+          'ASC'
+        end
+      end
+
+      def display_entries
+        @display_entries ||= begin
+          entries = (@default_entries.presence || EffectiveDatatables.default_entries)
+          entries = -1 if entries.to_s.downcase == 'all'
+          [10, 25, 50, 100, 250, 1000, -1].include?(entries) ? entries : 25
+        end
+      end
+
+      def search_terms
+        @search_terms ||= HashWithIndifferentAccess.new().tap do |terms|
+          if params[:columns].present? # This is an AJAX request from the DataTable
+            (params[:columns] || {}).each do |_, column|
+              next if table_columns[column[:name]].blank? || (column[:search] || {})[:value].blank?
+
+              terms[column[:name]] = column[:search][:value]
+            end
+          else # This is the initial render, and we have to apply default search terms only
+            table_columns.each do |name, values|
+              terms[name] = values[:filter][:selected] if values[:filter][:selected].present?
+            end
+          end
+        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
+        length = (params[:length].presence || display_entries).to_i
+
+        if length == -1
+          9999999
+        elsif length > 0
+          length
+        else
+          25
+        end
+      end
+
+      def per_page=(length)
+        case length
+        when Integer
+          params[:length] = length
+        when :all
+          params[:length] = -1
+        end
+      end
+
+      def page
+        params[:start].to_i / per_page + 1
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# This is extended as class level into Datatable
+
+module Effective
+  module EffectiveDatatable
+    module Dsl
+
+      module ClassMethods
+        def datatable(&block)
+          define_method('initialize_datatable') { instance_exec(&block) }
+        end
+      end
+
+      # Instance Methods inside the datatable do .. end block
+      def default_order(name, direction = :asc)
+        @default_order = {name => direction}
+      end
+
+      def default_entries(entries)
+        @default_entries = entries
+      end
+
+      def table_column(name, options = {}, proc = nil, &block)
+        if block_given?
+          raise "You cannot use partial: ... with the block syntax" if options[:partial]
+          raise "You cannot use proc: ... with the block syntax" if options[:proc]
+          options[:block] = block
+        end
+        raise "You cannot use both partial: ... and proc: ..." if options[:partial] && options[:proc]
+
+        self.class.send(:attr_accessor, name)
+        (@table_columns ||= HashWithIndifferentAccess.new())[name] = options
+      end
+
+      def array_column(name, options = {}, proc = nil, &block)
+        table_column(name, options.merge!(array_column: true), proc, &block)
+      end
+
+      def actions_column(options = {}, proc = nil, &block)
+        show = options.fetch(:show, false)
+        edit = options.fetch(:edit, true)
+        destroy = options.fetch(:destroy, true)
+        name = options.fetch(:name, 'actions')
+
+        opts = {
+          sortable: false,
+          filter: false,
+          partial_local: :resource,
+          partial_locals: { show_action: show, edit_action: edit, destroy_action: destroy }
+        }
+        opts[:partial] = '/effective/datatables/actions_column' unless (block_given? || proc.present?)
+
+        table_column(name, opts, proc, &block)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# This is extended as class level into Datatable
+
+module Effective
+  module EffectiveDatatable
+    module Options
+
+      def initialize_options
+        @table_columns = initialize_column_options(@table_columns)
+      end
+
+      protected
+
+      def initialize_column_options(cols)
+        sql_table = (collection.table rescue nil)
+
+        # Here we identify all belongs_to associations and build up a Hash like:
+        # {user: {foreign_key: 'user_id', klass: User}, order: {foreign_key: 'order_id', klass: Effective::Order}}
+        belong_tos = (collection.ancestors.first.reflect_on_all_associations(:belongs_to) rescue []).inject(HashWithIndifferentAccess.new()) do |retval, bt|
+          unless bt.options[:polymorphic]
+            begin
+              klass = bt.klass || bt.foreign_type.sub('_type', '').classify.constantize
+            rescue => e
+              klass = nil
+            end
+
+            retval[bt.name] = {foreign_key: bt.foreign_key, klass: klass} if bt.foreign_key.present? && klass.present?
+          end
+
+          retval
+        end
+
+        table_columns = cols.each_with_index do |(name, _), index|
+          # If this is a belongs_to, add an :if clause specifying a collection scope if
+          if belong_tos.key?(name)
+            cols[name][:if] ||= Proc.new { attributes[belong_tos[name][:foreign_key]].blank? }
+          end
+
+          sql_column = (collection.columns rescue []).find do |column|
+            column.name == name.to_s || (belong_tos.key?(name) && column.name == belong_tos[name][:foreign_key])
+          end
+
+          cols[name][:array_column] ||= false
+          cols[name][:array_index] = index # The index of this column in the collection, regardless of hidden table_columns
+          cols[name][:name] ||= name
+          cols[name][:label] ||= name.titleize
+          cols[name][:column] ||= (sql_table && sql_column) ? "\"#{sql_table.name}\".\"#{sql_column.name}\"" : name
+          cols[name][:width] ||= nil
+          cols[name][:sortable] = true if cols[name][:sortable] == nil
+          cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : sql_column.try(:type).presence) || :string
+          cols[name][:class] = "col-#{cols[name][:type]} col-#{name} #{cols[name][:class]}".strip
+
+          # EffectiveObfuscation
+          if name == 'id' && defined?(EffectiveObfuscation) && collection.respond_to?(:deobfuscate)
+            cols[name][:sortable] = false
+            cols[name][:type] = :obfuscated_id
+          end
+
+          # EffectiveRoles, if you do table_column :roles, everything just works
+          if name == 'roles' && defined?(EffectiveRoles) && collection.respond_to?(:with_role)
+            cols[name][:sortable] = true
+            cols[name][:column] = sql_table.present? ? "\"#{sql_table.name}\".\"roles_mask\"" : name
+            cols[name][:type] = :effective_roles
+          end
+
+          if sql_table.present? && sql_column.blank? # This is a SELECT AS column
+            cols[name][:sql_as_column] = true
+          end
+
+          cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type], belong_tos[name])
+
+          if cols[name][:partial]
+            cols[name][:partial_local] ||= (sql_table.try(:name) || cols[name][:partial].split('/').last(2).first.presence || 'obj').singularize.to_sym
+          end
+        end
+
+        # After everything is initialized
+        # Compute any col[:if] and assign an index
+        table_columns.select do |_, col|
+          col[:if] == nil || (col[:if].respond_to?(:call) ? (view || self).instance_exec(&col[:if]) : col[:if])
+        end.each_with_index { |(_, col), index| col[:index] = index }
+
+      end
+
+      def initialize_table_column_filter(filter, col_type, belongs_to)
+        return {type: :null} if filter == false
+
+        filter = {type: 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?
+
+        case col_type
+        when :belongs_to
+          {
+            type: :select,
+            values: Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[1] <=> y[1] } }
+          }
+        when :effective_roles
+          {type: :select, values: EffectiveRoles.roles}
+        when :integer
+          {type: :number}
+        when :boolean
+          {type: :boolean, values: [true, false]}
+        else
+          {type: :string}
+        end.merge(filter.symbolize_keys)
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# This is extended as class level into Datatable
+
+module Effective
+  module EffectiveDatatable
+    module Rendering
+
+      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
+      # And then run any array_columns through in post-processed results
+      def table_data
+        col = collection
+
+        if active_record_collection?
+          col = table_tool.order(col)
+          col = table_tool.search(col)
+
+          if table_tool.search_terms.present? && array_tool.search_terms.blank?
+            if collection_class.connection.respond_to?(:unprepared_statement)
+              # https://github.com/rails/rails/issues/15331
+              col_sql = collection_class.connection.unprepared_statement { col.to_sql }
+              self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col_sql}) AS datatables_filtered_count").first['count'] rescue 1).to_i
+            else
+              self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_filtered_count").first['count'] rescue 1).to_i
+            end
+          end
+        end
+
+        if array_tool.search_terms.present?
+          col = self.arrayize(col)
+          col = array_tool.search(col)
+          self.display_records = col.size
+        end
+
+        if array_tool.order_column.present?
+          col = self.arrayize(col)
+          col = array_tool.order(col)
+        end
+
+        self.display_records ||= total_records
+
+        if col.kind_of?(Array)
+          col = array_tool.paginate(col)
+        else
+          col = table_tool.paginate(col)
+          col = self.arrayize(col)
+        end
+
+        col = self.finalize(col)
+      end
+
+      def arrayize(collection)
+        return collection if @arrayized  # Prevent the collection from being arrayized more than once
+        @arrayized = true
+
+        # We want to use the render :collection for each column that renders partials
+        rendered = {}
+        table_columns.each do |name, opts|
+          if opts[:partial]
+            locals = {
+              datatable: self,
+              table_column: table_columns[name],
+              controller_namespace: view.controller_path.split('/')[0...-1].map { |path| path.downcase.to_sym if path.present? }.compact,
+              show_action: (opts[:partial_locals] || {})[:show_action],
+              edit_action: (opts[:partial_locals] || {})[:edit_action],
+              destroy_action: (opts[:partial_locals] || {})[:destroy_action]
+            }
+            locals.merge!(opts[:partial_locals]) if opts[:partial_locals]
+
+            rendered[name] = (render(
+              :partial => opts[:partial],
+              :as => opts[:partial_local],
+              :collection => collection,
+              :formats => :html,
+              :locals => locals,
+              :spacer_template => '/effective/datatables/spacer_template',
+            ) || '').split('EFFECTIVEDATATABLESSPACER')
+          end
+        end
+
+        collection.each_with_index.map do |obj, index|
+          (display_table_columns || table_columns).map do |name, opts|
+            value = if opts[:partial]
+              rendered[name][index]
+            elsif opts[:block]
+              view.instance_exec(obj, collection, self, &opts[:block])
+            elsif opts[:proc]
+              view.instance_exec(obj, collection, self, &opts[:proc])
+            elsif opts[:type] == :belongs_to
+              val = (obj.send(name) rescue nil).to_s
+            elsif opts[:type] == :obfuscated_id
+              (obj.send(:to_param) rescue nil).to_s
+            elsif opts[:type] == :effective_roles
+              (obj.send(:roles) rescue []).join(', ')
+            else
+              val = (obj.send(name) rescue nil)
+              val = (obj[opts[:array_index]] rescue nil) if val == nil
+              val
+            end
+
+            # Last minute formatting of dates
+            case value
+            when Date
+              value.strftime(EffectiveDatatables.date_format)
+            when Time, DateTime
+              value.strftime(EffectiveDatatables.datetime_format)
+            else
+              value.to_s
+            end
+          end
+        end
+      end
+
+    end # / Rendering
+  end
+end

data/app/views/effective/datatables/_actions_column.html.haml

@@ -10,5 +10,5 @@
 
 - if destroy_action
   - url = (polymorphic_path([*controller_namespace, resource]) rescue nil) || (polymorphic_path(resource) rescue nil)
-  %a{href: (polymorphic_path([*controller_namespace, resource]) rescue '#'), title: 'Delete', data: {method: :delete, confirm: 'Are you sure?'}}
+  %a{href: (url || '#'), title: 'Delete', data: {method: :delete, confirm: 'Are you sure?'}}
     %span.glyphicon.glyphicon-trash

data/app/views/effective/datatables/_datatable.html.haml

@@ -14,7 +14,7 @@
       'non-visible' => datatable_non_visible(datatable),
       'widths' => datatable_widths(datatable),
       'default-order' => datatable_default_order(datatable),
-      'default-entries' => datatable.default_entries,
+      'display-entries' => datatable.display_entries,
       'display-records' => (datatable.to_json[:recordsFiltered] || 0),
       'total-records' => (datatable.to_json[:recordsTotal] || 0),
       'column-classes' => datatable_column_classes(datatable)

data/lib/effective_datatables.rb

@@ -20,15 +20,4 @@ module EffectiveDatatables
     true
   end
 
-  def self.datatables
-    Rails.env.development? ? read_datatables : (@@datatables ||= read_datatables)
-  end
-
-  private
-
-  def self.read_datatables
-    Rails.application.eager_load! unless Rails.configuration.cache_classes
-    Effective::Datatable.descendants.map { |klass| klass }.compact
-  end
-
 end

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '1.8.3'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 1.8.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-06 00:00:00.000000000 Z
+date: 2015-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -123,6 +123,10 @@ files:
 - app/models/effective/active_record_datatable_tool.rb
 - app/models/effective/array_datatable_tool.rb
 - app/models/effective/datatable.rb
+- app/models/effective/effective_datatable/ajax.rb
+- app/models/effective/effective_datatable/dsl.rb
+- app/models/effective/effective_datatable/options.rb
+- app/models/effective/effective_datatable/rendering.rb
 - app/views/effective/datatables/_actions_column.html.haml
 - app/views/effective/datatables/_datatable.html.haml
 - app/views/effective/datatables/_spacer_template.html