active_scaffold_san 3.0.18

data/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -0,0 +1,55 @@
+module ActiveScaffold
+  module Helpers
+    module PaginationHelpers
+      def pagination_ajax_link(page_number, url_options, options)
+        link_to page_number, url_options.merge(:page => page_number), options.merge(:class => "as_paginate")
+      end
+
+      def pagination_ajax_links(current_page, url_options, options, window_size)
+        start_number = current_page.number - window_size
+        end_number = current_page.number + window_size
+        start_number = 1 if start_number <= 0
+        if current_page.pager.infinite?
+          offsets = [20, 100]
+        else
+          end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+        end
+
+        html = []
+        unless start_number == 1
+          last_page = 1
+          html << pagination_ajax_link(last_page, url_options, options)
+          if current_page.pager.infinite?
+            offsets.reverse.each do |offset|
+              page = current_page.number - offset
+              if page < start_number && page > 1
+                html << '..' if page > last_page + 1
+                html << pagination_ajax_link(page, params)
+                last_page = page
+              end
+            end
+          end
+          html << ".." if start_number > last_page + 1
+        end
+
+        start_number.upto(end_number) do |num|
+          if current_page.number == num
+            html << content_tag(:span, num.to_s, {:class => "as_paginate current"})
+          else
+            html << pagination_ajax_link(num, url_options, options)
+          end
+        end
+
+        if current_page.pager.infinite?
+          offsets.each do |offset|
+            html << '..' << pagination_ajax_link(current_page.number + offset, url_options, options)
+          end
+        else
+          html << ".." unless end_number >= current_page.pager.last.number - 1
+          html << pagination_ajax_link(current_page.pager.last.number, url_options, options) unless end_number == current_page.pager.last.number
+        end
+        html.join(' ').html_safe
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -0,0 +1,249 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a Form Column
+    module SearchColumnHelpers
+      # This method decides which input to use for the given column.
+      # It does not do any rendering. It only decides which method is responsible for rendering.
+      def active_scaffold_search_for(column)
+        options = active_scaffold_search_options(column)
+
+        # first, check if the dev has created an override for this specific field for search
+        if override_search_field?(column)
+          send(override_search_field(column), @record, options)
+
+        # second, check if the dev has specified a valid search_ui for this column, using specific ui for searches
+        elsif column.search_ui and override_search?(column.search_ui)
+          send(override_search(column.search_ui), column, options)
+
+        # third, check if the dev has specified a valid search_ui for this column, using generic ui for forms
+        elsif column.search_ui and override_input?(column.search_ui)
+          send(override_input(column.search_ui), column, options)
+
+        # fourth, check if the dev has created an override for this specific field
+        elsif override_form_field?(column)
+          send(override_form_field(column), @record, options)
+
+        # fallback: we get to make the decision
+        else
+          if column.association or column.virtual?
+            active_scaffold_search_text(column, options)
+
+          else # regular model attribute column
+            # if we (or someone else) have created a custom render option for the column type, use that
+            if override_search?(column.column.type)
+              send(override_search(column.column.type), column, options)
+            # if we (or someone else) have created a custom render option for the column type, use that
+            elsif override_input?(column.column.type)
+              send(override_input(column.column.type), column, options)
+            # final ultimate fallback: use rails' generic input method
+            else
+              # for textual fields we pass different options
+              text_types = [:text, :string, :integer, :float, :decimal]
+              options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+              text_field(:record, column.name, options.merge(column.options))
+            end
+          end
+        end
+      end
+
+      # the standard active scaffold options used for class, name and scope
+      def active_scaffold_search_options(column)
+        { :name => "search[#{column.name}]", :class => "#{column.name}-input", :id => "search_#{column.name}", :value => field_search_params[column.name] }
+      end
+
+      ##
+      ## Search input methods
+      ##
+
+      def active_scaffold_search_multi_select(column, options)
+        associated = options.delete :value
+        associated = [associated].compact unless associated.is_a? Array
+        associated.collect!(&:to_i)
+        
+        if column.association
+          select_options = options_for_association(column.association, false)
+        else
+          select_options = Array(column.options[:options])
+        end
+        return as_(:no_options) if select_options.empty?
+
+        active_scaffold_checkbox_list(column, select_options, associated, options)
+      end
+
+      def active_scaffold_search_select(column, html_options)
+        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
+          select_options = options_for_association(column.association, true)
+        else
+          method = column.name
+          select_options = Array(column.options[:options])
+        end
+
+        options = { :selected => associated }.merge! column.options
+        html_options.merge! column.options[:html_options] || {}
+        if html_options[:multiple]
+          html_options[:name] += '[]'
+        else
+          options[:include_blank] ||= as_(:_select_) 
+        end
+        select(:record, method, select_options, options, html_options)
+      end
+
+      def active_scaffold_search_text(column, options)
+        text_field :record, column.name, active_scaffold_input_text_options(options)
+      end
+
+      # we can't use active_scaffold_input_boolean because we need to have a nil value even when column can't be null
+      # to decide whether search for this field or not
+      def active_scaffold_search_boolean(column, options)
+        select_options = []
+        select_options << [as_(:_select_), nil]
+        select_options << [as_(:true), true]
+        select_options << [as_(:false), false]
+
+        select_tag(options[:name], options_for_select(select_options, column.column.type_cast(field_search_params[column.name])))
+      end
+      # we can't use checkbox ui because it's not possible to decide whether search for this field or not
+      alias_method :active_scaffold_search_checkbox, :active_scaffold_search_boolean
+      
+      def active_scaffold_search_null(column, options)
+        select_options = []
+        select_options << [as_(:_select_), nil]
+        select_options.concat ActiveScaffold::Finder::NullComparators.collect {|comp| [as_(comp), comp]}
+        select_tag(options[:name], options_for_select(select_options, field_search_params[column.name]))
+      end
+
+      def field_search_params_range_values(column)
+        values = field_search_params[column.name]
+        return nil if values.nil?
+        return values[:opt], (values[:from].blank? ? nil : values[:from]), (values[:to].blank? ? nil : values[:to])
+        
+      end
+
+      def active_scaffold_search_range_comparator_options(column)
+        select_options = ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+        if column.column && column.column.text?
+          select_options.unshift *ActiveScaffold::Finder::StringComparators.collect {|title, comp| [as_(title), comp]}
+        end
+        select_options
+      end
+
+      def active_scaffold_search_range(column, options)
+        opt_value, from_value, to_value = field_search_params_range_values(column)
+        
+        select_options = active_scaffold_search_range_comparator_options(column)
+        text_field_size = ((column.column && column.column.text?) ? 15 : 10)
+
+        from_value = controller.class.condition_value_for_numeric(column, from_value)
+        to_value = controller.class.condition_value_for_numeric(column, to_value)
+        from_value = format_number_value(from_value, column.options) if from_value.is_a?(Numeric)
+        to_value = format_number_value(to_value, column.options) if to_value.is_a?(Numeric)
+        html = select_tag("#{options[:name]}[opt]",
+              options_for_select(select_options, opt_value),
+              :id => "#{options[:id]}_opt",
+              :class => "as_search_range_option")
+        html << ' ' << text_field_tag("#{options[:name]}[from]", from_value, active_scaffold_input_text_options(:id => options[:id], :size => text_field_size))
+        html << ' ' << content_tag(:span, (' - ' + text_field_tag("#{options[:name]}[to]", to_value,
+              active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => text_field_size))).html_safe,
+              :id => "#{options[:id]}_between", :class => "as_search_range_between", :style => "display:#{(opt_value == 'BETWEEN') ? '' : 'none'}")
+        html
+      end
+      alias_method :active_scaffold_search_integer, :active_scaffold_search_range
+      alias_method :active_scaffold_search_decimal, :active_scaffold_search_range
+      alias_method :active_scaffold_search_float, :active_scaffold_search_range
+      alias_method :active_scaffold_search_string, :active_scaffold_search_range
+
+      def active_scaffold_search_record_select(column, options)
+        value = field_search_record_select_value(column)
+        active_scaffold_record_select(column, options, value, column.options[:multiple])
+      end
+      
+      def field_search_record_select_value(column)
+        begin 
+          value = field_search_params[column.name]
+          unless value.blank?
+            if column.options[:multiple]
+              column.association.klass.find value.collect!(&:to_i)
+            else
+              column.association.klass.find(value.to_i)
+            end
+          end
+        rescue Exception => e
+          logger.error Time.now.to_s + "Sorry, we are not that smart yet. Attempted to restore search values to search fields but instead got -- #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
+          raise e
+        end
+      end
+
+      def field_search_datetime_value(value)
+        DateTime.new(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
+      end
+      
+      def active_scaffold_search_datetime(column, options)
+        opt_value, from_value, to_value = field_search_params_range_values(column)
+        options = column.options.merge(options)
+        helper = "select_#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
+        
+        send(helper, field_search_datetime_value(from_value), {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options)) << 
+        ' - '.html_safe << send(helper, field_search_datetime_value(to_value), {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options))
+      end
+
+      def active_scaffold_search_date(column, options)
+        active_scaffold_search_datetime(column, options.merge!(:discard_time => true))
+      end
+      def active_scaffold_search_time(column, options)
+        active_scaffold_search_datetime(column, options.merge!(:discard_date => true))
+      end
+      alias_method :active_scaffold_search_timestamp, :active_scaffold_search_datetime
+
+      ##
+      ## Search column override signatures
+      ##
+
+      def override_search_field?(column)
+        respond_to?(override_search_field(column))
+      end
+
+      # the naming convention for overriding form fields with helpers
+      def override_search_field(column)
+        "#{column.name}_search_column"
+      end
+
+      def override_search?(search_ui)
+        respond_to?(override_search(search_ui))
+      end
+
+      # the naming convention for overriding search input types with helpers
+      def override_search(form_ui)
+        "active_scaffold_search_#{form_ui}"
+      end
+      
+      def visibles_and_hiddens(search_config)
+        visibles = [] 
+        hiddens = []
+        search_config.columns.each do |column|
+          next unless column.search_sql
+          if search_config.optional_columns.include?(column.name) && !searched_by?(column)
+            hiddens << column
+          else
+            visibles << column
+          end
+        end
+        return visibles, hiddens
+      end
+      
+      def searched_by?(column)
+        value = field_search_params[column.name]
+        case value
+        when Hash
+          !value['from'].blank?
+        when String
+          !value.blank?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -0,0 +1,46 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a List Column
+    module ShowColumnHelpers
+      def show_column_value(record, column)
+        # check for an override helper
+        if show_column_override? column
+          # 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(show_column_override(column), record)
+        # second, check if the dev has specified a valid list_ui for this column
+        elsif column.list_ui and override_show_column_ui?(column.list_ui)
+          send(override_show_column_ui(column.list_ui), column, record)
+        else
+          if column.column and override_show_column_ui?(column.column.type)
+            send(override_show_column_ui(column.column.type), column, record)
+          else
+            get_column_value(record, column)
+          end
+        end
+      end
+
+      def active_scaffold_show_text(column, record)
+        simple_format(clean_column_value(record.send(column.name)))
+      end
+
+      def show_column_override(column)
+        "#{column.name.to_s.gsub('?', '')}_show_column" # parse out any question marks (see issue 227)
+      end
+
+      def show_column_override?(column)
+        respond_to?(show_column_override(column))
+      end
+
+      def override_show_column_ui?(list_ui)
+        respond_to?(override_show_column_ui(list_ui))
+      end
+
+      # the naming convention for overriding show types with helpers
+      def override_show_column_ui(list_ui)
+        "active_scaffold_show_#{list_ui}"
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -0,0 +1,360 @@
+module ActiveScaffold
+  module Helpers
+    # All extra helpers that should be included in the View.
+    # Also a dumping ground for uncategorized helpers.
+    module ViewHelpers
+      include ActiveScaffold::Helpers::IdHelpers
+      include ActiveScaffold::Helpers::AssociationHelpers
+      include ActiveScaffold::Helpers::PaginationHelpers
+      include ActiveScaffold::Helpers::ListColumnHelpers
+      include ActiveScaffold::Helpers::ShowColumnHelpers
+      include ActiveScaffold::Helpers::FormColumnHelpers
+      include ActiveScaffold::Helpers::SearchColumnHelpers
+      include ActiveScaffold::Helpers::CountryHelpers
+      include ActiveScaffold::Helpers::HumanConditionHelpers
+
+      ##
+      ## Delegates
+      ##
+
+      # access to the configuration variable
+      def active_scaffold_config
+        controller.class.active_scaffold_config
+      end
+
+      def active_scaffold_config_for(*args)
+        controller.class.active_scaffold_config_for(*args)
+      end
+
+      def active_scaffold_controller_for(*args)
+        controller.class.active_scaffold_controller_for(*args)
+      end
+
+      ##
+      ## Uncategorized
+      ##
+
+      def controller_path_for_activerecord(klass)
+        begin
+          controller = active_scaffold_controller_for(klass)
+          controller.controller_path
+        rescue ActiveScaffold::ControllerNotFound
+          controller = nil
+        end
+      end
+
+      def generate_temporary_id
+        (Time.now.to_f*1000).to_i.to_s
+      end
+
+      # Turns [[label, value]] into <option> tags
+      # Takes optional parameter of :include_blank
+      def option_tags_for(select_options, options = {})
+        select_options.insert(0,[as_(:_select_),nil]) if options[:include_blank]
+        select_options.collect do |option|
+          label, value = option[0], option[1]
+          value.nil? ? "<option value="">#{label}</option>" : "<option value=\"#{value}\">#{label}</option>"
+        end
+      end
+
+      # Should this column be displayed in the subform?
+      def in_subform?(column, parent_record)
+        return true unless column.association
+
+        # Polymorphic associations can't appear because they *might* be the reverse association, and because you generally don't assign an association from the polymorphic side ... I think.
+        return false if column.polymorphic_association?
+
+        # A column shouldn't be in the subform if it's the reverse association to the parent
+        return false if column.association.reverse_for?(parent_record.class)
+
+        return true
+      end
+
+      def form_remote_upload_tag(url_for_options = {}, options = {})
+        options[:target] = action_iframe_id(url_for_options)
+        options[:multipart] ||= true
+        options[:class] = "#{options[:class]} as_remote_upload".strip 
+        output=""
+        output << form_tag(url_for_options, options)
+        (output << "<iframe id='#{action_iframe_id(url_for_options)}' name='#{action_iframe_id(url_for_options)}' style='display:none'></iframe>").html_safe
+      end
+
+      # Provides list of javascripts to include with +javascript_include_tag+
+      # You can use this with your javascripts like
+      #   <%= javascript_include_tag :defaults, 'your_own_cool_script', active_scaffold_javascripts, :cache => true %>
+      def active_scaffold_javascripts(frontend = :default)
+        ActiveScaffold::Config::Core.javascripts(frontend).collect do |name|
+          ActiveScaffold::Config::Core.asset_path(name, frontend)
+        end
+      end
+      
+      # Provides stylesheets to include with +stylesheet_link_tag+
+      def active_scaffold_stylesheets(frontend = :default)
+        [ActiveScaffold::Config::Core.asset_path("stylesheet.css", frontend)]
+      end
+
+      # Provides stylesheets for IE to include with +stylesheet_link_tag+ 
+      def active_scaffold_ie_stylesheets(frontend = :default)
+        [ActiveScaffold::Config::Core.asset_path("stylesheet-ie.css", frontend)]
+      end
+
+      # easy way to include ActiveScaffold assets
+      def active_scaffold_includes(*args)
+        frontend = args.first.is_a?(Symbol) ? args.shift : :default
+        options = args.first.is_a?(Hash) ? args.shift : {}
+        js = javascript_include_tag(*active_scaffold_javascripts(frontend).push(options))
+
+        css = stylesheet_link_tag(*active_scaffold_stylesheets(frontend).push(options))
+        options[:cache] += '_ie' if options[:cache].is_a? String
+        options[:concat] += '_ie' if options[:concat].is_a? String
+        ie_css = stylesheet_link_tag(*active_scaffold_ie_stylesheets(frontend).push(options))
+
+        js + "\n" + css + "\n<!--[if IE]>".html_safe + ie_css + "<![endif]-->\n".html_safe
+      end
+
+      # 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"
+      end
+
+      # Creates a javascript-based link that toggles the visibility of some element on the page.
+      # By default, it toggles the visibility of the sibling after the one it's nested in. You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
+      # You may also flag whether the other element is visible by default or not, and the initial text will adjust accordingly.
+      def link_to_visibility_toggle(id, options = {})
+        options[:default_visible] = true if options[:default_visible].nil?
+        options[:hide_label] = as_(:hide) 
+        options[:show_label] = as_(:show)
+        javascript_tag("ActiveScaffold.create_visibility_toggle('#{id}', #{options.to_json});")
+      end
+
+      def skip_action_link(link, *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 = {})
+        url_options = action_link_url_options(link, url_options, record)
+        html_options = action_link_html_options(link, url_options, record, html_options)
+        action_link_html(link, url_options, html_options, record)
+      end
+
+      def render_group_action_link(link, url_options, options, record = nil)
+        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
+          render_action_link(link, url_options, record)
+        end
+      end
+      
+      def action_link_url_options(link, url_options, record, options = {})
+        url_options = url_options.clone
+        url_options[:action] = link.action
+        url_options[:controller] = link.controller if link.controller
+        url_options.delete(:search) if link.controller and link.controller.to_s != params[:controller]
+        url_options.merge! link.parameters if link.parameters
+        @link_record = record
+        url_options.merge! self.instance_eval(&(link.dynamic_parameters)) if link.dynamic_parameters.is_a?(Proc)
+        @link_record = nil
+        url_options_for_nested_link(link.column, record, link, url_options, options) if link.nested_link?
+        url_options_for_sti_link(link.column, record, link, url_options, options) unless record.nil? || active_scaffold_config.sti_children.nil?
+        url_options[:_method] = link.method if !link.confirm? && link.inline? && link.method != :get
+        url_options
+      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        
+        html_options[:method] = link.method if link.method != :get
+
+        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[:class] += ' as_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
+
+      def get_action_link_id(url_options, record = nil, column = nil)
+        id = url_options[:id] || url_options[:parent_id]
+        id = "#{column.association.name}-#{record.id}" if column && column.plural_association?
+        if record.try(column.association.name.to_sym).present?
+          id = "#{column.association.name}-#{record.send(column.association.name).id}-#{record.id}"
+        else
+          id = "#{column.association.name}-#{record.id}" unless record.nil?
+        end if column && column.singular_association?
+        id = "#{id}-#{url_options[:batch_scope].downcase}" if url_options[:batch_scope]
+        action_id = "#{id_from_controller(url_options[:controller]) + '-' if url_options[:parent_controller]}#{url_options[:action].to_s}"
+        action_link_id(action_id, id)
+      end
+      
+      def action_link_html(link, url, html_options, record)
+        # issue 260, use url_options[:link] if it exists. This prevents DB data from being localized.
+        label = url.delete(:link) if url.is_a?(Hash) 
+        label ||= link.label
+        if link.image.nil?
+          html = link_to(label, url, html_options)
+        else
+          html = link_to(image_tag(link.image[:name] , :size => link.image[:size], :alt => label), url, html_options)
+        end
+        # if url is nil we would like to generate an anchor without href attribute
+        url.nil? ? html.sub(/href=".*?"/, '') : html 
+      end
+      
+      def url_options_for_nested_link(column, record, link, url_options, options = {})
+        if column && column.association 
+          url_options[:assoc_id] = url_options.delete(:id)
+          url_options[:id] = record.send(column.association.name).id if column.singular_association? && record.send(column.association.name).present?
+          link.eid = "#{controller_id.from(3)}_#{record.id}_#{column.association.name}" unless options.has_key?(:reuse_eid)
+          url_options[:eid] = link.eid
+        elsif link.parameters && link.parameters[:named_scope]
+          url_options[:assoc_id] = url_options.delete(:id)
+          link.eid = "#{controller_id.from(3)}_#{record.id}_#{link.parameters[:named_scope]}" unless options.has_key?(:reuse_eid)
+          url_options[:eid] = link.eid
+        end
+      end
+
+      def url_options_for_sti_link(column, record, link, url_options, options = {})
+        #need to find out controller of current record type
+        #and set parameters
+        sti_controller_path = controller_path_for_activerecord(record.class)
+        if sti_controller_path
+          url_options[:controller] = sti_controller_path
+          url_options[:parent_sti] = controller_path
+        end
+      end
+
+      def column_class(column, column_value, record)
+        classes = []
+        classes << "#{column.name}-column"
+        if column.css_class.is_a?(Proc)
+          css_class = column.css_class.call(column_value, record)
+          classes << css_class unless css_class.nil?
+        else
+          classes << column.css_class
+        end unless column.css_class.nil?
+         
+        classes << 'empty' if column_empty? column_value
+        classes << 'sorted' if active_scaffold_config.list.user.sorting.sorts_on?(column)
+        classes << 'numeric' if column.column and [:decimal, :float, :integer].include?(column.column.type)
+        classes.join(' ').rstrip
+      end
+      
+      def column_heading_class(column, sorting)
+        classes = []
+        classes << "#{column.name}-column_heading"
+        classes << "sorted #{sorting.direction_of(column).downcase}" if sorting.sorts_on? column
+        classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+        classes.join(' ')
+      end
+
+      def column_empty?(column_value)
+        empty = column_value.nil?
+        empty ||= column_value.empty? if column_value.respond_to? :empty?
+        empty ||= ['&nbsp;', active_scaffold_config.list.empty_field_text].include? column_value if String === column_value
+        return empty
+      end
+
+      def column_calculation(column)
+        unless column.calculate.instance_of? Proc
+          conditions = controller.send(:all_conditions)
+          includes = active_scaffold_config.list.count_includes
+          includes ||= controller.send(:active_scaffold_includes) unless conditions.nil?
+          calculation = beginning_of_chain.calculate(column.calculate, column.name, :conditions => conditions,
+           :joins => controller.send(:joins_for_collection), :include => includes)
+        else
+          column.calculate.call(@records)
+        end
+      end
+
+      def render_column_calculation(column)
+        calculation = column_calculation(column)
+        override_formatter = "render_#{column.name}_#{column.calculate}"
+        calculation = send(override_formatter, calculation) if respond_to? override_formatter
+
+        "#{"#{as_(column.calculate)}: " unless column.calculate.is_a? Proc}#{format_column_value nil, column, calculation}"
+      end
+
+      def column_show_add_existing(column)
+        (column.allow_add_existing and options_for_association_count(column.association) > 0)
+      end
+
+      def column_show_add_new(column, associated, record)
+        value = column.plural_association? || (column.singular_association? and not associated.empty?)
+        value = false unless record.class.authorized_for?(:crud_type => :create)
+        value
+      end
+      
+      def active_scaffold_error_messages_for(*params)
+        options = params.extract_options!.symbolize_keys
+        options.reverse_merge!(:container_tag => :div, :list_type => :ul)
+
+        objects = Array.wrap(options.delete(:object) || params).map do |object|
+          object = instance_variable_get("@#{object}") unless object.respond_to?(:to_model)
+          object = convert_to_model(object)
+
+          if object.class.respond_to?(:model_name)
+            options[:object_name] ||= object.class.model_name.human.downcase
+          end
+
+          object
+        end
+
+        objects.compact!
+        count = objects.inject(0) {|sum, object| sum + object.errors.count }
+
+        unless count.zero?
+          html = {}
+          [:id, :class].each do |key|
+            if options.include?(key)
+              value = options[key]
+              html[key] = value unless value.blank?
+            else
+              html[key] = 'errorExplanation'
+            end
+          end
+          options[:object_name] ||= params.first
+
+          header_message = if options.include?(:header_message)
+            options[:header_message]
+          else
+            as_('errors.template.header', :count => count, :model => options[:object_name].to_s.gsub('_', ' '))
+          end
+
+          message = options.include?(:message) ? options[:message] : as_('errors.template.body')
+
+          error_messages = objects.sum do |object|
+            object.errors.full_messages.map do |msg|
+              options[:list_type] != :br ? content_tag(:li, msg) : msg
+            end
+          end
+          error_messages = if options[:list_type] == :br
+            error_messages.join('<br/>').html_safe
+          else
+            content_tag(options[:list_type], error_messages.join.html_safe)
+          end
+
+          contents = []
+          contents << content_tag(options[:header_tag] || :h2, header_message) unless header_message.blank?
+          contents << content_tag(:p, message) unless message.blank?
+          contents << error_messages
+          contents = contents.join.html_safe
+          options[:container_tag] ? content_tag(options[:container_tag], contents, html) : contents
+        else
+          ''
+        end
+      end
+    end
+  end
+end