effective_datatables 4.7.5 → 4.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48cac2f10a4ebc72966c0dfffbb2cfa813743d2bcc37ca2571e86252241d66ec
-  data.tar.gz: d7baf2ef61b1008ee0265c65bb3acb878c8da0d4031ea12cb4a27b000f54ef08
+  metadata.gz: 9a83b549ce682f713931db6fb31f1432b9ccfca4d8e24ba43c56e0dcf8ff117f
+  data.tar.gz: 53709d9a9d9e7dd7bf8f6b8025088976090a8a3571f264e08e03da534b28119f
 SHA512:
-  metadata.gz: 77eeca0bd8b7908e0fa6a893cb4cd96ab84c16bd235f520829c862104540861381af977ea017fd926608ea06620f43e935fd7af53a565321a7e00f52b66db54b
-  data.tar.gz: 42d1909524c35fc87fdd8495c5c28b84f93f8259b008a66d0a1037d1fc13f30e2efe86776f5fb5a35b2985b2bc32febdf14347e84abf9deed186810c19c16ea5
+  metadata.gz: 0ebb22d41947d8e8fe4a8deebc9472f442617e4ace66e8cce6312e7f1e6de714e169b05a2146d823a568644b73a44871a82c7ab3faea72ca42fb1fb46d7c0ffb
+  data.tar.gz: ac2d99e28b03a04f60cd583c2a0c657380d505f53490be7a9a0e39d05d7005c6a0c2cb3f6e92723a5f126a22454834453a7581f0fbb124e9a4be56ed2436c038

data/app/assets/javascripts/effective_datatables/inline_crud.js.coffee

@@ -38,7 +38,6 @@ $(document).on 'ajax:success', '.dataTables_wrapper .col-actions', (event, data)
   EffectiveForm.remote_form_payload = ''
   EffectiveForm.remote_form_commit = ''
   EffectiveForm.remote_form_flash = ''
-  EffectiveForm.remote_form_refresh_datatables = ''
 
   true
 
@@ -53,7 +52,6 @@ $(document).on 'ajax:error', '.dataTables_wrapper', (event) ->
   EffectiveForm.remote_form_payload = ''
   EffectiveForm.remote_form_commit = ''
   EffectiveForm.remote_form_flash = ''
-  EffectiveForm.remote_form_refresh_datatables = ''
   true
 
 # Submitting an inline datatables form
@@ -84,7 +82,6 @@ $(document).on 'effective-form:success', '.dataTables_wrapper .col-inline-form',
     $tr.fadeOut('slow')
 
   $table.DataTable().draw()
-  refreshDatatables($table)
 
 beforeNew = ($action) ->
   $table = $action.closest('table')
@@ -150,9 +147,7 @@ afterAction = ($action) ->
   else
     $table.DataTable().flash('Successfully ' + $action.attr('title'), 'success')
 
-  unless redirectDatatables($table)
-    $table.DataTable().draw()
-    refreshDatatables($table)
+  $table.DataTable().draw()
 
 afterError = ($action) ->
   $table = $action.closest('table')
@@ -186,28 +181,6 @@ cancel = ($table) ->
   if $wrapper.find('.effective-datatables-inline-row').length == 0
     $wrapper.removeClass('effective-datatables-inline-expanded')
 
-redirectDatatables = ($source) ->
-  return false unless EffectiveForm.remote_form_refresh_datatables.length > 0
-
-  if EffectiveForm.remote_form_refresh_datatables.includes('refresh')
-    if Turbolinks?
-      Turbolinks.visit(window.location.href, { action: 'replace'})
-    else
-      window.location.reload()
-
-    return true
-
-  false
-
-refreshDatatables = ($source) ->
-  return unless EffectiveForm.remote_form_refresh_datatables.length > 0
-
-  $('table.dataTable.initialized').each ->
-    $table = $(this)
-
-    if EffectiveForm.remote_form_refresh_datatables.find((id) -> $table.attr('id').startsWith(id) || id == 'all')
-      $table.DataTable().draw() if $table != $source
-
 # Cancel button clicked. Blow away new tr, or restore edit tr
 # No data will have changed at this point
 $(document).on 'click', ".dataTables_wrapper a[data-role='inline-form-cancel']", (event) ->

data/app/helpers/effective_datatables_private_helper.rb

@@ -39,10 +39,24 @@ module EffectiveDatatablesPrivateHelper
   end
 
   def datatable_new_resource_button(datatable, name, column)
-    return unless column[:inline] && (column[:actions][:new] != false) && (datatable.resource.actions.include?(:new) rescue false)
+    return unless column[:inline] && (column[:actions][:new] != false)
 
-    actions = {t('effective_datatables.new') => { action: :new, class: ['btn', column[:btn_class].presence].compact.join(' '), 'data-remote': true } }
-    render_resource_actions(datatable.resource.klass, actions: actions, effective_resource: datatable.resource) # Will only work if permitted
+    action = { action: :new, class: ['btn', column[:btn_class].presence].compact.join(' '), 'data-remote': true }
+
+    if column[:actions][:new].kind_of?(Hash) # This might be active_record_array_collection?
+      action = action.merge(column[:actions][:new])
+
+      effective_resource = (datatable.effective_resource || datatable.fallback_effective_resource)
+      klass = (column[:actions][:new][:klass] || effective_resource&.klass || datatable.collection_class)
+    elsif Array(datatable.effective_resource&.actions).include?(:new)
+      effective_resource = datatable.effective_resource
+      klass = effective_resource.klass
+    else
+      return
+    end
+
+    # Will only work if permitted
+    render_resource_actions(klass, actions: { t('effective_datatables.new') => action }, effective_resource: effective_resource)
   end
 
   def datatable_label_tag(datatable, name, opts)

data/app/models/effective/datatable.rb

@@ -1,7 +1,7 @@
 module Effective
   class Datatable
     attr_reader :attributes # Anything that we initialize our table with. That's it. Can't be changed by state.
-    attr_reader :resource
+    attr_reader :effective_resource
     attr_reader :state
 
     # Hashes of DSL options
@@ -64,7 +64,6 @@ module Effective
       # This means filters do know about attributes but not about columns.
       initialize_filters if respond_to?(:initialize_filters)
       load_filters!
-
       load_state!
 
       # Bulk actions called first so it can add the bulk_actions_col first
@@ -83,8 +82,6 @@ module Effective
 
       # Figure out the class, and if it's activerecord, do all the resource discovery on it
       load_resource!
-      apply_belongs_to_attributes!
-      load_resource_search!
 
       # Check everything is okay
       validate_datatable!
@@ -165,6 +162,14 @@ module Effective
       @dsl_tool ||= DatatableDslTool.new(self)
     end
 
+    def resource
+      raise('depecated. Please use .effective_resource instead')
+    end
+
+    def fallback_effective_resource
+      @fallback_effective_resource ||= Effective::Resource.new('', namespace: controller_namespace)
+    end
+
     private
 
     def column_tool
@@ -177,8 +182,8 @@ module Effective
 
     def validate_datatable!
       if reorder?
-        raise 'cannot use reorder with an Array collection' if array_collection?
-        raise 'cannot use reorder with a non-Integer column' if resource.sql_type(columns[:_reorder][:reorder]) != :integer
+        raise 'cannot use reorder with an Array collection' unless active_record_collection?
+        raise 'cannot use reorder with a non-Integer column' if effective_resource.sql_type(columns[:_reorder][:reorder]) != :integer
       end
     end
 

data/app/models/effective/datatable_column_tool.rb

@@ -43,7 +43,7 @@ module Effective
       Rails.logger.info "COLUMN TOOL: order_column #{column.to_s} #{direction} #{sql_column}" if EffectiveDatatables.debug
 
       if column[:sql_as_column]
-        collection.order("#{sql_column} #{datatable.resource.sql_direction(direction)}")
+        collection.order("#{sql_column} #{datatable.effective_resource.sql_direction(direction)}")
       else
         Effective::Resource.new(collection)
           .order(column[:name], direction, as: column[:as], sort: column[:sort], sql_column: column[:sql_column], limit: datatable.limit)

data/app/models/effective/datatable_value_tool.rb

@@ -77,7 +77,6 @@ module Effective
     def search_column(collection, value, column, index)
       Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{value} #{index}" if EffectiveDatatables.debug
 
-      macros = Effective::Resource.new('').macros
       fuzzy = column[:search][:fuzzy]
 
       term = Effective::Attribute.new(column[:as]).parse(value, name: column[:name])
@@ -134,7 +133,7 @@ module Effective
           else
             obj == term
           end
-        when *macros, :resource
+        when *datatable.association_macros, :resource
           Array(obj).any? do |resource|
             Array(term).any? do |term|
               matched = false

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

@@ -7,10 +7,23 @@ module Effective
         @collection_class  # Will be either User/Post/etc or Array
       end
 
+      # User.all
       def active_record_collection?
         @active_record_collection == true
       end
 
+      # [User<1>, User<2>, Post<1>, Page<3>]
+      def active_record_array_collection?
+        @active_record_array_collection == true
+      end
+
+      def active_record_polymorphic_array_collection?
+        return false unless active_record_array_collection?
+        return @active_record_polymorphic_array_collection unless @active_record_polymorphic_array_collection.nil?
+        @active_record_polymorphic_array_collection = collection.map { |obj| obj.class }.uniq.length > 1
+      end
+
+      # [[1, 'foo'], [2, 'bar']]
       def array_collection?
         @array_collection == true
       end
@@ -21,11 +34,13 @@ module Effective
         raise 'No collection defined. Please add a collection with collection do ... end' if collection.nil?
 
         @collection_class = (collection.respond_to?(:klass) ? collection.klass : self.class)
+        
         @active_record_collection = (collection.ancestors.include?(ActiveRecord::Base) rescue false)
-        @array_collection = (collection.kind_of?(Array) && (collection.length == 0 || collection.first.kind_of?(Array)))
+        @active_record_array_collection = collection.kind_of?(Array) && collection.present? && collection.first.kind_of?(ActiveRecord::Base)
+        @array_collection = collection.kind_of?(Array) && (collection.blank? || collection.first.kind_of?(Array))
 
-        unless active_record_collection? || array_collection?
-          raise "Unsupported collection type. Expecting an ActiveRecord class, ActiveRecord relation, or an Array of Arrays [[1, 'foo'], [2, 'bar']]"
+        unless active_record_collection? || active_record_array_collection? || array_collection?
+          raise "Unsupported collection. Expecting an ActiveRecord relation, an Array of ActiveRecord objects, or an Array of Arrays [[1, 'foo'], [2, 'bar']]"
         end
 
         _scopes.each do |scope, _|

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

@@ -64,11 +64,15 @@ module Effective
             if state[:visible][name] == false && (name != order_name)  # Sort by invisible array column
               BLANK
             elsif opts[:compute]
-              dsl_tool.instance_exec(obj, (active_record_collection? ? collection : obj[opts[:index]]), &opts[:compute])
+              if array_collection?
+                dsl_tool.instance_exec(obj, obj[opts[:index]], &opts[:compute])
+              else
+                dsl_tool.instance_exec(obj, collection, &opts[:compute])
+              end
             elsif (opts[:partial] || opts[:format])
-              active_record_collection? ? obj : obj[opts[:index]]
+              array_collection? ? obj[opts[:index]] : obj
             elsif opts[:resource]
-              resource = active_record_collection? ? obj : obj[opts[:index]]
+              resource = array_collection? ? obj[opts[:index]] : obj
 
               if opts[:resource_field]
                 (associated, field) = name.to_s.split('.').first(2)

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

@@ -16,7 +16,7 @@ module Effective
           next unless state[:visible][name]
 
           if opts[:partial]
-            locals = { datatable: self, column: columns[name] }.merge(resource_col_locals(opts))
+            locals = { datatable: self, column: opts }.merge(resource_col_locals(opts))
 
             rendered[name] = (view.render(
               partial: opts[:partial],
@@ -29,11 +29,24 @@ module Effective
           elsif opts[:as] == :actions # This is actions_col and actions_col do .. end, but not actions_col partial: 'something'
             resources = collection.map { |row| row[opts[:index]] }
             locals = { datatable: self, column: opts, spacer_template: SPACER_TEMPLATE }
-            atts = { actions: actions_col_actions(opts), effective_resource: resource, locals: locals, partial: opts[:actions_partial], btn_class: opts[:btn_class] }.merge(opts[:actions])
 
-            rendered[name] = (view.render_resource_actions(resources, atts, &opts[:format]) || '').split(SPACER)
-          end
+            atts = {
+              actions: actions_col_actions(opts),
+              btn_class: opts[:btn_class],
+              effective_resource: effective_resource,
+              locals: locals,
+              partial: opts[:actions_partial],
+            }.compact.merge(opts[:actions])
 
+            rendered[name] = if effective_resource.blank?
+              resources.map do |resource|
+                polymorphic_resource = Effective::Resource.new(resource, namespace: controller_namespace)
+                (view.render_resource_actions(resource, atts.merge(effective_resource: polymorphic_resource), &opts[:format]) || '')
+              end
+            else
+              (view.render_resource_actions(resources, atts, &opts[:format]) || '').split(SPACER)
+            end
+          end
         end
 
         collection.each_with_index do |row, row_index|
@@ -69,9 +82,7 @@ module Effective
 
         case column[:as]
         when :actions
-          atts = { actions: actions_col_actions(column), effective_resource: resource, partial: column[:actions_partial] }.merge(column[:actions])
-
-          (view.render_resource_actions(value, atts) || '')
+          raise("please use actions_col instead of col(#{name}, as: :actions)")
         when :boolean
           view.t("effective_datatables.boolean_#{value}")
         when :currency
@@ -115,10 +126,12 @@ module Effective
       # Applies data-remote to anything that's data-method post or delete
       # Merges in any extra attributes when passed as a Hash
       def actions_col_actions(column)
+        resource_actions = (effective_resource&.resource_actions || fallback_effective_resource.fallback_resource_actions)
+
         actions = if column[:inline]
-          resource.resource_actions.transform_values { |opts| opts['data-remote'] = true; opts }
+          resource_actions.transform_values { |opts| opts['data-remote'] = true; opts }
         else
-          resource.resource_actions.transform_values { |opts| opts['data-remote'] = true if opts['data-method']; opts }
+          resource_actions.transform_values { |opts| opts['data-remote'] = true if opts['data-method']; opts }
         end
 
         # Merge local options. Special behaviour for remote: false
@@ -140,26 +153,32 @@ module Effective
       end
 
       def resource_col_locals(opts)
-        return {} unless (resource = opts[:resource]).present?
+        return {} unless (associated_resource = opts[:resource]).present?
 
+        associated = associated_resource.macros.include?(opts[:as])
         polymorphic = (opts[:as] == :belongs_to_polymorphic)
-        associated = resource.macros.include?(opts[:as])
 
-        resource_name = opts[:name] if associated 
+        resource_name = opts[:name] if associated
         resource_to_s = opts[:name] unless associated || array_collection?
 
-        locals = { resource_name: resource_name, resource_to_s: resource_to_s, effective_resource: resource, show_action: false, edit_action: false }
+        locals = {
+          resource_name: resource_name,
+          resource_to_s: resource_to_s,
+          effective_resource: associated_resource,
+          show_action: false,
+          edit_action: false
+        }
 
         case opts[:action]
         when :edit
-          locals[:edit_action] = (resource.routes[:edit].present? || polymorphic)
+          locals[:edit_action] = (polymorphic || associated_resource.routes[:edit].present?)
         when :show
-          locals[:show_action] = (resource.routes[:show].present? || polymorphic)
+          locals[:show_action] = (polymorphic || associated_resource.routes[:show].present?)
         when false
           # Nothing. Already false.
         else
-          locals[:edit_action] = (resource.routes[:edit].present? || polymorphic)
-          locals[:show_action] = (resource.routes[:show].present? || polymorphic)
+          locals[:edit_action] = (polymorphic || associated_resource.routes[:edit].present?)
+          locals[:show_action] = (polymorphic || associated_resource.routes[:show].present?)
         end
 
         locals

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

@@ -11,99 +11,126 @@ module Effective
         @attributes[:namespace]
       end
 
+      def association_macros
+        [:belongs_to, :belongs_to_polymorphic, :has_many, :has_and_belongs_to_many, :has_one]
+      end
+
       private
 
       # This looks at all the columns and figures out the as:
       def load_resource!
-        @resource = Effective::Resource.new(collection_class, namespace: controller_namespace)
+        load_effective_resource!
 
-        if active_record_collection?
-          columns.each do |name, opts|
+        load_active_record_collection!
+        load_active_record_array_collection!
+        load_array_collection!
 
-            # col 'comments.title'
-            if name.kind_of?(String) && name.include?('.')
-              raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
+        load_resource_columns!
+        load_resource_belongs_tos!
+        load_resource_search!
+      end
 
-              (associated, field) = name.split('.').first(2)
+      def load_effective_resource!
+        @effective_resource = if active_record_collection?
+          Effective::Resource.new(collection_class, namespace: controller_namespace)
+        end
+      end
 
-              unless resource.macros.include?(resource.sql_type(associated))
-                raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{resource}'."
-              end
+      def load_active_record_collection!
+        return unless active_record_collection?
 
-              joins_values = (collection.joins_values + collection.left_outer_joins_values)
+        columns.each do |name, opts|
+          # col 'comments.title'
+          if name.kind_of?(String) && name.include?('.')
+            raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
 
-              unless joins_values.include?(associated.to_sym)
-                raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
-              end
+            (associated, field) = name.split('.').first(2)
 
-              opts[:resource] = Effective::Resource.new(resource.associated(associated), namespace: controller_namespace)
+            unless association_macros.include?(effective_resource.sql_type(associated))
+              raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{effective_resource}'."
+            end
 
-              if opts[:resource].column(field)
-                opts[:as] ||= opts[:resource].sql_type(field)
-                opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
-                opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+            joins_values = (collection.joins_values + collection.left_outer_joins_values)
 
-                opts[:resource].sort_column = field
-                opts[:resource].search_columns = field
-              end
+            unless joins_values.include?(associated.to_sym)
+              raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
+            end
 
-              opts[:resource_field] = field
+            opts[:resource] = Effective::Resource.new(effective_resource.associated(associated), namespace: controller_namespace)
 
-              next
+            if opts[:resource].column(field)
+              opts[:as] ||= opts[:resource].sql_type(field)
+              opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
+              opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+
+              opts[:resource].sort_column = field
+              opts[:resource].search_columns = field
             end
 
-            # Regular fields
-            opts[:as] ||= resource.sql_type(name)
-            opts[:sql_column] = resource.sql_column(name) if opts[:sql_column].nil?
+            opts[:resource_field] = field
+
+            next
+          end
+
+          # Regular fields
+          opts[:as] ||= effective_resource.sql_type(name)
+          opts[:sql_column] = effective_resource.sql_column(name) if opts[:sql_column].nil?
 
-            case opts[:as]
-            when *resource.macros
-              opts[:resource] ||= Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
+          case opts[:as]
+          when *association_macros
+            opts[:resource] ||= Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
+            opts[:sql_column] = name if opts[:sql_column].nil?
+          when Class
+            if opts[:as].ancestors.include?(ActiveRecord::Base)
+              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+              opts[:as] = :resource
               opts[:sql_column] = name if opts[:sql_column].nil?
-            when Class
-              if opts[:as].ancestors.include?(ActiveRecord::Base)
-                opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
-                opts[:as] = :resource
-                opts[:sql_column] = name if opts[:sql_column].nil?
-              end
-            when :effective_addresses
-              opts[:resource] = Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
-              opts[:sql_column] = :effective_addresses
-            when :effective_roles
-              opts[:sql_column] = :effective_roles
-            when :string  # This is the fallback
-              # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
-              opts[:sql_as_column] = true if (resource.table && resource.column(name).blank?)
             end
+          when :effective_addresses
+            opts[:resource] = Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
+            opts[:sql_column] = :effective_addresses
+          when :effective_roles
+            opts[:sql_column] = :effective_roles
+          when :string  # This is the fallback
+            # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
+            opts[:sql_as_column] = true if (effective_resource.table && effective_resource.column(name).blank?)
+          end
 
-            if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
-              opts[:sql_as_column] = true
-            end
+          if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
+            opts[:sql_as_column] = true
           end
         end
+      end
 
-        if array_collection?
-          row = collection.first
+      def load_active_record_array_collection!
+        return unless active_record_array_collection?
+      end
 
-          columns.each do |name, opts|
-            if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
-              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+      def load_array_collection!
+        return unless array_collection?
+
+        row = collection.first
+
+        columns.each do |name, opts|
+          if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
+            opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+            opts[:as] = :resource
+          elsif opts[:as] == nil && row.present?
+            if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
+              opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
               opts[:as] = :resource
-            elsif opts[:as] == nil && row.present?
-              if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
-                opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
-                opts[:as] = :resource
-              end
             end
           end
         end
+      end
 
+      def load_resource_columns!
         columns.each do |name, opts|
           opts[:as] ||= :string
           opts[:as] = :email if (opts[:as] == :string && name.to_s.end_with?('email'))
 
           if opts[:action]
-            opts[:resource] ||= resource
+            opts[:resource] ||= effective_resource
           end
 
           if opts[:resource] && !opts[:resource_field] && opts[:as] != :effective_addresses
@@ -113,7 +140,7 @@ module Effective
           opts[:col_class] = [
             "col-#{opts[:as]}",
             "col-#{name.to_s.parameterize}",
-            ("colvis-default" if opts[:visible]),
+            ('colvis-default' if opts[:visible]),
             opts[:col_class].presence
           ].compact.join(' ')
         end
@@ -153,12 +180,13 @@ module Effective
 
           search[:fuzzy] = true unless search.key?(:fuzzy)
 
-          if array_collection? && opts[:resource].present?
-            search.reverse_merge!(resource.search_form_field(name, collection.first[opts[:index]]))
-          elsif search[:as] == :select && search.key?(:collection)
+          if search[:as] == :select && search.key?(:collection)
             # No Action
+          elsif array_collection? && opts[:resource].present?
+            search.reverse_merge!(opts[:resource].search_form_field(name, collection.first[opts[:index]]))
           elsif search[:as] != :string
-            search.reverse_merge!(resource.search_form_field(name, opts[:as]))
+            search_resource = (opts[:resource] || effective_resource || fallback_effective_resource)
+            search.reverse_merge!(search_resource.search_form_field(name, opts[:as]))
           end
 
           # Assign default include_null
@@ -168,7 +196,7 @@ module Effective
         end
       end
 
-      def apply_belongs_to_attributes!
+      def load_resource_belongs_tos!
         return unless active_record_collection?
 
         changed = attributes.select do |attribute, value|
@@ -181,19 +209,19 @@ module Effective
 
           if columns[associated][:as] == :belongs_to
             if @_collection_apply_belongs_to && !@_collection.where_values_hash.include?(attribute)
-              @_collection = @_collection.where(attribute => value) 
+              @_collection = @_collection.where(attribute => value)
             end
 
             columns.delete(associated)
           elsif columns[associated][:as] == :belongs_to_polymorphic
             associated_type = attributes["#{associated}_type".to_sym] || raise("Expected #{associated}_type attribute to be present when #{associated}_id is present on a polymorphic belongs to")
 
-            if @_collection_apply_belongs_to 
+            if @_collection_apply_belongs_to
               if !@_collection.where_values_hash.include?(attribute) && !@_collection.where_values_hash.include?("#{associated}_type")
                 @_collection = @_collection.where(attribute => value).where("#{associated}_type" => associated_type)
               end
             end
-            
+
             columns.delete(associated)
           end
 

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '4.7.5'.freeze
+  VERSION = '4.7.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 4.7.5
+  version: 4.7.6
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-17 00:00:00.000000000 Z
+date: 2019-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails