active_scaffold 3.5.3 → 3.6.0.rc2

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -24,9 +24,9 @@ module ActiveScaffold
         ul_options = record_or_ul_options if ul_options.nil? && record_or_ul_options.is_a?(Hash)
         record = record_or_ul_options unless record_or_ul_options.is_a?(Hash)
         html = content_tag :ul, ul_options do
-          safe_join links.map { |link| content_tag :li, link }
+          safe_join(links.map { |link| content_tag :li, link })
         end
-        raw "ActiveScaffold.display_dynamic_action_group('#{get_action_link_id action_link, record}', '#{escape_javascript html}');"
+        raw "ActiveScaffold.display_dynamic_action_group('#{get_action_link_id action_link, record}', '#{escape_javascript html}');" # rubocop:disable Rails/OutputSafety
       end
 
       def display_action_links(action_links, record, options, &block)
@@ -67,7 +67,7 @@ module ActiveScaffold
             html_classes << 'top' if options[:first_action]
             group_tag = :li
           end
-          content = content_tag(group_tag, :class => (html_classes if html_classes.present?), :onclick => ('' if hover_via_click?)) do
+          content = content_tag(group_tag, :class => html_classes.presence, :onclick => ('' if hover_via_click?)) do
             content_tag(:div, as_(link.label), :class => link.name.to_s.downcase) << content_tag(:ul, content)
           end
         else
@@ -79,13 +79,15 @@ module ActiveScaffold
       end
 
       def render_action_link(link, record = nil, options = {})
-        if link.action.nil? || link.column.try(:association).try(:polymorphic?)
-          link = action_link_to_inline_form(link, record) if link.column.try(:association)
+        if link.action.nil? || link.column&.association&.polymorphic?
+          link = action_link_to_inline_form(link, record) if link.column&.association
           options[:authorized] = false if link.action.nil? || link.controller.nil?
           options.delete :link if link.crud_type == :create
         end
         if link.action.nil? || (link.type == :member && options.key?(:authorized) && !options[:authorized])
-          action_link_html(link, nil, {:link => action_link_text(link, options), :class => "disabled #{link.action}#{" #{link.html_options[:class]}" if link.html_options[:class].present?}", :title => options[:not_authorized_reason]}, record)
+          html_class = "disabled #{link.action}#{" #{link.html_options[:class]}" if link.html_options[:class].present?}"
+          html_options = {:link => action_link_text(link, options), :class => html_class, :title => options[:not_authorized_reason]}
+          action_link_html(link, nil, html_options, record)
         else
           url = action_link_url(link, record)
           html_options = action_link_html_options(link, record, options)
@@ -95,9 +97,9 @@ module ActiveScaffold
 
       # setup the action link to inline form
       def action_link_to_inline_form(link, record)
-        link = link.clone
+        link = link.dup
         associated = record.send(link.column.association.name)
-        if link.column.association.try(:polymorphic?)
+        if link.column.association&.polymorphic?
           link.controller = controller_path_for_activerecord(associated.class)
           return link if link.controller.nil?
         end
@@ -106,12 +108,12 @@ module ActiveScaffold
       end
 
       def configure_column_link(link, record, associated, actions = nil)
-        actions ||= link.column.actions_for_association_links
+        actions ||= link.controller_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)
+            link.label ||= :create_new
           end
         elsif actions.include?(:edit)
           link.action = 'edit'
@@ -137,7 +139,7 @@ module ActiveScaffold
       def column_link_authorized?(link, column, record, associated)
         if column.association
           associated_for_authorized =
-            if column.association.collection? || (associated.respond_to?(:blank?) && associated.blank?)
+            if column.association.collection? || associated.nil?
               column.association.klass
             else
               associated
@@ -160,7 +162,7 @@ module ActiveScaffold
       end
 
       def cache_action_link_url?(link, record)
-        active_scaffold_config.cache_action_link_urls && link.type == :member && !link.dynamic_parameters.is_a?(Proc) && !sti_record?(record)
+        active_scaffold_config.user.cache_action_link_urls && link.type == :member && !link.dynamic_parameters.is_a?(Proc) && !sti_record?(record)
       end
 
       def cached_action_link_url(link, record)
@@ -178,8 +180,8 @@ module ActiveScaffold
 
       def replace_id_params_in_action_link_url(link, record, url)
         url = record ? url.sub('--ID--', record.to_param.to_s) : url.clone
-        if link.column.try(:association).try(:singular?)
-          child_id = record.send(link.column.association.name).try(:to_param)
+        if link.column&.association&.singular?
+          child_id = record.send(link.column.association.name)&.to_param
           if child_id.present?
             url.sub!('--CHILD_ID--', child_id)
           else
@@ -209,6 +211,18 @@ module ActiveScaffold
         url
       end
 
+      def column_in_params_conditions?(key)
+        if key =~ /!$/
+          conditions_from_params[1..-1].any? { |node| node.left.name.to_s == key[0..-2] }
+        else
+          conditions_from_params[0].include?(key)
+        end
+      end
+
+      def ignore_param_for_nested?(key)
+        NESTED_PARAMS.include?(key) || column_in_params_conditions?(key) || (nested? && nested.param_name == key)
+      end
+
       def query_string_for_action_links(link)
         if defined?(@query_string) && link.parameters.none? { |k, _| @query_string_params.include? k }
           return [@query_string, @non_nested_query_string]
@@ -224,12 +238,17 @@ module ActiveScaffold
             keep = false
             next
           end
-          if NESTED_PARAMS.include?(key) || conditions_from_params.include?(key) || (nested? && nested.param_name == key)
+          if ignore_param_for_nested?(key)
             non_nested_query_string_options[key] = value
           else
             query_string_options[key] = value
           end
         end
+        if nested_singular_association? && action_name == 'index'
+          # pass current path as return_to, for nested listing on singular association, so forms doesn't return to parent listing
+          @query_string_params << :return_to
+          non_nested_query_string_options[:return_to] = request.fullpath
+        end
 
         query_string = query_string_options.to_query if query_string_options.present?
         if non_nested_query_string_options.present?
@@ -243,7 +262,7 @@ module ActiveScaffold
       end
 
       def cache_action_link_url_options?(link, record)
-        active_scaffold_config.cache_action_link_urls && (link.type == :collection || !link.dynamic_parameters.is_a?(Proc)) && !sti_record?(record)
+        active_scaffold_config.user.cache_action_link_urls && (link.type == :collection || !link.dynamic_parameters.is_a?(Proc)) && !sti_record?(record)
       end
 
       def cached_action_link_url_options(link, record)
@@ -290,8 +309,8 @@ module ActiveScaffold
         missing_options, url_options = url.partition { |_, v| v.nil? }
         replacements = {}
         replacements['--ID--'] = record.id.to_s if record
-        if link.column.try(:association).try(:singular?)
-          replacements['--CHILD_ID--'] = record.send(link.column.association.name).try(:id).to_s
+        if link.column&.association&.singular?
+          replacements['--CHILD_ID--'] = record.send(link.column.association.name)&.id.to_s
         elsif nested?
           replacements['--CHILD_ID--'] = params[nested.param_name].to_s
         end
@@ -303,7 +322,7 @@ module ActiveScaffold
 
       def action_link_selected?(link, record)
         missing_options, url_options = replaced_action_link_url_options(link, record)
-        safe_params = (Rails.version < '4.2' ? params.to_h : params.to_unsafe_h)
+        safe_params = params.to_unsafe_h
         (url_options - safe_params.to_a).blank? && missing_options.all? { |k, _| params[k].nil? }
       end
 
@@ -316,7 +335,7 @@ module ActiveScaffold
         html_options[:method] = link.method if link.method != :get
 
         html_options[:data] ||= {}
-        html_options[:data][:confirm] = link.confirm(h(record.try(:to_label))) if link.confirm?
+        html_options[:data][:confirm] = link.confirm(h(record&.to_label)) if link.confirm?
         if !options[:page] && !options[:popup] && (options[:inline] || link.inline?)
           html_options[:class] << ' as_action'
           html_options[:data][:position] = link.position if link.position
@@ -331,7 +350,10 @@ module ActiveScaffold
           html_options[:class] << ' active' if action_link_selected?(link, record)
         end
 
-        html_options[:target] = '_blank' if !options[:page] && !options[:inline] && (options[:popup] || link.popup?)
+        if !options[:page] && !options[:inline] && (options[:popup] || link.popup?)
+          html_options[:target] = '_blank'
+          html_options[:rel] = [html_options[:rel], 'noopener noreferrer'].compact.join(' ')
+        end
         html_options[:id] = link_id
         if link.dhtml_confirm?
           unless link.inline?
@@ -344,20 +366,23 @@ module ActiveScaffold
         html_options
       end
 
-      def get_action_link_id(link, record = nil, column = nil)
-        column ||= link.column
-        if column.try(:association) && record
-          id = if column.association.collection?
-                 "#{column.association.name}-#{record.id}"
-               elsif record.send(column.association.name).present?
-                 "#{column.association.name}-#{record.send(column.association.name).id}-#{record.id}"
-               else
-                 "#{column.association.name}-#{record.id}"
-               end
+      def get_action_link_id(link, record = nil)
+        column = link.column
+        if column&.association && record
+          associated = record.send(column.association.name) unless column.association.collection?
+          id =
+            if associated
+              "#{column.association.name}-#{associated.id}-#{record.id}"
+            else
+              "#{column.association.name}-#{record.id}"
+            end
+        end
+        id ||= record&.id&.to_s || (nested? ? nested_parent_id.to_s : '')
+        action_link_id = ActiveScaffold::Registry.cache :action_link_id, link.name_to_cache do
+          action_id = "#{id_from_controller("#{link.controller}-") if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)}#{link.action}"
+          action_link_id(action_id, '--ID--')
         end
-        id ||= record.try(:id) || (nested? ? nested_parent_id : '')
-        action_id = "#{id_from_controller("#{link.controller}-") if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)}#{link.action}"
-        action_link_id(action_id, id)
+        action_link_id.sub('--ID--', id)
       end
 
       def action_link_html(link, url, html_options, record)
@@ -371,15 +396,16 @@ module ActiveScaffold
       end
 
       def url_options_for_nested_link(column, record, link, url_options)
-        if column.try(:association)
+        if column&.association
           url_options[:parent_scaffold] = controller_path
           url_options[column.model.name.foreign_key.to_sym] = url_options.delete(:id)
           url_options[:id] = if column.association.singular? && url_options[:action].to_sym != :index
                                '--CHILD_ID--'
                              end
-        elsif link.parameters && link.parameters[:named_scope]
+        elsif link.parameters&.dig(:named_scope)
           url_options[:parent_scaffold] = controller_path
           url_options[active_scaffold_config.model.name.foreign_key.to_sym] = url_options.delete(:id)
+          url_options[:id] = nil
         end
       end
 

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -16,11 +16,8 @@ module ActiveScaffold
       def association_options_find(association, conditions = nil, klass = nil, record = nil)
         if klass.nil? && association.polymorphic?
           class_name = record.send(association.foreign_type) if association.belongs_to?
-          if class_name.present?
-            klass = class_name.constantize
-          else
-            return []
-          end
+          return [] if class_name.blank?
+          klass = class_name.constantize
           cache = !block_given?
         else
           cache = !block_given? && klass.nil?
@@ -32,12 +29,14 @@ module ActiveScaffold
           klass = association_klass_scoped(association, klass, record)
           relation = klass.where(conditions)
           column = column_for_association(association, record)
-          if column && column.try(:sort) && column.sort[:sql]
-            if column.includes
-              include_assoc = column.includes.find { |assoc| assoc.is_a?(Hash) && assoc.include?(association.name) }
-              relation = relation.includes(include_assoc[association.name]) if include_assoc
-            end
-            relation = relation.order(column.sort[:sql])
+          if column&.includes
+            include_assoc = column.includes.find { |assoc| assoc.is_a?(Hash) && assoc.include?(association.name) }
+            relation = relation.includes(include_assoc[association.name]) if include_assoc
+          end
+          if column&.sort && column.sort&.dig(:sql)
+            # with threasafe enabled, column.sort[:sql] returns proxied strings and
+            # regexp capture won't work, which rails uses internally, so to_s is needed
+            relation = relation.order(Array(column.sort[:sql]).map(&:to_s))
           end
           relation = yield(relation) if block_given?
           relation.to_a
@@ -45,16 +44,20 @@ module ActiveScaffold
       end
 
       def column_for_association(association, record)
-        active_scaffold_config_for(record.class).columns[association.name] rescue nil
+        active_scaffold_config_for(record.class).columns[association.name]
+      rescue StandardError => e
+        message = "Error on config for #{record.class.name}:"
+        Rails.logger.warn "#{message}\n#{e.message}\n#{e.backtrace.join("\n")}"
+        nil
       end
 
       def association_klass_scoped(association, klass, record)
-        if nested? && nested.through_association? && nested.child_association.try(:through_reflection) == association
+        if nested? && nested.through_association? && nested.child_association&.through_reflection == association
           # only ActiveRecord associations
           if nested.association.through_reflection.collection?
             nested_parent_record.send(nested.association.through_reflection.name)
           else
-            klass.where(association.association_primary_key => nested_parent_record.send(nested.association.through_reflection.name).try(:id))
+            klass.where(association.association_primary_key => nested_parent_record.send(nested.association.through_reflection.name)&.id)
           end
         else
           klass
@@ -65,7 +68,7 @@ module ActiveScaffold
       def sorted_association_options_find(association, conditions = nil, record = nil)
         options = association_options_find(association, conditions, nil, record)
         column = column_for_association(association, record)
-        unless column && column.try(:sort) && column.sort[:sql]
+        unless column&.sort && column.sort&.dig(:sql)
           method = column.options[:label_method] if column
           options = options.sort_by(&(method || :to_label).to_sym)
         end
@@ -86,10 +89,9 @@ module ActiveScaffold
       # Check association.name to specialize the conditions per-column.
       def options_for_association_conditions(association, record = nil)
         return nil if association.through?
-        if association.has_one? || association.has_many?
-          # Find only orphaned objects
-          {association.foreign_key => nil}
-        end
+        return nil unless association.has_one? || association.has_many?
+        # Find only orphaned objects
+        {association.foreign_key => nil}
       end
 
       def record_select_params_for_add_existing(association, edit_associated_url_options, record)

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -2,25 +2,38 @@ module ActiveScaffold
   module Helpers
     module ControllerHelpers
       def self.included(controller)
-        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
+        return unless 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,
+                        :active_scaffold_config_for
         end
       end
 
       include ActiveScaffold::Helpers::IdHelpers
 
+      def active_scaffold_config_for(klass)
+        config = self.class.active_scaffold_config_for(klass)
+        if ActiveScaffold.threadsafe
+          config.user || config.new_user_settings({}, {})
+        else
+          config
+        end
+      end
+
       def generate_temporary_id(record = nil, generated_id = nil)
         (generated_id || (Time.now.to_f * 1000).to_i.to_s).tap do |id|
-          (@temporary_ids ||= {})[record.class.name] = id if record
+          cache_generated_id record, id
         end
       end
 
+      def cache_generated_id(record, generated_id)
+        (@temporary_ids ||= {})[record.class.name] = generated_id if record && generated_id
+      end
+
       def generated_id(record)
         @temporary_ids[record.class.name] if record && @temporary_ids
       end
@@ -91,7 +104,7 @@ module ActiveScaffold
         else
           exclude_parameters = %i[utf8 associated_id]
           parameters = {}
-          if params[:parent_scaffold] && nested? && nested.singular_association?
+          if params[:parent_scaffold] && 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?
@@ -167,6 +180,17 @@ module ActiveScaffold
           end
         end
       end
+
+      def save_record_to_association(record, association, value, reverse = nil)
+        return unless association
+        if association.collection?
+          record.association(association.name).target << value
+        elsif reverse&.belongs_to?
+          value.send("#{reverse.name}=", record)
+        else
+          record.send("#{association.name}=", value)
+        end
+      end
     end
   end
 end

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -16,47 +16,43 @@ module ActiveScaffold
         # first, check if the dev has created an override for this specific field
         if (method = override_form_field(column))
           send(method, record, options)
+
         # second, check if the dev has specified a valid form_ui for this column
         elsif column.form_ui && (method = override_input(column.form_ui))
           send(method, column, options)
-        # fallback: we get to make the decision
-        else
-          if column.association
-            if column.form_ui.nil?
-              # its an association and nothing is specified, we will assume form_ui :select
-              active_scaffold_input_select(column, options)
-            else
-              # if we get here, it's because the column has a form_ui but not one ActiveScaffold knows about.
-              raise "Unknown form_ui `#{column.form_ui}' for column `#{column.name}'"
-            end
-          elsif column.virtual?
-            options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
-            active_scaffold_input_virtual(column, options)
-
-          else # regular model attribute column
-            # if we (or someone else) have created a custom render option for the column type, use that
-            if (method = override_input(column.column.type))
-              send(method, column, options)
-            # final ultimate fallback: use rails' generic input method
-            else
-              # for textual fields we pass different options
-              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[:value] = format_number_value(record.send(column.name), column.options) if column.number?
-              text_field(:record, column.name, options.merge(column.options).except(:format))
-            end
+
+        elsif column.association
+          # if we get here, it's because the column has a form_ui but not one ActiveScaffold knows about.
+          raise "Unknown form_ui `#{column.form_ui}' for column `#{column.name}'" if column.form_ui
+
+          # its an association and nothing is specified, we will assume form_ui :select
+          active_scaffold_input_select(column, options)
+
+        elsif column.virtual?
+          options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
+          active_scaffold_input_virtual(column, options)
+
+        elsif (method = override_input(column.column.type)) # regular model attribute column
+          # if we (or someone else) have created a custom render option for the column type, use that
+          send(method, column, options)
+
+        else # final ultimate fallback: use rails' generic input method
+          # for textual fields we pass different options
+          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[:value] = format_number_value(record.send(column.name), column.options) if column.number?
+          text_field(:record, column.name, options.merge(column.options).except(:format))
         end
       rescue StandardError => e
         logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
         raise e
       end
 
-      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil)
+      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil) # rubocop:disable Metrics/ParameterLists
         if add_class
           col_class = []
           col_class << 'required' if column.required?
@@ -66,9 +62,7 @@ module ActiveScaffold
           col_class = col_class.join(' ')
         end
         if readonly && !record.new_record? || !record.authorized_for?(:crud_type => crud_type, :column => column.name)
-          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
+          form_attribute(column, record, scope, true, col_class)
         else
           renders_as = column_renders_as(column)
           html = render_column(column, record, renders_as, scope, false, col_class)
@@ -77,16 +71,16 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_subform_attributes(column, column_css_class = nil)
+      def active_scaffold_subform_attributes(column, column_css_class = nil, klass = nil)
         {
-          :class => "sub-form #{active_scaffold_config_for(column.association.klass).subform.layout}-sub-form #{column_css_class} #{column.name}-sub-form",
+          :class => "sub-form #{active_scaffold_config_for(klass || column.association.klass).subform.layout}-sub-form #{column_css_class} #{column.name}-sub-form",
           :id => sub_form_id(:association => column.name)
         }
       end
 
       # the standard active scaffold options used for textual inputs
       def active_scaffold_input_text_options(options = {})
-        options[:autocomplete] = 'off'
+        options[:autocomplete] ||= 'off'
         options[:class] = "#{options[:class]} text-input".strip
         options
       end
@@ -97,7 +91,7 @@ module ActiveScaffold
         record = options[:object]
 
         # Add some HTML5 attributes for in-browser validation and better user experience
-        if column.required? && (!@disable_required_for_new || scope.nil? || record.try(:persisted?))
+        if column.required? && (!@disable_required_for_new || scope.nil? || record&.persisted?)
           options[:required] = true
         end
         options[:placeholder] = column.placeholder if column.placeholder.present?
@@ -114,18 +108,20 @@ module ActiveScaffold
 
       def current_form_columns(record, scope, subform_controller = nil)
         if scope
-          subform_controller.active_scaffold_config.subform.columns.names
+          subform_controller.active_scaffold_config.subform.columns.visible_columns_names
         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
+          active_scaffold_config.send(record.new_record? ? :create : :update).columns.visible_columns_names
         end
       end
 
       def update_columns_options(column, scope, options, force = false)
         record = options[:object]
         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
+        if @main_columns && (scope.nil? || subform_controller == controller.class)
+          form_columns = @main_columns.visible_columns_names
+        end
         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)
@@ -134,7 +130,7 @@ module ActiveScaffold
             url_params = url_params.except(:parent_scaffold, :association, nested.param_name)
           end
           if scope
-            url_params[:parent_controller] ||= url_params[:controller].gsub(/^\//, '')
+            url_params[:parent_controller] ||= url_params[:controller].gsub(%r{^/}, '')
             url_params[:controller] = subform_controller.controller_path
             url_params[:scope] = scope
             url_params[:parent_id] = params[:parent_id] || params[:id]
@@ -152,8 +148,8 @@ module ActiveScaffold
         {}
       end
 
-      def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil)
-        if partial = override_form_field_partial(column)
+      def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil) # rubocop:disable Metrics/ParameterLists
+        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)
@@ -179,17 +175,23 @@ module ActiveScaffold
         else
           field = active_scaffold_input_for column, scope, column_options
         end
+        if field
+          field << loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns
+          field << content_tag(:span, column.description, :class => 'description') if column.description.present?
+        end
 
         content_tag :dl, attributes do
-          %(<dt>#{label_tag label_for(column, column_options), column.label}</dt><dd>#{field}
-#{loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns}
-#{content_tag :span, column.description, :class => 'description' if column.description.present?}
-</dd>).html_safe
+          content_tag(:dt, label_tag(label_for(column, column_options), form_column_label(column))) <<
+            content_tag(:dd, field)
         end
       end
 
       def label_for(column, options)
-        options[:id] unless column.form_ui == :select && column.association.try(:collection?)
+        options[:id] unless column.form_ui == :select && column.association&.collection?
+      end
+
+      def form_column_label(column)
+        column.label
       end
 
       def subform_label(column, hidden)
@@ -205,7 +207,7 @@ module ActiveScaffold
 
       def form_hidden_field(column, record, scope)
         options = active_scaffold_input_options(column, scope)
-        if column.association.try(:collection?)
+        if column.association&.collection?
           associated = record.send(column.name)
           if associated.blank?
             hidden_field_tag options[:name], '', options
@@ -217,7 +219,7 @@ module ActiveScaffold
             safe_join fields, ''
           end
         elsif column.association
-          hidden_field_tag options[:name], record.send(column.name).try(:id), options
+          hidden_field_tag options[:name], record.send(column.name)&.id, options
         else
           hidden_field :record, column.name, options.merge(object: record)
         end
@@ -245,7 +247,7 @@ module ActiveScaffold
       end
 
       def column_show_add_existing(column, record = nil)
-        column.allow_add_existing && options_for_association_count(column.association, record) > 0
+        column.allow_add_existing && options_for_association_count(column.association, record).positive?
       end
 
       def column_show_add_new(column, associated, record)
@@ -263,7 +265,7 @@ module ActiveScaffold
       def active_scaffold_grouped_options(column, select_options, optgroup)
         group_column = active_scaffold_config_for(column.association.klass).columns[optgroup]
         group_label = group_column.options[:label_method] if group_column
-        group_label ||= group_column.try(:association) ? :to_label : :to_s
+        group_label ||= group_column&.association ? :to_label : :to_s
         select_options.group_by(&optgroup.to_sym).collect do |group, options|
           [group.send(group_label), options.collect { |r| [r.send(column.options[:label_method] || :to_label), r.id] }]
         end
@@ -276,9 +278,8 @@ module ActiveScaffold
       end
 
       def active_scaffold_select_name_with_multiple(options)
-        if options[:multiple] && !options[:name].to_s.ends_with?('[]')
-          options[:name] = "#{options[:name]}[]"
-        end
+        return if !options[:multiple] || options[:name].to_s.ends_with?('[]')
+        options[:name] = "#{options[:name]}[]"
       end
 
       def active_scaffold_input_singular_association(column, html_options, options = {})
@@ -289,7 +290,7 @@ module ActiveScaffold
         select_options.unshift(associated) unless associated.nil? || select_options.include?(associated)
 
         method = column.name
-        options.merge! :selected => associated.try(:id), :include_blank => as_(:_select_), :object => record
+        options.merge! :selected => associated&.id, :include_blank => as_(:_select_), :object => record
 
         html_options.merge!(column.options[:html_options] || {})
         options.merge!(column.options)
@@ -303,10 +304,46 @@ module ActiveScaffold
             collection_select(:record, method, select_options, :id, column.options[:label_method] || :to_label, options, html_options)
           end
         html << active_scaffold_refresh_link(column, html_options, record) if column.options[:refresh_link]
+        html << active_scaffold_new_record_subform(column, record, html_options) if column.options[:add_new]
         html
       end
 
-      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, &block)
+      def active_scaffold_new_record_subform(column, record, html_options, new_record_attributes: nil, locals: {}, skip_link: false) # rubocop:disable Metrics/ParameterLists
+        klass =
+          if column.association.polymorphic? && column.association.belongs_to?
+            type = record.send(column.association.foreign_type)
+            column.association.klass(record) if type.present? && (column.options[:add_new] == true || type.in?(column.options[:add_new]))
+          else
+            column.association.klass
+          end
+        return content_tag(:div, '') unless klass
+        subform_attrs = active_scaffold_subform_attributes(column, nil, klass)
+        if record.send(column.name)&.new_record?
+          new_record = record.send(column.name)
+        else
+          subform_attrs[:style] = 'display: none'
+        end
+        subform_attrs[:class] << ' optional'
+        scope = html_options[:name].scan(/record(.*)\[#{column.name}\]/).dig(0, 0)
+        new_record ||= klass.new(new_record_attributes)
+        locals = locals.reverse_merge(column: column, parent_record: record, associated: [], show_blank_record: new_record, scope: scope)
+        subform = render(partial: subform_partial_for_column(column, klass), locals: locals)
+        if column.options[:hide_subgroups]
+          toggable_id = "#{sub_form_id(association: column.name, id: record.id || generated_id(record) || 99_999_999_999)}-div"
+          subform << link_to_visibility_toggle(toggable_id, default_visible: false)
+        end
+        html = content_tag(:div, subform, subform_attrs)
+        return html if skip_link
+        html << active_scaffold_show_new_subform_link(column, record, html_options[:id], subform_attrs[:id])
+      end
+
+      def active_scaffold_show_new_subform_link(column, record, select_id, subform_id)
+        data = {select_id: select_id, subform_id: subform_id, subform_text: as_(:add_existing), select_text: as_(:create_new)}
+        label = data[record.send(column.name)&.new_record? ? :subform_text : :select_text]
+        link_to(label, '#', data: data, class: 'show-new-subform')
+      end
+
+      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, &block) # rubocop:disable Metrics/ParameterLists
         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)
@@ -329,12 +366,13 @@ module ActiveScaffold
         object_name, method = options[:name].split(/\[(#{column.name})\]/)
         method.sub!(/#{column.name}/, "#{remove_file_prefix}\\0")
         fields = block_given? ? yield : ''
+        link_key = options[:multiple] ? :remove_files : :remove_file
         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)]
+                       content_tag(:a, as_(link_key), :href => '#', :onclick => js_remove_file_code)]
           end << content_tag(:div, input, :style => 'display: none')
         end
       end
@@ -345,7 +383,7 @@ module ActiveScaffold
           link_options['data-update_send_form'] = html_options['data-update_send_form']
           link_options['data-update_send_form_selector'] = html_options['data-update_send_form_selector']
         else
-          scope = html_options[:name].scan(/^record((\[[^\]]*\])*)\[#{column.name}\]/)[0].try(:first) if html_options[:name]
+          scope = html_options[:name].scan(/^record((\[[^\]]*\])*)\[#{column.name}\]/).dig(0, 0) if html_options[:name]
           link_options = update_columns_options(column, scope.presence, link_options, true)
         end
         link_options[:class] = 'refresh-link'
@@ -385,11 +423,11 @@ module ActiveScaffold
         label_method = column.options[:label_method] || :to_label
         html = hidden_field_tag("#{options[:name]}[]", '', :id => nil)
         html << content_tag(:ul, options.merge(:class => "#{options[:class]} checkbox-list#{' draggable-lists' if column.options[:draggable_lists]}")) do
-          content = ''.html_safe
+          content = []
           select_options.each_with_index do |option, i|
             content << active_scaffold_checkbox_option(option, label_method, associated_ids, :name => "#{options[:name]}[]", :id => "#{options[:id]}_#{i}_id")
           end
-          content
+          safe_join content
         end
         html
       end
@@ -418,9 +456,9 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_select(column, html_options)
-        if column.association.try :singular?
+        if column.association&.singular?
           active_scaffold_input_singular_association(column, html_options)
-        elsif column.association.try :collection?
+        elsif column.association&.collection?
           active_scaffold_input_plural_association(column, html_options)
         else
           active_scaffold_input_enum(column, html_options)
@@ -430,7 +468,8 @@ module ActiveScaffold
       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]
+          text = option.send(label_method)
+          value = option.id
           checked = {:checked => selected == value}
         else
           text, value = active_scaffold_translated_option(column, *option)
@@ -452,11 +491,36 @@ module ActiveScaffold
             active_scaffold_enum_options(column, record)
           end
 
-        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)
+        selected = record.send(column.association.name) if column.association
+        selected_id = selected&.id
+        if options.present?
+          if column.options[:add_new]
+            html_options[:data] ||= {}
+            html_options[:data][:subform_id] = active_scaffold_subform_attributes(column)[:id]
+            radio_html_options = html_options.merge(class: html_options[:class] + ' hide-new-subform')
+          else
+            radio_html_options = html_options
+          end
+          radios = options.map do |option|
+            active_scaffold_radio_option(option, selected_id, column, radio_html_options)
+          end
+          if column.options[:include_blank]
+            label = column.options[:include_blank]
+            label = as_(column.options[:include_blank]) if column.options[:include_blank].is_a?(Symbol)
+            radios.prepend content_tag(:label, radio_button(:record, column.name, '', html_options.merge(id: nil)) + label)
+          end
+          if column.options[:add_new]
+            create_new_button = radio_button_tag(html_options[:name], '', selected&.new_record?, html_options.merge(id: nil, class: html_options[:class] + ' show-new-subform'))
+            radios << content_tag(:label, create_new_button << as_(:create_new)) <<
+              active_scaffold_new_record_subform(column, record, html_options, skip_link: true)
+          end
+          safe_join radios
+        else
+          html = content_tag(:span, as_(:no_options), :class => "#{html_options[:class]} no-options", :id => html_options[:id])
+          html << hidden_field_tag(html_options[:name], '', :id => nil)
+          html << active_scaffold_new_record_subform(column, record, html_options) if column.options[:add_new]
+          html
         end
-        safe_join radios
       end
 
       def active_scaffold_input_checkbox(column, options)
@@ -464,7 +528,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_password(column, options)
-        active_scaffold_text_input :password_field, column, options
+        active_scaffold_text_input :password_field, column, options.reverse_merge(autocomplete: 'new-password')
       end
 
       def active_scaffold_input_textarea(column, options)
@@ -518,16 +582,17 @@ module ActiveScaffold
 
       # A color picker
       def active_scaffold_input_color(column, options)
+        html = []
         options = active_scaffold_input_text_options(options)
-        if column.column.try(:null)
+        if column.column&.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}")
+          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))
+        safe_join html
       end
 
       #
@@ -538,8 +603,8 @@ module ActiveScaffold
         record = options.delete(:object)
         select_options = []
         select_options << [as_(:_select_), nil] if !column.virtual? && column.column.null
-        select_options << [as_(:true), true]
-        select_options << [as_(:false), false]
+        select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
+        select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 
         select_tag(options[:name], options_for_select(select_options, record.send(column.name)), options)
       end
@@ -600,8 +665,8 @@ module ActiveScaffold
       end
       alias override_input? override_input
 
-      def subform_partial_for_column(column)
-        subform_partial = "#{active_scaffold_config_for(column.association.klass).subform.layout}_subform"
+      def subform_partial_for_column(column, klass = nil)
+        subform_partial = "#{column.options[:layout] || active_scaffold_config_for(klass || column.association.klass).subform.layout}_subform"
         override_subform_partial(column, subform_partial) || subform_partial
       end
 
@@ -622,7 +687,7 @@ module ActiveScaffold
       end
 
       def column_scope(column, scope = nil, record = nil)
-        if column.association.try(:collection?)
+        if column.association&.collection?
           "#{scope}[#{column.name}][#{record.id || generate_temporary_id(record)}]"
         else
           "#{scope}[#{column.name}]"
@@ -635,12 +700,12 @@ module ActiveScaffold
           remote_controller = active_scaffold_controller_for(record_select_config.model).controller_path
           options[:controller] = remote_controller
           options.merge!(active_scaffold_input_text_options)
-          record_select_field(options[:name], record, options)
+          record_select_field(options[:name], nil, options)
         else
           select_options = sorted_association_options_find(nested.association, nil, record)
           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?
+          select_tag 'associated_id', (content_tag(:option, as_(:_select_), value: '') + select_options) unless select_options.empty?
         end
       end
 
@@ -653,55 +718,62 @@ module ActiveScaffold
       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) && v.attributes.include?(column.name)
-          end
-          equal_to = (val = validators.find { |v| v.options[:equal_to] }) ? val.options[:equal_to] : nil
-
-          # If there is equal_to constraint - use it (unless otherwise specified by user)
-          if equal_to && !(options[:min] || 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] }.present?
-            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
+      def column_numerical_constraints(column, options)
+        validators = column.active_record_class.validators.select do |v|
+          v.is_a?(ActiveModel::Validations::NumericalityValidator) && v.attributes.include?(column.name)
+        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
+        equal_validator = validators.find { |v| v.options[:equal_to] }
+        # If there is equal_to constraint - use it (unless otherwise specified by user)
+        if equal_validator && !(options[:min] || options[:max])
+          equal_to = equal_validator.options[:equal_to]
+          return {min: equal_to, max: equal_to}
+        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] && 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].even?
-                numerical_constraints[:min] += 1 if only_even_valid && options[:min].odd?
-              end
-              numerical_constraints[:step] ||= 'any' unless only_integer
-            end
+        numerical_constraints = {}
+
+        # 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] }.present?
+        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&.scale.to_i.positive?
+          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].even?
+            numerical_constraints[:min] += 1 if only_even_valid && options[:min].odd?
           end
+          numerical_constraints[:step] ||= 'any' unless only_integer
+        end
 
-          column.numerical_constraints = numerical_constraints
+        numerical_constraints
+      end
+
+      def numerical_constraints_for_column(column, options)
+        constraints = Rails.cache.fetch("#{column.cache_key}#numerical_constarints") do
+          column_numerical_constraints(column, options)
         end
-        column.numerical_constraints.merge(options)
+        constraints.merge(options)
       end
     end
   end