effective_datatables 3.7.7 → 4.0.0

data/app/models/effective/datatable_column.rb

@@ -1,4 +1,3 @@
-# In practice this is just a regular hash with the aggregate, format, search, sort do syntax that saves a block
 module Effective
   class DatatableColumn
     attr_accessor :attributes

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.effective_resource.sql_direction(direction)}")
+        collection.order("#{sql_column} #{datatable.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_dsl_tool.rb

@@ -16,24 +16,16 @@ module Effective
       @view = datatable.view
     end
 
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args)
       # 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"
       end
 
       if datatable.respond_to?(method)
-        if block_given?
-          datatable.send(method, *args) { yield }
-        else
-          datatable.send(method, *args)
-        end
+        datatable.send(method, *args)
       elsif view.respond_to?(method)
-        if block_given?
-          view.send(method, *args) { yield }
-        else
-          view.send(method, *args)
-        end
+        view.send(method, *args)
       else
         super
       end

data/app/models/effective/datatable_value_tool.rb

@@ -74,12 +74,13 @@ module Effective
       collection
     end
 
-    def search_column(collection, original, column, index)
-      Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{original} #{index}" if EffectiveDatatables.debug
+    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(original, name: column[:name])
+      term = Effective::Attribute.new(column[:as]).parse(value, name: column[:name])
       term_downcased = term.to_s.downcase
 
       # term == 'nil' rescue false is a Rails 4.1 fix, where you can't compare a TimeWithZone to 'nil'
@@ -89,19 +90,18 @@ module Effective
 
       # See effective_resources gem search() method # relation.rb
       collection.select! do |row|
-        obj = row[index]
-        value = obj_to_value(row[index], column, row)
+        obj = obj_to_value(row[index], column, row)
 
         case column[:as]
         when :boolean
-          if term
-            ['Yes', 'yes', true, 'true', '1'].include?(value)
+          if fuzzy
+            term ? (obj == true) : (obj != true)
           else
-            ['No', 'no', false, 'false', '0'].include?(value)
+            obj == term
           end
         when :datetime, :date
           end_at = (
-            case (original.to_s.scan(/(\d+)/).flatten).length
+            case (value.to_s.scan(/(\d+)/).flatten).length
             when 1 ; term.end_of_year     # Year
             when 2 ; term.end_of_month    # Year-Month
             when 3 ; term.end_of_day      # Year-Month-Day
@@ -111,35 +111,35 @@ module Effective
             else term
             end
           )
-          value >= term && value <= end_at
+          obj >= term && obj <= end_at
         when :time
-          (value.hour == term.hour) && (term.min == 0 ? true : (value.min == term.min))
+          (obj.hour == term.hour) && (term.min == 0 ? true : (obj.min == term.min))
         when :decimal, :currency
-          if fuzzy && (term.round(0) == term) && original.to_s.include?('.') == false
+          if fuzzy && (term.round(0) == term) && value.to_s.include?('.') == false
             if term < 0
-              value <= term && value > (term - 1.0)
+              obj <= term && obj > (term - 1.0)
             else
-              value >= term && value < (term + 1.0)
+              obj >= term && obj < (term + 1.0)
             end
           else
-            value == term
+            obj == term
           end
         when :duration
-          if fuzzy && (term % 60 == 0) && original.to_s.include?('m') == false
+          if fuzzy && (term % 60 == 0) && value.to_s.include?('m') == false
             if term < 0
-              value <= term && value > (term - 60)
+              obj <= term && obj > (term - 60)
             else
-              value >= term && value < (term + 60)
+              obj >= term && obj < (term + 60)
             end
           else
-            value == term
+            obj == term
           end
-        when *datatable.association_macros, :resource
+        when *macros, :resource
           Array(obj).any? do |resource|
             Array(term).any? do |term|
               matched = false
 
-              if term.kind_of?(Integer) && resource.respond_to?(:id) && resource.respond_to?(:to_param)
+              if term.kind_of?(Integer) && resource.respond_to?(:to_param)
                 matched = (resource.id == term || resource.to_param == term)
               end
 
@@ -148,9 +148,9 @@ module Effective
           end
         else  # :string, :text, :email
           if fuzzy
-            value.to_s.downcase.include?(term_downcased)
+            obj.to_s.downcase.include?(term_downcased)
           else
-            value == term || (value.to_s == term.to_s)
+            obj == term || (obj.to_s == term.to_s)
           end
         end
       end || collection

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

@@ -4,14 +4,22 @@ module Effective
 
       private
 
-      def assert_attributes!
-        if datatables_ajax_request? || datatables_inline_request?
-          raise 'expected attributes to be present' unless attributes.present?
-        end
+      def initial_attributes(args)
+        raise "#{self.class.name}.new() expected Hash like arguments" unless args.kind_of?(Hash)
+        args
       end
 
       def load_attributes!
-        @attributes[:namespace] ||= view.controller_path.split('/')[0...-1].join('/')
+        if datatables_ajax_request?
+          raise 'expected cookie to be present' unless cookie
+          raise 'expected attributes cookie to be present' unless cookie[:attributes]
+
+          @attributes = cookie.delete(:attributes)
+        end
+
+        unless datatables_ajax_request?
+          @attributes[:_n] ||= view.controller_path.split('/')[0...-1].join('/').presence
+        end
       end
 
     end

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

@@ -7,23 +7,10 @@ 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
@@ -34,13 +21,11 @@ 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))
+        @array_collection = (collection.kind_of?(Array) && (collection.length == 0 || collection.first.kind_of?(Array)))
 
-        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']]"
+        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']]"
         end
 
         _scopes.each do |scope, _|

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