antfarm 0.3.0

data/rails/vendor/plugins/active_scaffold/lib/helpers/id_helpers.rb

@@ -0,0 +1,119 @@
+module ActiveScaffold
+  module Helpers
+    # A bunch of helper methods to produce the common view ids
+    module Ids
+      def controller_id
+        @controller_id ||= (params[:parent_controller] || params[:controller]).gsub("/", "__")
+      end
+
+      def active_scaffold_id
+        "#{controller_id}-active-scaffold"
+      end
+
+      def active_scaffold_content_id
+        "#{controller_id}-content"
+      end
+
+      def active_scaffold_tbody_id
+        "#{controller_id}-tbody"
+      end
+
+      def active_scaffold_messages_id
+        "#{controller_id}-messages"
+      end
+
+      def active_scaffold_calculations_id
+        "#{controller_id}-calculations"
+      end
+
+      def empty_message_id
+        "#{controller_id}-empty-message"
+      end
+
+      def before_header_id
+        "#{controller_id}-search-container"
+      end
+
+      def search_form_id
+        "#{controller_id}-search-form"
+      end
+
+      def search_input_id
+        "#{controller_id}-search-input"
+      end
+
+      def table_action_id(name)
+        "#{controller_id}-action-table-#{name}"
+      end
+
+      def action_link_id(link_action,link_id)
+        "#{controller_id}-#{link_action}-#{link_id}-link"
+      end
+
+      def active_scaffold_column_header_id(column)
+        name = column.respond_to?(:name) ? column.name : column.to_s
+        clean_id "#{controller_id}-#{name}-column"
+      end
+
+      def element_row_id(options = {})
+        options[:action] ||= params[:action]
+        options[:id] ||= params[:id]
+        clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-row"
+      end
+
+      def element_cell_id(options = {})
+        options[:action] ||= params[:action]
+        options[:id] ||= params[:id]
+        options[:name] ||= params[:name]
+        clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-#{options[:name]}-cell"
+      end
+
+      def element_form_id(options = {})
+        options[:action] ||= params[:action]
+        options[:id] ||= params[:id]
+        clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-form"
+      end
+
+      def association_subform_id(column)
+        klass = column.association.klass.to_s.underscore
+        clean_id "#{controller_id}-associated-#{klass}"
+      end
+
+      def loading_indicator_id(options = {})
+        options[:action] ||= params[:action]
+        unless options[:id]
+          clean_id "#{controller_id}-#{options[:action]}-loading-indicator"
+        else
+          clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-loading-indicator"
+        end
+      end
+
+      def sub_form_id(options = {})
+        options[:id] ||= params[:id]
+        clean_id "#{controller_id}-#{options[:id]}-#{options[:association]}-subform"
+      end
+
+      def sub_form_list_id(options = {})
+        options[:id] ||= params[:id]
+        clean_id "#{controller_id}-#{options[:id]}-#{options[:association]}-subform-list"
+      end
+
+      def element_messages_id(options = {})
+        options[:action] ||= params[:action]
+        options[:id] ||= params[:id]
+        clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-messages"
+      end
+
+      def action_iframe_id(options)
+        "#{controller_id}-#{options[:action]}-#{options[:id]}-iframe"
+      end
+
+      private
+
+      # whitelists id-safe characters
+      def clean_id(val)
+        val.gsub /[^-_0-9a-zA-Z]/, '-'
+      end
+    end
+  end
+end

data/rails/vendor/plugins/active_scaffold/lib/helpers/list_column_helpers.rb

@@ -0,0 +1,187 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a List Column
+    module ListColumns
+      def get_column_value(record, column)
+        # check for an override helper
+        value = if 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(column_override(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)
+
+        elsif column.inplace_edit and record.authorized_for?(:action => :update, :column => column.name)
+          active_scaffold_inplace_edit(record, column)
+        else
+          value = record.send(column.name)
+
+          if column.association.nil? or column_empty?(value)
+            formatted_value = clean_column_value(format_column(value))
+          else
+            case column.association.macro
+              when :has_one, :belongs_to
+                formatted_value = clean_column_value(format_column(value.to_label))
+
+              when :has_many, :has_and_belongs_to_many
+                firsts = value.first(4).collect { |v| v.to_label }
+                firsts[3] = '…' if firsts.length == 4
+                formatted_value = clean_column_value(format_column(firsts.join(', ')))
+            end
+          end
+
+          formatted_value
+        end
+
+        value = ' ' if value.nil? or (value.respond_to?(:empty?) and value.empty?) # fix for IE 6
+        return value
+      end
+
+      # TODO: move empty_field_text and   logic in here?
+      # TODO: move active_scaffold_inplace_edit in here?
+      # TODO: we need to distinguish between the automatic links *we* create and the ones that the dev specified. some logic may not apply if the dev specified the link.
+      def render_list_column(text, column, record)
+        if column.link
+          return "<a class='disabled'>#{text}</a>" unless record.authorized_for?(:action => column.link.crud_type)
+          return text if column.singular_association? and column_empty?(text)
+
+          url_options = params_for(:action => nil, :id => record.id, :link => text)
+          if column.singular_association? and column.link.action != 'nested' and associated = record.send(column.association.name)
+            url_options[:id] = associated.id
+          end
+
+          render_action_link(column.link, url_options)
+        else
+          text
+        end
+      end
+
+      # There are two basic ways to clean a column's value: h() and sanitize(). The latter is useful
+      # when the column contains *valid* html data, and you want to just disable any scripting. People
+      # can always use field overrides to clean data one way or the other, but having this override
+      # lets people decide which way it should happen by default.
+      #
+      # Why is it not a configuration option? Because it seems like a somewhat rare request. But it
+      # could eventually be an option in config.list (and config.show, I guess).
+      def clean_column_value(v)
+        h(v)
+      end
+
+      ##
+      ## Overrides
+      ##
+      def active_scaffold_column_checkbox(column, record)
+        column_value = record.send(column.name)
+        if column.inplace_edit and record.authorized_for?(:action => :update, :column => column.name)
+          id_options = {:id => record.id.to_s, :action => 'update_column', :name => column.name.to_s}
+          tag_options = {:tag => "span", :id => element_cell_id(id_options), :class => "in_place_editor_field"}
+          script = remote_function(:url => {:controller => params_for[:controller], :action => "update_column", :column => column.name, :id => record.id.to_s, :value => !column_value})
+          content_tag(:span, check_box_tag(tag_options[:id], 1, column_value || column_value == 1, {:onchange => script}) , tag_options)
+        else
+          check_box_tag(nil, 1, column_value || column_value == 1, :disabled => true)
+        end
+      end
+
+      def column_override(column)
+        "#{column.name.to_s.gsub('?', '')}_column" # parse out any question marks (see issue 227)
+      end
+
+      def column_override?(column)
+        respond_to?(column_override(column))
+      end
+
+      def override_column_ui?(list_ui)
+        respond_to?(override_column_ui(list_ui))
+      end
+
+      # the naming convention for overriding column types with helpers
+      def override_column_ui(list_ui)
+        "active_scaffold_column_#{list_ui}"
+      end
+
+      ##
+      ## Formatting
+      ##
+
+      def format_column(column_value)
+        if column_empty?(column_value)
+          active_scaffold_config.list.empty_field_text
+        elsif column_value.instance_of? Time
+          format_time(column_value)
+        elsif column_value.instance_of? Date
+          format_date(column_value)
+        else
+          column_value.to_s
+        end
+      end
+
+      def format_time(time)
+        format = ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS[:default] || "%m/%d/%Y %I:%M %p"
+        time.strftime(format)
+      end
+
+      def format_date(date)
+        format = ActiveSupport::CoreExtensions::Date::Conversions::DATE_FORMATS[:default] || "%m/%d/%Y"
+        date.strftime(format)
+      end
+
+      # ==========
+      # = Inline Edit =
+      # ==========
+      def format_inplace_edit_column(record,column)
+        value = record.send(column.name)
+        if column.list_ui == :checkbox
+          active_scaffold_column_checkbox(column, record)
+        else
+          clean_column_value(format_column(value))
+        end
+      end
+      
+      def active_scaffold_in_place_editor_js(field_id, options = {})
+        function =  "new Ajax.InPlaceEditor("
+        function << "'#{field_id}', "
+        function << "'#{url_for(options[:url])}'"
+
+        js_options = {}
+        js_options['cancelText'] = %('#{options[:cancel_text]}') if options[:cancel_text]
+        js_options['okText'] = %('#{options[:save_text]}') if options[:save_text]
+        js_options['loadingText'] = %('#{options[:loading_text]}') if options[:loading_text]
+        js_options['savingText'] = %('#{options[:saving_text]}') if options[:saving_text]
+        js_options['rows'] = options[:rows] if options[:rows]
+        js_options['htmlResponse'] = options[:html_response] if options.has_key?(:html_response)
+        js_options['cols'] = options[:cols] if options[:cols]
+        js_options['size'] = options[:size] if options[:size]
+        js_options['externalControl'] = "'#{options[:external_control]}'" if options[:external_control]
+        js_options['loadTextURL'] = "'#{url_for(options[:load_text_url])}'" if options[:load_text_url]        
+        js_options['ajaxOptions'] = options[:options] if options[:options]
+        js_options['evalScripts'] = options[:script] if options[:script]
+        js_options['callback']   = "function(form) { return #{options[:with]} }" if options[:with]
+        js_options['clickToEditText'] = %('#{options[:click_to_edit_text]}') if options[:click_to_edit_text]
+        function << (', ' + options_for_javascript(js_options)) unless js_options.empty?
+        
+        function << ')'
+
+        javascript_tag(function)
+      end
+      
+      def active_scaffold_inplace_edit(record, column)
+        formatted_column = format_inplace_edit_column(record,column)
+        id_options = {:id => record.id.to_s, :action => 'update_column', :name => column.name.to_s}
+        tag_options = {:tag => "span", :id => element_cell_id(id_options), :class => "in_place_editor_field"}
+        in_place_editor_options = {:url => {:controller => params_for[:controller], :action => "update_column", :column => column.name, :id => record.id.to_s},
+         :click_to_edit_text => as_("Click to edit"),
+         :cancel_text => as_("Cancel"),
+         :loading_text => as_("Loading…"),
+         :save_text => as_("Update"),
+         :saving_text => as_("Saving…"),
+         :html_response => false,
+         :options => "{method: 'post'}",
+         :script => true}.merge(column.options)
+        content_tag(:span, formatted_column, tag_options) + active_scaffold_in_place_editor_js(tag_options[:id], in_place_editor_options)
+      end
+
+    end
+  end
+end

data/rails/vendor/plugins/active_scaffold/lib/helpers/pagination_helpers.rb

@@ -0,0 +1,37 @@
+module ActiveScaffold
+  module Helpers
+    module Pagination
+      def pagination_ajax_link(page_number, params)
+        page_link = link_to_remote(page_number,
+                  { :url => params.merge(:page => page_number),
+                    :after => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'visible';",
+                    :complete => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'hidden';",
+                    :update => active_scaffold_content_id,
+                    :failure => "ActiveScaffold.report_500_response('#{active_scaffold_id}')",
+                    :method => :get },
+                  { :href => url_for(params.merge(:page => page_number)) })
+      end
+
+      def pagination_ajax_links(current_page, params)
+        start_number = current_page.number - 2
+        end_number = current_page.number + 2
+        start_number = 1 if start_number <= 0
+        end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+
+        html = []
+        html << pagination_ajax_link(1, params) unless current_page.number <= 3
+        html << ".." unless current_page.number <= 4
+        start_number.upto(end_number) do |num|
+          if current_page.number == num
+            html << num
+          else
+            html << pagination_ajax_link(num, params)
+          end
+        end
+        html << ".." unless current_page.number >= current_page.pager.last.number - 3
+        html << pagination_ajax_link(current_page.pager.last.number, params) unless current_page.number >= current_page.pager.last.number - 2
+        html.join(' ')
+      end
+    end
+  end
+end

data/rails/vendor/plugins/active_scaffold/lib/helpers/usa_state.rb

@@ -0,0 +1,46 @@
+module ActionView
+  module Helpers
+    module FormOptionsHelper
+
+      # Return a full select and option tags for the given object and method, using usa_state_options_for_select to generate the list of option <tags>.
+      def usa_state_select(object, method, priority_states = nil, options = {}, html_options = {})
+        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_usa_state_select_tag(priority_states, options, html_options)
+      end
+    
+
+      # Returns a string of option tags for the states in the United States. Supply a state name as +selected to
+      # have it marked as the selected option tag. Included also is the option to set a couple of +priority_states+ 
+      # in case you want to highligh a local area
+      # NOTE: Only the option tags are returned from this method, wrap it in a <select>
+      def usa_state_options_for_select(selected = nil, priority_states = nil)
+        state_options = ""
+        if priority_states
+          state_options += options_for_select(priority_states, selected)
+          state_options += "<option>-------------</option>\n"
+        end
+
+        if priority_states && priority_states.include?(selected)
+          state_options += options_for_select(USASTATES - priority_states, selected)
+        else
+          state_options += options_for_select(USASTATES, selected)
+        end
+
+        return state_options
+      end
+
+    	USASTATES = [["Alabama", "AL"], ["Alaska", "AK"], ["Arizona", "AZ"], ["Arkansas", "AR"], ["California", "CA"], ["Colorado", "CO"], ["Connecticut", "CT"], ["Delaware", "DE"], ["District of Columbia", "DC"], ["Florida", "FL"], ["Georgia", "GA"], ["Hawaii", "HI"], ["Idaho", "ID"], ["Illinois", "IL"], ["Indiana", "IN"], ["Iowa", "IA"], ["Kansas", "KS"], ["Kentucky", "KY"], ["Louisiana", "LA"], ["Maine", "ME"], ["Maryland", "MD"], ["Massachusetts", "MA"], ["Michigan", "MI"], ["Minnesota", "MN"], ["Mississippi", "MS"], ["Missouri", "MO"], ["Montana", "MT"], ["Nebraska", "NE"], ["Nevada", "NV"], ["New Hampshire", "NH"], ["New Jersey", "NJ"], ["New Mexico", "NM"], ["New York", "NY"], ["North Carolina", "NC"], ["North Dakota", "ND"], ["Ohio", "OH"], ["Oklahoma", "OK"], ["Oregon", "OR"], ["Pennsylvania", "PA"], ["Rhode Island", "RI"], ["South Carolina", "SC"], ["South Dakota", "SD"], ["Tennessee", "TN"], ["Texas", "TX"], ["Utah", "UT"], ["Vermont", "VT"], ["Virginia", "VA"], ["Washington", "WA"], ["Wisconsin", "WI"], ["West Virginia", "WV"], ["Wyoming", "WY"]] unless const_defined?("USASTATES")
+ 
+    end
+  
+    class InstanceTag #:nodoc:
+      include FormOptionsHelper
+ 
+      def to_usa_state_select_tag(priority_states, options, html_options)
+        html_options = html_options.stringify_keys
+        add_default_name_and_id(html_options)
+        value = value(object) if method(:value).arity > 0
+        content_tag("select", add_options(usa_state_options_for_select(value, priority_states), options, value), html_options)
+      end
+    end
+  end
+end

data/rails/vendor/plugins/active_scaffold/lib/helpers/view_helpers.rb

@@ -0,0 +1,205 @@
+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::Ids
+      include ActiveScaffold::Helpers::Associations
+      include ActiveScaffold::Helpers::Pagination
+      include ActiveScaffold::Helpers::ListColumns
+      include ActiveScaffold::Helpers::FormColumns
+
+      ##
+      ## 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 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?
+
+        # We don't have the UI to currently handle habtm in subforms
+        return false if column.association.macro == :has_and_belongs_to_many
+
+        # 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 false if column.association.klass == parent_record.class
+
+        return true
+      end
+
+      def form_remote_upload_tag(url_for_options = {}, options = {})
+        onsubmits = options[:onsubmit] ? [ options[:onsubmit] ] : [ ]
+        # simulate a "loading". the setTimeout prevents the Form.disable from being called before the submit, so that data actually posts.
+        onsubmits << "setTimeout(function() { #{options[:loading]} }, 10); "
+        onsubmits << "return true" # make sure the form still submits
+
+        options[:onsubmit] = onsubmits * ';'
+        options[:target] = action_iframe_id(url_for_options)
+        options[:multipart] = true
+
+        output=""
+        output << "<iframe id='#{action_iframe_id(url_for_options)}' name='#{action_iframe_id(url_for_options)}' style='display:none'></iframe>"
+        output << form_tag(url_for_options, options)
+      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(frontend = :default)
+        js = javascript_include_tag(*active_scaffold_javascripts(frontend))
+
+        css = stylesheet_link_tag(*active_scaffold_stylesheets(frontend))
+        ie_css = stylesheet_link_tag(*active_scaffold_ie_stylesheets(frontend))
+
+        js + "\n" + css + "\n<!--[if IE]>" + ie_css + "<![endif]-->\n"
+      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
+
+      def params_for(options = {})
+        # :adapter and :position are one-use rendering arguments. they should not propagate.
+        # :sort, :sort_direction, and :page are arguments that stored in the session. they need not propagate.
+        # and wow. no we don't want to propagate :record.
+        # :commit is a special rails variable for form buttons
+        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method]
+        unless @params_for
+          @params_for = params.clone.delete_if { |key, value| blacklist.include? key.to_sym if key }
+          @params_for[:controller] = '/' + @params_for[:controller] unless @params_for[:controller].first(1) == '/' # for namespaced controllers
+          @params_for.delete(:id) if @params_for[:id].nil?
+        end
+        @params_for.merge(options)
+      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(options = {})
+        options[:of] ||= '$(this.parentNode).next()'
+        options[:default_visible] = true if options[:default_visible].nil?
+
+        link_text = options[:default_visible] ? 'hide' : 'show'
+        link_to_function as_(link_text), "e = #{options[:of]}; e.toggle(); this.innerHTML = (e.style.display == 'none') ? '#{as_('show')}' : '#{as_('hide')}'", :class => 'visibility-toggle'
+      end
+
+      def render_action_link(link, url_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
+
+        html_options = {:class => link.action}
+        if link.inline?
+          # NOTE this is in url_options instead of html_options on purpose. the reason is that the client-side
+          # action link javascript needs to submit the proper method, but the normal html_options[:method]
+          # argument leaves no way to extract the proper method from the rendered tag.
+          url_options[:_method] = link.method
+
+          if link.method != :get and respond_to?(:protect_against_forgery?) and protect_against_forgery?
+            url_options[:authenticity_token] = form_authenticity_token
+          end
+
+          # robd: protect against submitting get links as forms, since this causes annoying 
+          # 'Do you wish to resubmit your form?' messages whenever you go back and forwards.
+        elsif link.method != :get
+          # 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
+        end
+
+        html_options[:confirm] = link.confirm if link.confirm?
+        html_options[:position] = link.position if link.position and link.inline?
+        html_options[:class] += ' action' if link.inline?
+        html_options[:popup] = true if link.popup?
+        html_options[:id] = action_link_id(url_options[:action],url_options[:id])
+
+        if link.dhtml_confirm?
+          html_options[:class] += ' 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,action_link_id(url_options[:action],url_options[:id]))
+        end
+
+        # issue 260, use url_options[:link] if it exists. This prevents DB data from being localized.
+        label = url_options.delete(:link) || link.label
+        link_to label, url_options, html_options
+      end
+
+      def column_class(column, column_value)
+        classes = []
+        classes << "#{column.name}-column"
+        classes << column.css_class 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(' ')
+      end
+
+      def column_empty?(column_value)
+        empty = column_value.nil?
+        empty ||= column_value.empty? if column_value.respond_to? :empty?
+        empty ||= (column_value == '&nbsp;')
+        empty ||= (column_value == active_scaffold_config.list.empty_field_text)
+        return empty
+      end
+
+      def column_calculation(column)
+        calculation = active_scaffold_config.model.calculate(column.calculate, column.name, :conditions => controller.send(:all_conditions),
+         :joins => controller.send(:joins_for_collection), :include => controller.send(:active_scaffold_joins))
+      end
+    end
+  end
+end