effective_datatables 2.12.2 → 3.0.0

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

@@ -1,20 +0,0 @@
-module Effective
-  module EffectiveDatatable
-    module Charts
-
-      def charts_data
-        HashWithIndifferentAccess.new().tap do |retval|
-          (charts || {}).each do |name, chart|
-            retval[name] = {
-              name: chart[:name],
-              type: chart[:type],
-              options: chart[:options],
-              data: (instance_exec(&chart[:block]) if chart[:block])
-            }
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Effective
-  module EffectiveDatatable
-    module Dsl
-      module Scopes
-        # Instance Methods inside the scopes do .. end 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
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-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

@@ -1,309 +0,0 @@
-# This is extended as class level into Datatable
-
-module Effective
-  module EffectiveDatatable
-    module Options
-
-      def initialize_datatable_options
-        @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
-        @charts = _initialize_chart_options(@charts)
-      end
-
-      def quote_sql(name)
-        collection_class.connection.quote_column_name(name) rescue name
-      end
-
-      protected
-
-      def _initialize_attributes(args)
-        args.compact.each do |arg|
-          # ActionController::Parameters / Rails 5 hack. TODO.
-          if arg.respond_to?(:permit)
-            arg = (arg.respond_to?(:to_unsafe_h) ? arg.to_unsafe_h : arg.to_h)
-          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 }
-        end
-      end
-
-      # The scope DSL is
-      # scope :start_date, default_value, options: {}
-      #
-      # The value might already be assigned, but if not, we have to assign the default to attributes
-
-      # 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|
-          value = attributes.key?(name) ? attributes[name].presence : options[:default]
-
-          if attributes.key?(name) == false
-            self.attributes[name] = options[:default]
-            value = options[:default]
-          end
-
-          if (options[:fallback] || options[:presence]) && attributes[name].blank?
-            self.attributes[name] = options[:default]
-            value = options[:default]
-          end
-
-          options[:filter] ||= {}
-          options[:filter][:input_html] ||= {}
-          options[:filter][:input_html][:value] = value
-          options[:filter][:selected] = value
-        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, 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.length == 0 || 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:
-        # {user: {foreign_key: 'user_id', klass: User}, order: {foreign_key: 'order_id', klass: Effective::Order}}
-        belong_tos = (collection.klass.reflect_on_all_associations(:belongs_to) rescue []).inject({}) do |retval, bt|
-          if bt.options[:polymorphic]
-            retval[bt.name.to_s] = {foreign_key: bt.foreign_key, klass: bt.name, polymorphic: true}
-          else
-            klass = bt.klass || (bt.foreign_type.sub('_type', '').classify.constantize rescue nil)
-            retval[bt.name.to_s] = {foreign_key: bt.foreign_key, klass: klass} if bt.foreign_key.present? && klass.present?
-          end
-
-          retval
-        end
-
-        # Figure out has_manys and has_many_belongs_to_many's
-        has_manys = {}
-        has_and_belongs_to_manys = {}
-
-        (collection.klass.reflect_on_all_associations() rescue []).each do |reflect|
-          if reflect.macro == :has_many
-            klass = reflect.klass || (reflect.build_association({}).class)
-            has_manys[reflect.name.to_s] = { klass: klass }
-          elsif reflect.macro == :has_and_belongs_to_many
-            klass = reflect.klass || (reflect.build_association({}).class)
-            has_and_belongs_to_manys[reflect.name.to_s] = { klass: klass }
-          end
-        end
-
-        table_columns = (cols || {}).each_with_index do |(name, _), index|
-          sql_column = (collection.columns rescue []).find do |column|
-            column.name == name.to_s || (belong_tos.key?(name) && column.name == belong_tos[name][:foreign_key])
-          end
-
-          cols[name][:array_column] ||= false
-          cols[name][:index] = index # The index of this column in the collection, regardless of hidden table_columns
-          cols[name][:name] ||= name
-          cols[name][:label] ||= name.titleize
-          cols[name][:column] ||= (sql_table && sql_column) ? "#{quote_sql(sql_table.name)}.#{quote_sql(sql_column.name)}" : name
-          cols[name][:width] ||= nil
-          cols[name][:sortable] = true if cols[name][:sortable].nil?
-          cols[name][:visible] = true if cols[name][:visible].nil?
-
-          # Type
-          cols[name][:type] ||= cols[name][:as]  # Use as: or type: interchangeably
-
-          cols[name][:type] ||= (
-            if belong_tos.key?(name)
-              if belong_tos[name][:polymorphic]
-                :belongs_to_polymorphic
-              else
-                :belongs_to
-              end
-            elsif has_manys.key?(name)
-              :has_many
-            elsif has_and_belongs_to_manys.key?(name)
-              :has_and_belongs_to_many
-            elsif cols[name][:bulk_actions_column]
-              :bulk_actions_column
-            elsif name.include?('_address') && defined?(EffectiveAddresses) && (collection_class.new rescue nil).respond_to?(:effective_addresses)
-              :effective_address
-            elsif name == 'id' && defined?(EffectiveObfuscation) && collection.respond_to?(:deobfuscate)
-              :obfuscated_id
-            elsif name == 'roles' && defined?(EffectiveRoles) && collection.respond_to?(:with_role)
-              :effective_roles
-            elsif sql_column.try(:type).present?
-              sql_column.type
-            elsif name.end_with?('_id')
-              :integer
-            else
-              :string # When in doubt
-            end
-          )
-
-          cols[name][:class] = "col-#{cols[name][:type]} col-#{name.parameterize} #{cols[name][:class]}".strip
-
-          # Formats
-          if name == 'id' || name.include?('year') || name.end_with?('_id')
-            cols[name][:format] = :non_formatted_integer
-          end
-
-          # Sortable - Disable sorting on these types
-          if [:has_many, :effective_address, :obfuscated_id].include?(cols[name][:type])
-            cols[name][:sortable] = false
-          end
-
-          # EffectiveRoles, if you do table_column :roles, everything just works
-          if cols[name][:type] == :effective_roles
-            cols[name][:column] = sql_table.present? ? "#{quote_sql(sql_table.name)}.#{quote_sql('roles_mask')}" : name
-          end
-
-          # This is a SELECT AS column, or a JOIN column or a delegated object
-          if sql_table.present? && sql_column.blank? && !cols[name][:array_column]
-            cols[name][:sql_as_column] = true
-          end
-
-          cols[name][:filter] = initialize_table_column_filter(cols[name], belong_tos[name], has_manys[name], has_and_belongs_to_manys[name])
-
-          if cols[name][:partial]
-            cols[name][:partial_local] ||= (sql_table.try(:name) || cols[name][:partial].split('/').last(2).first.presence || 'obj').singularize.to_sym
-          end
-        end
-
-      end
-
-      def initialize_table_column_filter(column, belongs_to, has_many, has_and_belongs_to_manys)
-        filter = column[:filter]
-        col_type = column[:type]
-        sql_column = column[:column].to_s.upcase
-
-        return {as: :null} if filter == false
-
-        filter = {as: filter.to_sym} if filter.kind_of?(String)
-        filter = {} unless filter.kind_of?(Hash)
-
-        # This is a fix for passing filter[:selected] == false, it needs to be 'false'
-        filter[:selected] = filter[:selected].to_s unless filter[:selected].nil?
-
-        # Allow :values or :collection to be used interchangeably
-        if filter.key?(:values)
-          filter[:collection] ||= filter[:values]
-        end
-
-        # Allow :as or :type to be used interchangeably
-        if filter.key?(:type)
-          filter[:as] ||= filter[:type]
-        end
-
-        # If you pass a collection, just assume it's a select
-        if filter.key?(:collection) && col_type != :belongs_to_polymorphic
-          filter[:as] ||= :select
-        end
-
-        # Fuzzy by default throughout
-        unless filter.key?(:fuzzy)
-          filter[:fuzzy] = true
-        end
-
-        # Check if this is an aggregate column
-        if ['SUM(', 'COUNT(', 'MAX(', 'MIN(', 'AVG('].any? { |str| sql_column.include?(str) }
-          filter[:sql_operation] = :having
-        end
-
-        case col_type
-        when :belongs_to
-          {
-            as: :select,
-            collection: (
-              if belongs_to[:klass].respond_to?(:datatables_filter)
-                Proc.new { belongs_to[:klass].datatables_filter }
-              elsif belongs_to[:klass].respond_to?(:sorted)
-                Proc.new { belongs_to[:klass].sorted }
-              else
-                Proc.new { belongs_to[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
-              end
-            )
-          }
-        when :belongs_to_polymorphic
-          {as: :grouped_select, polymorphic: true, collection: {}}
-        when :has_many
-          {
-            as: :select,
-            multiple: true,
-            collection: (
-              if has_many[:klass].respond_to?(:datatables_filter)
-                Proc.new { has_many[:klass].datatables_filter }
-              elsif has_many[:klass].respond_to?(:sorted)
-                Proc.new { has_many[:klass].sorted }
-              else
-                Proc.new { has_many[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
-              end
-            )
-          }
-        when :has_and_belongs_to_many
-          {
-            as: :select,
-            multiple: true,
-            collection: (
-              if has_and_belongs_to_manys[:klass].respond_to?(:datatables_filter)
-                Proc.new { has_and_belongs_to_manys[:klass].datatables_filter }
-              elsif has_and_belongs_to_manys[:klass].respond_to?(:sorted)
-                Proc.new { has_and_belongs_to_manys[:klass].sorted }
-              else
-                Proc.new { has_and_belongs_to_manys[:klass].all.map { |obj| [obj.to_s, obj.id] }.sort { |x, y| x[0] <=> y[0] } }
-              end
-            )
-          }
-        when :effective_address
-          {as: :string}
-        when :effective_roles
-          {as: :select, collection: EffectiveRoles.roles}
-        when :obfuscated_id
-          {as: :obfuscated_id}
-        when :integer
-          {as: :number}
-        when :boolean
-          if EffectiveDatatables.boolean_format == :yes_no
-            {as: :boolean, collection: [['Yes', true], ['No', false]] }
-          else
-            {as: :boolean, collection: [['true', true], ['false', false]] }
-          end
-        when :datetime
-          {as: :datetime}
-        when :date
-          {as: :date}
-        when :bulk_actions_column
-          {as: :bulk_actions_column}
-        else
-          {as: :string}
-        end.merge(filter.symbolize_keys)
-      end
-
-    end
-  end
-end

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

@@ -1,365 +0,0 @@
-# This is extended as class level into Datatable
-
-module Effective
-  module EffectiveDatatable
-    module Rendering
-      BLANK = ''.freeze
-
-      protected
-
-      # 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 = the_collection
-
-        if active_record_collection?
-          col = table_tool.order(col)
-          col = table_tool.search(col)
-
-          if table_tool.search_terms.present? && array_tool.search_terms.blank?
-            self.display_records = active_record_collection_size(col)
-          end
-
-          if array_tool.search_terms.present?
-            col = self.arrayize(col)
-            col = array_tool.search(col)
-            self.display_records = col.size
-          end
-
-          if array_tool.order_by_column.present?
-            col = self.arrayize(col)
-            col = array_tool.order(col)
-          end
-        end
-
-        if col.kind_of?(Array)
-          col = array_tool.order(col)
-          col = array_tool.search(col)
-        end
-
-        self.display_records ||= total_records
-
-        if col.kind_of?(Array)
-          col = array_tool.paginate(col)
-        else
-          col = table_tool.paginate(col)
-        end
-
-        col = self.arrayize(col)
-
-        self.format(col)
-        col = self.finalize(col)
-      end
-
-      def arrayize(collection)
-        return collection if @arrayized  # Prevent the collection from being arrayized more than once
-        @arrayized = true
-
-        # We want to use the render :collection for each column that renders partials
-        rendered = {}
-        (display_table_columns || table_columns).each do |name, opts|
-          if opts[:partial] && opts[:visible]
-            locals = HashWithIndifferentAccess.new(
-              datatable: self,
-              table_column: table_columns[name],
-              controller_namespace: controller_namespace,
-              show_action: (opts[:partial_locals] || {})[:show_action],
-              edit_action: (opts[:partial_locals] || {})[:edit_action],
-              destroy_action: (opts[:partial_locals] || {})[:destroy_action],
-              unarchive_action: (opts[:partial_locals] || {})[:unarchive_action]
-            )
-
-            locals.merge!(opts[:partial_locals]) if opts[:partial_locals]
-
-            if opts[:type] == :actions
-              add_actions_column_locals(locals)
-              locals[:actions_block] = opts[:actions_block]
-            end
-
-            rendered[name] = (render(
-              :partial => opts[:partial],
-              :as => opts[:partial_local],
-              :collection => collection,
-              :formats => :html,
-              :locals => locals,
-              :spacer_template => '/effective/datatables/spacer_template',
-            ) || '').split('EFFECTIVEDATATABLESSPACER')
-          end
-        end
-
-        collection.each_with_index.map do |obj, index|
-          (display_table_columns || table_columns).map do |name, opts|
-            begin
-              if opts[:visible] == false && (name != order_name.to_s) # Sort by invisible array column
-                BLANK
-              elsif opts[:block]
-                begin
-                  if active_record_collection?
-                    view.instance_exec(obj, collection, self, &opts[:block])
-                  else
-                    view.instance_exec(obj, obj[opts[:index]], collection, self, &opts[:block])
-                  end
-                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]
-                if active_record_collection?
-                  view.instance_exec(obj, collection, self, &opts[:proc])
-                else
-                  view.instance_exec(obj, obj[opts[:index]], collection, self, &opts[:proc])
-                end
-              elsif opts[:partial]
-                rendered[name][index]
-              elsif opts[:type] == :belongs_to
-                (obj.send(name) rescue nil).to_s
-              elsif opts[:type] == :belongs_to_polymorphic
-                (obj.send(name) rescue nil).to_s
-              elsif opts[:type] == :has_many
-                (obj.send(name).map { |obj| obj.to_s }.join('<br>') rescue BLANK)
-              elsif opts[:type] == :has_and_belongs_to_many
-                (obj.send(name).map { |obj| obj.to_s }.join('<br>') rescue BLANK)
-              elsif opts[:type] == :bulk_actions_column
-                BLANK
-              elsif opts[:type] == :year
-                obj.send(name).try(:year)
-              elsif opts[:type] == :obfuscated_id
-                (obj.send(:to_param) rescue nil).to_s
-              elsif opts[:type] == :effective_address
-                (Array(obj.send(name)) rescue [])
-              elsif opts[:type] == :effective_roles
-                (obj.send(:roles) rescue [])
-              elsif obj.kind_of?(Array) # Array backed collection
-                obj[opts[:index]]
-              elsif opts[:sql_as_column]
-                obj[name] || obj.send(name)
-              else
-                obj.send(name)
-              end
-            rescue => e
-              Rails.env.production? ? obj.try(:[], name) : raise(e)
-            end
-          end
-        end
-      end
-
-      def format(collection)
-        collection.each do |row|
-          (display_table_columns || table_columns).each_with_index do |(name, opts), index|
-            value = row[index]
-            next if value == nil || value == BLANK || opts[:visible] == false
-            next if opts[:block] || opts[:partial] || opts[:proc]
-
-            if opts[:sql_as_column]
-              row[index] = value.to_s
-            end
-
-            case (opts[:format] || opts[:type])
-            when :belongs_to, :belongs_to_polymorphic
-              row[index] = value.to_s
-            when :has_many
-              if value.kind_of?(Array)
-                if value.length == 0
-                  row[index] = BLANK
-                elsif value.length == 1
-                  row[index] = value.first.to_s
-                elsif opts[:sentence]
-                  row[index] = value.map { |v| v.to_s }.to_sentence
-                else
-                  row[index] = value.map { |v| v.to_s }.join('<br>')
-                end
-              end
-            when :effective_address
-              row[index] = value.map { |addr| addr.to_html }.join('<br>')
-            when :effective_roles
-              row[index] = value.join(', ')
-            when :datetime
-              row[index] = value.strftime(EffectiveDatatables.datetime_format) rescue BLANK
-            when :date
-              row[index] = value.strftime(EffectiveDatatables.date_format) rescue BLANK
-            when :price
-              # This is an integer value, "number of cents"
-              raise 'column type: price expects an Integer representing the number of cents' unless value.kind_of?(Integer)
-              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) }
-              elsif EffectiveDatatables.integer_format.respond_to?(:call)
-                row[index] = view.instance_exec { EffectiveDatatables.integer_format.call(value) }
-              end
-            when :boolean
-              if EffectiveDatatables.boolean_format == :yes_no && value == true
-                row[index] = 'Yes'
-              elsif EffectiveDatatables.boolean_format == :yes_no && value == false
-                row[index] = 'No'
-              end
-            when :string
-              row[index] = mail_to(value) if name == 'email'
-            else
-              ; # Nothing
-            end
-          end
-        end
-
-        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
-
-      protected
-
-      def add_actions_column_locals(locals)
-        return unless 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
-
-        # 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
-          raise 'no to param' unless resource.to_param.present?
-        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("/#{resource.to_param}", '/: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("/#{resource.to_param}", '/: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("/#{resource.to_param}", '/: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("/#{resource.to_param}", '/:to_param')
-            else
-              locals[:unarchive_action] = false
-            end
-          end
-        else
-          locals[:unarchive_action] = false
-        end
-
-      end
-
-      private
-
-      def controller_namespace
-        @controller_namespace ||= (
-          path = if attributes[:referer].present?
-            URI(attributes[:referer]).path
-          else
-            view.controller_path
-          end
-
-          path.split('/')[0...-1].map { |path| path.downcase.to_sym if path.present? }.compact
-        )
-      end
-
-    end # / Rendering
-  end
-end