effective_datatables 2.12.2 → 3.0.0

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

@@ -0,0 +1,29 @@
+module Effective
+  module EffectiveDatatable
+    module Cookie
+
+      def cookie_name
+        @cookie_name ||= "datatable-#{URI(datatables_ajax_request? ? view.request.referer : view.request.url).path}-#{to_param}".parameterize
+      end
+
+      private
+
+      def load_cookie!
+        @cookie ||= (
+          cookie = view.cookies.signed[cookie_name]
+
+          if cookie.present?
+            data = Marshal.load(Base64.decode64(cookie))
+            raise 'invalid cookie' unless [data, data[:attributes], data[:state]].all? { |obj| obj.kind_of?(Hash) }
+            data
+          end
+        )
+      end
+
+      def save_cookie!
+        view.cookies.signed[cookie_name] = Base64.encode64(Marshal.dump(attributes: attributes, state: state))
+      end
+
+    end
+  end
+end

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

@@ -1,19 +1,25 @@
-# These are Class level methods.
-
 module Effective
   module EffectiveDatatable
     module Dsl
 
-      def datatable(&block)
-        define_method('initialize_datatable') { instance_exec(&block) }
+      def bulk_actions(&block)
+        define_method('initialize_bulk_actions') { dsl_tool.instance_exec(&block) }
       end
 
-      def scopes(&block)
-        define_method('initialize_scopes') { instance_exec(&block) }
+      def charts(&block)
+        define_method('initialize_charts') { dsl_tool.instance_exec(&block) }
       end
 
-      def charts(&block)
-        define_method('initialize_charts') { instance_exec(&block) }
+      def collection(&block)
+        define_method('initialize_collection') { self._collection = dsl_tool.instance_exec(&block) }
+      end
+
+      def datatable(&block)
+        define_method('initialize_datatable') { dsl_tool.instance_exec(&block) }
+      end
+
+      def filters(&block)
+        define_method('initialize_filters') { dsl_tool.instance_exec(&block) }
       end
 
     end

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

@@ -2,22 +2,21 @@ module Effective
   module EffectiveDatatable
     module Dsl
       module BulkActions
-        # These get added into the view as helpers
-        # To be called inside datatable { bulk_actions_column do .. end }
+
         def bulk_action(*args)
-          concat content_tag(:li, link_to(*args))
+          datatable._bulk_actions.push(content_tag(:li, link_to(*args)))
         end
 
         def bulk_download(*args)
-          concat content_tag(:li, link_to(*args), 'data-authenticity-token' => form_authenticity_token)
+          datatable._bulk_actions.push(content_tag(:li, link_to(*args), 'data-authenticity-token' => form_authenticity_token))
         end
 
         def bulk_action_divider
-          concat content_tag(:li, '', class: 'divider', role: 'separator')
+          datatable._bulk_actions.push(content_tag(:li, '', class: 'divider', role: 'separator'))
         end
 
         def bulk_action_content(&block)
-          concat block.call
+          datatable._bulk_actions.push(block.call)
         end
 
       end

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

@@ -3,17 +3,15 @@ module Effective
     module Dsl
       module Charts
         # Instance Methods inside the charts do .. end block
-        def chart(name, type, options = {}, &block)
+        def chart(name, as = 'BarChart', label: nil, legend: true, partial: nil, **options, &compute)
+          raise 'expected a block returning an Array of Arrays' unless block_given?
 
-          options[:title] ||= (options[:label] || name.to_s.titleize)
-          options[:legend] = 'none' if options[:legend] == false
-
-          (@charts ||= HashWithIndifferentAccess.new)[name] = {
+          datatable._charts[name.to_sym] = {
+            as: as,
+            compute: compute,
             name: name,
-            type: type,
-            partial: options.delete(:partial),
-            options: options,
-            block: (block if block_given?)
+            options: { label: (label || name.to_s.titleize), legend: (legend || 'none') }.merge(options),
+            partial: partial || '/effective/datatables/chart'
           }
         end
       end

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

@@ -3,80 +3,130 @@ module Effective
     module Dsl
       module Datatable
         # Instance Methods inside the datatable do .. end block
-        def default_order(name, direction = :asc)
-          @default_order = {name => direction}
-        end
+        def order(name, dir = nil)
+          raise 'order direction must be :asc or :desc' unless [nil, :asc, :desc].include?(dir)
 
-        def default_entries(entries)
-          @default_entries = entries
+          datatable.state[:order_name] ||= name
+          datatable.state[:order_dir] ||= dir
         end
 
-        def table_column(name, options = {}, proc = nil, &block)
-          if block_given?
-            raise "You cannot use partial: ... with the block syntax" if options[:partial] && !options[:type] == :actions
-            raise "You cannot use proc: ... with the block syntax" if options[:proc]
-            options[:block] = block
-          end
-          raise "You cannot use both partial: ... and proc: ..." if options[:partial] && options[:proc]
-
-          (@table_columns ||= HashWithIndifferentAccess.new)[name] = options
+        def length(length)
+          raise 'length must be 10, 25, 50, 100, 250, 1000, :all' unless [10, 25, 50, 100, 250, 1000, :all].include?(length)
+          datatable.state[:length] ||= (length == :all ? 9999999 : length)
         end
 
-        def array_column(name, options = {}, proc = nil, &block)
-          table_column(name, options.merge!(array_column: true), proc, &block)
-        end
+        # A col has its internal values sorted/searched before the block is run
+        # Anything done in the block, is purely a format on the after sorted/ordered value
+        # the original object == the computed value, which is yielded to the format block
+        # You can't do compute with .col
+        def col(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: nil, th: nil, th_append: nil, visible: true, &format)
+          raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
-        def actions_column(options = {}, proc = nil, &block)
-          raise 'first parameter to actions_column should be a hash' unless options.kind_of?(Hash)
+          datatable._columns[name.to_sym] = Effective::DatatableColumn.new(
+            action: action,  # resource columns only
+            as: as,
+            compute: nil,
+            col_class: col_class,
+            format: (format if block_given?),
+            index: datatable.columns.length,
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+            partial: partial,
+            partial_as: partial_as,
+            responsive: responsive,
+            search: search,
+            sort: sort,
+            sql_column: sql_column,
+            th: th,
+            th_append: th_append,
+            visible: visible,
+          )
+        end
 
-          show = options.fetch(:show, (EffectiveDatatables.actions_column[:show] rescue false))
-          edit = options.fetch(:edit, (EffectiveDatatables.actions_column[:edit] rescue false))
-          destroy = options.fetch(:destroy, (EffectiveDatatables.actions_column[:destroy] rescue false))
-          unarchive = options.fetch(:unarchive, (EffectiveDatatables.actions_column[:unarchive] rescue false))
-          name = options.fetch(:name, 'actions')
+        # A val is a computed value that is then sorted/searched after the block is run
+        # You can have another block by calling .format afterwards to work on the computed value itself
+        def val(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: nil, th: nil, th_append: nil, visible: true, &compute)
+          raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
-          opts = {
-            type: :actions,
-            sortable: false,
-            filter: false,
-            responsivePriority: 0,
-            partial_locals: { show_action: show, edit_action: edit, destroy_action: destroy, unarchive_action: unarchive },
-            actions_block: block
-          }.merge(options)
+          datatable._columns[name.to_sym] = Effective::DatatableColumn.new(
+            action: action, # Resource columns only
+            as: as,
+            compute: (compute if block_given?),
+            col_class: col_class,
+            format: nil,
+            index: datatable.columns.length,
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+            partial: partial,
+            partial_as: partial_as,
+            responsive: responsive,
+            search: search,
+            sort: sort,
+            sql_column: (block_given? ? false : sql_column),
+            th: th,
+            th_append: th_append,
+            visible: visible,
+          )
+        end
 
-          opts[:partial_local] ||= :resource unless opts[:partial].present?
-          opts[:partial] ||= '/effective/datatables/actions_column' unless proc.present?
+        def bulk_actions_col(col_class: nil, partial: nil, partial_as: nil, responsive: 5000)
+          raise 'You can only have one bulk actions column' if datatable.columns[:_bulk_actions].present?
 
-          table_column(name, opts, proc)
+          datatable._columns[:_bulk_actions] = Effective::DatatableColumn.new(
+            action: false,
+            as: :bulk_actions,
+            compute: nil,
+            col_class: col_class,
+            format: nil,
+            index: datatable.columns.length,
+            label: '',
+            name: :bulk_actions,
+            partial: partial || '/effective/datatables/bulk_actions_column',
+            partial_as: partial_as,
+            responsive: responsive,
+            search: { as: :bulk_actions },
+            sort: false,
+            sql_column: nil,
+            th: nil,
+            th_append: nil,
+            visible: true,
+          )
         end
 
-        def bulk_actions_column(options = {}, proc = nil, &block)
-          raise 'first parameter to bulk_actions_column should be a hash' unless options.kind_of?(Hash)
+        def actions_col(show: true, edit: true, destroy: true, col_class: nil, partial: nil, partial_as: nil, responsive: 5000, visible: true, &format)
+          raise 'You can only have one actions column' if datatable.columns[:_actions].present?
 
-          name = options.fetch(:name, 'bulk_actions')
-          resource_method = options.fetch(:resource_method, :to_param)
-
-          opts = {
-            bulk_actions_column: true,
+          datatable._columns[:_actions] = Effective::DatatableColumn.new(
+            action: false,
+            as: :actions,
+            compute: nil,
+            col_class: col_class,
+            format: (format if block_given?),
+            index: datatable.columns.length,
             label: '',
-            partial_local: :resource,
-            partial: '/effective/datatables/bulk_actions_column',
-            partial_locals: { resource_method: resource_method },
-            sortable: false,
-            dropdown_partial: '/effective/datatables/bulk_actions_dropdown',
-            dropdown_block: block
-          }.merge(options)
+            name: :actions,
+            partial: partial || '/effective/datatables/actions_column',
+            partial_as: partial_as,
+            responsive: responsive,
+            search: false,
+            sort: false,
+            sql_column: nil,
+            th: nil,
+            th_append: nil,
+            visible: visible,
 
-          table_column(name, opts, proc)
+            show: show,
+            edit: edit,
+            destroy: destroy
+          )
         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
+        def aggregate(name, label: nil, &compute)
+          datatable._aggregates[name.to_sym] = {
+            compute: (compute if block_given?),
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+          }
         end
       end
     end

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

@@ -0,0 +1,50 @@
+module Effective
+  module EffectiveDatatable
+    module Dsl
+      module Filters
+        def filter(name = nil, value = :_no_value, as: nil, label: nil, parse: nil, required: false, **input_html)
+          return datatable.filter if (name == nil && value == :_no_value) # This lets block methods call 'filter' and get the values
+
+          raise 'expected second argument to be a value' if value == :_no_value
+          raise 'parse must be a Proc' if parse.present? && !parse.kind_of?(Proc)
+
+          datatable._filters[name.to_sym] = {
+            value: value,
+            as: as,
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+            parse: parse,
+            required: required,
+            input_html: input_html
+          }
+        end
+
+        def scope(name = nil, *args, default: nil, label: nil)
+          return datatable.scope unless name # This lets block methods call 'scope' and get the values
+
+          datatable._scopes[name.to_sym] = {
+            default: default,
+            label: label || name.to_s.titleize,
+            name: name.to_sym,
+            args: args.presence
+          }
+        end
+
+        # This changes the filters from using an AJAX, to a POST or GET
+        def form(url: nil, verb: nil)
+          url ||= request.path
+          verb ||= (Rails.application.routes.recognize_path(url, method: :post).present? rescue false) ? :post : :get
+
+          datatable._form[:url] = url
+          datatable._form[:verb] = verb
+        end
+
+        def changes_columns_count
+          form()
+        end
+        alias_method :changes_column_count, :changes_columns_count
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module Effective
+  module EffectiveDatatable
+    module Format
+      BLANK = ''.freeze
+
+      private
+
+      def format(collection)
+        # We want to use the render :collection for each column that renders partials
+        rendered = {}
+
+        columns.each do |name, opts|
+          if opts[:partial] && state[:visible][name]
+            locals = {
+              datatable: self,
+              column: columns[name],
+              controller_namespace: controller_namespace
+            }.merge(actions_col_locals(opts)).merge(resource_col_locals(opts))
+
+            rendered[name] = (view.render(
+              partial: opts[:partial],
+              as: (opts[:partial_as] || :resource),
+              collection: collection.map { |row| row[opts[:index]] },
+              formats: :html,
+              locals: locals,
+              spacer_template: '/effective/datatables/spacer_template',
+            ) || '').split('EFFECTIVEDATATABLESSPACER')
+          end
+        end
+
+        collection.each_with_index do |row, row_index|
+          columns.each do |name, opts|
+            next unless state[:visible][name]
+
+            index = opts[:index]
+            value = row[index]
+
+            row[index] = (
+              if opts[:format] && opts[:as] == :actions
+                result = dsl_tool.instance_exec(value, row, &opts[:format])
+                "#{rendered[name][row_index]}#{result}"
+              elsif opts[:format]
+                dsl_tool.instance_exec(value, row, &opts[:format])
+              elsif opts[:partial]
+                rendered[name][row_index]
+              else
+                format_column(value, opts)
+              end
+            )
+          end
+        end
+      end
+
+      def format_column(value, column)
+        case column[:as]
+        when :boolean
+          case value
+          when true   ; 'Yes'
+          when false  ; 'No'
+          when String ; value
+          end
+        when :currency
+          view.number_to_currency(value) if value.present?
+        when :date
+          (value.strftime('%F') rescue BLANK) if value.present?
+        when :datetime
+          (value.strftime('%F %H:%M') rescue BLANK) if value.present?
+        when :decimal
+          value
+        when :duration
+          view.number_to_duration(value) if value.present?
+        when :effective_addresses
+          value.to_html if value.present?
+        when :effective_obfuscation
+          value
+        when :effective_roles
+          value.join(', ')
+        when :email
+          view.mail_to(value) if value.present?
+        when :integer
+          value
+        when :percentage
+          case value
+          when Integer    ; "#{value}%"
+          when Numeric    ; view.number_to_percentage(value * 100, precision: 2)
+          when String     ; value
+          end
+        when :price
+          raise 'column type: price expects an Integer representing the number of cents' unless value.kind_of?(Integer)
+          view.number_to_currency(value / 100.0) if value.present?
+        else
+          value.to_s
+        end
+      end
+
+      def actions_col_locals(opts)
+        return {} unless opts[:as] == :actions
+        return { show_path: false, edit_path: false, destroy_path: false } unless active_record_collection?
+
+        locals = {}
+
+        locals[:show_action] = opts[:show]
+        locals[:edit_action] = opts[:edit]
+        locals[:destroy_action] = opts[:destroy]
+
+        if locals[:show_action] && (EffectiveDatatables.authorized?(view.controller, :show, collection_class) rescue false)
+          locals[:show_path] = resource.show_path(check: true)
+        else
+          locals[:show_path] = false
+        end
+
+        if locals[:edit_action] && (EffectiveDatatables.authorized?(view.controller, :edit, collection_class) rescue false)
+          locals[:edit_path] = resource.edit_path(check: true)
+        else
+          locals[:edit_path] = false
+        end
+
+        if locals[:destroy_action] && (EffectiveDatatables.authorized?(view.controller, :destroy, collection_class) rescue false)
+          locals[:destroy_path] = resource.destroy_path(check: true)
+        else
+          locals[:destroy_path] = false
+        end
+
+        locals
+      end
+
+      def resource_col_locals(opts)
+        return {} unless (resource = opts[:resource]).present?
+
+        locals = { name: opts[:name], macro: opts[:as], show_path: false, edit_path: false }
+
+        case opts[:action]
+        when :edit
+          if (EffectiveDatatables.authorized?(view.controller, :edit, resource.klass) rescue false)
+            locals[:edit_path] = resource.edit_path(check: true)
+          end
+        when :show
+          if (EffectiveDatatables.authorized?(view.controller, :show, resource.klass) rescue false)
+            locals[:show_path] = resource.show_path(check: true)
+          end
+        when false
+          # Nothing
+        else
+          # Fallback to defaults - check edit then show
+          if (EffectiveDatatables.authorized?(view.controller, :edit, resource.klass) rescue false)
+            locals[:edit_path] = resource.edit_path(check: true)
+          elsif (EffectiveDatatables.authorized?(view.controller, :show, resource.klass) rescue false)
+            locals[:show_path] = resource.show(check: true)
+          end
+        end
+
+        locals
+      end
+
+    end # / Rendering
+  end
+end