effective_datatables 2.10.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38df969bd8b6fe71d4e850119c2b65d8b961b858
-  data.tar.gz: b89352ad871da29903b18d0f1693740edce96141
+  metadata.gz: f5055d945bd4b6b8226f2841e55b02485199622b
+  data.tar.gz: 4c4f45643a7eb2918c5347c0961303fd6e53ec86
 SHA512:
-  metadata.gz: 1395f9861d1a4c806b3b1e21d618c6782e926d5f3e865d4e3060d99b7b0c56ae022afe50ab5381d940b196b51ec73c131104b1b92d2f5ffe7cbc353715fcefd8
-  data.tar.gz: 0bc0b48bbfd87c9e09b09520e19b27b68608230f07f7baaad76eb9f446f83d158554f388d4c96b1b3488c035e2671dac3a498768693cc134263dbe4e2bf5997e
+  metadata.gz: bfbfcd41cce3993fde4ccf3898a2cfd48d5651b7a6322a4aa6f96443c4fe03555a94b58274653b9d8a5a31aa535b9ae7ba21bf8bdd32338f6e4e3d251320c948
+  data.tar.gz: a7c027feb2545b7aed6363f7490eafc57291fa7804394e42ccdc589a0c1229f1788a3428a8ddf2102b9d519c257055ab425cbabeaaae6d12cb6648f78360d0a4

data/README.md

@@ -569,6 +569,35 @@ Pass `scope :start_date, Time.zone.now-3.months, fallback: true` to fallback to
 
 Any `filter: { ... }` options will be passed straight into simple_form.
 
+### current_scope / model scopes
+
+You can also use scopes as defined on your ActiveRecord model
+
+When a scope is passed like follows, without a default value, it is assumed to be a klass level scope:
+
+```ruby
+scopes do
+  scope :all
+  scope :standard, default: true
+  scope :extended
+  scope :archived
+end
+
+def collection
+  collection = Post.all
+  collection = collection.send(current_scope) if current_scope
+  collection
+end
+```
+
+The front end will render these klass scopes as a radio buttons / button group.
+
+To determine which scope is selected, you can call `current_scope` or `attributes[:current_scope]` or `attributes[:standard]`
+
+When no scopes are selected, and no defaults are present, the above will return nil.
+
+It's a bit confusing, but you can mix and match these with regular attribute scopes.
+
 ## aggregates
 
 Each `aggregate` directive adds an additional row to the table's tfoot.
@@ -847,6 +876,20 @@ def finalize(collection)
 end
 ```
 
+## Customize the datatables JS initializer
+
+You can customize the initializer javascript passed to datatables.
+
+The support for this is still pretty limitted.
+
+```
+= render_datatable(@datatable, {colReorder: false})
+```
+
+```
+= render_datatable(@datatable, { buttons_export_columns: ':visible:not(.col-actions)' })
+```
+
 ## Authorization
 
 All authorization checks are handled via the config.authorization_method found in the `config/initializers/effective_datatables.rb` file.

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

@@ -5,6 +5,7 @@ initializeDataTables = ->
     datatable = $(this)
     simple = (datatable.data('simple') == true)
     input_js_options = datatable.data('input-js-options') || {}
+    buttons_export_columns = input_js_options['buttons_export_columns'] || ':not(.col-actions)'
 
     if input_js_options['buttons'] == false
       input_js_options['buttons'] = []
@@ -26,21 +27,21 @@ initializeDataTables = ->
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':not(.col-actions)'
+            columns: buttons_export_columns
         },
         {
           extend: 'csv',
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':not(.col-actions)'
+            columns: buttons_export_columns
         },
         {
           extend: 'excel',
           exportOptions:
             format:
               header: (str) -> $("<div>#{str}</div>").children('.filter-label').first().text()
-            columns: ':not(.col-actions)'
+            columns: buttons_export_columns
         },
         {
           extend: 'print',

data/app/models/effective/datatable.rb

@@ -22,13 +22,13 @@ module Effective
     include Effective::EffectiveDatatable::Rendering
 
     def initialize(*args)
-      if args.present? && args.first != nil
-        raise "#{self.class.name}.new() can only be initialized with a Hash like arguments" unless args.first.kind_of?(Hash)
-        args.first.each { |k, v| self.attributes[k] = v.presence }
+      if respond_to?(:initialize_scopes) # There was at least one scope defined in the scopes do .. end block
+        initialize_scopes
       end
 
+      initialize_attributes(args)
+
       if respond_to?(:initialize_scopes)  # There was at least one scope defined in the scopes do .. end block
-        initialize_scopes
         initialize_scope_options
       end
 
@@ -59,6 +59,18 @@ module Effective
       @scopes
     end
 
+    def klass_scopes
+      scopes.select { |name, options| options[:klass_scope] }
+    end
+
+    def current_scope # The currently selected (klass) scope
+      attributes[:current_scope]
+    end
+
+    def permitted_params
+      scopes.keys + [:current_scope, :referer]
+    end
+
     def charts
       @charts
     end
@@ -91,8 +103,8 @@ module Effective
       raise "You must define a collection. Something like an ActiveRecord User.all or an Array of Arrays [[1, 'something'], [2, 'something else']]"
     end
 
-    def collection_class
-      @collection_class ||= (collection.respond_to?(:klass) ? collection.klass : self.class)
+    def collection_class  # This is set by initialize_datatable_options()
+      @collection_class  # Will be either User/Post/etc or Array
     end
 
     def to_json
@@ -121,7 +133,7 @@ module Effective
     end
 
     def total_records
-      @total_records ||= (active_record_collection? ? active_record_collection_size(collection) : collection.size)
+      @total_records ||= (active_record_collection? ? active_record_collection_size(the_collection) : the_collection.size)
     end
 
     def view=(view_context)
@@ -144,7 +156,7 @@ module Effective
         @view.class_eval { delegate helper_method, to: :@effective_datatable }
       end
 
-      (self.class.instance_methods(false) - [:collection, :search_column, :order_column]).each do |view_method|
+      (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
 
@@ -171,6 +183,10 @@ module Effective
 
     protected
 
+    def the_collection
+      @memoized_collection ||= collection
+    end
+
     def params
       view.try(:params) || HashWithIndifferentAccess.new()
     end
@@ -187,19 +203,11 @@ module Effective
     # Check if collection has an order() clause and warn about it
     # Usually that will make the table results look weird.
     def active_record_collection?
-      if @active_record_collection == nil
-        @active_record_collection = (collection.ancestors.include?(ActiveRecord::Base) rescue false)
-      end
-
-      @active_record_collection
+      @active_record_collection == true
     end
 
     def array_collection?
-      if @array_collection == nil
-        @array_collection = (collection.kind_of?(Array) && collection.first.kind_of?(Array))
-      end
-
-      @array_collection
+      @array_collection == true
     end
 
     # Not every ActiveRecord query will work when calling the simple .count

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

@@ -3,12 +3,17 @@ module Effective
     module Dsl
       module Scopes
         # Instance Methods inside the scopes do .. end block
-        def scope(name, default, options = {}, &block)
+        def scope(name, default = :klass_scope, options = {}, &block)
           if block_given?
             raise "You cannot use partial: ... with the block syntax" if options[:partial]
             options[:block] = block
           end
 
+          if default == :klass_scope || default == { default: true }
+            options[:klass_scope] = true
+            default = (default == :klass_scope ? nil : true)
+          end
+
           # This needs to be a {} not WithIndifferentAccess or rendering _scopes won't work correctly
           (@scopes ||= {})[name] = options.merge(default: default)
         end

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

@@ -5,11 +5,16 @@ module Effective
     module Options
 
       def initialize_datatable_options
-        @table_columns = _initialize_datatable_options(@table_columns)
+        @table_columns = _initialize_datatable_options(@table_columns, the_collection)
+      end
+
+      def initialize_attributes(args)
+        _initialize_attributes(args)
       end
 
       def initialize_scope_options
         @scopes = _initialize_scope_options(@scopes)
+        _initialize_current_scope_attribute
       end
 
       def initialize_chart_options
@@ -22,6 +27,18 @@ module Effective
 
       protected
 
+      def _initialize_attributes(args)
+        args.compact.each do |arg|
+          if arg.respond_to?(:permit) # ActionController::Parameters / Rails 5
+            arg = arg.permit(*permitted_params).to_h()  # We permit only the scopes params
+          end
+
+          raise "#{self.class.name}.new() can only be initialized with a Hash like arguments" unless arg.kind_of?(Hash)
+
+          arg.each { |k, v| self.attributes[k] = v.presence }
+        end
+      end
+
       # The scope DSL is
       # scope :start_date, default_value, options: {}
       #
@@ -50,11 +67,30 @@ module Effective
         end
       end
 
+      def _initialize_current_scope_attribute
+        attributes[:current_scope] ||= klass_scopes.find { |name, options| options[:klass_scope] && options[:default] }.try(:first)
+
+        if attributes[:current_scope].present?
+          attributes[:current_scope] = attributes[:current_scope].to_sym
+          attributes[:current_scope] = nil unless klass_scopes.keys.include?(attributes[:current_scope])
+        end
+
+        if attributes[:current_scope].present?
+          klass_scopes.each { |name, _| attributes[name] = (name == attributes[:current_scope]) }
+        end
+      end
+
       def _initialize_chart_options(charts)
         charts
       end
 
-      def _initialize_datatable_options(cols)
+      def _initialize_datatable_options(cols, collection)
+        # We set some memoized helper values
+        @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.first.kind_of?(Array))
+
+        # And then parse all the colums
         sql_table = (collection.table rescue nil)
 
         # Here we identify all belongs_to associations and build up a Hash like:

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

@@ -10,7 +10,7 @@ module Effective
       # So the idea here is that we want to do as much as possible on the database in ActiveRecord
       # And then run any array_columns through in post-processed results
       def table_data
-        col = collection
+        col = the_collection
 
         if active_record_collection?
           col = table_tool.order(col)
@@ -32,14 +32,14 @@ module Effective
           end
         end
 
-        if array_collection?
+        if col.kind_of?(Array)
           col = array_tool.order(col)
           col = array_tool.search(col)
         end
 
         self.display_records ||= total_records
 
-        if array_collection?
+        if col.kind_of?(Array)
           col = array_tool.paginate(col)
         else
           col = table_tool.paginate(col)

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

@@ -2,7 +2,13 @@
   .col-sm-12.effective-datatable-scopes
     = simple_form_for :scopes, url: request.path, method: :get, html: { class: 'form-inline' } do |form|
 
-      - datatable.scopes.each do |name, options|
+      - if datatable.klass_scopes.present?
+        = form.input :current_scope, label: false, as: (defined?(EffectiveFormInputs) ? :effective_radio_buttons : :radio_buttons),
+          collection: datatable.klass_scopes.keys.map { |key| [key.to_s.titleize, key] },
+          checked: datatable.current_scope,
+          buttons: true
+
+      - datatable.scopes.except(*datatable.klass_scopes.keys).each do |name, options|
         - if options[:block].present?
           = form.instance_exec(form, &options[:block])
         - elsif options[:partial].present?

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.10.0'.freeze
+  VERSION = '2.11.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.11.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-12 00:00:00.000000000 Z
+date: 2017-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails