effective_datatables 4.7.16 → 4.15.1

data/app/models/effective/datatable_dsl_tool.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
 
   class DatatableDslTool
@@ -16,7 +18,7 @@ module Effective
       @view = datatable.view
     end
 
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, **kwargs, &block)
       # Catch a common error
       if [:bulk_actions, :charts, :collection, :filters].include?(method) && in_datatables_do_block
         raise "#{method} block must be declared outside the datatable do ... end block"
@@ -24,15 +26,15 @@ module Effective
 
       if datatable.respond_to?(method)
         if block_given?
-          datatable.send(method, *args) { yield }
+          datatable.send(method, *args, **kwargs) { yield }
         else
-          datatable.send(method, *args)
+          datatable.send(method, *args, **kwargs)
         end
       elsif view.respond_to?(method)
         if block_given?
-          view.send(method, *args) { yield }
+          view.send(method, *args, **kwargs) { yield }
         else
-          view.send(method, *args)
+          view.send(method, *args, **kwargs)
         end
       else
         super

data/app/models/effective/datatable_value_tool.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   # The collection is an Array of Arrays
   class DatatableValueTool
@@ -77,7 +79,7 @@ module Effective
     def search_column(collection, original, column, index)
       Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{original} #{index}" if EffectiveDatatables.debug
 
-      fuzzy = column[:search][:fuzzy]
+      fuzzy = (column[:search][:operation] == :matches)
 
       term = Effective::Attribute.new(column[:as]).parse(original, name: column[:name])
       term_downcased = term.to_s.downcase
@@ -91,8 +93,11 @@ module Effective
       collection.select! do |row|
         obj = row[index]
         value = obj_to_value(row[index], column, row)
+        next if value.nil? || value == ''
+
+        obj_equals = obj.respond_to?(column[:name]) && obj.send(column[:name]).to_s.downcase == term_downcased
 
-        case column[:as]
+        obj_equals || case column[:as]
         when :boolean
           if fuzzy
             term ? (obj == true) : (obj != true)
@@ -174,6 +179,8 @@ module Effective
 
       if column[:format]
         datatable.dsl_tool.instance_exec(obj, row, &column[:format])
+      elsif column[:as] == :belongs_to_polymorphic
+        obj.send(column[:name]).to_s
       elsif column[:partial]
         obj.to_s
       elsif obj.respond_to?(column[:name])
@@ -187,9 +194,3 @@ module Effective
 
   end
 end
-
-# [
-#   [1, 'title 1'],
-#   [2, 'title 2'],
-#   [3, 'title 3']
-# ]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Attributes
@@ -11,9 +13,28 @@ module Effective
       end
 
       def load_attributes!
+        return unless view.respond_to?(:controller_path)
         @attributes[:namespace] ||= view.controller_path.split('/')[0...-1].join('/')
       end
 
+      # Polymorphic shorthand attributes.
+      # If you pass resource: User(1), it sets resource_id: 1, resource_type: 'User'
+      def initial_attributes(attributes)
+        return {} if attributes.blank?
+
+        resources = attributes.select { |k, v| v.kind_of?(ActiveRecord::Base) }
+        return attributes if resources.blank?
+
+        retval = attributes.except(*resources.keys)
+
+        resources.each do |k, resource|
+          retval["#{k}_id".to_sym] = resource.id
+          retval["#{k}_type".to_sym] = resource.class.name
+        end
+
+        retval
+      end
+
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Collection
@@ -34,7 +36,7 @@ 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)
         @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))

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Compute
@@ -36,6 +38,9 @@ module Effective
         # Apply value ordering
         col = value_tool.order(col)
 
+        # Charts too
+        @charts_data = chart(collection, col) if _charts.present?
+
         # Apply pagination
         col = col.kind_of?(Array) ? value_tool.paginate(col) : column_tool.paginate(col)
 
@@ -48,9 +53,6 @@ module Effective
         # Compute aggregate data
         @aggregates_data = aggregate(col) if _aggregates.present?
 
-        # Charts too
-        @charts_data = chart(col) if _charts.present?
-
         # Format all results
         format(col)
 
@@ -58,10 +60,12 @@ module Effective
         finalize(col)
       end
 
-      def arrayize(collection)
+      def arrayize(collection, csv: false)
         collection.map do |obj|
           columns.map do |name, opts|
-            if state[:visible][name] == false && (name != order_name)  # Sort by invisible array column
+            if state[:visible][name] == false && !csv && (name != order_name)  # Sort by invisible array column
+              BLANK
+            elsif csv && !opts[:csv]
               BLANK
             elsif opts[:compute]
               if array_collection?
@@ -161,11 +165,11 @@ module Effective
         end || BLANK
       end
 
-      def chart(collection)
+      def chart(collection, searched_collection)
         _charts.inject({}) do |retval, (name, chart)|
           retval[name] = {
             as: chart[:as],
-            data: dsl_tool.instance_exec(collection, &chart[:compute]),
+            data: dsl_tool.instance_exec(collection, searched_collection, &chart[:compute]),
             name: chart[:name],
             options: chart[:options]
           }

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Cookie
@@ -10,6 +12,8 @@ module Effective
 
       def load_cookie!
         return unless EffectiveDatatables.save_state
+        return if skip_save_state?
+        return unless (view.cookies rescue false) # Rails 6.1 view doesn't respond_to?(:cookies)
 
         @dt_cookie = view.cookies.signed['_effective_dt']
 
@@ -33,6 +37,8 @@ module Effective
 
       def save_cookie!
         return unless EffectiveDatatables.save_state
+        return if skip_save_state?
+        return unless (view.cookies rescue false)
 
         @dt_cookie ||= []
         @dt_cookie << [cookie_key, cookie_payload]

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Effective
+  module EffectiveDatatable
+    module Csv
+
+      def csv_filename
+        self.class.name.underscore.parameterize + '.csv'
+      end
+
+      def csv_content_type
+        'text/csv; charset=utf-8'
+      end
+
+      def csv_header
+        columns.map do |name, opts|
+          opts[:label].presence || csv_human_attribute_name(name)
+        end
+      end
+
+      def csv_human_attribute_name(name)
+        if active_record_collection?
+          collection_class.human_attribute_name(name)
+        else
+          (name.to_s.split('.').last || '')
+        end
+      end
+
+      def csv_file
+        CSV.generate do |csv|
+          csv << csv_header()
+
+          collection.find_in_batches do |resources|
+            resources = arrayize(resources, csv: true)
+            format(resources, csv: true)
+            finalize(resources)
+
+            resources.each { |resource| csv << resource }
+          end
+        end
+      end
+
+      def csv_stream
+        EffectiveResources.with_resource_enumerator do |lines|
+          lines << CSV.generate_line(csv_header)
+
+          if active_record_collection?
+            collection.find_in_batches do |resources|
+              resources = arrayize(resources, csv: true)
+              format(resources, csv: true)
+              finalize(resources)
+
+              resources.each { |resource| lines << CSV.generate_line(resource) }
+            end
+          else
+            resources = collection
+
+            format(resources, csv: true)
+            finalize(resources)
+
+            resources.each { |resource| lines << CSV.generate_line(resource) }
+          end
+
+        end
+      end
+
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Dsl
@@ -34,7 +36,7 @@ module Effective
 
           opts[:class] = [opts[:class], 'dropdown-item'].compact.join(' ')
 
-          link_to(title, url, opts)
+          link_to(title, url, **opts)
         end
 
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Dsl

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Dsl
@@ -24,11 +26,19 @@ module Effective
           reorder_col(name)
         end
 
+        def download(bool)
+          datatable.attributes[:downloadable] = bool
+        end
+
+        def skip_save_state!
+          datatable.attributes[:skip_save_state] = true
+        end
+
         # A col has its internal values sorted/searched before the block is run
         # Anything done in the block, is purely a format on the after sorted/ordered value
         # the original object == the computed value, which is yielded to the format block
         # You can't do compute with .col
-        def col(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: nil, th: nil, th_append: nil, visible: true, &format)
+        def col(name, action: nil, as: nil, col_class: nil, csv: true, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: nil, th: nil, th_append: nil, visible: true, &format)
           raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
           name = name.to_sym unless name.to_s.include?('.')
@@ -38,9 +48,10 @@ module Effective
             as: as,
             compute: nil,
             col_class: col_class,
+            csv: csv,
             format: (format if block_given?),
             index: nil,
-            label: (label.nil? ? name.to_s.split('.').last.titleize : label),
+            label: label,
             name: name,
             partial: partial,
             partial_as: partial_as,
@@ -56,7 +67,7 @@ module Effective
 
         # A val is a computed value that is then sorted/searched after the block is run
         # You can have another block by calling .format afterwards to work on the computed value itself
-        def val(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: false, th: nil, th_append: nil, visible: true, &compute)
+        def val(name, action: nil, as: nil, col_class: nil, csv: true, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: false, th: nil, th_append: nil, visible: true, &compute)
           raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
           name = name.to_sym unless name.to_s.include?('.')
@@ -66,9 +77,10 @@ module Effective
             as: as,
             compute: (compute if block_given?),
             col_class: col_class,
+            csv: csv,
             format: nil,
             index: nil,
-            label: (label.nil? ? name.to_s.split('.').last.titleize : label),
+            label: label,
             name: name,
             partial: partial,
             partial_as: partial_as,
@@ -82,7 +94,7 @@ 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)
+        def actions_col(btn_class: nil, col_class: 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(
@@ -91,9 +103,9 @@ module Effective
             compute: nil,
             btn_class: (btn_class || 'btn-sm btn-outline-primary'),
             col_class: col_class,
+            csv: false,
             format: (format if block_given?),
             index: nil,
-            inline: (inline.nil? ? datatable.inline? : inline),
             label: false,
             name: :actions,
             partial: partial,
@@ -130,6 +142,7 @@ module Effective
             as: :bulk_actions,
             compute: nil,
             col_class: col_class,
+            csv: false,
             format: nil,
             index: nil,
             input_name: (input_name || 'bulk_actions_resources'),
@@ -157,6 +170,7 @@ module Effective
             as: :reorder,
             compute: nil,
             col_class: col_class,
+            csv: false,
             format: nil,
             index: nil,
             label: false,

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Dsl
@@ -20,7 +22,7 @@ module Effective
             elsif value != nil
               Effective::Attribute.new(value).type
             end
-          ) || :text
+          ) || :string
 
           datatable._filters[name.to_sym] = {
             value: value,

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Dsl
@@ -11,11 +13,11 @@ module Effective
       end
 
       def collection(apply_belongs_to: true, apply_scope: true, &block)
-        define_method('initialize_collection') { 
+        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) 
+
+          self._collection = dsl_tool.instance_exec(&block)
         }
       end
 
@@ -24,6 +26,8 @@ module Effective
           dsl_tool.in_datatables_do_block = true
           dsl_tool.instance_exec(&block)
           dsl_tool.in_datatables_do_block = false
+
+          self.source_location = block.source_location.first if block.respond_to?(:source_location)
         end
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Format
@@ -8,15 +10,17 @@ module Effective
 
       private
 
-      def format(collection)
+      def format(collection, csv: false)
         # We want to use the render :collection for each column that renders partials
         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 state[:visible][name] == false && !csv
+            # Nothing to do
+          elsif csv && !opts[:csv]
+            # Nothing to do
+          elsif opts[:partial]
+            locals = { datatable: self, column: opts }.merge!(resource_col_locals(opts))
 
             rendered[name] = (view.render(
               partial: opts[:partial],
@@ -26,8 +30,8 @@ module Effective
               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 = {
@@ -36,15 +40,15 @@ module Effective
               effective_resource: effective_resource,
               locals: locals,
               partial: opts[:actions_partial],
-            }.compact.merge(opts[:actions])
+            }.merge!(opts[:actions]).tap(&:compact!)
 
             rendered[name] = if effective_resource.blank?
-              resources.map do |resource|
+              collection.map { |row| row[opts[:index]] }.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)
+              (view.render_resource_actions(collection.map { |row| row[opts[:index]] }, atts, &opts[:format]) || '').split(SPACER)
             end
           end
         end
@@ -54,32 +58,52 @@ module Effective
             index = opts[:index]
             value = row[index]
 
-            row[index] = (
-              if state[:visible][name] == false
+            formatted = (
+              if state[:visible][name] == false && !csv
                 NONVISIBLE
+              elsif csv && !opts[:csv]
+                BLANK
               elsif opts[:as] == :actions
                 rendered[name][row_index]
               elsif 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])
+                dsl_tool.instance_exec(value, row, &opts[:format]).to_s
               elsif opts[:partial]
                 rendered[name][row_index]
               else
-                format_column(value, opts)
+                format_column(value, opts, csv: csv)
               end
             )
+
+            if csv && (opts[:format] || opts[:partial])
+              formatted = view.strip_tags(formatted)
+
+              formatted.gsub!("\n\n", ' ') unless formatted.frozen?
+              formatted.gsub!("\n", '')  unless formatted.frozen?
+            end
+
+            row[index] = formatted
           end
         end
       end
 
-      def format_column(value, column)
+      # Must return a string
+      def format_column(value, column, csv: false)
         return if value.nil? || (column[:resource] && value.blank?)
 
         unless column[:as] == :email
           return value if value.kind_of?(String)
         end
 
+        if value.kind_of?(Array) && column[:as] == :string
+          if csv
+            return value.map { |v| format_column(v, column, csv: csv) }.join("\n")
+          else
+            return value.map { |v| view.content_tag(:div, format_column(v, column, csv: csv), class: 'col-resource_item') }.join.html_safe
+          end
+        end
+
         case column[:as]
         when :actions
           raise("please use actions_col instead of col(#{name}, as: :actions)")
@@ -88,23 +112,27 @@ module Effective
         when :currency
           view.number_to_currency(value)
         when :date
-          (value.strftime('%F') rescue BLANK)
+          value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_date) : BLANK
         when :datetime
-          (value.strftime('%F %H:%M') rescue BLANK)
+          if csv
+            value.to_s
+          else
+            value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_datetime) : BLANK
+          end
         when :decimal
-          value
+          value.to_s
         when :duration
           view.number_to_duration(value)
         when :effective_addresses
-          value.to_html
+          csv ? value.to_html.gsub('<br>', "\n") : value.to_html
         when :effective_obfuscation
-          value
+          value.to_s
         when :effective_roles
           value.join(', ')
         when :email
-          view.mail_to(value)
+          csv ? value : view.mail_to(value)
         when :integer
-          value
+          value.to_s
         when :percent
           case value
           when Integer    ; view.number_to_percentage(value / 1000.0, precision: 3).gsub('.000%', '%')
@@ -116,7 +144,7 @@ module Effective
           when Numeric    ; view.number_to_currency(value)
           end
         when :time
-          (value.strftime('%H:%M') rescue BLANK)
+          value.respond_to?(:strftime) ? value.strftime(EffectiveDatatables.format_time) : BLANK
         else
           value.to_s
         end
@@ -128,14 +156,14 @@ module Effective
       def actions_col_actions(column)
         resource_actions = (effective_resource&.resource_actions || fallback_effective_resource.fallback_resource_actions)
 
-        actions = if column[:inline]
+        actions = if 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)
+        if column[:actions].present? && column[:actions].kind_of?(Hash)
           column[:actions].each do |action, opts|
             next unless opts.kind_of?(Hash)
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Hooks

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Effective
   module EffectiveDatatable
     module Params
@@ -6,18 +8,23 @@ module Effective
 
       def datatables_ajax_request?
         return @_datatables_ajax_request unless @_datatables_ajax_request.nil?
+        return unless view.respond_to?(:params)
 
-        @_datatables_ajax_request = (view.present? && view.params.key?(:draw) && view.params.key?(:columns))
+        @_datatables_ajax_request = (view.params.key?(:draw) && view.params.key?(:columns))
       end
 
       def datatables_inline_request?
         return @_datatables_inline_request unless @_datatables_inline_request.nil?
+        return unless view.respond_to?(:params)
 
-        @_datatables_inline_request = (view.present? && view.params[:_datatable_id].to_s.split('-')[0...-1] == to_param.split('-')[0...-1])
+        @_datatables_inline_request = (view.params[:_datatable_id].to_s.split('-')[0...-1] == to_param.split('-')[0...-1])
       end
 
       def params
         return {} unless view.present?
+        return view.rendered_params if view.respond_to?(:rendered_params)
+        return {} unless view.respond_to?(:request)
+
         @params ||= {}.tap do |params|
           Rack::Utils.parse_query(URI(view.request.referer.presence || '/').query).each { |k, v| params[k.to_sym] = v }
           view.params.each { |k, v| params[k.to_sym] = v }