effective_datatables 2.6.13 → 2.6.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbedb70b17b8aaafe9d68c0b32257e91ebca11e1
-  data.tar.gz: 661091c0e5b7ec23b9be50f63dd92f85f8c4de6a
+  metadata.gz: e74b48943a26fed6030dccee8555337684bc4c49
+  data.tar.gz: ef20573e54accb0e2135e66a6c9f77a8720c51af
 SHA512:
-  metadata.gz: a38284cf5ad1da7d474151355b8179da9788beef16e087bc3a4af453d089fdf47b14d505e7ff12875a0a401c6870972bbe015f29103fb066b5cdeba475c9d21a
-  data.tar.gz: fd5bebb9d4114a6d7bc03eb5a4c6142bbf8056e8d52fd3fca011f8972b61c2abc65d1ce1d57987e1cda12404c96c30e8136d690207d06220d11626a34a2db0fc
+  metadata.gz: 01980cdb85274c5cf73a7131bbbe8ef9b1873930eb61a03b23bcec45b62e97f4c79bd3e59c9fa298306da752de323127cf556670fe351de2e69f77f33c516ff7
+  data.tar.gz: b163136bc40e04ec0cc698b9ff20c58e97402573071ee47a67513d710140fbb00e031e5388b9c34a1140af4a232d3751fccb3823aa239406551b43f3614f078b

data/app/helpers/effective_datatables_helper.rb

@@ -1,13 +1,40 @@
+# These are expected to be called by a developer.  They are part of the datatables DSL.
 module EffectiveDatatablesHelper
+
   def render_datatable(datatable, input_js_options = nil)
-    return if datatable.nil?
+    raise 'expected datatable to be present' unless datatable
+
     datatable.view ||= self
 
+    begin
+      EffectiveDatatables.authorized?(controller, :index, datatable.try(:collection_class) || datatable.try(:class)) || raise('unauthorized')
+    rescue => e
+      return content_tag(:p, "You are not authorized to view this datatable. (cannot :index, #{datatable.try(:collection_class) || datatable.try(:class)})")
+    end
+
     render partial: 'effective/datatables/datatable',
       locals: { datatable: datatable, input_js_options: input_js_options.try(:to_json) }
   end
 
+  def render_simple_datatable(datatable, input_js_options = nil)
+    raise 'expected datatable to be present' unless datatable
+
+    datatable.view ||= self
+    datatable.simple = true
+
+    begin
+      EffectiveDatatables.authorized?(controller, :index, datatable.try(:collection_class) || datatable.try(:class)) || raise('unauthorized')
+    rescue => e
+      return content_tag(:p, "You are not authorized to view this datatable. (cannot :index, #{datatable.try(:collection_class) || datatable.try(:class)})")
+    end
+
+    render partial: 'effective/datatables/datatable',
+      locals: {datatable: datatable, input_js_options: input_js_options.try(:to_json) }
+  end
+
   def render_datatable_scopes(datatable)
+    raise 'expected datatable to be present' unless datatable
+
     return unless datatable.scopes.present?
     datatable.view ||= self
 
@@ -15,6 +42,8 @@ module EffectiveDatatablesHelper
   end
 
   def render_datatable_charts(datatable)
+    raise 'expected datatable to be present' unless datatable
+
     return unless datatable.charts.present?
     datatable.view ||= self
 
@@ -22,6 +51,8 @@ module EffectiveDatatablesHelper
   end
 
   def render_datatable_chart(datatable, name)
+    raise 'expected datatable to be present' unless datatable
+
     return unless datatable.charts.present?
     return unless datatable.charts[name].present?
     datatable.view ||= self
@@ -40,116 +71,6 @@ module EffectiveDatatablesHelper
       locals: { datatable: datatable, chart: chart }
   end
 
-  def render_simple_datatable(datatable, input_js_options = nil)
-    return if datatable.nil?
-    datatable.view ||= self
-    datatable.simple = true
-
-    render partial: 'effective/datatables/datatable',
-      locals: {datatable: datatable, input_js_options: input_js_options.try(:to_json) }
-  end
-
-  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 }
-
-    datatable.table_columns.map do |name, options|
-      {
-        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]
-      }
-    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
-
-    {
-      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()
-  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?
-
-    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].key?(:placeholder) ? opts[:filter][:placeholder] : (opts[:label] || name.titleize)
-    title = opts[:filter].key?(:title) ? opts[:filter][:title] : (opts[:label] || name.titleize)
-
-    case opts[:filter][:as]
-    when :string, :text, :number
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        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"
-
-      form.input name, label: false, required: false, value: value,
-        as: :string,
-        placeholder: placeholder,
-        input_html: { name: nil, value: value, title: title, pattern: pattern, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} }
-    when :date
-      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,
-        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 }
-    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,
-        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
-    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,
-        include_blank: include_blank,
-        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
-        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,
-        grouped: true,
-        polymorphic: opts[:filter][:polymorphic] == true,
-        group_label_method: opts[:filter][:group_label_method] || :first,
-        group_method: opts[:filter][:group_method] || :last,
-        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
-        input_js: { placeholder: placeholder }
-    when :bulk_actions_column
-      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'} }
-    end
-  end
-
   def datatables_admin_path?
     @datatables_admin_path ||= (
       path = request.path.to_s.downcase.chomp('/') + '/'
@@ -163,4 +84,56 @@ module EffectiveDatatablesHelper
     attributes[:active_admin_path] rescue false
   end
 
+  ### Icon Helpers for actions_column or elsewhere
+  def show_icon_to(path, options = {})
+    glyphicon_to('eye-open', path, {title: 'Show'}.merge(options))
+  end
+
+  def edit_icon_to(path, options = {})
+    glyphicon_to('edit', path, {title: 'Edit'}.merge(options))
+  end
+
+  def destroy_icon_to(path, options = {})
+    defaults = {title: 'Destroy', data: {method: :delete, confirm: 'Delete this item?'}}
+    glyphicon_to('trash', path, defaults.merge(options))
+  end
+
+  def archive_icon_to(path, options = {})
+    defaults = {title: 'Archive', data: {method: :delete, confirm: 'Archive this item?'}}
+    glyphicon_to('trash', path, defaults.merge(options))
+  end
+
+  def unarchive_icon_to(path, options = {})
+    defaults = {title: 'Unarchive', data: {confirm: 'Unarchive this item?'}}
+    glyphicon_to('retweet', path, defaults.merge(options))
+  end
+
+  def settings_icon_to(path, options = {})
+    glyphicon_to('cog', path, {title: 'Settings'}.merge(options))
+  end
+
+  def ok_icon_to(path, options = {})
+    glyphicon_to('ok', path, {title: 'OK'}.merge(options))
+  end
+
+  def approve_icon_to(path, options = {})
+    glyphicon_to('ok', path, {title: 'Approve'}.merge(options))
+  end
+
+  def remove_icon_to(path, options = {})
+    glyphicon_to('remove', path, {title: 'Remove'}.merge(options))
+  end
+
+  def glyphicon_to(icon, path, options = {})
+    content_tag(:a, options.merge(href: path)) do
+      if icon.start_with?('glyphicon-')
+        content_tag(:span, '', class: "glyphicon #{icon}")
+      else
+        content_tag(:span, '', class: "glyphicon glyphicon-#{icon}")
+      end
+    end
+  end
+  alias_method :bootstrap_icon_to, :glyphicon_to
+  alias_method :glyph_icon_to, :glyphicon_to
+
 end

data/app/helpers/effective_datatables_private_helper.rb

@@ -0,0 +1,106 @@
+# These aren't expected to be called by a developer.
+# They are internal datatables methods, but you could still call them on the view.
+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 }
+
+    datatable.table_columns.map do |name, options|
+      {
+        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]
+      }
+    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
+
+    {
+      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()
+  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?
+
+    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].key?(:placeholder) ? opts[:filter][:placeholder] : (opts[:label] || name.titleize)
+    title = opts[:filter].key?(:title) ? opts[:filter][:title] : (opts[:label] || name.titleize)
+
+    case opts[:filter][:as]
+    when :string, :text, :number
+      form.input name, label: false, required: false, value: value,
+        as: :string,
+        placeholder: placeholder,
+        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'
+
+      form.input name, label: false, required: false, value: value,
+        as: :string,
+        placeholder: placeholder,
+        input_html: { name: nil, value: value, title: title, pattern: pattern, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} }
+    when :date
+      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,
+        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 }
+    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,
+        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
+    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,
+        include_blank: include_blank,
+        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        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,
+        grouped: true,
+        polymorphic: opts[:filter][:polymorphic] == true,
+        group_label_method: opts[:filter][:group_label_method] || :first,
+        group_method: opts[:filter][:group_method] || :last,
+        input_html: { name: nil, value: value, title: title, autocomplete: 'off', data: {'column-name' => opts[:name], 'column-index' => opts[:index]} },
+        input_js: { placeholder: placeholder }
+    when :bulk_actions_column
+      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'} }
+    end
+  end
+
+end

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

@@ -13,7 +13,7 @@ module Effective
 
         def table_column(name, options = {}, proc = nil, &block)
           if block_given?
-            raise "You cannot use partial: ... with the block syntax" if options[:partial]
+            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
@@ -27,6 +27,8 @@ module Effective
         end
 
         def actions_column(options = {}, proc = nil, &block)
+          raise 'first parameter to actions_column should be a hash' unless options.kind_of?(Hash)
+
           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))
@@ -34,6 +36,7 @@ module Effective
           name = options.fetch(:name, 'actions')
 
           opts = {
+            type: :actions,
             sortable: false,
             filter: false,
             responsivePriority: 0,
@@ -41,12 +44,14 @@ module Effective
           }.merge(options)
 
           opts[:partial_local] ||= :resource unless opts[:partial].present?
-          opts[:partial] ||= '/effective/datatables/actions_column' unless (block_given? || proc.present?)
+          opts[:partial] ||= '/effective/datatables/actions_column' unless proc.present?
 
           table_column(name, opts, proc, &block)
         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)
+
           name = options.fetch(:name, 'bulk_actions')
           resource_method = options.fetch(:resource_method, :to_param)
 

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

@@ -65,25 +65,7 @@ module Effective
 
             locals.merge!(opts[:partial_locals]) if opts[:partial_locals]
 
-            if active_record_collection?
-              if locals[:show_action] == :authorize
-                locals[:show_action] = (EffectiveDatatables.authorized?(controller, :show, collection_class) rescue false)
-              end
-
-              if locals[:edit_action] == :authorize
-                locals[:edit_action] = (EffectiveDatatables.authorized?(controller, :edit, collection_class) rescue false)
-              end
-
-              if locals[:destroy_action] == :authorize
-                locals[:destroy_action] = (EffectiveDatatables.authorized?(controller, :destroy, collection_class) rescue false)
-              end
-
-              if locals[:unarchive_action] == :authorize
-                locals[:unarchive_action] = (EffectiveDatatables.authorized?(controller, :unarchive, collection_class) rescue false)
-              end
-            end
-
-            # If locals[:show_action] == :authorize_each, this will get run again.
+            add_actions_column_locals(locals) if opts[:type] == :actions
 
             rendered[name] = (render(
               :partial => opts[:partial],
@@ -101,12 +83,20 @@ module Effective
             begin
               if opts[:visible] == false
                 BLANK
-              elsif opts[:partial]
-                rendered[name][index]
               elsif opts[:block]
-                view.instance_exec(obj, collection, self, &opts[:block])
+                begin
+                  view.instance_exec(obj, collection, self, &opts[:block])
+                rescue NoMethodError => e
+                  if opts[:type] == :actions && e.message == 'super called outside of method'
+                    rendered[name][index]
+                  else
+                    raise(e)
+                  end
+                end
               elsif opts[:proc]
                 view.instance_exec(obj, collection, self, &opts[:proc])
+              elsif opts[:partial]
+                rendered[name][index]
               elsif opts[:type] == :belongs_to
                 (obj.send(name) rescue nil).to_s
               elsif opts[:type] == :belongs_to_polymorphic
@@ -224,6 +214,122 @@ module Effective
         end
       end
 
+      protected
+
+      def add_actions_column_locals(locals)
+        return unless active_record_collection?
+
+        # Consider authorization levels first
+
+        if locals[:show_action] == :authorize
+          locals[:show_action] = (EffectiveDatatables.authorized?(controller, :show, collection_class) rescue false)
+        end
+
+        if locals[:edit_action] == :authorize
+          locals[:edit_action] = (EffectiveDatatables.authorized?(controller, :edit, collection_class) rescue false)
+        end
+
+        if locals[:destroy_action] == :authorize
+          locals[:destroy_action] = (EffectiveDatatables.authorized?(controller, :destroy, collection_class) rescue false)
+        end
+
+        if locals[:unarchive_action] == :authorize
+          locals[:unarchive_action] = (EffectiveDatatables.authorized?(controller, :unarchive, collection_class) rescue false)
+        end
+
+        # Then we look at the routes to see if these actions _actually_ exist
+
+        routes = Rails.application.routes
+
+        begin
+          resource = collection_class.new(id: 123)
+          resource.define_singleton_method(:persisted?) { true }  # We override persisted? to get the correct action urls
+        rescue => e
+          return
+        end
+
+        if (locals[:show_action] == true || locals[:show_action] == :authorize_each) && !locals[:show_path]
+          # Try our namespace
+          url = (view.polymorphic_path([*controller_namespace, resource]) rescue false)
+          url = false if url && !(routes.recognize_path(url) rescue false)
+
+          # Try no namespace
+          unless url
+            url = (view.polymorphic_path(resource) rescue false)
+            url = false if url && !(routes.recognize_path(url) rescue false)
+          end
+
+          # So if we have a URL, this is an action we can link to
+          if url
+            locals[:show_path] = url.gsub('123', ':to_param')
+          else
+            locals[:show_action] = false
+          end
+        end
+
+        if (locals[:edit_action] == true || locals[:edit_action] == :authorize_each) && !locals[:edit_path]
+          # Try our namespace
+          url = (view.edit_polymorphic_path([*controller_namespace, resource]) rescue false)
+          url = false if url && !(routes.recognize_path(url) rescue false)
+
+          # Try no namespace
+          unless url
+            url = (view.edit_polymorphic_path(resource) rescue false)
+            url = false if url && !(routes.recognize_path(url) rescue false)
+          end
+
+          # So if we have a URL, this is an action we can link to
+          if url
+            locals[:edit_path] = url.gsub('123', ':to_param')
+          else
+            locals[:edit_action] = false
+          end
+        end
+
+        if (locals[:destroy_action] == true || locals[:destroy_action] == :authorize_each) && !locals[:destroy_path]
+          # Try our namespace
+          url = (view.polymorphic_path([*controller_namespace, resource]) rescue false)
+          url = false if url && !(routes.recognize_path(url, method: :delete) rescue false)
+
+          # Try no namespace
+          unless url
+            url = (view.polymorphic_path(resource) rescue false)
+            url = false if url && !(routes.recognize_path(url, method: :delete) rescue false)
+          end
+
+          # So if we have a URL, this is an action we can link to
+          if url
+            locals[:destroy_path] = url.gsub('123', ':to_param')
+          else
+            locals[:destroy_action] = false
+          end
+        end
+
+        if resource.respond_to?(:archived?)
+          if (locals[:unarchive_action] == true || locals[:unarchive_action] == :authorize_each) && !locals[:unarchive_path]
+            # Try our namespace
+            url = (view.polymorphic_path([*controller_namespace, resource], action: :unarchive) rescue false)
+            url = false if url && !(routes.recognize_path(url) rescue false)
+
+            # Try no namespace
+            unless url
+              url = (view.polymorphic_path(resource, action: :unarchive) rescue false)
+              url = false if url && !(routes.recognize_path(url) rescue false)
+            end
+
+            # So if we have a URL, this is an action we can link to
+            if url
+              locals[:unarchive_path] = url.gsub('123', ':to_param')
+            else
+              locals[:unarchive_action] = false
+            end
+          end
+        else
+          locals[:unarchive_action] = false
+        end
+
+      end
+
       private
 
       def controller_namespace

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

@@ -23,30 +23,18 @@
     unarchive_action = instance_exec(resource, &unarchive_action)
   end
 
-- if show_action
-  - url = (polymorphic_path([*controller_namespace, resource]) rescue nil) || (polymorphic_path(resource) rescue nil)
-  - if url.present?
-    %a{href: url, title: 'Show'}
-      %span.glyphicon.glyphicon-eye-open
+- if show_action && show_path
+  = show_icon_to show_path.gsub(':to_param', resource.to_param)
 
-- if edit_action
-  - url = (edit_polymorphic_path([*controller_namespace, resource]) rescue nil) || (edit_polymorphic_path(resource) rescue nil)
-  - if url.present?
-    %a{href: url, title: 'Edit'}
-      %span.glyphicon.glyphicon-edit
+- if edit_action && edit_path
+  = edit_icon_to edit_path.gsub(':to_param', resource.to_param)
 
-- if destroy_action
-  - url = (polymorphic_path([*controller_namespace, resource]) rescue nil) || (polymorphic_path(resource) rescue nil)
-  - if url.present?
-    - if resource.respond_to?(:archived?) && !resource.archived?
-      %a{href: url, title: 'Archive', data: {method: :delete, confirm: "Are you sure you want to archive this item?"}}
-        %span.glyphicon.glyphicon-trash
-    - elsif resource.respond_to?(:archived?) == false
-      %a{href: url, title: 'Delete', data: {method: :delete, confirm: "Are you sure you want to delete this item?"}}
-        %span.glyphicon.glyphicon-trash
+- if destroy_action && destroy_path
+  - if resource.respond_to?(:archived?) && !resource.archived?
+    = archive_icon_to destroy_path.gsub(':to_param', resource.to_param)
+  - elsif resource.respond_to?(:archived?) == false
+    = destroy_icon_to destroy_path.gsub(':to_param', resource.to_param)
 
-- if unarchive_action && resource.respond_to?(:archived?) && resource.archived?
-  - url = (polymorphic_path([*controller_namespace, resource], action: :unarchive) rescue nil) || (polymorphic_path(resource, action: :unarchive) rescue nil)
-  - if url.present?
-    %a{href: url, title: 'Unarchive', data: {confirm: 'Are you sure you want to unarchive this item?'}}
-      %span.glyphicon.glyphicon-retweet
+- if unarchive_action && unarchive_path
+  - if resource.respond_to?(:archived?) && resource.archived?
+    = unarchive_icon_to unarchive_path.gsub(':to_param', resource.to_param)

data/lib/effective_datatables/engine.rb

@@ -8,6 +8,7 @@ module EffectiveDatatables
     initializer 'effective_datatables.action_controller' do |app|
       ActiveSupport.on_load :action_controller do
         helper EffectiveDatatablesHelper
+        helper EffectiveDatatablesPrivateHelper
       end
     end
 

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '2.6.13'.freeze
+  VERSION = '2.6.14'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 2.6.13
+  version: 2.6.14
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-29 00:00:00.000000000 Z
+date: 2016-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -135,6 +135,7 @@ files:
 - app/assets/stylesheets/effective_datatables/_overrides.scss.erb
 - app/controllers/effective/datatables_controller.rb
 - app/helpers/effective_datatables_helper.rb
+- app/helpers/effective_datatables_private_helper.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/active_record_datatable_tool.rb
 - app/models/effective/array_datatable_tool.rb