antfarm 0.4.0 → 0.5.0.beta2

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

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

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

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

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

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