active_scaffold 3.2.20 → 3.3.0.rc

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -2,18 +2,37 @@ module ActiveScaffold
   module Helpers
     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)
-        relation = association.klass.where(conditions).where(association.options[:conditions])
+      def association_options_find(association, conditions = nil, klass = nil)
+        if klass.nil? && association.options[:polymorphic]
+          class_name = @record.send(association.foreign_type)
+          if class_name.present?
+            klass = class_name.constantize
+          else
+            return []
+          end
+        else
+          klass ||= association.klass
+        end
+
+        conditions = options_for_association_conditions(association) if conditions.nil?
+        relation = klass.where(conditions).where(association.options[:conditions])
         relation = relation.includes(association.options[:include]) if association.options[:include]
+        relation = yield(relation) if block_given?
         relation.all
       end
 
+      # Provides a way to honor the :conditions on an association while searching the association's klass
+      def sorted_association_options_find(association, conditions = nil)
+        association_options_find(association, conditions).sort_by(&:to_label)
+      end
+
       def association_options_count(association, conditions = nil)
         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.
       def options_for_association(association, include_all = false)
+        ActiveSupport::Deprecation.warn "options_for_association should not be used, use association_options_find directly"
         available_records = association_options_find(association, include_all ? nil : options_for_association_conditions(association))
         available_records ||= []
         available_records.sort{|a,b| a.to_label <=> b.to_label}.collect { |model| [ model.to_label, model.id ] }

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -2,24 +2,20 @@ module ActiveScaffold
   module Helpers
     module ControllerHelpers
       def self.included(controller)
-        controller.class_eval { helper_method :params_for, :params_conditions, :main_path_to_return, :render_parent?, :render_parent_options, :render_parent_action, :nested_singular_association?, :build_associated}
+        controller.class_eval { helper_method :params_for, :conditions_from_params, :main_path_to_return, :render_parent?, :render_parent_options, :render_parent_action, :nested_singular_association?, :build_associated}
       end
       
       include ActiveScaffold::Helpers::IdHelpers
-
-      def params_conditions
-        conditions_from_params.keys
-      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, :authenticity_token, :iframe]
+        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method, :authenticity_token, :iframe, :associated_id, :dont_close]
         unless @params_for
           @params_for = {}
-          params.select { |key, value| blacklist.exclude? key.to_sym if key }.each {|key, value| @params_for[key.to_sym] = value.duplicable? ? value.clone : value}
+          params.except(*blacklist).each {|key, value| @params_for[key.to_sym] = value.duplicable? ? value.clone : value}
           @params_for[:controller] = '/' + @params_for[:controller].to_s unless @params_for[:controller].to_s.first(1) == '/' # for namespaced controllers
           @params_for.delete(:id) if @params_for[:id].nil?
         end
@@ -31,23 +27,21 @@ module ActiveScaffold
         if params[:return_to]
           params[:return_to]
         else
+          exclude_parameters = [:utf8, :associated_id]
           parameters = {}
-          if params[:parent_controller]
-            parameters[:controller] = params[:parent_controller]
-            #parameters[:eid] = params[:parent_controller] # not neeeded anymore?
+          if params[:parent_scaffold] && nested? && nested.singular_association?
+            parameters[:controller] = params[:parent_scaffold]
+            exclude_parameters.concat [nested.param_name, :association, :parent_scaffold]
+            #parameters[:eid] = params[:parent_scaffold] # not neeeded anymore?
           end
           parameters.merge! nested.to_params if nested?
           if params[:parent_sti]
             parameters[:controller] = params[:parent_sti]
             #parameters[:eid] = nil # not neeeded anymore?
           end
-          parameters[:parent_column] = nil
-          parameters[:parent_id] = nil
           parameters[:action] = "index"
           parameters[:id] = nil
-          parameters[:associated_id] = nil
-          parameters[:utf8] = nil
-          params_for(parameters)
+          params_for(parameters).except(*exclude_parameters)
         end
       end
 
@@ -84,7 +78,11 @@ module ActiveScaffold
       
       def build_associated(column, record)
         if column.singular_association?
-          record.send(:"build_#{column.name}")
+          if column.association.options[:through]
+            record.send(:"build_#{column.association.through_reflection.name}").send(:"build_#{column.name}")
+          else
+            record.send(:"build_#{column.name}")
+          end
         else
           record.send(column.name).build
         end

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -58,6 +58,24 @@ module ActiveScaffold
           raise e
         end
       end
+      
+      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false)
+        if add_class
+          col_class = []
+          col_class << 'required' if column.required?
+          col_class << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+          col_class << 'hidden' if column_renders_as(column) == :hidden
+          col_class << 'checkbox' if column.form_ui == :checkbox
+          col_class = col_class.join(' ')
+        end
+        unless readonly and not @record.new_record? or not @record.authorized_for?(:crud_type => crud_type, :column => column.name)
+          render :partial => form_partial_for_column(column), :locals => { :column => column, :scope => scope, :col_class => col_class }
+        else
+          options = active_scaffold_input_options(column, scope).except(:name)
+          options[:class] = "#{options[:class]} #{col_class}" if col_class
+          content_tag :span, get_column_value(@record, column), options
+        end
+      end
 
       # the standard active scaffold options used for textual inputs
       def active_scaffold_input_text_options(options = {})
@@ -70,6 +88,12 @@ module ActiveScaffold
       def active_scaffold_input_options(column, scope = nil, options = {})
         name = scope ? "record#{scope}[#{column.name}]" : "record[#{column.name}]"
 
+        # Add some HTML5 attributes for in-browser validation and better user experience
+        if column.required? && (!@disable_required_for_new || scope.nil? || @record.persisted?)
+          options[:required] = true
+        end
+        options[:placeholder] = column.placeholder if column.placeholder.present?
+
         # Fix for keeping unique IDs in subform
         id_control = "record_#{column.name}_#{[params[:eid], params[:id]].compact.join '_'}"
         id_control += scope_id(scope) if scope
@@ -81,16 +105,24 @@ module ActiveScaffold
       end
 
       def update_columns_options(column, scope, options)
-        if column.update_columns
-          form_action = params[:action] == 'edit' ? :update : :create
-          url_params = {:action => 'render_field', :id => params[:id], :column => column.name}
+        form_action = if scope
+          subform_controller = controller.class.active_scaffold_controller_for(@record.class)
+          subform_controller.active_scaffold_config.subform
+        elsif [:new, :create, :edit, :update, :render_field].include? params[:action].to_sym
+          active_scaffold_config.send(@record.new_record? ? :create : :update)
+        end
+        if form_action && column.update_columns && (column.update_columns & form_action.columns.names).present?
+          url_params = {:action => 'render_field', :column => column.name, :id => nil}
+          url_params[:id] = @record.id if column.send_form_on_update_column
           url_params[:eid] = params[:eid] if params[:eid]
-          url_params[:controller] = controller.class.active_scaffold_controller_for(@record.class).controller_path if scope
-          url_params[:scope] = scope if scope
+          if scope
+            url_params[:controller] = subform_controller.controller_path
+            url_params[:scope] = scope
+          end
 
           options[:class] = "#{options[:class]} update_form".strip
           options['data-update_url'] = url_for(url_params)
-          options['data-update_send_form'] = true if column.send_form_on_update_column
+          options['data-update_send_form'] = column.send_form_on_update_column
           options['data-update_send_form_selector'] = column.options[:send_form_selector] if column.options[:send_form_selector]
         end
         options
@@ -99,41 +131,57 @@ module ActiveScaffold
       ##
       ## Form input methods
       ##
+      
+      def grouped_options_for_select(column, select_options, optgroup)
+        group_label = active_scaffold_config_for(column.association.klass).columns[optgroup].try(:association) ? :to_label : :to_s
+        select_options.group_by(&optgroup.to_sym).collect do |group, options|
+          [group.send(group_label), options.collect {|r| [r.to_label, r.id]}]
+        end
+      end
 
       def active_scaffold_translate_select_options(options)
-        options[:include_blank] = as_(options[:include_blank]) if options[:include_blank].is_a? Symbol
-        options[:prompt] = as_(options[:prompt]) if options[:prompt].is_a? Symbol
+        options[:include_blank] = as_(options[:include_blank].to_s) if options[:include_blank].is_a? Symbol
+        options[:prompt] = as_(options[:prompt].to_s) if options[:prompt].is_a? Symbol
         options
       end
       
       def active_scaffold_input_singular_association(column, html_options)
         associated = @record.send(column.association.name)
 
-        select_options = options_for_association(column.association)
-        select_options.unshift([ associated.to_label, associated.id ]) unless associated.nil? or select_options.find {|label, id| id == associated.id}
+        select_options = sorted_association_options_find(column.association)
+        select_options.unshift(associated) unless associated.nil? || select_options.include?(associated)
 
         method = column.name
-        #html_options[:name] += '[id]'
         options = {:selected => associated.try(:id), :include_blank => as_(:_select_)}
 
         html_options.update(column.options[:html_options] || {})
         options.update(column.options)
-        html_options[:name] = "#{html_options[:name]}[]" if (html_options[:multiple] == true && !html_options[:name].to_s.ends_with?("[]"))
+        html_options[:name] = "#{html_options[:name]}[]" if html_options[:multiple] == true && !html_options[:name].to_s.ends_with?("[]")
         active_scaffold_translate_select_options(options)
-        select(:record, method, select_options.uniq, options, html_options)
+
+        if optgroup = options.delete(:optgroup)
+          select(:record, method, grouped_options_for_select(column, select_options, optgroup), options, html_options)
+        else
+          collection_select(:record, method, select_options, :id, :to_label, options, html_options)
+        end
+      end
+
+      def active_scaffold_plural_association_options(column)
+        associated_options = @record.send(column.association.name)
+        [associated_options, associated_options | sorted_association_options_find(column.association)]
       end
 
       def active_scaffold_input_plural_association(column, options)
-        associated_options = @record.send(column.association.name).collect {|r| [r.to_label, r.id]}
-        select_options = associated_options | options_for_association(column.association)
+        associated_options, select_options = active_scaffold_plural_association_options(column)
         return content_tag(:span, as_(:no_options), :class => options[:class], :id => options[:id]) if select_options.empty?
 
-        active_scaffold_checkbox_list(column, select_options, associated_options.collect {|a| a[1]}, options)
+        active_scaffold_checkbox_list(column, select_options.collect {|r| [r.to_label, r.id]}, associated_options.collect(&:id), options)
       end
       
       def active_scaffold_checkbox_list(column, select_options, associated_ids, options)
-        html = content_tag :ul, :class => "#{options[:class]} checkbox-list", :id => options[:id] do
-          content = hidden_field_tag("#{options[:name]}[]", '')
+        html = hidden_field_tag("#{options[:name]}[]", '')
+        html << content_tag(:ul, :class => "#{options[:class]} checkbox-list", :id => options[:id]) do
+          content = ''.html_safe
           select_options.each_with_index do |option, i|
             label, id = option
             this_id = "#{options[:id]}_#{i}_id"
@@ -152,10 +200,14 @@ module ActiveScaffold
         value = text if value.nil?
         [(text.is_a?(Symbol) ? column.active_record_class.human_attribute_name(text) : text), value]
       end
+      
+      def active_scaffold_enum_options(column)
+        column.options[:options]
+      end
 
       def active_scaffold_input_enum(column, html_options)
         options = { :selected => @record.send(column.name) }
-        options_for_select = column.options[:options].collect do |text, value|
+        options_for_select = active_scaffold_enum_options(column).collect do |text, value|
           active_scaffold_translated_option(column, text, value)
         end
         html_options.update(column.options[:html_options] || {})
@@ -200,6 +252,41 @@ module ActiveScaffold
         text_field :record, column.name, options.merge(column.options)
       end
 
+      # Some fields from HTML5 (primarily for using in-browser validation)
+      # Sadly, many of them lacks browser support
+
+      # A text box, that accepts only valid email address (in-browser validation)
+      def active_scaffold_input_email(column, options)
+        options = active_scaffold_input_text_options(options)
+        email_field :record, column.name, options.merge(column.options)
+      end
+
+      # A text box, that accepts only valid URI (in-browser validation)
+      def active_scaffold_input_url(column, options)
+        options = active_scaffold_input_text_options(options)
+        url_field :record, column.name, options.merge(column.options)
+      end
+
+      # A text box, that accepts only valid phone-number (in-browser validation)
+      def active_scaffold_input_telephone(column, options)
+        options = active_scaffold_input_text_options(options)
+        telephone_field :record, column.name, options.merge(column.options)
+      end
+
+      # A spinbox control for number values (in-browser validation)
+      def active_scaffold_input_number(column, options)
+        options = numerical_constraints_for_column(column, options)
+        options = active_scaffold_input_text_options(options)
+        number_field :record, column.name, options.merge(column.options)
+      end
+
+      # A slider control for number values (in-browser validation)
+      def active_scaffold_input_range(column, options)
+        options = numerical_constraints_for_column(column, options)
+        options = active_scaffold_input_text_options(options)
+        range_field :record, column.name, options.merge(column.options)
+      end
+
       #
       # Column.type-based inputs
       #
@@ -304,8 +391,9 @@ module ActiveScaffold
           options.merge!(active_scaffold_input_text_options)
           record_select_field(options[:name], @record, options)
         else
-          select_options = options_for_select(options_for_association(nested.association)) #unless column.through_association?
-          select_options ||= options_for_select(active_scaffold_config.model.all.collect {|c| [h(c.to_label), c.id]})
+          select_options = sorted_association_options_find(nested.association)
+          select_options ||= active_scaffold_config.model.all
+          select_options = options_from_collection_for_select(select_options, :id, :to_label)
           select_tag 'associated_id', ('<option value="">' + as_(:_select_) + '</option>' + select_options).html_safe unless select_options.empty?
         end
       end
@@ -317,6 +405,58 @@ module ActiveScaffold
           active_scaffold_config.model.model_name.human
         end
       end
+
+      # Try to get numerical constraints from model's validators
+      def numerical_constraints_for_column(column, options)
+        if column.numerical_constraints.nil?
+          numerical_constraints = {}
+          validators = column.active_record_class.validators.select do |v|
+            v.is_a? ActiveModel::Validations::NumericalityValidator and v.attributes.include? column.name
+          end
+          equal_to = (v = validators.find{ |v| v.options[:equal_to] }) ? v.options[:equal_to] : nil
+          
+          # If there is equal_to constraint - use it (unless otherwise specified by user)
+          if equal_to and not (options[:min] or options[:max])
+            numerical_constraints[:min] = numerical_constraints[:max] = equal_to
+          else # find minimum and maximum from validators
+            # we can safely modify :min and :max by 1 for :greater_tnan or :less_than value only for integer values
+            only_integer = column.column.type == :integer if column.column
+            only_integer ||= !!validators.find{ |v| v.options[:only_integer] }
+            margin = only_integer ? 1 : 0
+            
+            # Minimum
+            unless options[:min]
+              min = validators.map{ |v| v.options[:greater_than_or_equal] }.compact.max
+              greater_than = validators.map{ |v| v.options[:greater_than] }.compact.max
+              numerical_constraints[:min] = [min, (greater_than+margin if greater_than)].compact.max
+            end
+            
+            # Maximum
+            unless options[:max]
+              max = validators.map{ |v| v.options[:less_than_or_equal] }.compact.min
+              less_than = validators.map{ |v| v.options[:less_than] }.compact.min
+              numerical_constraints[:max] = [max, (less_than-margin if less_than)].compact.min
+            end
+            
+            # Set step = 2 for column values restricted to be odd or even (but only if minimum is set)
+            unless options[:step]
+              only_odd_valid  = validators.any?{ |v| v.options[:odd] }
+              only_even_valid = validators.any?{ |v| v.options[:even] } unless only_odd_valid
+              if !only_integer
+                numerical_constraints[:step] ||= "0.#{'0'*(column.column.scale-1)}1" if column.column && column.column.scale.to_i > 0
+              elsif options[:min] and options[:min].respond_to? :even? and (only_odd_valid or only_even_valid)
+                numerical_constraints[:step] = 2
+                numerical_constraints[:min] += 1 if only_odd_valid  and not options[:min].odd?
+                numerical_constraints[:min] += 1 if only_even_valid and not options[:min].even?
+              end
+              numerical_constraints[:step] ||= 'any' unless only_integer
+            end
+          end
+          
+          column.numerical_constraints = numerical_constraints
+        end
+        return column.numerical_constraints.merge(options)
+      end
     end
   end
 end

data/lib/active_scaffold/helpers/id_helpers.rb

@@ -58,14 +58,14 @@ module ActiveScaffold
       def element_row_id(options = {})
         options[:action] ||= params[:action]
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{options[:controller_id] || controller_id}-#{options[:action]}-#{options[:id]}-row"
       end
 
       def element_cell_id(options = {})
         options[:action] ||= params[:action]
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         options[:name] ||= params[:name]
         clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-#{options[:name]}-cell"
       end
@@ -73,7 +73,7 @@ module ActiveScaffold
       def element_form_id(options = {})
         options[:action] ||= params[:action]
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-form"
       end
 
@@ -89,26 +89,26 @@ module ActiveScaffold
       
       def sub_section_id(options = {})
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{controller_id}-#{options[:id]}-#{options[:sub_section]}-subsection"
       end
 
       def sub_form_id(options = {})
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{controller_id}-#{options[:id]}-#{options[:association]}-subform"
       end
       
       def sub_form_list_id(options = {})
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{controller_id}-#{options[:id]}-#{options[:association]}-subform-list"
       end
 
       def element_messages_id(options = {})
         options[:action] ||= params[:action]
         options[:id] ||= params[:id]
-        options[:id] ||= params[:parent_id]
+        options[:id] ||= nested.parent_id if nested?
         clean_id "#{controller_id}-#{options[:action]}-#{options[:id]}-messages"
       end
 

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -5,32 +5,37 @@ module ActiveScaffold
     module ListColumnHelpers
       def get_column_value(record, column)
         begin
-          # check for an override helper
-          value = if (method = column_override(column))
+          method = get_column_method(record, column)
+          value = send(method, record, column)
+          value = ' '.html_safe if value.nil? or value.blank? # fix for IE 6
+          return value
+        rescue Exception => e
+          logger.error "#{Time.now.to_s} #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
+          raise e
+        end
+      end
+
+
+      def get_column_method(record, column)
+        # check for an override helper
+        method = column.list_method
+        unless method
+          method = if (method = 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.
-            if method(method).arity == 1
-              ActiveSupport::Deprecation.warn("Add column argument to field override, signature is unified with list_ui")
-              send(method, record)
-            else
-              send(method, record, column)
-            end
+            method
           # second, check if the dev has specified a valid list_ui for this column
           elsif column.list_ui and (method = override_column_ui(column.list_ui))
-            send(method, column, record)
+            method
           elsif column.column and (method = override_column_ui(column.column.type))
-            send(method, column, record)
+            method
           else
-            format_column_value(record, column)
+            :format_column_value
           end
-
-          value = ' '.html_safe if value.nil? or (value.respond_to?(:empty?) and value.empty?) # fix for IE 6
-          return value
-        rescue Exception => e
-          logger.error Time.now.to_s + "#{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
-          raise e
+          column.list_method = method
         end
+        method
       end
 
       # TODO: move empty_field_text and   logic in here?
@@ -39,21 +44,7 @@ module ActiveScaffold
         if column.link
           link = column.link
           associated = record.send(column.association.name) if column.association
-          url_options = params_for(:action => nil, :id => record.id)
-
-          # setup automatic link
-          if column.autolink? && column.singular_association? # link to inline form
-            link = action_link_to_inline_form(column, record, associated, text)
-            return text if link.nil?
-          else
-            url_options[:link] = text
-          end
-
-          if column_link_authorized?(link, column, record, associated)
-            render_action_link(link, url_options, record)
-          else
-            "<a class='disabled'>#{text}</a>".html_safe
-          end
+          render_action_link(link, record, :link => text, :authorized => link.action.nil? || column_link_authorized?(link, column, record, associated))
         elsif inplace_edit?(record, column)
           active_scaffold_inplace_edit(record, column, {:formatted_column => text})
         elsif active_scaffold_config.list.wrap_tag
@@ -63,53 +54,6 @@ module ActiveScaffold
         end
       end
 
-      # setup the action link to inline form
-      def action_link_to_inline_form(column, record, associated, text)
-        link = column.link.clone
-        link.label = text
-        if column.polymorphic_association?
-          polymorphic_controller = controller_path_for_activerecord(record.send(column.association.name).class)
-          return link if polymorphic_controller.nil?
-          link.controller = polymorphic_controller
-        end
-        configure_column_link(link, associated, column.actions_for_association_links)
-      end
-
-      def configure_column_link(link, associated, actions)
-        if column_empty?(associated) # if association is empty, we only can link to create form
-          if actions.include?(:new)
-            link.action = 'new'
-            link.crud_type = :create
-            link.label = as_(:create_new)
-          end
-        elsif actions.include?(:edit)
-          link.action = 'edit'
-          link.crud_type = :update
-        elsif actions.include?(:show)
-          link.action = 'show'
-          link.crud_type = :read
-        elsif actions.include?(:list)
-          link.action = 'index'
-          link.crud_type = :read
-        end
-        link if link.action.present?
-      end
-
-      def column_link_authorized?(link, column, record, associated)
-        if column.association
-          associated_for_authorized = if column.plural_association? || (associated.respond_to?(:blank?) && associated.blank?)
-            column.association.klass
-          else
-            associated
-          end
-          authorized = associated_for_authorized.authorized_for?(:crud_type => link.crud_type)
-          authorized = authorized and record.authorized_for?(:crud_type => :update, :column => column.name) if link.crud_type == :create
-          authorized
-        else
-          record.authorized_for?(:crud_type => link.crud_type)
-        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
@@ -124,16 +68,20 @@ module ActiveScaffold
       ##
       ## Overrides
       ##
-      def active_scaffold_column_text(column, record)
+      def active_scaffold_column_text(record, column)
         clean_column_value(truncate(record.send(column.name), :length => column.options[:truncate] || 50))
       end
 
-      def active_scaffold_column_marked(column, record)
+      def active_scaffold_column_fulltext(record, column)
+        clean_column_value(record.send(column.name))
+      end
+
+      def active_scaffold_column_marked(record, column)
         options = {:id => nil, :object => record}
         content_tag(:span, check_box(:record, column.name, options), :class => 'in_place_editor_field', :data => {:ie_id => record.id.to_s})
       end
 
-      def active_scaffold_column_checkbox(column, record)
+      def active_scaffold_column_checkbox(record, column)
         options = {:disabled => true, :id => nil, :object => record}
         options.delete(:disabled) if inplace_edit?(record, column)
         check_box(:record, column.name, options)
@@ -146,8 +94,10 @@ module ActiveScaffold
 
       # the naming convention for overriding column types with helpers
       def override_column_ui(list_ui)
+        @_column_ui_overrides ||= {}
+        return @_column_ui_overrides[list_ui] if @_column_ui_overrides.include? list_ui
         method = "active_scaffold_column_#{list_ui}"
-        method if respond_to? method
+        @_column_ui_overrides[list_ui] = (method if respond_to? method)
       end
       alias_method :override_column_ui?, :override_column_ui
 
@@ -237,7 +187,7 @@ module ActiveScaffold
           if column.associated_limit.nil?
             Rails.logger.warn "ActiveScaffold: Enable eager loading for #{column.name} association to reduce SQL queries"
           elsif column.associated_limit > 0
-            value.target = value.find(:all, :limit => column.associated_limit + 1, :select => column.select_associated_columns)
+            value.target = value.find(:all, :limit => column.associated_limit + 1, :select => column.select_columns)
           elsif @cache_associations
             value.target = size.to_i.zero? ? [] : [nil]
           end
@@ -251,8 +201,7 @@ module ActiveScaffold
       def inplace_edit?(record, column)
         if column.inplace_edit
           editable = controller.send(:update_authorized?, record) if controller.respond_to?(:update_authorized?)
-          editable = record.authorized_for?(:crud_type => :update, :column => column.name) if editable.nil? || editable == true
-          editable
+          editable ||= record.authorized_for?(:crud_type => :update, :column => column.name)
         end
       end
 
@@ -265,6 +214,7 @@ module ActiveScaffold
         id_options = {:id => record.id.to_s, :action => 'update_column', :name => column.name.to_s}
         tag_options = {:id => element_cell_id(id_options), :class => "in_place_editor_field",
                        :title => as_(:click_to_edit), :data => {:ie_id => record.id.to_s}}
+        tag_options[:data][:ie_update] = column.inplace_edit if column.inplace_edit != true
 
         content_tag(:span, as_(:inplace_edit_handle), :class => 'handle') <<
         content_tag(:span, formatted_column, tag_options)
@@ -288,7 +238,7 @@ module ActiveScaffold
 
       def inplace_edit_data(column)
         data = {}
-        data[:ie_url] = url_for({:controller => params_for[:controller], :action => "update_column", :column => column.name, :id => '__id__'})
+        data[:ie_url] = url_for(params_for(:action => "update_column", :column => column.name, :id => '__id__'))
         data[:ie_cancel_text] = column.options[:cancel_text] || as_(:cancel)
         data[:ie_loading_text] = column.options[:loading_text] || as_(:loading)
         data[:ie_save_text] = column.options[:save_text] || as_(:update)
@@ -302,7 +252,7 @@ module ActiveScaffold
         elsif inplace_edit_cloning?(column)
           data[:ie_mode] = :clone
         elsif column.inplace_edit == :ajax
-          url = url_for(:controller => params_for[:controller], :action => 'render_field', :id => '__id__', :column => column.name, :update_column => column.name, :in_place_editing => true)
+          url = url_for(:controller => params_for[:controller], :action => 'render_field', :id => '__id__', :update_column => column.name)
           plural = column.plural_association? && !override_form_field?(column) && [:select, :record_select].include?(column.form_ui)
           data[:ie_render_url] = url
           data[:ie_mode] = :ajax
@@ -315,7 +265,7 @@ module ActiveScaffold
         if active_scaffold_config.mark.mark_all_mode == :page
           all_marked = @page.items.detect { |record| !marked_records.include?(record.id) }.nil?
         else
-          all_marked = (marked_records.length >= @page.pager.count)
+          all_marked = (marked_records.length >= @page.pager.count.to_i)
         end
       end
 
@@ -356,12 +306,12 @@ module ActiveScaffold
         end
       end
       
-      def render_nested_view(action_links, url_options, record)
+      def render_nested_view(action_links, record)
         rendered = []
         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 = {: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)
+            link_url_options = {:adapter => '_list_inline_adapter', :format => :js}.merge(action_link_url_options(link, record))
+            link_id = get_action_link_id(link, record)
             rendered << (controller.send(:render_component_into_view, link_url_options) + javascript_tag("ActiveScaffold.ActionLink.get('#{link_id}').set_opened();"))
           end 
         end