effective_datatables 2.12.2 → 3.0.0

data/app/helpers/effective_datatables_private_helper.rb

@@ -1,112 +1,103 @@
-# These aren't expected to be called by a developer.
-# They are internal datatables methods, but you could still call them on the view.
+# These aren't expected to be called by a developer. They are internal methods.
 module EffectiveDatatablesPrivateHelper
 
-  def datatable_default_order(datatable)
-    [datatable.order_index, datatable.order_direction.downcase].to_json()
-  end
-
   # https://datatables.net/reference/option/columns
   def datatable_columns(datatable)
     form = nil
-    simple_form_for(:datatable_filter, url: '#', html: {id: "#{datatable.to_param}-form"}) { |f| form = f }
+    simple_form_for(:datatable_search, url: '#', html: {id: "#{datatable.to_param}-form"}) { |f| form = f }
 
-    datatable.table_columns.map do |name, options|
+    datatable.columns.map do |name, opts|
       {
-        name: options[:name],
-        title: content_tag(:span, options[:label], class: 'filter-label'),
-        className: options[:class],
-        width: options[:width],
-        responsivePriority: (options[:responsivePriority] || 10000),  # 10,000 is datatables default
-        sortable: (options[:sortable] && !datatable.simple?),
-        visible: (options[:visible].respond_to?(:call) ? datatable.instance_exec(&options[:visible]) : options[:visible]),
-        filterHtml: (datatable_header_filter(form, name, datatable.search_terms[name], options) unless datatable.simple?),
-        filterSelectedValue: options[:filter][:selected]
+        name: name,
+        title: content_tag(:span, opts[:label], class: 'search-label'),
+        className: opts[:col_class],
+        searchHtml: (datatable_search_html(form, name, datatable.state[:search][name], opts) unless datatable.simple?),
+        responsivePriority: opts[:responsive],
+        search: datatable.state[:search][name],
+        sortable: (opts[:sort] && !datatable.simple?),
+        visible: datatable.state[:visible][name],
       }
-    end.to_json()
+    end.to_json
   end
 
   def datatable_bulk_actions(datatable)
-    bulk_actions_column = datatable.table_columns.find { |_, options| options[:bulk_actions_column] }.try(:second)
-    return false unless bulk_actions_column
+    render(partial: '/effective/datatables/bulk_actions_dropdown', locals: { datatable: datatable }) if datatable._bulk_actions.present?
+  end
 
-    {
-      dropdownHtml: render(
-        partial: bulk_actions_column[:dropdown_partial],
-        locals: { datatable: datatable, dropdown_block: bulk_actions_column[:dropdown_block] }.merge(bulk_actions_column[:partial_locals])
-      )
-    }.to_json()
+  def datatable_reset(datatable)
+    render(partial: '/effective/datatables/reset', locals: { datatable: datatable })
   end
 
-  def datatable_header_filter(form, name, value, opts)
-    return render(partial: opts[:header_partial], locals: {form: form, name: (opts[:label] || name), column: opts}) if opts[:header_partial].present?
+  def datatable_search_html(form, name, value, opts)
+    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' }
 
-    include_blank = opts[:filter].key?(:include_blank) ? opts[:filter][:include_blank] : (opts[:label] || name.titleize)
-    pattern = opts[:filter].key?(:pattern) ? opts[:filter][:pattern] : nil
-    placeholder = (opts[:filter][:placeholder] || '')
-    title = opts[:filter].key?(:title) ? opts[:filter][:title] : (opts[:label] || name.titleize)
-    wrapper_html = { class: 'datatable_filter' }
+    input_html = {
+      name: nil,
+      value: value,
+      title: title,
+      pattern: pattern,
+      autocomplete: 'off',
+      data: {'column-name' => name, 'column-index' => opts[:index]}
+    }.delete_if { |k, v| v.blank? && k != :name }
 
-    case opts[:filter][:as]
+    case opts[:search][:as]
     when :string, :text, :number
       form.input name, label: false, required: false, value: value,
         as: :string,
         placeholder: placeholder,
         wrapper_html: wrapper_html,
-        input_html: { name: nil, value: value, title: title, pattern: pattern, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} }
-    when :obfuscated_id
-      pattern ||= '[0-9]{3}-?[0-9]{4}-?[0-9]{3}'
-      title = opts[:filter].key?(:title) ? opts[:filter][:title] : 'Expected format: XXX-XXXX-XXX'
+        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.presence || '###-####-###',
+        placeholder: placeholder,
         wrapper_html: wrapper_html,
-        input_html: { name: nil, value: value, title: title, pattern: pattern, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} }
-    when :date
+        input_html: input_html
+    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: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        input_html: input_html,
         input_js: { useStrict: true, keepInvalid: true }
-    when :datetime
-      form.input name, label: false, required: false, value: value,
-        as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_date_time_picker) ? :effective_date_time_picker : :string),
-        placeholder: placeholder,
-        wrapper_html: wrapper_html,
-        input_group: false,
-        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
-        input_js: { useStrict: true, keepInvalid: true } # Keep invalid format like "2015-11" so we can still filter by year, month or day
+        # Keep invalid format like "2015-11" so we can still search by year, month or day
     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: opts[:filter][:collection],
-        selected: opts[:filter][:selected],
-        multiple: opts[:filter][:multiple] == true,
+        collection: opts[:search][:collection],
+        selected: opts[:search][:value],
+        multiple: opts[:search][:multiple] == true,
         include_blank: include_blank,
         wrapper_html: wrapper_html,
-        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        input_html: input_html,
         input_js: { placeholder: placeholder }
     when :grouped_select
       form.input name, label: false, required: false, value: value,
         as: (ActionView::Helpers::FormBuilder.instance_methods.include?(:effective_select) ? :effective_select : :grouped_select),
-        collection: opts[:filter][:collection],
-        selected: opts[:filter][:selected],
-        multiple: opts[:filter][:multiple] == true,
-        include_blank: include_blank,
+        collection: opts[:search][:collection],
+        selected: opts[:search][:value],
+        multiple: opts[:search][:multiple] == true,
         grouped: true,
-        polymorphic: opts[:filter][:polymorphic] == true,
-        group_label_method: opts[:filter][:group_label_method] || :first,
-        group_method: opts[:filter][:group_method] || :last,
+        polymorphic: opts[:search][:polymorphic] == true,
+        group_label_method: opts[:search][:group_label_method] || :first,
+        group_method: opts[:search][:group_method] || :last,
         wrapper_html: wrapper_html,
-        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        input_html: input_html,
         input_js: { placeholder: placeholder }
-    when :bulk_actions_column
+    when :bulk_actions
+      input_html[:data]['role'] = 'bulk-actions-all'
+
       form.input name, label: false, required: false, value: nil,
         as: :boolean,
-        input_html: { name: nil, value: nil, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index], 'role' => 'bulk-actions-all'} }
+        input_html: input_html
     end
   end
 

data/app/models/effective/datatable.rb

@@ -1,234 +1,160 @@
 module Effective
   class Datatable
-    attr_accessor :display_records, :view, :attributes
-
-    # These two options control the render behaviour of a datatable
-    attr_accessor :table_html_class, :simple
-
-    delegate :render, :controller, :link_to, :mail_to, :number_to_currency, :number_to_percentage, :to => :@view
+    attr_reader :attributes # Anything that we initialize our table with. That's it. Can't be changed by state.
+    attr_reader :resource
+    attr_reader :state
+
+    # Hashes of DSL options
+    attr_reader :_aggregates
+    attr_reader :_bulk_actions
+    attr_reader :_charts
+    attr_reader :_columns
+    attr_reader :_filters
+    attr_reader :_form
+    attr_reader :_scopes
+
+    # The collection itself. Only evaluated once.
+    attr_accessor :_collection
+
+    # The view, and the ajax/cookie/default state
+    attr_reader :cookie
+    attr_reader :view
 
     extend Effective::EffectiveDatatable::Dsl
 
-    include Effective::EffectiveDatatable::Dsl::BulkActions
-    include Effective::EffectiveDatatable::Dsl::Charts
-    include Effective::EffectiveDatatable::Dsl::Datatable
-    include Effective::EffectiveDatatable::Dsl::Scopes
-
-    include Effective::EffectiveDatatable::Ajax
-    include Effective::EffectiveDatatable::Charts
-    include Effective::EffectiveDatatable::Helpers
+    include Effective::EffectiveDatatable::Attributes
+    include Effective::EffectiveDatatable::Collection
+    include Effective::EffectiveDatatable::Compute
+    include Effective::EffectiveDatatable::Cookie
+    include Effective::EffectiveDatatable::Format
     include Effective::EffectiveDatatable::Hooks
-    include Effective::EffectiveDatatable::Options
-    include Effective::EffectiveDatatable::Rendering
-
-    def initialize(*args)
-      initialize_attributes(args)
+    include Effective::EffectiveDatatable::Params
+    include Effective::EffectiveDatatable::Resource
+    include Effective::EffectiveDatatable::State
 
-      if respond_to?(:initialize_scopes) # There was at least one scope defined in the scopes do .. end block
-        initialize_scopes
-        initialize_scope_options
-      end
-
-      if respond_to?(:initialize_datatable)
-        initialize_datatable          # This creates @table_columns based on the DSL datatable do .. end block
-        initialize_datatable_options  # This normalizes all the options
-      end
+    def initialize(view = nil, attributes = {})
+      (attributes = view; view = nil) if view.kind_of?(Hash)
 
-      if respond_to?(:initialize_charts)
-        initialize_charts
-        initialize_chart_options
-      end
+      @attributes = initial_attributes(attributes)
+      @state = initial_state
 
-      unless active_record_collection? || array_collection?
-        raise "Unsupported collection type. Should be ActiveRecord class, ActiveRecord relation, or an Array of Arrays [[1, 'something'], [2, 'something else']]"
-      end
+      @_aggregates = {}
+      @_bulk_actions = []
+      @_charts = {}
+      @_columns = {}
+      @_filters = {}
+      @_form = {}
+      @_scopes = {}
 
-      if @default_order.present? && !table_columns.key?((@default_order.keys.first rescue nil))
-        raise "default_order :#{(@default_order.keys.first rescue 'nil')} must exist as a table_column or array_column"
-      end
+      raise 'collection is defined as a method. Please use the collection do ... end syntax.' unless collection.nil?
+      self.view = view if view
     end
 
-    def table_columns
-      @table_columns
-    end
+    # Once the view is assigned, we initialize everything
+    def view=(view)
+      @view = (view.respond_to?(:view_context) ? view.view_context : view)
+      raise 'expected view to respond to params' unless @view.respond_to?(:params)
 
-    def scopes
-      @scopes
-    end
+      load_cookie!
+      load_attributes!
 
-    def klass_scopes
-      scopes.select { |name, options| options[:klass_scope] }
-    end
+      # 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.
+      initialize_filters if respond_to?(:initialize_filters)
+      load_filters!
+      load_state!
 
-    def current_scope # The currently selected (klass) scope
-      attributes[:current_scope]
-    end
+      # Now we initialize all the columns. columns knows about attributes and filters and scope
+      initialize_datatable if respond_to?(:initialize_datatable)
+      load_columns!
 
-    def permitted_params
-      scopes.keys + [:current_scope, :referer]
-    end
+      # Execute any additional DSL methods
+      initialize_bulk_actions if respond_to?(:initialize_bulk_actions)
+      initialize_charts if respond_to?(:initialize_charts)
 
-    def charts
-      @charts
-    end
+      # Load the collection. This is the first time def collection is called on the Datatable itself
+      initialize_collection if respond_to?(:initialize_collection)
+      load_collection!
 
-    def aggregates
-      @aggregates
-    end
+      # Figure out the class, and if it's activerecord, do all the resource discovery on it
+      load_resource!
 
-    # Any attributes set on initialize will be echoed back and available to the class
-    def attributes
-      @attributes ||= HashWithIndifferentAccess.new
+      save_cookie!
     end
 
-    def to_key; []; end # Searching & Filters
+    def present?(view = nil)
+      unless (@view || view)
+        raise 'unable to call present? without an assigned view. In your view, either call render_datatable(@datatable) first, or use @datatable.present?(self)'
+      end
 
-    # Instance method.  In Rails 4.2 this needs to be defined on the instance, before it was on the class
-    def model_name # Searching & Filters
-      @model_name ||= ActiveModel::Name.new(self.class)
-    end
+      self.view ||= view
 
-    def self.model_name # Searching & Filters
-      @model_name ||= ActiveModel::Name.new(self)
+      to_json[:recordsTotal] > 0
     end
 
-    def to_param
-      @to_param ||= self.class.name.underscore
-    end
+    def blank?(view = nil)
+      unless (@view || view)
+        raise 'unable to call blank? without an assigned view. In your view, either call render_datatable(@datatable) first, or use @datatable.blank?(self)'
+      end
 
-    def collection
-      raise "You must define a collection. Something like an ActiveRecord User.all or an Array of Arrays [[1, 'something'], [2, 'something else']]"
-    end
+      self.view ||= view
 
-    def collection_class  # This is set by initialize_datatable_options()
-      @collection_class  # Will be either User/Post/etc or Array
+      to_json[:recordsTotal] == 0
     end
 
     def to_json
-      raise 'Effective::Datatable to_json called with a nil view.  Please call render_datatable(@datatable) or @datatable.view = view before this method' unless view.present?
-
-      @json ||= begin
-        data = table_data
-
+      @json ||= (
         {
+          data: (compute || []),
           draw: (params[:draw] || 0),
-          data: (data || []),
-          recordsTotal: (total_records || 0),
-          recordsFiltered: (display_records || 0),
-          aggregates: (aggregate_data(data) || []),
-          charts: (charts_data || {})
+          recordsTotal: (@total_records || 0),
+          recordsFiltered: (@display_records || 0),
+          aggregates: (@aggregates_data || []),
+          charts: (@charts_data || {})
         }
-      end
-    end
-
-    def present?
-      total_records > 0 || current_scope.present?
-    end
-
-    def empty?
-      total_records == 0 && current_scope.blank?
-    end
-
-    def total_records
-      @total_records ||= (active_record_collection? ? active_record_collection_size(the_collection) : the_collection.size)
-    end
-
-    def view=(view_context)
-      @view = view_context
-      @view.formats = [:html]
-
-      # 'Just work' with attributes
-      @view.class.send(:attr_accessor, :attributes)
-      @view.attributes = self.attributes
-
-      # Delegate any methods defined on the datatable directly to our view
-      @view.class.send(:attr_accessor, :effective_datatable)
-      @view.effective_datatable = self
-
-      unless @view.respond_to?(:bulk_action)
-        @view.class.send(:include, Effective::EffectiveDatatable::Dsl::BulkActions)
-      end
-
-      Effective::EffectiveDatatable::Helpers.instance_methods(false).each do |helper_method|
-        @view.class_eval { delegate helper_method, to: :@effective_datatable }
-      end
-
-      (self.class.instance_methods(false) - [:initialize_datatable, :collection, :search_column, :order_column]).each do |view_method|
-        @view.class_eval { delegate view_method, to: :@effective_datatable }
-      end
-
-      # Clear the search_terms memoization
-      @search_terms = nil
-      @order_name = nil
-      @order_direction = nil
-    end
-
-    def view_context
-      view
-    end
-
-    def table_html_class
-      @table_html_class.presence || 'table table-bordered table-striped'
+      )
     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?
-      @simple == true
+      attributes[:simple] == true
     end
 
-    protected
+    # Whether the filters must be rendered as a <form> or we can keep the normal <div> behaviour
+    def _filters_form_required?
+      _form[:verb].present?
+    end
 
-    def the_collection
-      @memoized_collection ||= collection
+    def table_html_class
+      attributes[:class] || 'table table-bordered table-striped'
     end
 
-    def params
-      view.try(:params) || HashWithIndifferentAccess.new()
+    def to_param
+      @to_param ||= self.class.name.underscore.parameterize
     end
 
-    def table_tool
-      @table_tool ||= ActiveRecordDatatableTool.new(self, table_columns.reject { |_, col| col[:array_column] })
+    def columns
+      @_columns
     end
 
-    def array_tool
-      @array_tool ||= ArrayDatatableTool.new(self, table_columns.select { |_, col| col[:array_column] })
+    def collection
+      @_collection
     end
 
-    # TODO
-    # Check if collection has an order() clause and warn about it
-    # Usually that will make the table results look weird.
-    def active_record_collection?
-      @active_record_collection == true
+    def dsl_tool
+      @dsl_tool ||= DatatableDslTool.new(self)
     end
 
-    def array_collection?
-      @array_collection == true
+    private
+
+    def column_tool
+      @column_tool ||= DatatableColumnTool.new(self)
     end
 
-    # Not every ActiveRecord query will work when calling the simple .count
-    # Custom selects:
-    #   User.select(:email, :first_name).count will throw an error
-    #   .count(:all) and .size seem to work
-    # Grouped Queries:
-    #   User.all.group(:email).count will return a Hash
-    def active_record_collection_size(collection)
-      count = (collection.size rescue nil)
-
-      case count
-      when Integer
-        count
-      when Hash
-        count.size  # This represents the number of displayed datatable rows, not the sum all groups (which might be more)
-      else
-        if collection.klass.connection.respond_to?(:unprepared_statement)
-          collection_sql = collection.klass.connection.unprepared_statement { collection.to_sql }
-          (collection.klass.connection.exec_query("SELECT COUNT(*) FROM (#{collection_sql}) AS datatables_total_count").rows[0][0] rescue 1)
-        else
-          (collection.klass.connection.exec_query("SELECT COUNT(*) FROM (#{collection.to_sql}) AS datatables_total_count").rows[0][0] rescue 1)
-        end.to_i
-      end
+    def value_tool
+      @value_tool ||= DatatableValueTool.new(self)
     end
 
   end