effective_datatables 3.7.10 → 4.0.0

data/app/helpers/effective_datatables_private_helper.rb

@@ -1,21 +1,18 @@
 # These aren't expected to be called by a developer. They are internal methods.
-# These aren't expected to be called by a developer. They are internal methods.
 module EffectiveDatatablesPrivateHelper
 
   # https://datatables.net/reference/option/columns
   def datatable_columns(datatable)
-    sortable = datatable.sortable?
-
     datatable.columns.map do |name, opts|
       {
-        className: opts[:col_class],
         name: name,
+        title: content_tag(:span, opts[:label].presence),
+        className: opts[:col_class],
         responsivePriority: opts[:responsive],
         search: datatable.state[:search][name],
         searchHtml: datatable_search_tag(datatable, name, opts),
-        sortable: (opts[:sort] && sortable),
-        title: datatable_label_tag(datatable, name, opts),
-        visible: datatable.state[:visible][name]
+        sortable: (opts[:sort] && !datatable.simple?),
+        visible: datatable.state[:visible][name],
       }
     end.to_json.html_safe
   end
@@ -26,207 +23,78 @@ module EffectiveDatatablesPrivateHelper
     end
   end
 
-  def datatable_display_order(datatable)
-    (datatable.sortable? ? [datatable.order_index, datatable.order_direction] : false).to_json.html_safe
-  end
-
   def datatable_reset(datatable)
-    link_to(content_tag(:span, t('effective_datatables.reset')), '#', class: 'btn btn-link btn-sm buttons-reset-search')
-  end
-
-  def datatable_reorder(datatable)
-    return unless datatable.reorder? && EffectiveDatatables.authorized?(self, :update, datatable.collection_class)
-    link_to(content_tag(:span, t('effective_datatables.reorder')), '#', class: 'btn btn-link btn-sm buttons-reorder', disabled: true)
-  end
-
-  def datatable_new_resource_button(datatable, name, column)
-    return unless column[:inline] && (column[:actions][:new] != false)
-
-    action = { action: :new, class: ['btn', column[:btn_class].presence].compact.join(' '), 'data-remote': true }
-
-    if column[:actions][:new].kind_of?(Hash) # This might be active_record_array_collection?
-      action = action.merge(column[:actions][:new])
-
-      effective_resource = (datatable.effective_resource || datatable.fallback_effective_resource)
-      klass = (column[:actions][:new][:klass] || effective_resource.try(:klass) || datatable.collection_class)
-    elsif Array(datatable.effective_resource.try(:actions)).include?(:new)
-      effective_resource = datatable.effective_resource
-      klass = effective_resource.klass
-    else
-      return
-    end
-
-    # Will only work if permitted
-    render_resource_actions(klass, actions: { t('effective_datatables.new') => action }, effective_resource: effective_resource)
-  end
-
-  def datatable_label_tag(datatable, name, opts)
-    case opts[:as]
-    when :actions
-      content_tag(:span, t('effective_datatables.actions'), style: 'display: none;')
-    when :bulk_actions
-      content_tag(:span, t('effective_datatables.bulk_actions'), style: 'display: none;')
-    when :reorder
-      content_tag(:span, t('effective_datatables.reorder'), style: 'display: none;')
-    else
-      content_tag(:span, opts[:label].presence)
-    end
+    link_to(content_tag(:span, 'Reset'), '#', class: 'btn btn-link btn-sm buttons-reset-search')
   end
 
   def datatable_search_tag(datatable, name, opts)
-    return datatable_new_resource_button(datatable, name, opts) if name == :_actions
-
     return if opts[:search] == false
 
     # Build the search
-    @_effective_datatables_form_builder ||  simple_form_for(:datatable_search, url: '#', html: {id: "#{datatable.to_param}-form"}) { |f| @_effective_datatables_form_builder = f }
+    @_effective_datatables_form_builder || effective_form_with(scope: :datatable_search, url: '#') { |f| @_effective_datatables_form_builder = f }
     form = @_effective_datatables_form_builder
 
-    include_blank = opts[:search].key?(:include_blank) ? opts[:search][:include_blank] : opts[:label]
-    pattern = opts[:search][:pattern]
-    placeholder = opts[:search][:placeholder] || ''
-    title = opts[:search][:title] || opts[:label]
-    wrapper_html = { class: 'datatable_search' }
-
     collection = opts[:search].delete(:collection)
     value = datatable.state[:search][name]
 
-    input_html = {
+    options = opts[:search].except(:fuzzy).merge!(
       name: nil,
+      feedback: false,
+      label: false,
       value: value,
-      title: title,
-      pattern: pattern,
-      data: {'column-name' => name, 'column-index' => opts[:index]}
-    }.delete_if { |k, v| v.blank? && k != :name }
+      data: { 'column-name': name, 'column-index': opts[:index] }
+    )
 
-    case opts[:search][:as]
+    case options.delete(:as)
     when :string, :text, :number
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_html: input_html
-    when :effective_obfuscation
-      input_html[:pattern] ||= '[0-9]{3}-?[0-9]{4}-?[0-9]{3}'
-      input_html[:title] = 'Expected format: XXX-XXXX-XXX'
-
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_html: input_html
+      form.text_field name, options
     when :date, :datetime
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_date_picker) ? :effective_date_picker : :string),
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_group: false,
-        input_html: input_html,
-        date_linked: false,
-        input_js: { useStrict: true, keepInvalid: true }
-        # Keep invalid format like "2015-11" so we can still search by year, month or day
+      form.date_field name, options.reverse_merge(
+        date_linked: false, prepend: false, input_js: { useStrict: true, keepInvalid: true }
+      )
     when :time
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_time_picker) ? :effective_time_picker : :string),
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_group: false,
-        input_html: input_html,
-        date_linked: false,
-        input_js: { useStrict: false, keepInvalid: true }
+      form.time_field name, options.reverse_merge(
+        date_linked: false, prepend: false, input_js: { useStrict: false, keepInvalid: true }
+      )
     when :select, :boolean
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_select) ? :effective_select : :select),
-        collection: collection,
-        selected: opts[:search][:value],
-        multiple: opts[:search][:multiple],
-        grouped: opts[:search][:grouped],
-        polymorphic: opts[:search][:polymorphic],
-        template: opts[:search][:template],
-        include_blank: include_blank,
-        wrapper_html: wrapper_html,
-        input_html: input_html,
-        input_js: { placeholder: placeholder }
+      options[:input_js] = (options[:input_js] || {}).reverse_merge(placeholder: '')
+      form.select name, collection, options
     when :bulk_actions
-      input_html[:data]['role'] = 'bulk-actions'
-
-      form.input name, label: false, required: false, value: nil,
-        as: :boolean,
-        input_html: input_html
-    end
-  end
-
-  def render_datatable_filters(datatable)
-    raise 'expected datatable to be present' unless datatable
-
-    datatable.view ||= self
-    return unless datatable._scopes.present? || datatable._filters.present?
-
-    if datatable._filters_form_required?
-      render partial: 'effective/datatables/filters', locals: { datatable: datatable }
-    else
-      render(partial: 'effective/datatables/filters', locals: { datatable: datatable }).gsub('<form', '<div').gsub('/form>', '/div>').html_safe
+      options[:data]['role'] = 'bulk-actions-all'
+      form.check_box name, options.merge(custom: false)
     end
-
   end
 
   def datatable_filter_tag(form, datatable, name, opts)
-    as = opts[:as].to_s.chomp('_field').to_sym
+    placeholder = opts.delete(:label)
+
+    collection = opts.delete(:collection)
     value = datatable.state[:filter][name]
-    collection = opts[:collection]
-    input_html = opts[:input_html] || {}
 
-    attributes = {
+    options = opts.except(:parse).merge(
+      placeholder: placeholder,
+      feedback: false,
+      label: false,
       value: value,
-      selected: value,
-      as: as,
-      collection: collection,
-      label: opts[:label],
-      required: input_html.delete(:required) || opts[:required],
-      multiple: input_html.delete(:multiple) || opts[:multiple],
-      include_blank: input_html.delete(:include_blank) || opts[:include_blank],
-      group_method: input_html.delete(:group_method),
-      group_label_method: input_html.delete(:group_label_method),
-      value_method: input_html.delete(:value_method),
-      label_method: input_html.delete(:label_method),
-      input_html: (({name: ''} unless datatable._filters_form_required?) || {}).merge(input_html),
-      input_js: ({ placeholder: ''} if as == :effective_select),
-      wrapper_html: {class: 'form-group-sm'}
-    }.compact
-
-    form.input name, **attributes
-  end
-
-  def datatable_scope_tag(form, datatable, opts = {})
-    collection = datatable._scopes.map { |name, opts| [opts[:label], name] }
-    value = datatable.state[:scope]
+      wrapper: { class: 'form-group col-auto'},
+      autocomplete: 'off'
+    )
 
-    form.input :scope, label: false, required: false, checked: value,
-      as: (defined?(EffectiveFormInputs) ? :effective_radio_buttons : :radio_buttons),
-      collection: collection,
-      buttons: true,
-      wrapper_html: {class: 'btn-group-sm'}
-  end
-
-  def render_datatable_charts(datatable)
-    raise 'expected datatable to be present' unless datatable
-
-    datatable.view ||= self
-    return unless datatable._charts.present?
-
-    datatable._charts.map { |name, _| render_datatable_chart(datatable, name) }.join.html_safe
-  end
-
-  def render_datatable_chart(datatable, name)
-    raise 'expected datatable to be present' unless datatable
+    options[:name] = '' unless datatable._filters_form_required?
 
-    datatable.view ||= self
-    return unless datatable._charts[name].present?
-
-    chart = datatable._charts[name]
-    chart_data = datatable.to_json[:charts][name][:data]
-
-    render partial: chart[:partial], locals: { datatable: datatable, chart: chart, chart_data: chart_data }
+    case options.delete(:as)
+    when :date
+      form.date_field name, options
+    when :datetime
+      form.datetime_field name, options
+    when :time
+      form.time_field name, options
+    when :select, :boolean
+      options[:input_js] = (options[:input_js] || {}).reverse_merge(placeholder: placeholder)
+      form.select name, collection, options
+    else
+      form.text_field name, options
+    end
   end
 
 end

data/app/models/effective/datatable.rb

@@ -1,7 +1,7 @@
 module Effective
   class Datatable
     attr_reader :attributes # Anything that we initialize our table with. That's it. Can't be changed by state.
-    attr_reader :effective_resource
+    attr_reader :resource
     attr_reader :state
 
     # Hashes of DSL options
@@ -15,8 +15,6 @@ 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
@@ -33,10 +31,10 @@ module Effective
     include Effective::EffectiveDatatable::Resource
     include Effective::EffectiveDatatable::State
 
-    def initialize(view = nil, attributes = nil)
+    def initialize(view = nil, attributes = {})
       (attributes = view; view = nil) if view.kind_of?(Hash)
 
-      @attributes = (attributes || {})
+      @attributes = initial_attributes(attributes)
       @state = initial_state
 
       @_aggregates = {}
@@ -47,7 +45,6 @@ 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
@@ -57,23 +54,21 @@ module Effective
       @view = (view.respond_to?(:view_context) ? view.view_context : view)
       raise 'expected view to respond to params' unless @view.respond_to?(:params)
 
-      assert_attributes!
+      load_cookie!
       load_attributes!
 
       # We need early access to filter and scope, to define defaults from the model first
-      # This means filters do know about attributes but not about columns.
+      # This means filters do knows 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
@@ -83,10 +78,9 @@ module Effective
       # Figure out the class, and if it's activerecord, do all the resource discovery on it
       load_resource!
 
-      # Check everything is okay
-      validate_datatable!
+      # If attributes match a belongs_to column, scope the collection and remove the column
+      apply_belongs_to_attributes!
 
-      # Save for next time
       save_cookie!
     end
 
@@ -123,18 +117,11 @@ module Effective
       )
     end
 
-    # Inline crud
-    def inline?
-      attributes[:inline] == true
-    end
-
-    # Reordering
-    def reorder?
-      columns.key?(:_reorder)
-    end
-
-    def sortable?
-      !reorder? && attributes[:sortable] != false
+    # 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
     end
 
     # Whether the filters must be rendered as a <form> or we can keep the normal <div> behaviour
@@ -142,12 +129,12 @@ module Effective
       _form[:verb].present?
     end
 
-    def html_class
-      Array(attributes[:class] || EffectiveDatatables.html_class).join(' ').presence
+    def table_html_class
+      attributes[:class] || EffectiveDatatables.html_class
     end
 
     def to_param
-      "#{self.class.name.underscore.parameterize}-#{[self.class, attributes].hash.abs.to_s.last(12)}"
+      @to_param ||= "#{self.class.name.underscore.parameterize}-#{cookie_param}"
     end
 
     def columns
@@ -162,14 +149,6 @@ module Effective
       @dsl_tool ||= DatatableDslTool.new(self)
     end
 
-    def resource
-      raise('depecated. Please use .effective_resource instead')
-    end
-
-    def fallback_effective_resource
-      @fallback_effective_resource ||= Effective::Resource.new('', namespace: controller_namespace)
-    end
-
     private
 
     def column_tool
@@ -180,12 +159,5 @@ 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,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)
@@ -75,10 +75,8 @@ module Effective
     def search_column(collection, value, column, sql_column)
       Rails.logger.info "COLUMN TOOL: search_column #{column.to_s} #{value} #{sql_column}" if EffectiveDatatables.debug
 
-      operation = (column[:search][:fuzzy] && column[:as] == :string) ? :matches : :eq
-
       Effective::Resource.new(collection)
-        .search(column[:name], value, as: column[:as], operation: operation, column: sql_column)
+        .search(column[:name], value, as: column[:as], fuzzy: column[:search][:fuzzy], sql_column: sql_column)
     end
 
     def paginate(collection)

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, _|