effective_datatables 3.6.3 → 3.7.0

data/app/models/effective/datatable.rb

@@ -15,6 +15,8 @@ module Effective
 
     # The collection itself. Only evaluated once.
     attr_accessor :_collection
+    attr_accessor :_collection_apply_belongs_to
+    attr_accessor :_collection_apply_scope
 
     # The view
     attr_reader :view
@@ -31,10 +33,10 @@ module Effective
     include Effective::EffectiveDatatable::Resource
     include Effective::EffectiveDatatable::State
 
-    def initialize(view = nil, attributes = {})
+    def initialize(view = nil, attributes = nil)
       (attributes = view; view = nil) if view.kind_of?(Hash)
 
-      @attributes = initial_attributes(attributes)
+      @attributes = (attributes || {})
       @state = initial_state
 
       @_aggregates = {}
@@ -45,6 +47,7 @@ module Effective
       @_form = {}
       @_scopes = {}
 
+      raise 'expected a hash of arguments' unless @attributes.kind_of?(Hash)
       raise 'collection is defined as a method. Please use the collection do ... end syntax.' unless collection.nil?
       self.view = view if view
     end
@@ -54,21 +57,23 @@ module Effective
       @view = (view.respond_to?(:view_context) ? view.view_context : view)
       raise 'expected view to respond to params' unless @view.respond_to?(:params)
 
-      load_cookie!
+      assert_attributes!
       load_attributes!
 
       # We need early access to filter and scope, to define defaults from the model first
-      # This means filters do knows about attributes but not about columns.
+      # This means filters do know about attributes but not about columns.
       initialize_filters if respond_to?(:initialize_filters)
       load_filters!
       load_state!
 
+      # Bulk actions called first so it can add the bulk_actions_col first
+      initialize_bulk_actions if respond_to?(:initialize_bulk_actions)
+
       # Now we initialize all the columns. columns knows about attributes and filters and scope
       initialize_datatable if respond_to?(:initialize_datatable)
       load_columns!
 
       # Execute any additional DSL methods
-      initialize_bulk_actions if respond_to?(:initialize_bulk_actions)
       initialize_charts if respond_to?(:initialize_charts)
 
       # Load the collection. This is the first time def collection is called on the Datatable itself
@@ -78,9 +83,10 @@ module Effective
       # Figure out the class, and if it's activerecord, do all the resource discovery on it
       load_resource!
 
-      # If attributes match a belongs_to column, scope the collection and remove the column
-      apply_belongs_to_attributes!
+      # Check everything is okay
+      validate_datatable!
 
+      # Save for next time
       save_cookie!
     end
 
@@ -117,11 +123,18 @@ module Effective
       )
     end
 
-    # When simple only a table will be rendered with
-    # no sorting, no filtering, no export buttons, no pagination, no per page, no colReorder
-    # default sorting only, default visibility only, all records returned, and responsive enabled
-    def simple?
-      attributes[:simple] == true
+    # Inline crud
+    def inline?
+      attributes[:inline] == true
+    end
+
+    # Reordering
+    def reorder?
+      columns.key?(:_reorder)
+    end
+
+    def sortable?
+      !reorder? && attributes[:sortable] != false
     end
 
     # Whether the filters must be rendered as a <form> or we can keep the normal <div> behaviour
@@ -129,12 +142,12 @@ module Effective
       _form[:verb].present?
     end
 
-    def table_html_class
-      attributes[:class] || EffectiveDatatables.html_class
+    def html_class
+      Array(attributes[:class] || EffectiveDatatables.html_class).join(' ').presence
     end
 
     def to_param
-      @to_param ||= "#{self.class.name.underscore.parameterize}-#{cookie_param}"
+      "#{self.class.name.underscore.parameterize}-#{[self.class, attributes].hash.abs.to_s.last(12)}"
     end
 
     def columns
@@ -150,7 +163,7 @@ module Effective
     end
 
     def resource
-      @effective_resource
+      raise('depecated. Please use .effective_resource instead')
     end
 
     def fallback_effective_resource
@@ -167,5 +180,12 @@ module Effective
       @value_tool ||= DatatableValueTool.new(self)
     end
 
+    def validate_datatable!
+      if reorder?
+        raise 'cannot use reorder with an Array collection' unless active_record_collection?
+        raise 'cannot use reorder with a non-Integer column' if effective_resource.sql_type(columns[:_reorder][:reorder]) != :integer
+      end
+    end
+
   end
 end

data/app/models/effective/datatable_column.rb

@@ -1,3 +1,4 @@
+# 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_value_tool.rb

@@ -74,13 +74,12 @@ module Effective
       collection
     end
 
-    def search_column(collection, value, column, index)
-      Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{value} #{index}" if EffectiveDatatables.debug
+    def search_column(collection, original, column, index)
+      Rails.logger.info "VALUE TOOL: search_column #{column.to_s} #{original} #{index}" if EffectiveDatatables.debug
 
-      macros = Effective::Resource.new('').macros
       fuzzy = column[:search][:fuzzy]
 
-      term = Effective::Attribute.new(column[:as]).parse(value, name: column[:name])
+      term = Effective::Attribute.new(column[:as]).parse(original, 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'
@@ -90,7 +89,8 @@ module Effective
 
       # See effective_resources gem search() method # relation.rb
       collection.select! do |row|
-        obj = obj_to_value(row[index], column, row)
+        obj = row[index]
+        value = obj_to_value(row[index], column, row)
 
         case column[:as]
         when :boolean
@@ -101,7 +101,7 @@ module Effective
           end
         when :datetime, :date
           end_at = (
-            case (value.to_s.scan(/(\d+)/).flatten).length
+            case (original.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
           )
-          obj >= term && obj <= end_at
+          value >= term && value <= end_at
         when :time
-          (obj.hour == term.hour) && (term.min == 0 ? true : (obj.min == term.min))
+          (value.hour == term.hour) && (term.min == 0 ? true : (value.min == term.min))
         when :decimal, :currency
-          if fuzzy && (term.round(0) == term) && value.to_s.include?('.') == false
+          if fuzzy && (term.round(0) == term) && original.to_s.include?('.') == false
             if term < 0
-              obj <= term && obj > (term - 1.0)
+              value <= term && value > (term - 1.0)
             else
-              obj >= term && obj < (term + 1.0)
+              value >= term && value < (term + 1.0)
             end
           else
-            obj == term
+            value == term
           end
         when :duration
-          if fuzzy && (term % 60 == 0) && value.to_s.include?('m') == false
+          if fuzzy && (term % 60 == 0) && original.to_s.include?('m') == false
             if term < 0
-              obj <= term && obj > (term - 60)
+              value <= term && value > (term - 60)
             else
-              obj >= term && obj < (term + 60)
+              value >= term && value < (term + 60)
             end
           else
-            obj == term
+            value == term
           end
-        when *macros, :resource
+        when *datatable.association_macros, :resource
           Array(obj).any? do |resource|
             Array(term).any? do |term|
               matched = false
 
-              if term.kind_of?(Integer) && resource.respond_to?(:to_param)
+              if term.kind_of?(Integer) && resource.respond_to?(:id) && 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
-            obj.to_s.downcase.include?(term_downcased)
+            value.to_s.downcase.include?(term_downcased)
           else
-            obj == term || (obj.to_s == term.to_s)
+            value == term || (value.to_s == term.to_s)
           end
         end
       end || collection

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

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

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

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

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

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

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

@@ -5,26 +5,16 @@ module Effective
         @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.abs.to_s.last(12) # Not guaranteed to be 12 long
-      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)
 
@@ -37,21 +27,33 @@ 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.max_cookie_size.to_i
+        while @dt_cookie.to_s.size > EffectiveDatatables.cookie_max_size.to_i
           @dt_cookie.shift((@dt_cookie.length / 3) + 1)
         end
 
-        view.cookies.signed['_effective_dt'] = Base64.encode64(Marshal.dump(@dt_cookie))
+        # 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
       end
 
       def cookie_payload
-        payload = state.except(:attributes, :visible)
+        payload = state.except(:visible)
 
         # Turn visible into a bitmask.  This is undone in load_columns!
         payload[:vismask] = (
@@ -60,8 +62,7 @@ module Effective
           end
         )
 
-        # Just store the values
-        [attributes.delete_if { |k, v| v.nil? }] + payload.values
+        payload.values # Just store the values
       end
 
     end

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

@@ -3,15 +3,20 @@ module Effective
     module Dsl
 
       def bulk_actions(&block)
-        define_method('initialize_bulk_actions') { dsl_tool.instance_exec(&block) }
+        define_method('initialize_bulk_actions') { dsl_tool.instance_exec(&block); dsl_tool.bulk_actions_col }
       end
 
       def charts(&block)
         define_method('initialize_charts') { dsl_tool.instance_exec(&block) }
       end
 
-      def collection(&block)
-        define_method('initialize_collection') { self._collection = dsl_tool.instance_exec(&block) }
+      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) 
+        }
       end
 
       def datatable(&block)