active_scaffold_vho 3.0.31 → 3.1.0

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -1,24 +1,28 @@
 module ActionView
   class LookupContext
     module ViewPaths
-      def find_all_templates(name, prefix = nil, partial = false)
-        templates = []
-        @view_paths.each do |resolver|
-          template = resolver.find_all(*args_for_lookup(name, prefix, partial)).first
-          templates << template unless template.nil?
-        end
-        templates
+
+      def find_all_templates(name, partial = false, locals = {})
+        prefixes.collect do |prefix|
+          @view_paths.collect do |resolver|
+            temp_args = *args_for_lookup(name, [prefix], partial, locals)
+            temp_args[1] = temp_args[1][0]
+            resolver.find_all(*temp_args)
+          end
+        end.flatten!
       end
     end
   end
 end
 
 # wrap the action rendering for ActiveScaffold views
-module ActionView::Rendering #:nodoc:
+module ActionView #:nodoc:
+  class Renderer
+  #
   # Adds two rendering options.
   #
   # ==render :super
-  # ==render :super, :locals =>{:headline => 'formheadline'}
+  # ==render :partial => :super, :locals =>{:headline => 'formheadline'}
   #
   # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
   # Useful if you want to wrap an existing template. Just call super!
@@ -37,83 +41,99 @@ module ActionView::Rendering #:nodoc:
   #
   # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
   #
-  def render_with_active_scaffold(*args, &block)
-    options = args.first
-    if options == :super
+    def render_with_active_scaffold(context, options, &block)
+      if options && options[:partial] == :super
+        render_as_super_view(context, options, &block)
+      elsif context.is_a?(Hash) and context[:active_scaffold]
+        render_as_embedded_view(context, options, &block)
+      else
+        render_as_view(context, options, &block)
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+
+    def render_partial_with_active_scaffold(context, options, &block) #:nodoc:
+      if block_given?
+        render(context, options, block)
+      else
+        render(context, options)
+      end
+    end
+    alias_method_chain :render_partial, :active_scaffold
+
+    def render_template_with_active_scaffold(context, options) #:nodoc:
+      render(context, options)
+    end
+    alias_method_chain :render_template, :active_scaffold
+
+
+    def render_as_super_view(context, options, &block)
       last_view = @view_stack.last
-      options = args[1] || {}
       options[:locals] ||= {}
       options[:locals].reverse_merge!(last_view[:locals] || {})
       if last_view[:templates].nil?
-        last_view[:templates] = lookup_context.find_all_templates(last_view[:view], controller_path, !last_view[:is_template])
+        last_view[:templates] = lookup_context.find_all_templates(last_view[:view], !last_view[:is_template], options[:locals].keys)
         last_view[:templates].shift
       end
       options[:template] = last_view[:templates].shift
       @view_stack << last_view
-      result = render_without_active_scaffold options
+      options.delete(:partial) if options[:partial] == :super
+      result = if options.key?(:partial)
+        render_partial_without_active_scaffold(last_view[:context], options)
+      else
+        render_template_without_active_scaffold(last_view[:context], options)
+      end
       @view_stack.pop
       result
-    elsif options.is_a?(Hash) && options[:active_scaffold]
-      require 'digest/md5'
+    end
 
+    def render_as_embedded_view(context, options, &block)
+      require 'digest/md5'
       remote_controller = options[:active_scaffold]
       constraints = options[:constraints]
       conditions = options[:conditions]
       eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
-      session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => options[:label]}}
+      session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
       options[:params] ||= {}
       options[:params].merge! :eid => eid, :embedded => true
-      
+
       id = "as_#{eid}-content"
       url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
-      
-      unless controller.respond_to?(:render_component_into_view)
+
+      if controller.respond_to?(:render_component_into_view)
         controller.send(:render_component_into_view, url_options)
       else
-        url_options.delete(:embedded)
-        content_tag(:div, {:id => id, :class => 'active-scaffold-component'}) do
+        content_tag(:div, {:id => id}) do
           url = url_for(url_options)
-          link_to(remote_controller.to_s, url, {:remote => true, :class => 'as_link_to_component'})
-        end
-      end
-      
-    else
-      if options.is_a?(Hash)
-        current_view = {:view => options[:partial], :is_template => false} if options[:partial]
-        current_view = {:view => options[:template], :is_template => !!options[:template]} if current_view.nil? && options[:template]
-        current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
-        if current_view.present?
-          @view_stack ||= []
-          @view_stack << current_view
+          link_to(remote_controller.to_s, url, {:remote => true, :id => id}) <<
+            if ActiveScaffold.js_framework == :prototype
+            javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+          elsif ActiveScaffold.js_framework == :jquery
+            javascript_tag("$('##{id}').load('#{url}');")
+          end
         end
       end
-      result = render_without_active_scaffold(*args, &block)
-      @view_stack.pop if current_view.present?
-      result
     end
-  end
-  alias_method_chain :render, :active_scaffold
-  
 
-  def partial_pieces(partial_path)
-    if partial_path.include?('/')
-      return File.dirname(partial_path), File.basename(partial_path)
-    else
-      return controller.class.controller_path, partial_path
+    def render_as_view(context, options, &block)
+       if options.is_a?(Hash)
+          current_view = {:view => options[:partial], :is_template => false} if options[:partial]
+          current_view = {:view => options[:template], :is_template => !!options[:template]} if current_view.nil? && options[:template]
+          if current_view.present?
+            current_view[:locals] = options[:locals] if options[:locals]
+            current_view[:context] = context
+            @view_stack ||= []
+            @view_stack << current_view
+          end
+        end
+        result = if options.key?(:partial)
+          render_partial_without_active_scaffold(context, options, &block)
+        else
+          render_template_without_active_scaffold(context, options, &block)
+        end
+        result
     end
   end
+
   
-  # This is the template finder logic, keep it updated with however we find stuff in rails
-  # currently this very similar to the logic in ActionBase::Base.render for options file
-  # TODO: Work with rails core team to find a better way to check for this.
-  def template_exists?(template_name, lookup_overrides = false)
-    begin
-      method = 'find_template'
-      method << '_without_active_scaffold' unless lookup_overrides
-      self.view_paths.send(method, template_name, @template_format)
-      return true
-    rescue ActionView::MissingTemplate => e
-      return false
-    end
-  end
 end

data/lib/active_scaffold/extensions/action_view_resolver.rb

@@ -1,7 +1,9 @@
 module ActionView
   class ActiveScaffoldResolver < FileSystemResolver
-    def build_path(name, prefix, partial, details)
-      super(name, '', partial, details)
+    # standard resolvers have a base path to views and append a controller subdirectory
+    # activescaffolds view path do not have a subdir, so just remove the prefix
+    def find_templates(name, prefix, partial, details)
+      super(name,'',partial, details)
     end
   end
 end

data/lib/active_scaffold/extensions/active_association_reflection.rb

@@ -1,13 +1,13 @@
 # Bugfix: building an sti model from an association fails
 # https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/6306-collection-associations-build-method-not-supported-for-sti
 ActiveRecord::Reflection::AssociationReflection.class_eval do
-  def build_association(*opts)
+  def build_association(*opts, &block)
     col = klass.inheritance_column.to_sym
     if !col.nil? && opts.first.is_a?(Hash) && (opts.first.symbolize_keys[col])
       sti_model = opts.first.delete(col)
-      sti_model.to_s.camelize.constantize.new(*opts)
+      sti_model.to_s.camelize.constantize.new(*opts, &block)
     else
-      klass.new(*opts)
+      klass.new(*opts, &block)
     end
   end
 end

data/lib/active_scaffold/extensions/reverse_associations.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         def reverse_matches_for(klass)
           reverse_matches = []
 
-          # stage 1 filter: collect associations that point back to this model and use the same primary_key_name
+          # stage 1 filter: collect associations that point back to this model and use the same foreign_key
           klass.reflect_on_all_associations.each do |assoc|
             if self.options[:through]
               # only iterate has_many :through associations
@@ -40,9 +40,9 @@ module ActiveRecord
                 when 1
                 next
 
-                # otherwise, match them based on the primary_key_name
+                # otherwise, match them based on the foreign_key
                 when 0
-                next unless assoc.primary_key_name.to_sym == self.primary_key_name.to_sym
+                next unless assoc.foreign_key.to_sym == self.foreign_key.to_sym
               end
             end
 

data/lib/active_scaffold/finder.rb

@@ -83,28 +83,21 @@ module ActiveScaffold
         end
       end
 
-
       def condition_for_range(column, value, like_pattern = nil)
         if !value.is_a?(Hash)
           if column.column.nil? || column.column.text?
-            ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', column.stripped_value(value))]
+            ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
           else
             ["#{column.search_sql} = ?", column.column.type_cast(value)]
           end
         elsif value[:from].blank?
           nil
         elsif ActiveScaffold::Finder::StringComparators.values.include?(value[:opt])
-          if(active_scaffold_config.field_search.or_columns.include? column.name)
-            search_values = column.stripped_value(value[:from]).split(active_scaffold_config.field_search.or_delimiter).compact
-            sql_prepared_statement = search_values.collect {|search_value| "#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?"}.join(' OR ')
-            [sql_prepared_statement] + search_values.collect{|search_value| value[:opt].sub('?', column.stripped_value(search_value))}
-          else
-            ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', column.stripped_value(value[:from]))]
-          end
+          ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
         elsif value[:opt] == 'BETWEEN'
-          ["#{column.search_sql} BETWEEN ? AND ?", column.stripped_value(value[:from]), column.stripped_value(value[:to])]
+          ["#{column.search_sql} BETWEEN ? AND ?", value[:from], value[:to]]
         elsif ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
-          ["#{column.search_sql} #{value[:opt]} ?", column.stripped_value(value[:from])]
+          ["#{column.search_sql} #{value[:opt]} ?", value[:from]]
         else
           nil
         end
@@ -250,7 +243,7 @@ module ActiveScaffold
       return record
     end
 
-    # returns a records relation for the current page
+    # returns a Paginator::Page (not from ActiveRecord::Paginator) for the given parameters
     # options may include:
     # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction, e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]). please note that multi-column sorting has some limitations: if any column in a multi-field sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
     # * :per_page
@@ -263,46 +256,41 @@ module ActiveScaffold
       full_includes = (active_scaffold_includes.blank? ? nil : active_scaffold_includes)
       options[:per_page] ||= 999999999
       options[:page] ||= 1
-       #TODO not supported by kaminari
       options[:count_includes] ||= full_includes unless search_conditions.nil?
 
-      #active_scaffold_config.model.skip_total_count = true if options[:pagination] == :infinite
-
       klass = beginning_of_chain
-      klass = klass.where("") if klass.is_a?(Array)
-
+      
       # create a general-use options array that's compatible with Rails finders
       finder_options = { :order => options[:sorting].try(:clause),
                          :where => search_conditions,
                          :joins => joins_for_finder,
-                         :includes => add_association_to_includes_for_sorting(options[:sorting], full_includes)}
-
-
+                         :includes => options[:count_includes]}
+                         
       finder_options.merge! custom_finder_options
 
+      # NOTE: we must use :include in the count query, because some conditions may reference other tables
+      count_query = append_to_query(klass, finder_options.reject{|k, v| [:select, :order].include?(k)})
+      count = count_query.count unless options[:pagination] == :infinite
+  
+      # Converts count to an integer if ActiveRecord returned an OrderedHash
+      # that happens when finder_options contains a :group key
+      count = count.length if count.is_a? ActiveSupport::OrderedHash
+      finder_options.merge! :includes => full_includes
+
       # we build the paginator differently for method- and sql-based sorting
-      records = if options[:sorting] && options[:sorting].sorts_by_method?
-        Kaminari.paginate_array(sort_collection_by_column(append_to_query(klass, finder_options).all, *options[:sorting].first))
+      if options[:sorting] and options[:sorting].sorts_by_method?
+        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
+          sorted_collection = sort_collection_by_column(append_to_query(klass, finder_options).all, *options[:sorting].first)
+          sorted_collection = sorted_collection.slice(offset, per_page) if options[:pagination]
+          sorted_collection
+        end
       else
-        append_to_query(klass, finder_options)
-      end
-      records = records.page(options[:page]).per(options[:per_page]) if options[:pagination]
-      records
-    end
-
-    # if someone excludes association from includes in configuration
-    # and sorts by that that column... database will not be happy about it :-)
-    # just a safety check to prevent many many database queries
-    def add_association_to_includes_for_sorting(sorting, full_includes)
-      if sorting && sorting.sorts_by_method?
-        sorting_column = sorting.first.first
-        #wants to sort by assocation which is not included bad performance...
-        if sorting_column.association && !sorting_column.polymorphic_association? &&
-           sorting_column.includes.empty? && !full_includes.include?(sorting_column.association.name)
-           full_includes << sorting_column.association.name
+        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
+          finder_options.merge!(:offset => offset, :limit => per_page) if options[:pagination]
+          append_to_query(klass, finder_options).all
         end
       end
-      full_includes
+      pager.page(options[:page])
     end
     
     def append_to_query(query, options)

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -3,11 +3,11 @@ module ActiveScaffold
     module AssociationHelpers
       # Provides a way to honor the :conditions on an association while searching the association's klass
       def association_options_find(association, conditions = nil)
-        association.klass.where(conditions).where(association.options[:conditions])
+        association.klass.where(conditions).where(association.options[:conditions]).all
       end
 
       def association_options_count(association, conditions = nil)
-        association_options_find(association, conditions).count
+        association.klass.where(conditions).where(association.options[:conditions]).count
       end
 
       # returns options for the given association as a collection of [id, label] pairs intended for the +options_for_select+ helper.
@@ -29,7 +29,7 @@ module ActiveScaffold
         case association.macro
           when :has_one, :has_many
             # Find only orphaned objects
-            "#{association.primary_key_name} IS NULL"
+            "#{association.foreign_key} IS NULL"
           when :belongs_to, :has_and_belongs_to_many
             # Find all
             nil

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -190,7 +190,7 @@ module ActiveScaffold
         # if the opposite association is a :belongs_to (in that case association in this class must be has_one or has_many)
         # then only show records that have not been associated yet
         if [:has_one, :has_many].include?(column.association.macro)
-          params.merge!({column.association.primary_key_name => ''})
+          params.merge!({column.association.foreign_key => ''})
         end
  
         record_select_options = {:controller => remote_controller, :id => options[:id]}
@@ -245,7 +245,7 @@ module ActiveScaffold
       # add functionality for overriding subform partials from association class path
       def override_subform_partial?(column, subform_partial)
         path, partial_name = partial_pieces(override_subform_partial(column, subform_partial))
-        template_exists?(partial_name, path, true)
+        template_exists?(partial_name, path)
       end
 
       def override_subform_partial(column, subform_partial)
@@ -254,7 +254,7 @@ module ActiveScaffold
 
       def override_form_field_partial?(column)
         path, partial_name = partial_pieces(override_form_field_partial(column))
-        template_exists?(partial_name, path, true)
+        template_exists?(partial_name, path)
       end
 
       # the naming convention for overriding form fields with partials

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -17,14 +17,12 @@ module ActiveScaffold
             "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value[:opt].downcase).downcase} #{format_number_value(controller.class.condition_value_for_numeric(column, value[:from]), column.options)} #{value[:opt] == 'BETWEEN' ? '- ' + format_number_value(controller.class.condition_value_for_numeric(column, value[:to]), column.options).to_s : ''}"
           when :string
             opt = ActiveScaffold::Finder::StringComparators.index(value[:opt]) || value[:opt]
-            "#{column.active_record_class.human_attribute_name(column.name)} #{as_(opt).downcase} '#{column.stripped_value(value[:from])}' #{opt == 'BETWEEN' ? '- ' + column.stripped_value(value[:to]).to_s : ''}"
+            "#{column.active_record_class.human_attribute_name(column.name)} #{as_(opt).downcase} '#{value[:from]}' #{opt == 'BETWEEN' ? '- ' + value[:to].to_s : ''}"
           when :date, :time, :datetime, :timestamp
             conversion = column.column.type == :date ? :to_date : :to_time
             from = controller.condition_value_for_datetime(value[:from], conversion)
             to = controller.condition_value_for_datetime(value[:to], conversion)
-            unless from.nil? || (value[:opt] == 'BETWEEN' && to.nil?)
-              "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value[:opt])} #{I18n.l(from)} #{value[:opt] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
-            end
+            "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value[:opt])} #{I18n.l(from)} #{value[:opt] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
           when :select, :multi_select, :record_select
             associated = value
             associated = [associated].compact unless associated.is_a? Array

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -10,7 +10,7 @@ module ActiveScaffold
             # we only pass the record as the argument. we previously also passed the formatted_value,
             # but mike perham pointed out that prohibited the usage of overrides to improve on the
             # performance of our default formatting. see issue #138.
-            send(column_override(column), record)
+            send(column_override(column), column, record)
           # second, check if the dev has specified a valid list_ui for this column
           elsif column.list_ui and override_column_ui?(column.list_ui)
             send(override_column_ui(column.list_ui), column, record)
@@ -42,6 +42,7 @@ module ActiveScaffold
             return text if link.crud_type.nil?
             url_options[:link] = as_(:create_new) if link.crud_type == :create
           end
+
           if column_link_authorized?(link, column, record, associated)
             render_action_link(link, url_options, record)
           else
@@ -123,7 +124,6 @@ module ActiveScaffold
           format_column_value(record, column)
         else
           value = record.send(column.name)
-          value = value.to_s unless value.nil?
           text, val = column.options[:options].find {|text, val| (val || text).to_s == value}
           value = active_scaffold_translated_option(column, text, val).first if text
           format_column_value(record, column, value)
@@ -229,15 +229,16 @@ module ActiveScaffold
       end
 
       def cache_association(value, column)
+        # loaded? and target seems to be gone in rails 3.1
         # we are not using eager loading, cache firsts records in order not to query the database in a future
-        unless value.loaded?
+        #unless value.loaded?
           # load at least one record, is needed for column_empty? and checking permissions
-          if column.associated_limit.nil?
-            Rails.logger.warn "ActiveScaffold: Enable eager loading for #{column.name} association to reduce SQL queries"
-          else
-            value.target = value.find(:all, :limit => column.associated_limit + 1, :select => column.select_columns)
-          end
-        end
+        #  if column.associated_limit.nil?
+        #    Rails.logger.warn "ActiveScaffold: Enable eager loading for #{column.name} association to reduce SQL queries"
+        #  else
+        #    value.target = value.find(:all, :limit => column.associated_limit + 1, :select => column.select_columns)
+        #  end
+        #end
       end
 
       # ==========
@@ -315,17 +316,11 @@ module ActiveScaffold
       def mark_column_heading
         if active_scaffold_config.mark.mark_all_mode == :page then
           all_marked = true
-          @records.each do |record|
+          @page.items.each do |record|
             all_marked = false if !marked_records.entries.include?(record.id)
           end
         else
-          # if relation does not respond to kaminari total_count...
-          # kaminari paging is nt active
-          if @records.respond_to?(:total_count)
-            all_marked = (marked_records.length >= @records.total_count)
-          else
-            all_marked = (marked_records.length >= @records.count)
-          end
+          all_marked = (marked_records.length >= @page.pager.count)
         end
         tag_options = {:id => "#{controller_id}_mark_heading", :class => "mark_heading in_place_editor_field"}
         tag_options['data-ie_url'] = url_for({:controller => params_for[:controller], :action => 'mark_all', :eid => params[:eid]})
@@ -358,15 +353,14 @@ module ActiveScaffold
       
       def render_nested_view(action_links, url_options, record)
         rendered = []
-        link_nested_controllers = []
         action_links.member.each do |link|
           if link.nested_link? && link.column && @nested_auto_open[link.column.name] && @records.length <= @nested_auto_open[link.column.name] && controller.respond_to?(:render_component_into_view)
-            link_url_options = {:embedded => true, :format => :js}.merge(action_link_url_options(link, url_options, record, options = {:reuse_eid => true}))
-            link_nested_controllers << link.controller.to_s if link.controller
-            rendered << (controller.send(:render_component_into_view, link_url_options))
+            link_url_options = {:adapter => '_list_inline_adapter', :format => :js}.merge(action_link_url_options(link, url_options, record, options = {:reuse_eid => true})) 
+            link_id = get_action_link_id(link_url_options, record, link.column)
+            rendered << (controller.send(:render_component_into_view, link_url_options) + javascript_tag("ActiveScaffold.ActionLink.get('#{link_id}').set_opened();"))
           end 
         end
-        content_tag(:tr, content_tag(:td, rendered.join(' ').html_safe), :class => "inline-adapter-autoopen", 'data-actionlink-controllers' => link_nested_controllers.join('::').html_safe, 'data-as_load'=>"tr");
+        rendered.join(' ').html_safe
       end  
       
     end

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -74,7 +74,7 @@ module ActiveScaffold
         associated = html_options.delete :value
         if column.association
           associated = associated.is_a?(Array) ? associated.map(&:to_i) : associated.to_i unless associated.nil?
-          method = column.association.macro == :belongs_to ? column.association.primary_key_name : column.name
+          method = column.association.macro == :belongs_to ? column.association.foreign_key : column.name
           select_options = options_for_association(column.association, true)
         else
           method = column.name

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -42,6 +42,28 @@ module ActiveScaffold
         end
       end
 
+      def partial_pieces(partial_path)
+        if partial_path.include?('/')
+          return File.dirname(partial_path), File.basename(partial_path)
+        else
+          return controller.class.controller_path, partial_path
+        end
+      end
+
+      # This is the template finder logic, keep it updated with however we find stuff in rails
+      # currently this very similar to the logic in ActionBase::Base.render for options file
+      # TODO: Work with rails core team to find a better way to check for this.
+      # Not working so far for rais 3.1
+      def template_exists?(template_name, path)
+        begin
+          method = 'find_template'
+          #self.view_paths.send(method, template_name)
+          return false
+        rescue ActionView::MissingTemplate => e
+          return false
+        end
+      end
+
       def generate_temporary_id
         (Time.now.to_f*1000).to_i.to_s
       end
@@ -113,7 +135,7 @@ module ActiveScaffold
 
       # a general-use loading indicator (the "stuff is happening, please wait" feedback)
       def loading_indicator_tag(options)
-        image_tag "/images/active_scaffold/default/indicator.gif", :style => "visibility:hidden;", :id => loading_indicator_id(options), :alt => "loading indicator", :class => "loading-indicator"
+        image_tag "indicator.gif", :style => "visibility:hidden;", :id => loading_indicator_id(options), :alt => "loading indicator", :class => "loading-indicator"
       end
 
       # Creates a javascript-based link that toggles the visibility of some element on the page.
@@ -127,7 +149,7 @@ module ActiveScaffold
       end
 
       def skip_action_link(link, *args)
-        (!link.ignore_method.nil? && controller.respond_to?(link.ignore_method) && controller.send(link.ignore_method, *args)) || ((link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method, *args))
+        (!link.ignore_method.nil? and controller.try(link.ignore_method, *args)) || ((link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method, *args))
       end
 
       def render_action_link(link, url_options, record = nil, html_options = {})
@@ -140,12 +162,7 @@ module ActiveScaffold
         if link.type == :member && !options[:authorized]
           action_link_html(link, nil, {:class => "disabled #{link.action}#{link.html_options[:class].blank? ? '' : (' ' + link.html_options[:class])}"}, record)
         else
-          begin
-            render_action_link(link, url_options, record)
-          rescue
-            Rails.logger.error("render_action_link: exception occured: #{$!} link: #{link.inspect}, url_options: #{url_options.inspect}, options: #{options.inspect}, record: #{record.inspect}")
-            action_link_html(link, nil, {:class => "disabled #{link.action}#{link.html_options[:class].blank? ? '' : (' ' + link.html_options[:class])}"}, record)
-          end
+          render_action_link(link, url_options, record)
         end
       end
       
@@ -165,6 +182,7 @@ module ActiveScaffold
       end
       
       def action_link_html_options(link, url_options, record, html_options)
+        link_id = get_action_link_id(url_options, record, link.column)
         html_options.reverse_merge! link.html_options.merge(:class => link.action)
 
         # Needs to be in html_options to as the adding _method to the url is no longer supported by Rails        
@@ -172,14 +190,20 @@ module ActiveScaffold
 
         html_options['data-confirm'] = link.confirm(record.try(:to_label)) if link.confirm?
         html_options['data-position'] = link.position if link.position and link.inline?
-        html_options['data-controller'] = link.controller.to_s if link.controller
         html_options[:class] += ' as_action' if link.inline?
         html_options['data-action'] = link.action if link.inline?
         if link.popup?
           html_options['data-popup'] = true
           html_options[:target] = '_blank'
         end
+        html_options[:id] = link_id
         html_options[:remote] = true unless link.page? || link.popup?
+        if link.dhtml_confirm?
+          html_options[:class] += ' as_action' if !link.inline?
+          html_options[:page_link] = 'true' if !link.inline?
+          html_options[:dhtml_confirm] = link.dhtml_confirm.value
+          html_options[:onclick] = link.dhtml_confirm.onclick_function(controller, link_id)
+        end
         html_options[:class] += " #{link.html_options[:class]}" unless link.html_options[:class].blank?
         html_options
       end
@@ -239,7 +263,6 @@ module ActiveScaffold
       end
 
       def column_class(column, column_value, record)
-        @numeric_classes ||= [:decimal, :float, :integer]
         classes = []
         classes << "#{column.name}-column"
         if column.css_class.is_a?(Proc)
@@ -251,7 +274,7 @@ module ActiveScaffold
          
         classes << 'empty' if column_empty? column_value
         classes << 'sorted' if active_scaffold_config.list.user.sorting.sorts_on?(column)
-        classes << 'numeric' if column.column && @numeric_classes.include?(column.column.type)
+        classes << 'numeric' if column.column and [:decimal, :float, :integer].include?(column.column.type)
         classes.join(' ').rstrip
       end
       
@@ -270,10 +293,9 @@ module ActiveScaffold
       end
 
       def column_empty?(column_value)
-        @empty_column_strings ||= ['&nbsp;', active_scaffold_config.list.empty_field_text]
         empty = column_value.nil?
         empty ||= column_value.empty? if column_value.respond_to? :empty?
-        empty ||= @empty_column_strings.include?(column_value) if String === column_value
+        empty ||= ['&nbsp;', active_scaffold_config.list.empty_field_text].include? column_value if String === column_value
         return empty
       end