effective_datatables 2.4.6 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac1937cf904292d69703161cb4421ff66e342a42
-  data.tar.gz: b42cb1580452e1a46800769f87ee3a2b107b5925
+  metadata.gz: 698076a0613349e6b87650757f70464530e59933
+  data.tar.gz: 6ec43352f2160e31f382dcccfdc5091537f0fcdb
 SHA512:
-  metadata.gz: 68dcd1719dae5c4406160279e27b36b9d24acb2c2b2bcf353aec79fcfcd7f378d03b6ad02c45030580dea565c85aa9dfe26402f94ee74dfac3e384550d11b232
-  data.tar.gz: c7cf87f9d6232f53d10d14e3d543507773359ceca3945915a2f030738044470e5903e3c73cb48c1b1cf0a469001e06fe28c3612b6cdf475e248b79df7937f09b
+  metadata.gz: bf5374370d10c21eda392ea2db88460eeb676de33a7e6e3f0236940955aa6a7399e14c3bbc52c902d390df5f3154b567a443819752b0ec4b8c19610964bd3aee
+  data.tar.gz: 0dfdf316d031c7d34c2e2fa0b338d1dde5560375fb14bc9e319129dcc77e2d7845ce3004c276e9f3527dd0f3c760ab05bf302cf362f56b295b7d3637aeed4169

data/README.md

@@ -537,6 +537,57 @@ resources :posts do
 end
 ```
 
+## scopes
+
+When declaring a scope, a form field will automatically be placed above the datatable that can filter on the collection.
+
+The value of the scope, its default value, will be available for use anywehre in your datatable via the `attributes` hash.
+
+```ruby
+scope :start_date, Time.zone.now-3.months, filter: { input_html: { class: 'datepicker' } }
+```
+
+and then in your collection, or any `table_column` block:
+
+```ruby
+def collection
+  Post.where('updated_at > ?', attributes[:start_date])
+end
+```
+
+So initially, the `:start_date` will have the value of `Time.zone.now-3.months` and when submitted by the form, the value will be set there.
+
+The form value will come back as a string, so you may need to `Time.zone.parse` that value.
+
+Pass `scope :start_date, Time.zone.now-3.months, fallback: true` to fallback to the default value when the form submission is not present.
+
+Any `filter: { ... }` options will be passed straight into simple_form.
+
+## aggregates
+
+Each `aggregate` directive adds an additional row to the table's tfoot.
+
+This feature is intended to display a sum or average of all the table's currently displayed values.
+
+```ruby
+aggregate :average do |table_column, values, table_data|
+  if table_column[:name] == 'user'
+    'Average'
+  else
+    average = (values.sum { |value| convert_to_column_type(table_column, value) } / [values.length, 1].max)
+    content_tag(:span, number_to_percentage(average, precision: 0))
+  end
+end
+```
+
+The above aggregate block will be called for each currently visible column in a datatable.
+
+Here `table_column` is the table_column being rendered, `values` is an array of all the values in this one column. `table_data` is the whole transposed array of data.
+
+The values will be whatever datatype each table_column returns.
+
+It might be the case that the formatted values (strings) are returned, which is why `convert_to_column_type` is used above.
+
 ## table_columns
 
 Quickly create multiple table_columns all with default options:

data/app/assets/javascripts/effective_datatables/initialize.js.coffee

@@ -26,21 +26,21 @@ initializeDataTables = ->
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':visible:not(.col-actions)'
+            columns: ':not(.col-actions)'
         },
         {
           extend: 'csv',
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':visible:not(.col-actions)'
+            columns: ':not(.col-actions)'
         },
         {
           extend: 'excel',
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':visible:not(.col-actions)'
+            columns: ':not(.col-actions)'
         },
         {
           extend: 'print',
@@ -69,12 +69,16 @@ initializeDataTables = ->
       pagingType: 'simple_numbers'
       initComplete: (settings) ->
         initializeBulkActions(this.api())
+        initializeScopes(this.api())
         initializeFilters(this.api())
       drawCallback: (settings) ->
         $table = $(this.api().table().node())
         selected = $table.data('bulk-actions-restore-selected-values')
         completeBulkAction($table, selected) if selected && selected.length > 0
 
+        if settings['json'] && settings['json']['aggregates']
+          drawAggregates($table, settings['json']['aggregates'])
+
     # Copies the bulk actions html, stored in a data attribute on the table, into the buttons area
     initializeBulkActions = (api) ->
       $table = $(api.table().node())
@@ -94,6 +98,22 @@ initializeDataTables = ->
       $wrapper.children().first().find('.buttons-bulk-actions').children('button').removeAttr('disabled')
       $table.siblings('.dataTables_processing').html('Processing...')
 
+    drawAggregates = ($table, aggregates) ->
+      $tfoot = $table.find('tfoot').first()
+
+      $.each aggregates, (row, values) =>
+        $row = $tfoot.children().eq(row)
+
+        if $row
+          $.each values, (col, value) => $row.children().eq(col).html(value)
+
+    # Appends the scope html
+    initializeScopes = (api) ->
+      $table = $(api.table().node())
+      scopes = $table.data('scopes')
+
+      $table.closest('.dataTables_wrapper').prepend(scopes['scopeHtml']) if scopes
+
     # Appends the filter html, stored in the column definitions, into each column header
     initializeFilters = (api) ->
       api.columns().flatten().each (index) =>

data/app/assets/javascripts/effective_datatables/scopes.js.coffee

@@ -0,0 +1,3 @@
+$(document).on 'click', 'a[data-reset-form]', (event) ->
+  event.preventDefault()
+  $(event.currentTarget).closest('form').trigger('reset')

data/app/assets/javascripts/effective_datatables.js

@@ -17,6 +17,7 @@
 
 //= require effective_datatables/bulk_actions
 //= require effective_datatables/responsive
+//= require effective_datatables/scopes
 //= require effective_datatables/initialize
 
 $.extend( $.fn.dataTable.defaults, {

data/app/assets/stylesheets/effective_datatables/_overrides.scss.erb

@@ -49,7 +49,8 @@ table.dataTable.sort-hidden thead .sorting_desc { background-image: none; }
 
 // Filter bar
 table.dataTable .form-group { width: 100%; margin-left: 0px; margin-right: 0px; }
-table.dataTable input,select { width: 100%;  }
+table.dataTable input { width: 100%; }
+table.dataTable select { width: 100%; }
 table.dataTable .form-control { width: 100%;  }
 table.dataTable .form-group.datatable_filter_bulk_actions { margin-left: 4px; }
 

data/app/helpers/effective_datatables_helper.rb

@@ -51,6 +51,17 @@ module EffectiveDatatablesHelper
     }.to_json()
   end
 
+  def datatable_scopes(datatable)
+    return false unless datatable.scopes.present?
+
+    {
+      scopeHtml: render(
+        partial: 'effective/datatables/scopes',
+        locals: HashWithIndifferentAccess.new(datatable: datatable)
+      )
+    }.to_json()
+  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?
 
@@ -119,7 +130,6 @@ module EffectiveDatatablesHelper
     attributes[:active_admin_path] rescue false
   end
 
-
   ### Bulk Actions DSL Methods
   def bulk_action(*args)
     content_for(:effective_datatables_bulk_actions) { content_tag(:li, link_to(*args)) }

data/app/models/effective/active_record_datatable_tool.rb

@@ -211,7 +211,7 @@ module Effective
       when :price
         price_in_cents = (term.gsub(/[^0-9|\.]/, '').to_f * 100.0).to_i
         collection.public_send(sql_op, "#{sql_column} = :term", term: price_in_cents)
-      when :currency, :decimal, :number
+      when :currency, :decimal, :number, :percentage
         collection.public_send(sql_op, "#{sql_column} = :term", term: term.gsub(/[^0-9|\.]/, '').to_f)
       else
         collection.public_send(sql_op, "#{sql_column} = :term", term: term)

data/app/models/effective/array_datatable_tool.rb

@@ -3,7 +3,7 @@ module Effective
   class ArrayDatatableTool
     attr_accessor :table_columns
 
-    delegate :page, :per_page, :search_column, :order_column, :display_table_columns, :to => :@datatable
+    delegate :page, :per_page, :search_column, :order_column, :display_table_columns, :convert_to_column_type, :to => :@datatable
 
     def initialize(datatable, table_columns)
       @datatable = datatable
@@ -30,7 +30,7 @@ module Effective
       if direction == :asc
         collection.sort! do |x, y|
           if (x[index] && y[index])
-            cast_array_column_value(table_column, x[index]) <=> cast_array_column_value(table_column, y[index])
+            convert_to_column_type(table_column, x[index]) <=> convert_to_column_type(table_column, y[index])
           elsif x[index]
             -1
           elsif y[index]
@@ -42,7 +42,7 @@ module Effective
       else
         collection.sort! do |x, y|
           if (x[index] && y[index])
-            cast_array_column_value(table_column, y[index]) <=> cast_array_column_value(table_column, x[index])
+            convert_to_column_type(table_column, y[index]) <=> convert_to_column_type(table_column, x[index])
           elsif x[index]
             1
           elsif y[index]
@@ -70,7 +70,7 @@ module Effective
 
       collection.select! do |row|
         if table_column[:filter][:fuzzy]
-          row[index].to_s.downcase.include?(search_term)
+          convert_to_column_type(table_column, row[index]).to_s.downcase.include?(search_term)
         else
           row[index] == search_term
         end
@@ -87,19 +87,6 @@ module Effective
       display_table_columns.present? ? display_table_columns.keys.index(column[:name]) : column[:array_index]
     end
 
-    # When we order by Array, it's already a string.
-    # This gives us a mechanism to sort numbers as numbers
-    def cast_array_column_value(table_column, value)
-      case table_column[:type]
-      when :number, :price, :decimal, :float
-        (value.to_s.gsub(/[^0-9|\.]/, '').to_f rescue 0.00)
-      when :integer
-        (value.to_s.gsub(/\D/, '').to_i rescue 0)
-      else
-        value
-      end
-    end
-
   end
 end
 

data/app/models/effective/datatable.rb

@@ -11,6 +11,7 @@ module Effective
     extend Effective::EffectiveDatatable::Dsl::ClassMethods
 
     include Effective::EffectiveDatatable::Ajax
+    include Effective::EffectiveDatatable::Helpers
     include Effective::EffectiveDatatable::Hooks
     include Effective::EffectiveDatatable::Options
     include Effective::EffectiveDatatable::Rendering
@@ -23,6 +24,7 @@ module Effective
 
       initialize_datatable  # This creates @table_columns based on the DSL datatable do .. end block
       initialize_options    # This normalizes all the options
+      initialize_scopes     # This normalizes scopes, and copies scopes to attributes
 
       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']]"
@@ -37,9 +39,17 @@ module Effective
       @table_columns
     end
 
+    def scopes
+      @scopes
+    end
+
+    def aggregates
+      @aggregates
+    end
+
     # Any attributes set on initialize will be echoed back and available to the class
     def attributes
-      @attributes ||= HashWithIndifferentAccess.new()
+      @attributes ||= HashWithIndifferentAccess.new
     end
 
     def to_key; []; end # Searching & Filters
@@ -68,12 +78,17 @@ module Effective
     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 ||= {
-        :draw => (params[:draw] || 0),
-        :data => (table_data || []),
-        :recordsTotal => (total_records || 0),
-        :recordsFiltered => (display_records || 0)
-      }
+      @json ||= begin
+        data = table_data
+
+        {
+          :draw => (params[:draw] || 0),
+          :data => (data || []),
+          :recordsTotal => (total_records || 0),
+          :recordsFiltered => (display_records || 0),
+          :aggregates => (aggregate_data(data) || [])
+        }
+      end
     end
 
     def present?
@@ -104,6 +119,22 @@ module Effective
       @view = view_context
       @view.formats = [:html]
 
+      # Set any scopes
+      if @view.params[:scopes].kind_of?(Hash)
+        @view.params[:scopes].each do |name, value|
+          next unless scopes.key?(name)
+
+          if scopes[name][:fallback] || scopes[name][:presence]
+            value = value.presence || scopes[name][:default]
+          end
+
+          self.attributes[name] = value
+
+          self.scopes[name][:filter][:input_html] ||= HashWithIndifferentAccess.new
+          self.scopes[name][:filter][:input_html][:value] = value
+        end
+      end
+
       # 'Just work' with attributes
       @view.class.send(:attr_accessor, :attributes)
       @view.attributes = self.attributes
@@ -116,6 +147,10 @@ module Effective
         @view.class_eval { delegate view_method, :to => :@effective_datatable }
       end
 
+      Effective::EffectiveDatatable::Helpers.instance_methods(false).each do |helper_method|
+        @view.class_eval { delegate helper_method, :to => :@effective_datatable }
+      end
+
       # Clear the search_terms memoization
       @search_terms = nil
       @order_name = nil

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

@@ -27,7 +27,7 @@ module Effective
         end
         raise "You cannot use both partial: ... and proc: ..." if options[:partial] && options[:proc]
 
-        (@table_columns ||= HashWithIndifferentAccess.new())[name] = options
+        (@table_columns ||= HashWithIndifferentAccess.new)[name] = options
       end
 
       def array_column(name, options = {}, proc = nil, &block)
@@ -72,6 +72,24 @@ module Effective
         table_column(name, opts, proc)
       end
 
+      def scope(name, default, options = {}, &block)
+        if block_given?
+          raise "You cannot use partial: ... with the block syntax" if options[:partial]
+          options[:block] = block
+        end
+
+        (@scopes ||= HashWithIndifferentAccess.new)[name] = options.merge(default: default)
+      end
+
+      def aggregate(name, options = {}, &block)
+        if block_given?
+          raise "You cannot use proc: ... with the block syntax" if options[:proc]
+          options[:block] = block
+        end
+
+        (@aggregates ||= HashWithIndifferentAccess.new)[name] = options
+      end
+
     end
   end
 end

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

@@ -0,0 +1,24 @@
+module Effective
+  module EffectiveDatatable
+    module Helpers
+
+      # When we order by Array, it's already a string.
+      # This gives us a mechanism to sort numbers as numbers
+      def convert_to_column_type(table_column, value)
+        if value.html_safe? && value.kind_of?(String) && value.start_with?('<')
+          value = ActionView::Base.full_sanitizer.sanitize(value)
+        end
+
+        case table_column[:type]
+        when :number, :price, :decimal, :float, :percentage
+          (value.to_s.gsub(/[^0-9|\.]/, '').to_f rescue 0.00) unless value.kind_of?(Numeric)
+        when :integer
+          (value.to_s.gsub(/\D/, '').to_i rescue 0) unless value.kind_of?(Integer)
+        else
+          ; # Do nothing
+        end || value
+      end
+
+    end
+  end
+end

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

@@ -8,12 +8,36 @@ module Effective
         @table_columns = initialize_column_options(@table_columns)
       end
 
+      def initialize_scopes
+        @scopes = initialize_scope_options(@scopes)
+      end
+
       def quote_sql(name)
         collection_class.connection.quote_column_name(name) rescue name
       end
 
       protected
 
+      # The scope DSL is
+      # scope :start_date, default_value, options {}
+
+      # A scope comes to us like {:start_date => {default: Time.zone.now, filter: {as: :select, collection: ... input_html :}}}
+      # We want to make sure an input_html: { value: default } exists
+      def initialize_scope_options(scopes)
+        (scopes || []).each do |name, options|
+          options[:filter] ||= HashWithIndifferentAccess.new()
+          options[:filter][:input_html] ||= HashWithIndifferentAccess.new()
+          options[:filter][:input_html][:value] = options[:default]
+        end
+
+        # For each scope, copy it into the attributes, so we can get at the value
+        (scopes || []).each do |name, options|
+          self.attributes[name] ||= options[:default]
+        end
+
+        scopes
+      end
+
       def initialize_column_options(cols)
         sql_table = (collection.table rescue nil)
 
@@ -81,8 +105,6 @@ module Effective
               :bulk_actions_column
             elsif name.include?('_address') && (collection_class.new rescue nil).respond_to?(:effective_addresses)
               :effective_address
-            elsif name == 'id' || name.include?('year') || name.include?('_id')
-              :non_formatted_integer
             elsif sql_column.try(:type).present?
               sql_column.type
             else
@@ -92,6 +114,11 @@ module Effective
 
           cols[name][:class] = "col-#{cols[name][:type]} col-#{name} #{cols[name][:class]}".strip
 
+          # Formats
+          if name == 'id' || name.include?('year') || name.include?('_id')
+            cols[name][:format] = :non_formatted_integer
+          end
+
           # We can't really sort a HasMany or EffectiveAddress field
           if [:has_many, :effective_address].include?(cols[name][:type])
             cols[name][:sortable] = false

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

@@ -137,7 +137,7 @@ module Effective
                 obj.send(name)
               end
             rescue => e
-              obj.try(:[], name)
+              Rails.env.production? ? obj.try(:[], name) : raise(e)
             end
           end
         end
@@ -154,7 +154,7 @@ module Effective
               row[index] = value.to_s
             end
 
-            case opts[:type]
+            case (opts[:format] || opts[:type])
             when :belongs_to, :belongs_to_polymorphic
               row[index] = value.to_s
             when :has_many
@@ -183,6 +183,8 @@ module Effective
               row[index] = number_to_currency(value / 100.0)
             when :currency
               row[index] = number_to_currency(value || 0)
+            when :percentage
+              row[index] = number_to_percentage(value || 0)
             when :integer
               if EffectiveDatatables.integer_format.kind_of?(Symbol)
                 row[index] = view.instance_exec { public_send(EffectiveDatatables.integer_format, value) }
@@ -206,6 +208,26 @@ module Effective
         collection
       end
 
+      # This should return an Array of values the same length as table_data
+      def aggregate_data(table_data)
+        return false unless aggregates.present?
+
+        values = table_data.transpose
+
+        aggregates.map do |name, options|
+          (display_table_columns || table_columns).map.with_index do |(name, column), index|
+
+            if column[:visible] != true
+              ''
+            elsif (options[:block] || options[:proc]).respond_to?(:call)
+              view.instance_exec(column, (values[index] || []), values, &(options[:block] || options[:proc]))
+            else
+              ''
+            end
+          end
+        end
+      end
+
       private
 
       def controller_namespace

data/app/views/effective/datatables/_datatable.html.haml

@@ -7,6 +7,7 @@
       'bulk-actions' => datatable_bulk_actions(datatable),
       'columns' => datatable_columns(datatable),
       'input-js-options' => local_assigns[:input_js_options],
+      'scopes' => datatable_scopes(datatable),
       'simple' => datatable.simple?.to_s,
       'source' => effective_datatables.datatable_path(datatable, {format: 'json'}.merge(attributes: datatable.attributes)).chomp('?'),
       'default-order' => datatable_default_order(datatable),
@@ -23,7 +24,14 @@
         %th= opts[:label] || name
 
   %tbody
-    - (datatable.to_json[:data] || []).each do |row|
+    - datatable.to_json[:data].each do |row|
       %tr
         - row.each do |col|
           %td= col.to_s.html_safe
+
+  - if datatable.aggregates.present?
+    %tfoot
+      - datatable.to_json[:aggregates].each do |row|
+        %tr
+          - row.each do |col|
+            %td= col.to_s.html_safe

data/app/views/effective/datatables/_scopes.html.haml

@@ -0,0 +1,15 @@
+.row
+  .col-sm-12
+    = simple_form_for :scopes, url: request.path, method: :get, html: { class: 'form-inline' } do |form|
+
+      - datatable.scopes.each do |name, options|
+        - if options[:block].present?
+          = form.instance_exec(form, &options[:block])
+        - elsif options[:partial].present?
+          = render partial: options[:partial], locals: { form: form, f: form, datatable: datatable }
+        - else
+          = form.input name, options[:filter]
+
+      = form.submit 'Refresh', class: 'btn btn-primary', 'data-disable-with' => 'Refreshing...'
+      = link_to 'Reset', '#', 'data-reset-form' => true
+

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.4.6'.freeze
+  VERSION = '2.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.4.6
+  version: 2.5.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-13 00:00:00.000000000 Z
+date: 2016-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -123,6 +123,7 @@ files:
 - app/assets/javascripts/effective_datatables/bulk_actions.js.coffee
 - app/assets/javascripts/effective_datatables/initialize.js.coffee
 - app/assets/javascripts/effective_datatables/responsive.js.coffee
+- app/assets/javascripts/effective_datatables/scopes.js.coffee
 - app/assets/javascripts/vendor/jquery.debounce.min.js
 - app/assets/javascripts/vendor/jszip.min.js
 - app/assets/stylesheets/dataTables/buttons/buttons.bootstrap.min.css
@@ -143,6 +144,7 @@ files:
 - app/models/effective/datatable.rb
 - app/models/effective/effective_datatable/ajax.rb
 - app/models/effective/effective_datatable/dsl.rb
+- app/models/effective/effective_datatable/helpers.rb
 - app/models/effective/effective_datatable/hooks.rb
 - app/models/effective/effective_datatable/options.rb
 - app/models/effective/effective_datatable/rendering.rb
@@ -150,6 +152,7 @@ files:
 - app/views/effective/datatables/_bulk_actions_column.html.haml
 - app/views/effective/datatables/_bulk_actions_dropdown.html.haml
 - app/views/effective/datatables/_datatable.html.haml
+- app/views/effective/datatables/_scopes.html.haml
 - app/views/effective/datatables/_spacer_template.html
 - config/routes.rb
 - lib/effective_datatables.rb