effective_datatables 3.7.7 → 4.0.0

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

@@ -5,7 +5,7 @@ module Effective
         def filter(name = nil, value = :_no_value, as: nil, label: nil, parse: nil, required: false, **input_html)
           return datatable.filter if (name == nil && value == :_no_value) # This lets block methods call 'filter' and get the values
 
-          raise 'expected second argument to be a value. the default value for this filter.' if value == :_no_value
+          raise 'expected second argument to be a value' if value == :_no_value
           raise 'parse must be a Proc' if parse.present? && !parse.kind_of?(Proc)
 
           # Merge search
@@ -17,19 +17,19 @@ module Effective
           as ||= (
             if input_html.key?(:collection)
               :select
-            elsif value != nil
+            elsif value.present?
               Effective::Attribute.new(value).type
             end
-          ) || :text
+          )
 
           datatable._filters[name.to_sym] = {
             value: value,
             as: as,
-            label: label,
+            label: label || (label == false ? false : name.to_s.titleize),
             name: name.to_sym,
             parse: parse,
             required: required,
-          }.compact.reverse_merge(input_html)
+          }.reverse_merge(input_html)
         end
 
         def scope(name = nil, *args, default: nil, label: nil)

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

@@ -2,9 +2,6 @@ module Effective
   module EffectiveDatatable
     module Format
       BLANK = ''.freeze
-      NONVISIBLE = '...'.freeze
-      SPACER = 'EFFECTIVEDATATABLESSPACER'.freeze
-      SPACER_TEMPLATE = '/effective/datatables/spacer_template'.freeze
 
       private
 
@@ -13,10 +10,12 @@ module Effective
         rendered = {}
 
         columns.each do |name, opts|
-          next unless state[:visible][name]
-
-          if opts[:partial]
-            locals = { datatable: self, column: opts }.merge(resource_col_locals(opts))
+          if opts[:partial] && state[:visible][name]
+            locals = {
+              datatable: self,
+              column: columns[name],
+              controller_namespace: controller_namespace
+            }.merge(actions_col_locals(opts)).merge(resource_col_locals(opts))
 
             rendered[name] = (view.render(
               partial: opts[:partial],
@@ -24,42 +23,20 @@ module Effective
               collection: collection.map { |row| row[opts[:index]] },
               formats: :html,
               locals: locals,
-              spacer_template: SPACER_TEMPLATE
-            ) || '').split(SPACER)
-          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),
-              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
+              spacer_template: '/effective/datatables/spacer_template',
+            ) || '').split('EFFECTIVEDATATABLESSPACER')
           end
         end
 
         collection.each_with_index do |row, row_index|
           columns.each do |name, opts|
+            next unless state[:visible][name]
+
             index = opts[:index]
             value = row[index]
 
             row[index] = (
-              if state[:visible][name] == false
-                NONVISIBLE
-              elsif opts[:as] == :actions
-                rendered[name][row_index]
-              elsif opts[:format] && rendered.key?(name)
+              if opts[:format] && rendered.key?(name)
                 dsl_tool.instance_exec(value, row, rendered[name][row_index], &opts[:format])
               elsif opts[:format]
                 dsl_tool.instance_exec(value, row, &opts[:format])
@@ -81,22 +58,23 @@ module Effective
         end
 
         case column[:as]
-        when :actions
-          raise("please use actions_col instead of col(#{name}, as: :actions)")
         when :boolean
-          view.t("effective_datatables.boolean_#{value}")
+          case value
+          when true   ; 'Yes'
+          when false  ; 'No'
+          end
         when :currency
           view.number_to_currency(value)
         when :date
-          value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_date) : BLANK
+          (value.strftime('%F') rescue BLANK)
         when :datetime
-          value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_datetime) : BLANK
+          (value.strftime('%F %H:%M') rescue BLANK)
         when :decimal
           value
         when :duration
           view.number_to_duration(value)
         when :effective_addresses
-          (value.respond_to?(:to_html) ? value.to_html : value).to_s
+          value.to_html
         when :effective_obfuscation
           value
         when :effective_roles
@@ -105,10 +83,10 @@ module Effective
           view.mail_to(value)
         when :integer
           value
-        when :percent
+        when :percentage
           case value
-          when Integer    ; view.number_to_percentage(value / 1000.0, precision: 3).gsub('.000%', '%')
-          when Numeric    ; view.number_to_percentage(value, precision: 3).gsub('.000%', '%')
+          when Integer    ; "#{value}%"
+          when Numeric    ; view.number_to_percentage(value * 100, precision: 2)
           end
         when :price
           case value
@@ -116,74 +94,51 @@ module Effective
           when Numeric    ; view.number_to_currency(value)
           end
         when :time
-          value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_time) : BLANK
+          (value.strftime('%H:%M') rescue BLANK)
         else
           value.to_s
         end
       end
 
-      # Takes all default resource actions
-      # 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.try(:resource_actions) || fallback_effective_resource.fallback_resource_actions)
-
-        actions = if column[:inline]
-          resource_actions.transform_values { |opts| opts['data-remote'] = true; opts }
-        else
-          resource_actions.transform_values { |opts| opts['data-remote'] = true if opts['data-method']; opts }
-        end
-
-        # Merge local options. Special behaviour for remote: false
-        if column[:actions].kind_of?(Hash)
-          column[:actions].each do |action, opts|
-            next unless opts.kind_of?(Hash)
-
-            existing = actions.find { |_, v| v[:action] == action }.try(:first)
-            next unless existing.present?
+      def actions_col_locals(opts)
+        return {} unless opts[:as] == :actions
 
-            actions[existing]['data-remote'] = opts[:remote] if opts.key?(:remote)
-            actions[existing]['data-remote'] = opts['remote'] if opts.key?('remote')
-
-            actions[existing].merge!(opts.except(:remote, 'remote'))
-          end
-
-          actions = actions.sort do |(_, a), (_, b)|
-            (column[:actions].keys.index(a[:action]) || 99) <=> (column[:actions].keys.index(b[:action]) || 99)
-          end.to_h
-
-        end
-
-        actions
+        locals = {
+          show_action: (
+            active_record_collection? && opts[:show] && resource.routes[:show] &&
+            EffectiveDatatables.authorized?(view.controller, :show, collection_class)
+          ),
+          edit_action: (
+            active_record_collection? && opts[:edit] && resource.routes[:edit] &&
+            EffectiveDatatables.authorized?(view.controller, :edit, collection_class)
+          ),
+          destroy_action: (
+            active_record_collection? && opts[:destroy] && resource.routes[:destroy] &&
+            EffectiveDatatables.authorized?(view.controller, :destroy, collection_class)
+          ),
+          effective_resource: resource
+        }
       end
 
       def resource_col_locals(opts)
-        return {} unless (associated_resource = opts[:resource]).present?
-
-        associated = associated_resource.macros.include?(opts[:as])
-        polymorphic = (opts[:as] == :belongs_to_polymorphic)
-
-        resource_name = opts[:name] if associated
-        resource_to_s = opts[:name] unless associated || array_collection?
+        return {} unless (resource = opts[:resource]).present?
 
-        locals = {
-          resource_name: resource_name,
-          resource_to_s: resource_to_s,
-          effective_resource: associated_resource,
-          show_action: false,
-          edit_action: false
-        }
+        locals = { name: opts[:name], effective_resource: resource, show_action: false, edit_action: false }
 
         case opts[:action]
         when :edit
-          locals[:edit_action] = (polymorphic || associated_resource.routes[:edit].present?)
+          locals[:edit_action] = (resource.routes[:edit] && EffectiveDatatables.authorized?(view.controller, :edit, resource.klass))
         when :show
-          locals[:show_action] = (polymorphic || associated_resource.routes[:show].present?)
+          locals[:show_action] = (resource.routes[:show] && EffectiveDatatables.authorized?(view.controller, :show, resource.klass))
         when false
-          # Nothing. Already false.
+          # Nothing
         else
-          locals[:edit_action] = (polymorphic || associated_resource.routes[:edit].present?)
-          locals[:show_action] = (polymorphic || associated_resource.routes[:show].present?)
+          # Fallback to defaults - check edit then show
+          if resource.routes[:edit] && EffectiveDatatables.authorized?(view.controller, :edit, resource.klass)
+            locals[:edit_action] = true
+          elsif resource.routes[:show] && EffectiveDatatables.authorized?(view.controller, :show, resource.klass)
+            locals[:show_action] = true
+          end
         end
 
         locals

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

@@ -7,13 +7,8 @@ module Effective
       def datatables_ajax_request?
         return @_datatables_ajax_request unless @_datatables_ajax_request.nil?
 
-        @_datatables_ajax_request = (view.present? && view.params.key?(:draw) && view.params.key?(:columns))
-      end
-
-      def datatables_inline_request?
-        return @_datatables_inline_request unless @_datatables_inline_request.nil?
-
-        @_datatables_inline_request = (view.present? && view.params[:_datatable_id].to_s.split('-')[0...-1] == to_param.split('-')[0...-1])
+        @_datatables_ajax_request =
+          (view && view.params[:draw] && view.params[:columns] && cookie_keys.include?(view.params[:cookie])) == true
       end
 
       def params
@@ -34,7 +29,7 @@ module Effective
 
       def search_params
         params.select do |name, value|
-          columns.key?(name) && ![:id, :action].include?(name) && !value.kind_of?(Hash) && value.class.name != 'ActionController::Parameters'.freeze
+          columns.key?(name) && (name != :id) && !value.kind_of?(Hash) && value.class.name != 'ActionController::Parameters'.freeze
         end
       end
     end

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

@@ -8,148 +8,108 @@ module Effective
       end
 
       def controller_namespace
-        @attributes[:namespace]
-      end
-
-      def association_macros
-        [:belongs_to, :belongs_to_polymorphic, :has_many, :has_and_belongs_to_many, :has_one]
+        @attributes[:_n]
       end
 
       private
 
-      def load_effective_resource!
-        @effective_resource = if active_record_collection?
-          Effective::Resource.new(collection_class, namespace: controller_namespace)
-        end
-      end
-
       # This looks at all the columns and figures out the as:
       def load_resource!
-        load_effective_resource!
+        @resource = Effective::Resource.new(collection_class, namespace: controller_namespace)
 
-        load_active_record_collection!
-        load_active_record_array_collection!
-        load_array_collection!
+        if active_record_collection?
+          columns.each do |name, opts|
 
-        load_resource_columns!
-        load_resource_belongs_tos!
-        load_resource_search!
-      end
+            # 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
 
-      def load_effective_resource!
-        @effective_resource = if active_record_collection?
-          Effective::Resource.new(collection_class, namespace: controller_namespace)
-        end
-      end
-
-      def load_active_record_collection!
-        return unless active_record_collection?
+              (associated, field) = name.split('.').first(2)
 
-        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 resource.macros.include?(resource.sql_type(associated))
+                raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{resource}'."
+              end
 
-            (associated, field) = name.split('.').first(2)
+              joins_values = (collection.joins_values + collection.left_outer_joins_values)
 
-            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
+              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
 
-            joins_values = (collection.joins_values + collection.left_outer_joins_values)
+              opts[:resource] = Effective::Resource.new(resource.associated(associated), namespace: controller_namespace)
 
-            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
+              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] = Effective::Resource.new(effective_resource.associated(associated), namespace: controller_namespace)
+                opts[:resource].sort_column = field
+                opts[:resource].search_columns = field
+              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?
+              opts[:resource_field] = field
 
-              opts[:resource].sort_column = field
-              opts[:resource].search_columns = field
+              next
             end
 
-            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?
+            # Regular fields
+            opts[:as] ||= resource.sql_type(name)
+            opts[:sql_column] = resource.sql_column(name) if opts[:sql_column].nil?
 
-          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
+            case opts[:as]
+            when *resource.macros
+              opts[:resource] ||= Effective::Resource.new(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?
+              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
+            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
-      end
-
-      def load_active_record_array_collection!
-        return unless active_record_array_collection?
-      end
-
-      def load_array_collection!
-        return unless array_collection?
 
-        row = collection.first
+        if 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)
+          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
+              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] ||= effective_resource
-          end
-
           if opts[:resource] && !opts[:resource_field] && opts[:as] != :effective_addresses
             opts[:partial] ||= '/effective/datatables/resource_column'
           end
 
-          opts[:col_class] = [
-            "col-#{opts[:as]}",
-            "col-#{name.to_s.parameterize}",
-            ('colvis-default' if opts[:visible]),
-            opts[:col_class].presence
-          ].compact.join(' ')
+          opts[:col_class] = "col-#{opts[:as]} col-#{name.to_s.parameterize} #{opts[:col_class]}".strip
         end
+
+        load_resource_search!
       end
 
       def load_resource_search!
@@ -161,7 +121,7 @@ module Effective
           when Symbol
             opts[:search] = { as: opts[:search] }
           when Array, ActiveRecord::Relation
-            opts[:search] = { as: :select, collection: opts[:search] }
+            opts[:search] = { collection: opts[:search] }
           when Hash
             # Nothing
           else
@@ -170,35 +130,31 @@ module Effective
 
           search = opts[:search]
 
-          # Parameterize collection
           if search[:collection].kind_of?(ActiveRecord::Relation)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
           elsif search[:collection].kind_of?(Array) && search[:collection].first.kind_of?(ActiveRecord::Base)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
+          elsif search[:collection].kind_of?(Array)
+            search[:collection].each { |obj| obj[1] = 'nil' if obj[1] == nil }
+          elsif search[:collection].kind_of?(Hash)
+            search[:collection].each { |k, v| search[:collection][k] = 'nil' if v == nil }
           end
 
-          search[:as] ||= :select if search.key?(:collection)
-          search[:fuzzy] ||= true unless search.key?(:fuzzy)
           search[:value] ||= search.delete(:selected) if search.key?(:selected)
 
-          # Merge with defaults
-          search_resource = [opts[:resource], effective_resource, fallback_effective_resource].compact
-          search_resource = search_resource.find { |res| res.klass.present? } || search_resource.first
+          search[:as] ||= :select if (search.key?(:collection) && opts[:as] != :belongs_to_polymorphic)
 
-          if array_collection? && opts[:resource].present?
-            search.reverse_merge!(search_resource.search_form_field(name, collection.first[opts[:index]]))
-          elsif search[:as] != :string
-            search.reverse_merge!(search_resource.search_form_field(name, opts[:as]))
-          end
+          search[:fuzzy] = true unless search.key?(:fuzzy)
 
-          # Assign default include_null
-          if search[:as] == :select && !search.key?(:include_null)
-            search[:include_null] = true
+          if array_collection? && opts[:resource].present?
+            search.reverse_merge!(resource.search_form_field(name, collection.first[opts[:index]]))
+          else
+            search.reverse_merge!(resource.search_form_field(name, opts[:as]))
           end
         end
       end
 
-      def load_resource_belongs_tos!
+      def apply_belongs_to_attributes!
         return unless active_record_collection?
 
         changed = attributes.select do |attribute, value|
@@ -206,27 +162,10 @@ module Effective
           next unless attribute.ends_with?('_id')
 
           associated = attribute.gsub(/_id\z/, '').to_sym  # Replace last _id
+          next unless columns[associated] && columns[associated][:as] == :belongs_to
 
-          next unless columns[associated]
-
-          if columns[associated][:as] == :belongs_to
-            if @_collection_apply_belongs_to && !@_collection.where_values_hash.include?(attribute)
-              @_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.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
-
+          @_collection = @_collection.where(attribute => value)
+          columns.delete(associated)
         end.present?
 
         load_columns! if changed