effective_datatables 1.2.5 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 087d65c39d2b88c60fcc041b5f7a564bc61bded7
-  data.tar.gz: 611af4b47aaa06ccb61d59b5d8cd4bcb56363d91
+  metadata.gz: 42c5bd2f4e9f486d7aaf7b6eb9f50d518d454b54
+  data.tar.gz: b759ac1ff2af026ff64e514ee520d2e0a894ca53
 SHA512:
-  metadata.gz: 6ddaca87e620c93d477081bd48fc4e6ba8029fef349ef3042d1b4b4dae736d6603822366d9d7f0741f0ecb5280e91833466ed2fd9a53b520d79b4e5de066d08c
-  data.tar.gz: e2217a2fd7c3b191bbf755a55f46b5ac85ac6ec44d67a6465302590710982660f3ab4f4a3d56661c4f47864c0d1023e49cd3073cce75c59795e345a9df26e840
+  metadata.gz: 70674bc43be1f4d30d4be2f97f73841bcf5300193a2e0968470669bd6902a015a8cf147e1aa91b799779a864fa8d331c165e16f9435111209efa8fa5f51d4aad
+  data.tar.gz: ee6b5e40da9ef3d41e70d951be314aabfd4cab55da491bfbb5f5197638ee9666dc06ba32218dd6c0ab6ef57292476a3f7ce61faaaee0ea920933b9dda77e5320

data/README.md

@@ -99,14 +99,10 @@ Here we just render the datatable:
 
 ```erb
 <h1>All Posts</h1>
-
-<% if @datatable.collection.length == 0 %>
-  <p>There are no posts.</p>
-<% else %>
-  <%= render_datatable(@datatable) %>
-<% end %>
+<%= render_datatable(@datatable) %>
 ```
 
+
 ## How It Works
 
 When the jQuery DataTable is first initialized on the front-end, it makes an AJAX request back to the server asking for data.
@@ -403,6 +399,69 @@ Valid options are `10, 25, 50, 100, 250, 1000, :all`
 
 There are a few other ways to customize the behaviour of effective_datatables
 
+### Display of an Empty Datatable
+
+How an empty datatable (0 display records) is displayed depends on how `render_datatable` is called.
+
+To render the full datatable with the default 'No data available in table' message:
+
+```haml
+= render_datatable(@datatable)
+```
+
+To skip rendering the datatable and just output a custom message:
+
+```haml
+= render_datatable(@datatable, 'There are no posts.')
+```
+
+or
+
+```haml
+= render_datatable(@datatable, :empty => 'There are no posts.')
+```
+
+To skip rendering the datatable and instead render given content:
+
+```haml
+= render_datatable(@datatable) do
+  %p There are no posts.
+  %p
+    Have a picture of a cat instead
+    = image_tag('cat.png')
+```
+
+### Checking for Empty collection
+
+While the 'what to render when empty' situation is handled by the above syntax, you may still check whether the datatable has records to display by calling `@datatable.empty?` and `@datatable.present?`.
+
+The gotcha with these methods is that the `@datatable.view` must first be assigned (which is done automatically by the `render_datatable` view method).
+
+This implementation is a bit awkward but has significant performance tradeoffs.
+
+To check for an empty datatable collection before it's rendered, you must manually assign a view:
+
+```ruby
+class PostsController < ApplicationController
+  def index
+    @datatable = Effective::Datatables::Posts.new()
+    @datatable.view = view_context  # built in Rails controller method refering to the view
+    @datatable.empty?
+  end
+end
+```
+
+or
+
+```ruby
+class PostsController < ApplicationController
+  def index
+    @datatable = Effective::Datatables::Posts.new()
+    @datatable.empty?(view_context)
+  end
+end
+```
+
 ### Customize Filter Behaviour
 
 This gem does its best to provide "just works" filtering of both raw SQL (table_column) and processed results (array_column) out-of-the-box.

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

@@ -13,6 +13,7 @@ initializeDataTables = ->
         bProcessing: true
         bSaveState: true
         bAutoWidth: false
+        deferLoading: datatable.data('total-entries')
         deferRender: true
         order: datatable.data('default-order')
         sAjaxSource: datatable.data('source')
@@ -27,7 +28,7 @@ initializeDataTables = ->
           # If this is the very first request to the server we have to manually set any selected filter options here
           # So that we can skip an fnFilter call in the dataTables.columnFilter that results in a double AJAX call
           ((sEcho = data; break) if data.name == 'sEcho') for data in aoData
-          if sEcho && sEcho.value == 1
+          if sEcho && sEcho.value == 2
             $.each (datatable.data('filter') || []), (index, filter) ->
               if(filter.selected)
                 sSearch = undefined

data/app/controllers/effective/datatables_controller.rb

@@ -4,7 +4,7 @@ module Effective
 
     def show
       @datatable = Effective::Datatable.find(params[:id], params[:attributes])
-      @datatable.view = view_context if @datatable.present?
+      @datatable.view = view_context if !@datatable.nil?
 
       EffectiveDatatables.authorized?(self, :index, @datatable.try(:collection_class) || Effective::Datatable)
 

data/app/helpers/effective_datatables_helper.rb

@@ -1,10 +1,23 @@
 module EffectiveDatatablesHelper
-  def render_datatable(datatable, opts = {})
+  def render_datatable(datatable, opts = {}, &block)
     datatable.view = self
-    locals = {:style => :full, :filterable => true, :sortable => true, :table_class => 'table-bordered table-striped'}.merge(opts)
+
+    locals = {:style => :full, :filterable => true, :sortable => true, :table_class => 'table-bordered table-striped'}
+    locals = locals.merge(opts) if opts.kind_of?(Hash)
     locals[:table_class] = 'sorting-hidden ' + locals[:table_class].to_s if locals[:sortable] == false
 
-    render :partial => 'effective/datatables/datatable', :locals => locals.merge(:datatable => datatable)
+    # Do we have to look at empty? behaviour
+    if (block_given? || opts.kind_of?(String) || (opts.kind_of?(Hash) && opts[:empty].present?)) && datatable.empty?
+      if block_given?
+        yield; nil
+      elsif opts.kind_of?(String)
+        opts
+      elsif opts.kind_of?(Hash) && opts[:empty].present?
+        opts[:empty]
+      end
+    else
+      render :partial => 'effective/datatables/datatable', :locals => locals.merge(:datatable => datatable)
+    end
   end
 
   def render_simple_datatable(datatable, opts = {})
@@ -58,12 +71,6 @@ module EffectiveDatatablesHelper
     ].to_json()
   end
 
-  def datatable_default_entries(datatable)
-    default_entries = (datatable.default_entries.presence || EffectiveDatatables.default_entries)
-    default_entries = -1 if default_entries.to_s.downcase == 'all'
-    [10, 25, 50, 100, 250, 1000, -1].include?(default_entries) ? default_entries : 25
-  end
-
   def datatable_widths(datatable)
     datatable.table_columns.values.map { |options| {'sWidth' => options[:width]} if options[:width] }.to_json()
   end

data/app/models/effective/datatable.rb

@@ -44,7 +44,6 @@ module Effective
       def default_entries(entries)
         @default_entries = entries
       end
-
     end
 
     def initialize(*args)
@@ -86,8 +85,10 @@ module Effective
       end.each_with_index { |(_, col), index| col[:index] = index }
     end
 
-    def to_json(options = {})
-      {
+    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 ||= {
         :sEcho => params[:sEcho].to_i,
         :aaData => table_data || [],
         :iTotalRecords => (
@@ -105,14 +106,35 @@ module Effective
       }
     end
 
-    # Wish these were protected
+    def present?(view = nil)
+      self.view = view unless view.nil?
+      to_json[:iTotalDisplayRecords] > 0
+    end
 
+    def empty?(view = nil)
+      self.view = view unless view.nil?
+      to_json[:iTotalDisplayRecords] == 0
+    end
+
+    # Wish these were protected
     def order_column_index
-      params[:iSortCol_0].to_i
+      if params[:iSortCol_0].present?
+        params[:iSortCol_0].to_i
+      elsif default_order.present?
+        table_columns[default_order.keys.first].fetch(:index, 0)
+      else
+        0
+      end
     end
 
     def order_direction
-      params[:sSortDir_0].try(:downcase) == 'desc' ? 'DESC' : 'ASC'
+      if params[:sSortDir_0].present?
+        params[:sSortDir_0].try(:downcase) == 'desc' ? 'DESC' : 'ASC'
+      elsif default_order.present?
+        default_order.values.first.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
+      else
+        'ASC'
+      end
     end
 
     def default_order
@@ -120,14 +142,27 @@ module Effective
     end
 
     def default_entries
-      self.class.instance_variable_get(:@default_entries)
+      @default_entries ||= begin
+        entries = (self.class.instance_variable_get(:@default_entries).presence || EffectiveDatatables.default_entries)
+        entries = -1 if entries.to_s.downcase == 'all'
+        [10, 25, 50, 100, 250, 1000, -1].include?(entries) ? entries : 25
+      end
     end
 
     def search_terms
       @search_terms ||= HashWithIndifferentAccess.new().tap do |terms|
-        table_columns.keys.each_with_index do |col, x|
-          unless (params["sVisible_#{x}"] == 'false' && table_columns[col][:filter][:when_hidden] != true)
-            terms[col] = params["sSearch_#{x}"] if params["sSearch_#{x}"].present?
+        if params[:sEcho].present?
+          table_columns.keys.each_with_index do |col, x|
+            unless (params["sVisible_#{x}"] == 'false' && table_columns[col][:filter][:when_hidden] != true)
+              terms[col] = params["sSearch_#{x}"] if params["sSearch_#{x}"].present?
+            end
+          end
+        else
+          # We are in the initial render and have to apply default search terms only
+          table_columns.each do |name, values|
+            if (values[:filter][:selected].present?) && (values[:visible] != false || values[:filter][:when_hidden] == true)
+              terms[name] = values[:filter][:selected]
+            end
           end
         end
       end
@@ -150,7 +185,7 @@ module Effective
       elsif length > 0
         length
       else
-        10
+        default_entries
       end
     end
 
@@ -188,13 +223,13 @@ module Effective
       col = collection
 
       if active_record_collection?
-        self.total_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_count").first['count'] rescue 1)
+        self.total_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_total_count").first['count'] rescue 1)
 
         col = table_tool.order(col)
         col = table_tool.search(col)
 
         if table_tool.search_terms.present? && array_tool.search_terms.blank?
-          self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_count").first['count'] rescue 1)
+          self.display_records = (collection_class.connection.execute("SELECT COUNT(*) FROM (#{col.to_sql}) AS datatables_filtered_count").first['count'] rescue 1)
         end
       else
         self.total_records = col.size

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

@@ -1,4 +1,4 @@
-%table.effective-datatable{:id => "#{datatable.to_param}-table", :class => ('table ' + table_class.to_s), :data => {'effective-datatables-table' => style, 'source' => effective_datatables.datatable_path(datatable, {:format => 'json'}.merge(:attributes => datatable.attributes)), 'filter' => datatable_filter(datatable, filterable), 'non-sortable' => datatable_non_sortable(datatable, sortable), 'non-visible' => datatable_non_visible(datatable), 'widths' => datatable_widths(datatable), 'default-order' => datatable_default_order(datatable), 'default-entries' => datatable_default_entries(datatable), 'column-classes' => datatable_column_classes(datatable)}}
+%table.effective-datatable{:id => "#{datatable.to_param}-table", :class => ('table ' + table_class.to_s), :data => {'effective-datatables-table' => style, 'source' => effective_datatables.datatable_path(datatable, {:format => 'json'}.merge(:attributes => datatable.attributes)), 'filter' => datatable_filter(datatable, filterable), 'non-sortable' => datatable_non_sortable(datatable, sortable), 'non-visible' => datatable_non_visible(datatable), 'widths' => datatable_widths(datatable), 'default-order' => datatable_default_order(datatable), 'default-entries' => datatable.default_entries, 'total-entries' => (datatable.to_json[:iTotalRecords] || false), 'column-classes' => datatable_column_classes(datatable)}}
   %thead
     - max_depth = datatable.table_columns.map { |_, opts| opts[:th][:depth].to_i rescue 0 }.max
     - [*0..max_depth].each do |depth|
@@ -9,3 +9,7 @@
           - (opts[:append_th] || []).each do |faux_col|
             %th{(faux_col[:th] || {}).merge({:title => faux_col[:label]})}= faux_col[:label]
   %tbody
+    - (datatable.to_json[:aaData] || []).each do |row|
+      %tr
+        - row.each do |col|
+          %td= col.to_s.html_safe

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '1.2.5'.freeze
+  VERSION = '1.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.3.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails