active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -2,7 +2,15 @@ module ActiveScaffold
   module Helpers
     module ControllerHelpers
       def self.included(controller)
-        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, :generate_temporary_id, :generated_id }
+        if controller.respond_to? :helper_method
+          controller.class_eval do
+            helper_method :params_for, :conditions_from_params, :render_parent?,
+                          :main_path_to_return, :render_parent_options,
+                          :render_parent_action, :nested_singular_association?,
+                          :main_form_controller, :build_associated,
+                          :generate_temporary_id, :generated_id
+          end
+        end
       end
 
       include ActiveScaffold::Helpers::IdHelpers
@@ -19,7 +27,7 @@ module ActiveScaffold
 
       # These params should not propagate:
       # :adapter and :position are one-use rendering arguments.
-      # :sort, :sort_direction, and :page are arguments that stored in the session.
+      # :sort, :sort_direction, and :page are arguments that stored in the session, if store_user_settings is enabled
       # and wow. no we don't want to propagate :record.
       # :commit is a special rails variable for form buttons
       # :_method is a special rails variable to simulate put, patch and delete actions.
@@ -28,16 +36,52 @@ module ActiveScaffold
       # :iframe is used to simulate ajax forms loading form in iframe.
       # :associated_id used in add_existing
       # :authenticity_token is sent on some ajax requests
-      BLACKLIST_PARAMS = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method, :dont_close, :auto_pagination, :iframe, :associated_id, :authenticity_token].freeze
+      # :_added is sent on checkbox-list with update_columns
+      # :_removed is sent on checkbox-list with update_columns
+      # :_popstate sent when loading previous page from history, after using history.pushState
+      # :_ jQuery param added for GET requests with cache disabled
+      BLACKLIST_PARAMS = %i[adapter position sort sort_direction page record commit _method dont_close auto_pagination
+                            iframe associated_id authenticity_token _added _removed _popstate _].freeze
 
       def params_for(options = {})
         unless @params_for
           @params_for = {}
-          params.except(*BLACKLIST_PARAMS).each { |key, value| @params_for[key.to_sym] = value.duplicable? ? value.clone : value }
+          params.except(*BLACKLIST_PARAMS).each do |key, value|
+            @params_for[key.to_sym] = copy_param(value)
+          end
           @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
-        @params_for.merge(options)
+
+        url_options = @params_for.merge(options)
+        if !active_scaffold_config.store_user_settings && controller_requested(url_options[:controller]) == controller_path
+          url_options[:search] ||= copy_param search_params if respond_to?(:search_params, true) && search_params.present?
+          url_options[:page] ||= params[:page]
+          if active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.user.user_sorting?
+            column, direction = active_scaffold_config.list.user.sorting.first
+            url_options[:sort] ||= column.name
+            url_options[:sort_direction] ||= direction
+          end
+        end
+        url_options
+      end
+
+      def controller_requested(controller)
+        if controller.to_s.first(1) == '/'
+          controller[1..-1]
+        else
+          path = controller_path.split('/')[0..-2]
+          path << controller
+          path.join('/')
+        end
+      end
+
+      def copy_param(value)
+        if controller_params? value
+          params_hash value
+        else
+          value.duplicable? ? value.clone : value
+        end
       end
 
       # Parameters to generate url to the main page (override if the ActiveScaffold is used as a component on another controllers page)
@@ -45,7 +89,7 @@ module ActiveScaffold
         if params[:return_to]
           params[:return_to]
         else
-          exclude_parameters = [:utf8, :associated_id]
+          exclude_parameters = %i[utf8 associated_id]
           parameters = {}
           if params[:parent_scaffold] && nested? && nested.singular_association?
             parameters[:controller] = params[:parent_scaffold]
@@ -67,6 +111,10 @@ module ActiveScaffold
         nested? && (nested.belongs_to? || nested.has_one?)
       end
 
+      def main_form_controller
+        parent_controller_name.constantize if params[:parent_controller]
+      end
+
       def render_parent?
         nested_singular_association? || params[:parent_sti]
       end
@@ -74,24 +122,21 @@ module ActiveScaffold
       def render_parent_options
         if nested_singular_association?
           {:controller => nested.parent_scaffold.controller_path, :action => :index, :id => nested.parent_id}
-        elsif params[:parent_sti]
-          options = params_for(:controller => params[:parent_sti], :action => render_parent_action, :parent_sti => nil)
-          options.merge(:action => :index, :id => @record.to_param) if render_parent_action == :row
+        elsif parent_sti_controller
+          options = params_for(:controller => parent_sti_controller.controller_path, :action => render_parent_action, :parent_sti => nil)
+          options.merge!(:action => :index, :id => @record.to_param) if render_parent_action == :row
+          options
         end
       end
 
       def render_parent_action
         if @parent_action.nil?
-          begin
-            @parent_action = :row
-            if params[:parent_sti]
-              parent_controller = "#{params[:parent_sti].to_s.camelize}Controller".constantize
-              @parent_action = :index if action_name == 'create' && parent_controller.active_scaffold_config.actions.include?(:create) && parent_controller.active_scaffold_config.create.refresh_list == true
-              @parent_action = :index if action_name == 'update' && parent_controller.active_scaffold_config.actions.include?(:update) && parent_controller.active_scaffold_config.update.refresh_list == true
-              @parent_action = :index if action_name == 'destroy' && parent_controller.active_scaffold_config.actions.include?(:delete) && parent_controller.active_scaffold_config.delete.refresh_list == true
-            end
-          rescue ActiveScaffold::ControllerNotFound => ex
-            logger.warn "#{ex.message} for parent_sti #{params[:parent_sti]}"
+          @parent_action = :row
+          if parent_sti_controller
+            parent_sti_config = parent_sti_controller.active_scaffold_config
+            @parent_action = :index if action_name == 'create' && parent_sti_config.actions.include?(:create) && parent_sti_config.create.refresh_list == true
+            @parent_action = :index if action_name == 'update' && parent_sti_config.actions.include?(:update) && parent_sti_config.update.refresh_list == true
+            @parent_action = :index if action_name == 'destroy' && parent_sti_config.actions.include?(:delete) && parent_sti_config.delete.refresh_list == true
           end
         end
         @parent_action
@@ -99,12 +144,17 @@ module ActiveScaffold
 
       # build an associated record for association
       def build_associated(association, parent_record)
-        if association.options[:through]
+        if association.through? && association.through_reflection.collection?
           # build full chain, only check create_associated on initial parent_record
-          parent_record = build_associated(association.through_reflection, parent_record)
-          build_associated(association.source_reflection, parent_record).tap do |record|
-            save_record_to_association(record, association.source_reflection.reverse, parent_record) # set inverse
+          parent_record = build_associated(association.class.new(association.through_reflection), parent_record)
+          source_assoc = association.class.new(association.source_reflection)
+          build_associated(source_assoc, parent_record).tap do |record|
+            save_record_to_association(record, source_assoc.reverse_association, parent_record) # set inverse
           end
+        elsif association.through? # through belongs_to/has_one
+          parent_record = parent_record.send(association.through_reflection.name)
+          source_assoc = association.class.new(association.source_reflection)
+          build_associated(source_assoc, parent_record)
         elsif association.collection?
           parent_record.send(association.name).build
         elsif association.belongs_to? || parent_record.new_record? || parent_record.send(association.name).nil?
@@ -113,7 +163,7 @@ module ActiveScaffold
           parent_record.send("build_#{association.name}")
         else
           association.klass.new.tap do |record|
-            save_record_to_association(record, association.reverse, parent_record) # set inverse
+            save_record_to_association(record, association.reverse_association, parent_record) # set inverse
           end
         end
       end

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -12,8 +12,6 @@ module ActiveScaffold
 
       def active_scaffold_render_input(column, options)
         record = options[:object]
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
 
         # first, check if the dev has created an override for this specific field
         if (method = override_form_field(column))
@@ -42,15 +40,14 @@ module ActiveScaffold
             # final ultimate fallback: use rails' generic input method
             else
               # for textual fields we pass different options
-              text_types = [:text, :string, :integer, :float, :decimal, :date, :time, :datetime]
+              text_types = %i[text string integer float decimal]
               options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
               if column.column.type == :string && options[:maxlength].blank?
                 options[:maxlength] = column.column.limit
                 options[:size] ||= options[:maxlength].to_i > 30 ? 30 : options[:maxlength]
               end
-              options[:include_blank] = true if column.column.null && [:date, :datetime, :time].include?(column.column.type)
               options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
-              text_field(:record, column.name, options.merge(column.options))
+              text_field(:record, column.name, options.merge(column.options).except(:format))
             end
           end
         end
@@ -60,8 +57,6 @@ module ActiveScaffold
       end
 
       def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, call with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         if add_class
           col_class = []
           col_class << 'required' if column.required?
@@ -120,22 +115,24 @@ module ActiveScaffold
       def current_form_columns(record, scope, subform_controller = nil)
         if scope
           subform_controller.active_scaffold_config.subform.columns.names
-        elsif [:new, :create, :edit, :update, :render_field].include? action_name.to_sym
+        elsif %i[new create edit update render_field].include? action_name.to_sym
+          # disable update_columns for inplace_edit (GET render_field)
+          return if action_name == 'render_field' && request.get?
           active_scaffold_config.send(record.new_record? ? :create : :update).columns.names
         end
       end
 
       def update_columns_options(column, scope, options, force = false)
         record = options[:object]
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         subform_controller = controller.class.active_scaffold_controller_for(record.class) if scope
         form_columns = @main_columns.try(:names) if scope.nil? || subform_controller == controller.class
         form_columns ||= current_form_columns(record, scope, subform_controller)
         if force || (form_columns && column.update_columns && (column.update_columns & form_columns).present?)
           url_params = params_for(:action => 'render_field', :column => column.name, :id => record.to_param)
-          url_params = url_params.except(:parent_scaffold, :association, nested.param_name) if nested? && scope
-          url_params[:eid] = params[:eid] if params[:eid]
+          if nested? && scope
+            url_params[:nested] = url_params.slice(:parent_scaffold, :association, nested.param_name)
+            url_params = url_params.except(:parent_scaffold, :association, nested.param_name)
+          end
           if scope
             url_params[:parent_controller] ||= url_params[:controller].gsub(/^\//, '')
             url_params[:controller] = subform_controller.controller_path
@@ -144,7 +141,7 @@ module ActiveScaffold
           end
 
           options[:class] = "#{options[:class]} update_form".strip
-          options['data-update_url'] = url_for(url_params.merge(:_added => nil, :_removed => nil))
+          options['data-update_url'] = url_for(url_params)
           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
@@ -156,8 +153,8 @@ module ActiveScaffold
       end
 
       def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil)
-        if override_form_field_partial?(column)
-          render :partial => override_form_field_partial(column), :locals => {:column => column, :only_value => only_value, :scope => scope, :col_class => col_class, :record => record}
+        if partial = override_form_field_partial(column)
+          render :partial => partial, :locals => {:column => column, :only_value => only_value, :scope => scope, :col_class => col_class, :record => record}
         elsif renders_as == :field || override_form_field?(column)
           form_attribute(column, record, scope, only_value, col_class)
         elsif renders_as == :subform
@@ -171,13 +168,17 @@ module ActiveScaffold
         column_options = active_scaffold_input_options(column, scope, :object => record)
         attributes = field_attributes(column, record)
         attributes[:class] = "#{attributes[:class]} #{col_class}" if col_class.present?
-        field =
-          if only_value
-            content_tag(:span, get_column_value(record, column), column_options.except(:name, :object)) <<
-            hidden_field(:record, column.association ? column.association.foreign_key : column.name, column_options)
-          else
-            active_scaffold_input_for column, scope, column_options
+        if only_value
+          field = content_tag(:span, get_column_value(record, column), column_options.except(:name, :object))
+          if column.association.nil? || column.association.belongs_to?
+            # hidden field probably not needed, but leaving it just in case
+            # but it isn't working for assocations which are not belongs_to
+            method = column.association ? column.association.foreign_key : column.name
+            field << hidden_field(:record, method, column_options)
           end
+        else
+          field = active_scaffold_input_for column, scope, column_options
+        end
 
         content_tag :dl, attributes do
           %(<dt>#{label_tag label_for(column, column_options), column.label}</dt><dd>#{field}
@@ -188,7 +189,7 @@ module ActiveScaffold
       end
 
       def label_for(column, options)
-        options[:id] unless column.form_ui == :select && column.plural_association?
+        options[:id] unless column.form_ui == :select && column.association.try(:collection?)
       end
 
       def subform_label(column, hidden)
@@ -196,33 +197,60 @@ module ActiveScaffold
       end
 
       def form_hidden_attribute(column, record, scope = nil)
-        %(<dl style="display: none;"><dt></dt><dd>
-#{hidden_field :record, column.name, active_scaffold_input_options(column, scope).merge(:object => record)}
-</dd></dl>).html_safe
+        content_tag :dl, style: 'display: none' do
+          content_tag(:dt, '') <<
+            content_tag(:dd, form_hidden_field(column, record, scope))
+        end
+      end
+
+      def form_hidden_field(column, record, scope)
+        options = active_scaffold_input_options(column, scope)
+        if column.association.try(:collection?)
+          associated = record.send(column.name)
+          if associated.blank?
+            hidden_field_tag options[:name], '', options
+          else
+            options[:name] += '[]'
+            fields = associated.map do |r|
+              hidden_field_tag options[:name], r.id, options.merge(id: options[:id] + "_#{r.id}")
+            end
+            safe_join fields, ''
+          end
+        else
+          hidden_field :record, column.name, options.merge(object: record)
+        end
       end
 
       # Should this column be displayed in the subform?
-      def in_subform?(column, parent_record)
+      def in_subform?(column, parent_record, parent_column)
         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?
+        if column.association.reverse.nil?
+          # Polymorphic associations can't appear because they *might* be the reverse association
+          return false if column.association.polymorphic?
 
-        # A column shouldn't be in the subform if it's the reverse association to the parent
-        return false if column.association.inverse_for?(parent_record.class)
-
-        true
+          # A column shouldn't be in the subform if it's the reverse association to the parent
+          !column.association.inverse_for?(parent_record.class)
+        elsif column.association.reverse == parent_column.name
+          if column.association.polymorphic?
+            column.association.name != parent_column.association.as
+          else
+            !column.association.inverse_for?(parent_record.class)
+          end
+        else
+          true
+        end
       end
 
       def column_show_add_existing(column, record = nil)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, call with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
-        (column.allow_add_existing && options_for_association_count(column.association, record) > 0)
+        column.allow_add_existing && options_for_association_count(column.association, record) > 0
       end
 
       def column_show_add_new(column, associated, record)
-        value = (column.plural_association? && !column.readonly_association?) || column.singular_association?
-        value &&= false unless column.association.klass.authorized_for?(:crud_type => :create)
+        assoc = column.association
+        value = assoc.singular?
+        value ||= assoc.collection? && !assoc.readonly? && (!assoc.through? || !assoc.through_reflection.collection?)
+        value &&= false unless assoc.klass.authorized_for?(:crud_type => :create)
         value
       end
 
@@ -245,21 +273,25 @@ module ActiveScaffold
         options
       end
 
-      def active_scaffold_input_singular_association(column, html_options)
+      def active_scaffold_select_name_with_multiple(options)
+        if options[:multiple] && !options[:name].to_s.ends_with?('[]')
+          options[:name] = "#{options[:name]}[]"
+        end
+      end
+
+      def active_scaffold_input_singular_association(column, html_options, options = {})
         record = html_options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in html_options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         associated = record.send(column.association.name)
 
         select_options = sorted_association_options_find(column.association, nil, record)
         select_options.unshift(associated) unless associated.nil? || select_options.include?(associated)
 
         method = column.name
-        options = {:selected => associated.try(:id), :include_blank => as_(:_select_), :object => record}
+        options.merge! :selected => associated.try(:id), :include_blank => as_(:_select_), :object => record
 
         html_options.merge!(column.options[:html_options] || {})
         options.merge!(column.options)
-        html_options[:name] = "#{html_options[:name]}[]" if html_options[:multiple] == true && !html_options[:name].to_s.ends_with?('[]')
+        active_scaffold_select_name_with_multiple html_options
         active_scaffold_translate_select_options(options)
 
         html =
@@ -272,6 +304,39 @@ module ActiveScaffold
         html
       end
 
+      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, &block)
+        options = active_scaffold_input_text_options(options.merge(column.options))
+        if content
+          active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class, &block)
+        else
+          file_field(:record, column.name, options)
+        end
+      end
+
+      def active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class)
+        required = options.delete(:required)
+        case ActiveScaffold.js_framework
+        when :jquery
+          js_remove_file_code = "jQuery(this).prev().val('true'); jQuery(this).parent().hide().next().show()#{".find('input').attr('required', 'required')" if required}; return false;"
+          js_dont_remove_file_code = "jQuery(this).parents('div.#{controls_class}').find('input.remove_file').val('false'); return false;"
+        when :prototype
+          js_remove_file_code = "$(this).previous().value='true'; $(this).up().hide().next().show()#{".down().writeAttribute('required', 'required')" if required}; return false;"
+          js_dont_remove_file_code = "jQuery(this).parents('div.#{controls_class}').find('input.remove_file').val('false'); return false;"
+        end
+
+        object_name, method = options[:name].split(/\[(#{column.name})\]/)
+        method.sub!(/#{column.name}/, "#{remove_file_prefix}\\0")
+        fields = block_given? ? yield : ''
+        input = file_field(:record, column.name, options.merge(:onchange => js_dont_remove_file_code))
+        content_tag(:div, class: controls_class) do
+          content_tag(:div) do
+            safe_join [content, ' | ', fields,
+                       hidden_field(object_name, method, :value => 'false', class: 'remove_file'),
+                       content_tag(:a, as_(:remove_file), :href => '#', :onclick => js_remove_file_code)]
+          end << content_tag(:div, input, :style => 'display: none')
+        end
+      end
+
       def active_scaffold_refresh_link(column, html_options, record)
         link_options = {:object => record}
         if html_options['data-update_url']
@@ -286,16 +351,12 @@ module ActiveScaffold
       end
 
       def active_scaffold_plural_association_options(column, record = nil)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, call with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         associated_options = record.send(column.association.name)
         [associated_options, associated_options | sorted_association_options_find(column.association, nil, record)]
       end
 
       def active_scaffold_input_plural_association(column, options)
         record = options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         associated_options, select_options = active_scaffold_plural_association_options(column, record)
 
         html =
@@ -339,31 +400,45 @@ module ActiveScaffold
         column.options[:options]
       end
 
-      def active_scaffold_input_enum(column, html_options)
+      def active_scaffold_input_enum(column, html_options, options = {})
         record = html_options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in html_options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
-        options = {:selected => record.send(column.name), :object => record}
+        options[:selected] = record.send(column.name)
+        options[:object] = record
         options_for_select = active_scaffold_enum_options(column, record).collect do |text, value|
           active_scaffold_translated_option(column, text, value)
         end
         html_options.merge!(column.options[:html_options] || {})
         options.merge!(column.options)
-        html_options[:name] = "#{html_options[:name]}[]" if html_options[:multiple] == true && !html_options[:name].to_s.ends_with?('[]')
+        active_scaffold_select_name_with_multiple html_options
         active_scaffold_translate_select_options(options)
         select(:record, column.name, options_for_select, options, html_options)
       end
 
       def active_scaffold_input_select(column, html_options)
-        if column.singular_association?
+        if column.association.try :singular?
           active_scaffold_input_singular_association(column, html_options)
-        elsif column.plural_association?
+        elsif column.association.try :collection?
           active_scaffold_input_plural_association(column, html_options)
         else
           active_scaffold_input_enum(column, html_options)
         end
       end
 
+      def active_scaffold_radio_option(option, selected, column, radio_options)
+        if column.association
+          label_method = column.options[:label_method] || :to_label
+          text, value = [option.send(label_method), option.id]
+          checked = {:checked => selected == value}
+        else
+          text, value = active_scaffold_translated_option(column, *option)
+        end
+
+        id_key = radio_options[:"data-id"] ? :"data-id" : :id
+        radio_options = radio_options.merge(id_key => radio_options[id_key] + '-' + value.to_s.parameterize)
+        radio_options.merge!(checked) if checked
+        content_tag(:label, radio_button(:record, column.name, value, radio_options) + text)
+      end
+
       def active_scaffold_input_radio(column, html_options)
         record = html_options[:object]
         html_options.merge!(column.options[:html_options] || {})
@@ -373,21 +448,12 @@ module ActiveScaffold
           else
             active_scaffold_enum_options(column, record)
           end
-        id_key = html_options[:"data-id"] ? :"data-id" : :id
-        label_method = column.options[:label_method] || :to_label if column.association
 
-        options.each_with_object('') do |(text, value), html|
-          if column.association
-            text, value = [text.send(label_method), text.id]
-            checked = {:checked => html_options[:object].send(column.association.name).try(:id) == value}
-          else
-            text, value = active_scaffold_translated_option(column, text, value)
-          end
-
-          radio_options = html_options.merge(id_key => html_options[id_key] + '-' + value.to_s.parameterize)
-          radio_options.merge!(checked) if checked
-          html << content_tag(:label, radio_button(:record, column.name, value, radio_options) + text)
-        end.html_safe
+        selected = record.send(column.association.name).try(:id) if column.association
+        radios = options.map do |option|
+          active_scaffold_radio_option(option, selected, column, html_options)
+        end
+        safe_join radios
       end
 
       def active_scaffold_input_checkbox(column, options)
@@ -395,8 +461,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_password(column, options)
-        options = active_scaffold_input_text_options(options)
-        password_field :record, column.name, options.merge(column.options)
+        active_scaffold_text_input :password_field, column, options
       end
 
       def active_scaffold_input_textarea(column, options)
@@ -404,8 +469,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_virtual(column, options)
-        options = active_scaffold_input_text_options(options)
-        text_field :record, column.name, options.merge(column.options)
+        active_scaffold_text_input :text_field, column, options
       end
 
       # Some fields from HTML5 (primarily for using in-browser validation)
@@ -413,34 +477,54 @@ module ActiveScaffold
 
       # 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)
+        active_scaffold_text_input :email_field, 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)
+        active_scaffold_text_input :url_field, 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)
+        active_scaffold_text_input :telephone_field, column, options, :format
       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)
+        active_scaffold_number_input :number_field, column, options, :format
       end
 
       # A slider control for number values (in-browser validation)
       def active_scaffold_input_range(column, options)
+        active_scaffold_number_input :range_field, column, options, :format
+      end
+
+      # A slider control for number values (in-browser validation)
+      def active_scaffold_number_input(method, column, options, remove_options = nil)
         options = numerical_constraints_for_column(column, options)
+        active_scaffold_text_input method, column, options, remove_options
+      end
+
+      def active_scaffold_text_input(method, column, options, remove_options = nil)
         options = active_scaffold_input_text_options(options)
-        range_field :record, column.name, options.merge(column.options)
+        options = options.merge(column.options)
+        options = options.except(*remove_options) if remove_options.present?
+        send method, :record, column.name, options
+      end
+
+      # A color picker
+      def active_scaffold_input_color(column, options)
+        options = active_scaffold_input_text_options(options)
+        if column.column.try(:null)
+          no_color = options[:object].send(column.name).nil?
+          method = no_color ? :hidden_field : :color_field
+          html = content_tag(:label, check_box_tag('disable', '1', no_color, id: nil, name: nil, class: 'no-color') << " #{as_ column.options[:no_color] || :no_color}")
+        else
+          method = :color_field
+          html = ''.html_safe
+        end
+        html << send(method, :record, column.name, options.merge(column.options).except(:format, :no_color))
       end
 
       #
@@ -449,8 +533,6 @@ module ActiveScaffold
 
       def active_scaffold_input_boolean(column, options)
         record = options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         select_options = []
         select_options << [as_(:_select_), nil] if !column.virtual? && column.column.null
         select_options << [as_(:true), true]
@@ -459,51 +541,65 @@ module ActiveScaffold
         select_tag(options[:name], options_for_select(select_options, record.send(column.name)), options)
       end
 
-      def onsubmit
+      def active_scaffold_input_date(column, options)
+        active_scaffold_text_input :date_field, column, options
+      end
+
+      def active_scaffold_input_time(column, options)
+        active_scaffold_text_input :time_field, column, options
+      end
+
+      def active_scaffold_input_datetime(column, options)
+        active_scaffold_text_input :datetime_local_field, column, options
+      end
+
+      def active_scaffold_input_month(column, options)
+        active_scaffold_text_input :month_field, column, options
+      end
+
+      def active_scaffold_input_week(column, options)
+        active_scaffold_text_input :week_field, column, options
       end
 
       ##
       ## Form column override signatures
       ##
 
-      # add functionality for overriding subform partials from association class path
-      def override_subform_partial?(column, subform_partial)
-        template_exists?(override_subform_partial(column, subform_partial), true)
+      def partial_for_model(model, partial)
+        controller = active_scaffold_controller_for(model)
+        while controller.uses_active_scaffold?
+          path = File.join(controller.controller_path, partial)
+          return path if template_exists?(path, true)
+          controller = controller.superclass
+        end
+        nil
       end
 
+      # add functionality for overriding subform partials from association class path
       def override_subform_partial(column, subform_partial)
-        File.join(active_scaffold_controller_for(column.association.klass).controller_path, subform_partial) if column_renders_as(column) == :subform
-      end
-
-      def override_form_field_partial?(column)
-        template_exists?(override_form_field_partial(column), true)
+        partial_for_model(column.association.klass, subform_partial) if column_renders_as(column) == :subform
       end
 
       # the naming convention for overriding form fields with helpers
       def override_form_field_partial(column)
-        path = active_scaffold_controller_for(column.active_record_class).controller_path
-        File.join(path, "#{clean_column_name(column.name)}_form_column")
+        partial_for_model(column.active_record_class, "#{clean_column_name(column.name)}_form_column")
       end
 
       def override_form_field(column)
         override_helper column, 'form_column'
       end
-      alias_method :override_form_field?, :override_form_field
+      alias override_form_field? override_form_field
 
       # the naming convention for overriding form input types with helpers
       def override_input(form_ui)
         method = "active_scaffold_input_#{form_ui}"
         method if respond_to? method
       end
-      alias_method :override_input?, :override_input
+      alias override_input? override_input
 
       def subform_partial_for_column(column)
         subform_partial = "#{active_scaffold_config_for(column.association.klass).subform.layout}_subform"
-        if override_subform_partial?(column, subform_partial)
-          override_subform_partial(column, subform_partial)
-        else
-          subform_partial
-        end
+        override_subform_partial(column, subform_partial) || subform_partial
       end
 
       ##
@@ -512,19 +608,18 @@ module ActiveScaffold
 
       def column_renders_as(column)
         if column.respond_to? :each
-          return :subsection
+          :subsection
         elsif column.active_record_class.locking_column.to_s == column.name.to_s || column.form_ui == :hidden
-          return :hidden
+          :hidden
         elsif column.association.nil? || column.form_ui || !active_scaffold_config_for(column.association.klass).actions.include?(:subform) || override_form_field?(column)
-          return :field
+          :field
         else
-          return :subform
+          :subform
         end
       end
 
       def column_scope(column, scope = nil, record = nil)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, call with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        if column.plural_association?
+        if column.association.try(:collection?)
           "#{scope}[#{column.name}][#{record.id || generate_temporary_id(record)}]"
         else
           "#{scope}[#{column.name}]"
@@ -533,11 +628,9 @@ module ActiveScaffold
 
       def active_scaffold_add_existing_input(options)
         record = options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         if !ActiveScaffold.js_framework.nil? && controller.respond_to?(:record_select_config, true)
           remote_controller = active_scaffold_controller_for(record_select_config.model).controller_path
-          options.merge!(:controller => remote_controller)
+          options[:controller] = remote_controller
           options.merge!(active_scaffold_input_text_options)
           record_select_field(options[:name], record, options)
         else
@@ -596,8 +689,8 @@ module ActiveScaffold
                 numerical_constraints[:step] ||= "0.#{'0' * (column.column.scale - 1)}1" if column.column && column.column.scale.to_i > 0
               elsif options[:min] && options[:min].respond_to?(:even?) && (only_odd_valid || only_even_valid)
                 numerical_constraints[:step] = 2
-                numerical_constraints[:min] += 1 if only_odd_valid  && !options[:min].odd?
-                numerical_constraints[:min] += 1 if only_even_valid && !options[:min].even?
+                numerical_constraints[:min] += 1 if only_odd_valid  && options[:min].even?
+                numerical_constraints[:min] += 1 if only_even_valid && options[:min].odd?
               end
               numerical_constraints[:step] ||= 'any' unless only_integer
             end