effective_datatables 3.7.10 → 4.0.0

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

@@ -14,14 +14,11 @@ module Effective
         @total_records = (active_record_collection? ? column_tool.size(col) : value_tool.size(col))
 
         # Apply scope
-        col = column_tool.scope(col) if @_collection_apply_scope
+        col = column_tool.scope(col)
 
         # Apply column searching
         col = column_tool.search(col)
-
-        unless value_tool.searched.present? || (column_tool.scoped.blank? && column_tool.searched.blank?)
-          @display_records = column_tool.size(col)
-        end
+        @display_records = column_tool.size(col) unless value_tool.searched.present?
 
         # Apply column ordering
         col = column_tool.order(col)
@@ -64,15 +61,11 @@ module Effective
             if state[:visible][name] == false && (name != order_name)  # Sort by invisible array column
               BLANK
             elsif 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
+              dsl_tool.instance_exec(obj, (active_record_collection? ? collection : obj[opts[:index]]), &opts[:compute])
             elsif (opts[:partial] || opts[:format])
-              array_collection? ? obj[opts[:index]] : obj
+              active_record_collection? ? obj : obj[opts[:index]]
             elsif opts[:resource]
-              resource = array_collection? ? obj[opts[:index]] : obj
+              resource = active_record_collection? ? obj : obj[opts[:index]]
 
               if opts[:resource_field]
                 (associated, field) = name.to_s.split('.').first(2)
@@ -82,8 +75,6 @@ module Effective
                 resource.send(name)
               end
 
-            elsif opts[:as] == :actions
-              obj
             elsif opts[:as] == :effective_obfuscation
               obj.to_param
             elsif array_collection?
@@ -135,11 +126,9 @@ module Effective
         length = values.length
         values = values.reject { |value| value.nil? }
 
-        return BLANK if [:id, :year].include?(column[:name])
-
         case aggregate[:name]
         when :total
-          if [:percent].include?(column[:as])
+          if [:percentage].include?(column[:as])
             BLANK
           elsif values.all? { |value| value.kind_of?(Numeric) }
             values.sum

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

@@ -1,20 +1,32 @@
 module Effective
   module EffectiveDatatable
     module Cookie
+      MAX_COOKIE_SIZE = 2500  # String size. Real byte size is about 1.5 times bigger.
+
       def cookie
         @cookie
       end
 
+      def cookie_key
+        @cookie_key ||= (datatables_ajax_request? ? view.params[:cookie] : cookie_param)
+      end
+
+      # All possible dt cookie keys.  Used to make sure the datatable has a cookie set for this session.
+      def cookie_keys
+        @cookie_keys ||= Array(@dt_cookie).compact.map(&:first)
+      end
+
+      def cookie_param
+        [self.class, attributes].hash.to_s.last(12)
+      end
+
       private
 
       def load_cookie!
-        return unless EffectiveDatatables.save_state
-
         @dt_cookie = view.cookies.signed['_effective_dt']
 
         # Load global datatables cookie
         if @dt_cookie.present?
-
           @dt_cookie = Marshal.load(Base64.decode64(@dt_cookie))
           raise 'invalid datatables cookie' unless @dt_cookie.kind_of?(Array)
 
@@ -27,33 +39,21 @@ module Effective
         if @cookie.kind_of?(Array)
           @cookie = initial_state.keys.zip(@cookie.second).to_h
         end
-
       end
 
       def save_cookie!
-        return unless EffectiveDatatables.save_state
-
         @dt_cookie ||= []
         @dt_cookie << [cookie_key, cookie_payload]
 
-        while @dt_cookie.to_s.size > EffectiveDatatables.cookie_max_size.to_i
+        while @dt_cookie.to_s.size > MAX_COOKIE_SIZE
           @dt_cookie.shift((@dt_cookie.length / 3) + 1)
         end
 
-        # Generate cookie
-        domain = EffectiveDatatables.cookie_domain || :all
-        tld_length = EffectiveDatatables.cookie_tld_length
-        tld_length ||= (view.request.host == 'localhost' ? nil : view.request.host.to_s.split('.').count)
-
-        view.cookies.signed['_effective_dt'] = { value: Base64.encode64(Marshal.dump(@dt_cookie)), domain: domain, tld_length: tld_length }.compact
-      end
-
-      def cookie_key
-        @cookie_key ||= to_param
+        view.cookies.signed['_effective_dt'] = Base64.encode64(Marshal.dump(@dt_cookie))
       end
 
       def cookie_payload
-        payload = state.except(:visible)
+        payload = state.except(:attributes, :visible)
 
         # Turn visible into a bitmask.  This is undone in load_columns!
         payload[:vismask] = (
@@ -62,7 +62,8 @@ module Effective
           end
         )
 
-        payload.values # Just store the values
+        # Just store the values
+        [attributes.delete_if { |k, v| v.nil? }] + payload.values
       end
 
     end

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

@@ -3,12 +3,12 @@ module Effective
     module Dsl
       module BulkActions
 
-        def bulk_action(title, url, opts = {})
-          datatable._bulk_actions.push(link_to_bulk_action(title, url, opts))
+        def bulk_action(*args)
+          datatable._bulk_actions.push(link_to_bulk_action(*args))
         end
 
-        def bulk_download(title, url, opts = {})
-          datatable._bulk_actions.push(link_to_bulk_action(title, url, opts.merge('data-bulk-download': true)))
+        def bulk_download(*args)
+          datatable._bulk_actions.push(link_to_bulk_action(*args.merge('data-authenticity-token' => form_authenticity_token)))
         end
 
         def bulk_action_divider
@@ -22,19 +22,30 @@ module Effective
         private
 
         # We can't let any data-method be applied to the link, or jquery_ujs does the wrong thing with it
-        def link_to_bulk_action(title, url, opts = {})
-
-          # Transform data: { ... } hash into 'data-' keys
-          if (data = opts.delete(:data))
-            data.each { |k, v| opts["data-#{k}"] ||= v }
+        def link_to_bulk_action(*args)
+          args.map! do |arg|
+            if arg.kind_of?(Hash)
+              data_method = (
+                arg.delete(:'data-method') ||
+                arg.delete('data-method') ||
+                (arg[:data] || {}).delete('method') ||
+                (arg[:data] || {}).delete(:method)
+              )
+
+              # But if the data-method was :get, we add bulk-actions-get-link = true
+              if data_method.to_s == 'get'
+                arg[:data].present? ? arg[:data]['bulk-actions-get'] = true : arg['data-bulk-actions-get'] = true
+              end
+
+              arg[:class] = [arg[:class], 'dropdown-item'].compact.join(' ')
+            end
+
+            arg
           end
 
-          verbs = {'DELETE' => 'DELETE', 'GET' => 'GET'}
-          opts['data-ajax-method'] = verbs[opts.delete('data-method').to_s.upcase] || 'POST'
-
-          opts[:class] = [opts[:class], 'dropdown-item'].compact.join(' ')
+          args << { class: 'dropdown-item' } if args.none? { |arg| arg.kind_of?(Hash) }
 
-          content_tag(:li, link_to(title, url, opts))
+          link_to(*args)
         end
 
       end

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

@@ -3,11 +3,6 @@ module Effective
     module Dsl
       module Datatable
         # Instance Methods inside the datatable do .. end block
-        def length(length)
-          raise 'length must be 5, 10, 25, 50, 100, 250, 500, :all' unless [5, 10, 25, 50, 100, 250, 500, :all].include?(length)
-          datatable.state[:length] ||= (length == :all ? 9999999 : length)
-        end
-
         def order(name, dir = nil)
           raise 'order direction must be :asc or :desc' unless [nil, :asc, :desc].include?(dir)
 
@@ -15,13 +10,9 @@ module Effective
           datatable.state[:order_dir] ||= dir
         end
 
-        def reorder(name, dir = nil)
-          raise 'order direction must be :asc or :desc' unless [nil, :asc, :desc].include?(dir)
-
-          datatable.state[:order_name] = :_reorder
-          datatable.state[:order_dir] = dir
-
-          reorder_col(name)
+        def length(length)
+          raise 'length must be 5, 10, 25, 50, 100, 250, 500, :all' unless [5, 10, 25, 50, 100, 250, 500, :all].include?(length)
+          datatable.state[:length] ||= (length == :all ? 9999999 : length)
         end
 
         # A col has its internal values sorted/searched before the block is run
@@ -34,7 +25,7 @@ module Effective
           name = name.to_sym unless name.to_s.include?('.')
 
           datatable._columns[name] = Effective::DatatableColumn.new(
-            action: action,
+            action: action,  # resource columns only
             as: as,
             compute: nil,
             col_class: col_class,
@@ -62,7 +53,7 @@ module Effective
           name = name.to_sym unless name.to_s.include?('.')
 
           datatable._columns[name] = Effective::DatatableColumn.new(
-            action: action,
+            action: action, # Resource columns only
             as: as,
             compute: (compute if block_given?),
             col_class: col_class,
@@ -82,48 +73,8 @@ module Effective
           )
         end
 
-        def actions_col(btn_class: nil, col_class: nil, inline: nil, partial: nil, partial_as: nil, actions_partial: nil, responsive: 5000, visible: true, **actions, &format)
-          raise 'You can only have one actions column' if datatable.columns[:_actions].present?
-
-          datatable._columns[:_actions] = Effective::DatatableColumn.new(
-            action: false,
-            as: :actions,
-            compute: nil,
-            btn_class: (btn_class || 'btn-sm btn-outline-primary'),
-            col_class: col_class,
-            format: (format if block_given?),
-            index: nil,
-            inline: (inline.nil? ? datatable.inline? : inline),
-            label: false,
-            name: :actions,
-            partial: partial,
-            partial_as: partial_as,
-            actions_partial: (actions_partial || :glyphicons),
-            responsive: responsive,
-            search: false,
-            sort: false,
-            sql_column: nil,
-            th: nil,
-            th_append: nil,
-            visible: visible,
-
-            # { approve: false }. These args are passed to effective_resources render_resource_actions
-            actions: actions
-          )
-        end
-
-        def aggregate(name, label: nil, &compute)
-          datatable._aggregates[name.to_sym] = {
-            compute: (compute if block_given?),
-            label: label || name.to_s.titleize,
-            name: name.to_sym,
-          }
-        end
-
-        # Called automatically after bulk_actions do ... end
-        # Call again if you want to change the position of the bulk_actions_col
-        def bulk_actions_col(col_class: nil, input_name: nil, partial: nil, partial_as: nil, responsive: 5000)
-          datatable._columns.delete(:_bulk_actions) if datatable.columns[:_bulk_actions]
+        def bulk_actions_col(col_class: nil, partial: nil, partial_as: nil, responsive: 5000)
+          raise 'You can only have one bulk actions column' if datatable.columns[:_bulk_actions].present?
 
           datatable._columns[:_bulk_actions] = Effective::DatatableColumn.new(
             action: false,
@@ -132,7 +83,6 @@ module Effective
             col_class: col_class,
             format: nil,
             index: nil,
-            input_name: (input_name || 'bulk_actions_resources'),
             label: false,
             name: :bulk_actions,
             partial: partial || '/effective/datatables/bulk_actions_column',
@@ -147,33 +97,41 @@ module Effective
           )
         end
 
-        # Called automatically after reorder
-        # Call again if you want to change the position of the reorder_col
-        def reorder_col(name, col_class: nil, partial: nil, partial_as: nil, sql_column: nil, responsive: 5000)
-          datatable._columns.delete(:_reorder) if datatable.columns[:_reorder]
+        def actions_col(show: true, edit: true, destroy: true, col_class: nil, partial: nil, partial_as: nil, responsive: 5000, visible: true, &format)
+          raise 'You can only have one actions column' if datatable.columns[:_actions].present?
 
-          datatable._columns[:_reorder] = Effective::DatatableColumn.new(
+          datatable._columns[:_actions] = Effective::DatatableColumn.new(
             action: false,
-            as: :reorder,
+            as: :actions,
             compute: nil,
             col_class: col_class,
-            format: nil,
+            format: (format if block_given?),
             index: nil,
             label: false,
-            name: :reorder,
-            partial: partial || '/effective/datatables/reorder_column',
+            name: :actions,
+            partial: partial || '/effective/datatables/actions_column',
             partial_as: partial_as,
-            reorder: name,
             responsive: responsive,
             search: false,
-            sort: true,
-            sql_column: (sql_column || name),
+            sort: false,
+            sql_column: nil,
             th: nil,
             th_append: nil,
-            visible: false
+            visible: visible,
+
+            show: show,
+            edit: edit,
+            destroy: destroy
           )
         end
 
+        def aggregate(name, label: nil, &compute)
+          datatable._aggregates[name.to_sym] = {
+            compute: (compute if block_given?),
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+          }
+        end
       end
     end
   end

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/dsl.rb

@@ -3,20 +3,15 @@ module Effective
     module Dsl
 
       def bulk_actions(&block)
-        define_method('initialize_bulk_actions') { dsl_tool.instance_exec(&block); dsl_tool.bulk_actions_col }
+        define_method('initialize_bulk_actions') { dsl_tool.instance_exec(&block) }
       end
 
       def charts(&block)
         define_method('initialize_charts') { dsl_tool.instance_exec(&block) }
       end
 
-      def collection(apply_belongs_to: true, apply_scope: true, &block)
-        define_method('initialize_collection') { 
-          self._collection_apply_belongs_to = apply_belongs_to
-          self._collection_apply_scope = apply_scope
-          
-          self._collection = dsl_tool.instance_exec(&block) 
-        }
+      def collection(&block)
+        define_method('initialize_collection') { self._collection = dsl_tool.instance_exec(&block) }
       end
 
       def datatable(&block)

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