active_scaffold 4.1.6 → 4.2.0

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveScaffold
   module Helpers
     # Helpers rendering action links
@@ -5,16 +7,16 @@ module ActiveScaffold
       # params which mustn't be copying to nested links
       NESTED_PARAMS = %i[eid embedded association parent_scaffold].freeze
 
-      def skip_action_link?(link, *args)
-        !link.ignore_method.nil? && controller.respond_to?(link.ignore_method, true) && controller.send(link.ignore_method, *args)
+      def skip_action_link?(link, *)
+        !link.ignore_method.nil? && controller.respond_to?(link.ignore_method, true) && controller.send(link.ignore_method, *)
       end
 
-      def action_link_authorized?(link, *args)
+      def action_link_authorized?(link, *args) # rubocop:disable Naming/PredicateMethod
         auth, reason =
           if link.security_method_set? || controller.respond_to?(link.security_method, true)
             controller.send(link.security_method, *args)
           else
-            args.empty? ? true : args.first.authorized_for?(crud_type: link.crud_type, action: link.action, reason: true)
+            args.empty? || args.first.authorized_for?(crud_type: link.crud_type, action: link.action, reason: true)
           end
         [auth, reason]
       end
@@ -22,6 +24,8 @@ module ActiveScaffold
       def display_dynamic_action_group(action_link, links, record_or_ul_options = nil, ul_options = nil)
         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)
+        ul_options ||= {}
+        ul_options[:class] = [ul_options[:class], 'dynamic-menu'].compact.join(' ')
         html = content_tag :ul, ul_options do
           safe_join(links.map { |link| content_tag :li, link })
         end
@@ -33,7 +37,7 @@ module ActiveScaffold
         options[:options_level_0_tag] ||= nil
         options[:level] ||= 0
         options[:first_action] = true
-        output = ActiveSupport::SafeBuffer.new
+        output = options.delete(:output) || ActiveSupport::SafeBuffer.new
         prev_link = separator = nil
 
         action_links.each(reverse: options.delete(:reverse), groups: true) do |link|
@@ -62,10 +66,14 @@ module ActiveScaffold
       end
 
       def display_action_link_group(link, record, options, &)
-        options[:level] += 1
-        content = display_action_links(link, record, options, &)
-        options[:level] -= 1
-        display_action_link(link, content, record, options).tap { options[:first_action] = false } if content.present?
+        if link.click_menu?
+          display_click_menu_link(link, record, options)
+        else
+          options[:level] += 1
+          content = display_action_links(link, record, options, &)
+          options[:level] -= 1
+          display_action_link(link, content, record, options).tap { options[:first_action] = false } if content.present?
+        end
       end
 
       def display_action_link_separator(options)
@@ -73,14 +81,30 @@ module ActiveScaffold
         content_tag(tag || :li, ' '.html_safe, class: 'separator')
       end
 
+      def display_click_menu_link(link, record, options)
+        action_link =
+          if link.path.start_with?('collection.')
+            ActiveScaffold::DataStructures::ActionLinks::COLLECTION_CLICK_MENU_LINK
+          else
+            ActiveScaffold::DataStructures::ActionLinks::MEMBER_CLICK_MENU_LINK
+          end
+        html = display_action_link(
+          action_link,
+          nil,
+          record,
+          options.merge(authorized: true, link: link.label(record), link_id: get_action_link_id(link, record))
+        )
+        html.gsub('--ACTION-LINKS--', ERB::Util.unwrapped_html_escape(link.path)).html_safe # rubocop:disable Rails/OutputSafety
+      end
+
       def display_action_link(link, content, record, options)
         if content
           html_classes = hover_via_click? ? 'hover_click ' : ''
           if options[:level].zero?
-            html_classes << 'action_group'
+            html_classes += 'action_group'
             group_tag = :div
           else
-            html_classes << 'top' if options[:first_action]
+            html_classes += 'top' if options[:first_action]
             group_tag = :li
           end
           content = content_tag(group_tag, class: html_classes.presence, onclick: ('' if hover_via_click?)) do
@@ -100,17 +124,61 @@ module ActiveScaffold
           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])
-          html_class = "disabled #{link.action}#{" #{link.html_options[:class]}" if link.html_options[:class].present?}"
-          html_options = {link: action_link_text(link, record, options), class: html_class, title: options[:not_authorized_reason]}
-          action_link_html(link, nil, html_options, record)
+        method =
+          if link.action.nil? || (link.type == :member && options.key?(:authorized) && !options[:authorized])
+            :render_unauthorized_action_link
+          else
+            :render_authorized_action_link
+          end
+
+        cache_link = cache_action_link?(link)
+        label = options[:link]
+        result = optional_cache_helper(method, link.name_to_cache.to_s, cache_link, link, record, options, cache: cache_link)
+        cache_link ? replace_tags_for_action_link(result, method, link, label, record, options) : result
+      end
+
+      def optional_cache_helper(method, key, cache, ...)
+        if cache
+          ActiveScaffold::Registry.cache(method, key) { send(method, ...) }
         else
-          url = action_link_url(link, record)
-          html_options = action_link_html_options(link, record, options)
-          action_link_html(link, url, html_options, record)
+          send(method, ...)
         end
       end
 
+      def replace_tags_for_action_link(html, method, link, label, record, options) # rubocop:disable Metrics/ParameterLists
+        case method
+        when :render_unauthorized_action_link
+          html = html.gsub('--REASON--', ERB::Util.unwrapped_html_escape(options[:not_authorized_reason]))
+        when :render_authorized_action_link
+          html = html.gsub('--URL--', ERB::Util.unwrapped_html_escape(action_link_url(link, record)))
+                   .gsub('--LINK_ID--', ERB::Util.unwrapped_html_escape(options[:link_id] || get_action_link_id(link, record)))
+                   .gsub('--CONFIRM--') { ERB::Util.unwrapped_html_escape(link.confirm(h(record&.to_label))) }
+                   .gsub('--PROMPT--') { ERB::Util.unwrapped_html_escape(link.prompt(h(record&.to_label))) }
+                   .gsub('--ACTIVE--') { action_link_selected?(link, record) ? 'active' : '' }
+        end
+        html&.gsub('--LABEL--', h(label || link.label(record)))&.html_safe # rubocop:disable Rails/OutputSafety
+      end
+
+      def render_unauthorized_action_link(link, record = nil, options = {}, cache: false)
+        html_class = "disabled #{link.action}#{" #{link.html_options[:class]}" if link.html_options[:class].present?}"
+        options[:link] = '--LABEL--' if cache
+        html_options = {
+          link: action_link_text(link, record, options),
+          class: html_class,
+          title: cache ? '--REASON--' : options[:not_authorized_reason]
+        }
+        html = action_link_html(link, nil, html_options, record)
+        cache ? html.to_str : html
+      end
+
+      def render_authorized_action_link(link, record = nil, options = {}, cache: false)
+        url = cache ? '--URL--' : action_link_url(link, record)
+        options[:link] = '--LABEL--' if cache
+        html_options = action_link_html_options(link, record, options, cache: cache)
+        html = action_link_html(link, url, html_options, record)
+        cache ? html.to_str : html
+      end
+
       # setup the action link to inline form
       def action_link_to_inline_form(link, record)
         link = link.dup
@@ -182,6 +250,10 @@ module ActiveScaffold
         active_scaffold_config.user.cache_action_link_urls && link.type == :member && !link.dynamic_parameters.is_a?(Proc) && !sti_record?(record)
       end
 
+      def cache_action_link?(link)
+        active_scaffold_config.user.cache_action_links && link.type == :member
+      end
+
       def cached_action_link_url(link, record)
         @action_links_urls ||= {}
         @action_links_urls[link.name_to_cache.to_s] || begin
@@ -196,7 +268,7 @@ module ActiveScaffold
       end
 
       def replace_id_params_in_action_link_url(link, record, url)
-        url = record ? url.sub('--ID--', record.to_param.to_s) : url.clone
+        url = record ? url.sub('--ID--', record.to_param.to_s) : url.dup
         if link.column&.association&.singular?
           child_id = record.send(link.column.association.name)&.to_param
           if child_id.present?
@@ -284,12 +356,7 @@ module ActiveScaffold
       end
 
       def cached_action_link_url_options(link, record)
-        @action_links_url_options ||= {}
-        @action_links_url_options[link.name_to_cache.to_s] || begin
-          options = action_link_url_options(link, record)
-          @action_links_url_options[link.name_to_cache.to_s] = options if cache_action_link_url_options?(link, record)
-          options
-        end
+        optional_cache_helper(:action_link_url_options, link.name_to_cache.to_s, cache_action_link_url_options?(link, record), link, record)
       end
 
       def action_link_url_options(link, record)
@@ -317,7 +384,7 @@ module ActiveScaffold
       def action_link_text(link, record, options)
         if link.image
           title = options[:link] || link.label(record)
-          asset = (@_link_images ||= {})[link.image[:name]] ||= image_path(link.image[:name])
+          asset = ActiveScaffold::Registry.cache(:link_images, link.image[:name]) { image_path(link.image[:name]) }
           text = image_tag(asset, size: link.image[:size], alt: title, title: title, skip_pipeline: true)
         end
         text || options[:link]
@@ -354,8 +421,8 @@ module ActiveScaffold
         end
       end
 
-      def action_link_html_options(link, record, options)
-        link_id = get_action_link_id(link, record)
+      def action_link_html_options(link, record, options, cache: false)
+        link_id = cache ? '--LINK_ID--' : options[:link_id] || get_action_link_id(link, record)
         html_options = options[:html_options] || link.html_options
         html_options = html_options.merge(class: [html_options[:class], link.action.to_s].compact.join(' '))
         html_options[:link] = action_link_text(link, record, options)
@@ -365,23 +432,27 @@ module ActiveScaffold
 
         html_options[:data] ||= {}
         html_options[:data] = html_options[:data].deep_dup if html_options[:data].frozen?
-        html_options[:data][:confirm] = link.confirm(h(record&.to_label)) if link.confirm?
+        html_options[:data][:confirm] = cache ? '--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[:class] += ' as_action'
           html_options[:data][:position] = link.position if link.position
           html_options[:data][:action] = link.action
           html_options[:data][:cancel_refresh] = true if link.refresh_on_close
           html_options[:data][:keep_open] = true if link.keep_open?
           if link.prompt?
-            html_options[:data][:prompt] = link.prompt(h(record&.to_label))
+            html_options[:data][:prompt] = cache ? '--PROMPT--' : link.prompt(h(record&.to_label))
             html_options[:data][:prompt_required] = true if link.prompt_required?
           end
           html_options[:remote] = true
         end
 
         if link.toggle
-          html_options[:class] << ' toggle'
-          html_options[:class] << ' active' if action_link_selected?(link, record)
+          html_options[:class] += ' toggle'
+          if cache
+            html_options[:class] << ' --ACTIVE--'
+          elsif action_link_selected?(link, record)
+            html_options[:class] << ' active'
+          end
         end
 
         if !options[:page] && !options[:inline] && (options[:popup] || link.popup?)
@@ -393,7 +464,7 @@ module ActiveScaffold
       end
 
       def get_action_link_id(link, record = nil)
-        column = link.column
+        column = link.column unless link.is_a?(ActiveScaffold::DataStructures::ActionLinks)
         if column&.association && record
           associated = record.send(column.association.name) unless column.association.collection?
           id =
@@ -405,10 +476,14 @@ module ActiveScaffold
         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.to_s do
-          if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)
-            controller_id = id_from_controller("#{link.controller}-")
+          if link.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+            action_link_id(link.path.tr('.', '_'), '--ID--')
+          else
+            if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)
+              controller_id = id_from_controller("#{link.controller}-")
+            end
+            action_link_id("#{controller_id}#{link.action}", '--ID--')
           end
-          action_link_id("#{controller_id}#{link.action}", '--ID--')
         end
         action_link_id.sub('--ID--', id)
       end

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveScaffold
   module Helpers
     module AssociationHelpers
@@ -39,7 +41,7 @@ module ActiveScaffold
             include_assoc = includes_for_association(column, klass)
             relation = relation.includes(include_assoc) if include_assoc
           end
-          if column&.sort && column.sort&.dig(:sql)
+          if 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 { |sql| Arel.sql(sql.to_s) })
@@ -92,7 +94,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&.sort && column.sort&.dig(:sql)
+        unless column&.sort&.dig(:sql)
           method = column.options[:label_method] if column
           options = options.sort_by(&(method || :to_label).to_sym)
         end

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveScaffold
   module Helpers
     module ControllerHelpers

data/lib/active_scaffold/helpers/filter_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveScaffold
   module Helpers
     # Helpers rendering filters
@@ -9,8 +11,14 @@ module ActiveScaffold
       end
 
       def display_filters(filters)
-        content = filters.sort_by(&:weight).map { |filter| display_filter(filter) }
-        content_tag :div, safe_join(content), class: 'filters' if content.present?
+        return unless filters_enabled?
+
+        content = render_filters filters
+        content_tag :div, content, class: 'filters' if content.present?
+      end
+
+      def render_filters(filters)
+        safe_join(filters.sort_by(&:weight).filter_map { |filter| display_filter(filter) })
       end
 
       def display_filter(filter)
@@ -29,7 +37,7 @@ module ActiveScaffold
         content = options.map do |option|
           content_tag :option, option.label(nil), data: {url: action_link_url(option, nil)}, selected: action_link_selected?(option, nil), title: option.description
         end
-        select_tag nil, safe_join(content), class: "action_group #{link.css_class}", title: filter.description || filter.label, data: {remote: :url} if content.present?
+        select_tag nil, safe_join(content), class: "action_group #{filter.css_class}", title: filter.description || filter.label, data: {remote: :url} if content.present?
       end
     end
   end

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveScaffold
   module Helpers
     # Helpers that assist with the rendering of a Form Column
@@ -23,7 +25,7 @@ module ActiveScaffold
 
         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
+          raise ArgumentError, "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)
@@ -47,14 +49,15 @@ module ActiveScaffold
           text_field(:record, column.name, options.merge(column.options).except(:format))
         end
       rescue StandardError => e
-        Rails.logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
-        raise e
+        message = "on the ActiveScaffold column = :#{column.name} in #{controller.class}"
+        ActiveScaffold.log_exception(e, message)
+        raise e.class, "#{e.message} -- #{message}", e.backtrace
       end
 
       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?(action_for_validation?(record))
+          col_class << 'required' if column.required?(action_for_validation(record))
           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
@@ -77,6 +80,18 @@ module ActiveScaffold
         }
       end
 
+      def active_scaffold_subform_record_actions(association_column, record, locked, scope)
+        return unless association_column.association.collection? && !locked
+
+        auth = %i[destroy delete_all delete].exclude?(association_column.association.dependent)
+        auth, reason = record.authorized_for?(crud_type: :delete, reason: true) unless auth
+        if auth
+          link_to(as_(:remove), '#', class: 'destroy')
+        else
+          content_tag :span, reason, class: 'destroy reason'
+        end
+      end
+
       # the standard active scaffold options used for textual inputs
       def active_scaffold_input_text_options(options = {})
         options[:autocomplete] ||= 'off'
@@ -84,7 +99,7 @@ module ActiveScaffold
         options
       end
 
-      def action_for_validation?(record)
+      def action_for_validation(record)
         record&.persisted? ? :update : :create
       end
 
@@ -94,7 +109,7 @@ module ActiveScaffold
         record = options[:object]
 
         # Add some HTML5 attributes for in-browser validation and better user experience
-        if column.required?(action_for_validation?(record)) && (!@disable_required_for_new || scope.nil? || record&.persisted?)
+        if column.required?(action_for_validation(record)) && (!@disable_required_for_new || scope.nil? || record&.persisted?)
           options[:required] = true
         end
         options[:placeholder] = column.placeholder if column.placeholder.present?
@@ -112,7 +127,9 @@ module ActiveScaffold
       end
 
       def current_form_columns(record, scope, subform_controller = nil)
-        if scope
+        if @main_columns && (scope.nil? || subform_controller == controller.class)
+          @main_columns.visible_columns_names
+        elsif scope
           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)
@@ -122,29 +139,33 @@ module ActiveScaffold
         end
       end
 
+      def url_options_for_render_field(column, record, scope, subform_controller, url_params)
+        url_params.reverse_merge! params_for(action: 'render_field', column: column.name, id: record.to_param)
+        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(%r{^/}, '')
+          url_params[:controller] = subform_controller.controller_path
+          url_params[:scope] = scope
+          url_params[:parent_id] = params[:parent_id] || params[:id]
+        end
+        url_params
+      end
+
       def update_columns_options(column, scope, options, force = false, form_columns: nil, url_params: {})
         record = options[:object]
         subform_controller = controller.class.active_scaffold_controller_for(record.class) if scope
-        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&.intersect?(form_columns))
-          url_params.reverse_merge! params_for(action: 'render_field', column: column.name, id: record.to_param)
-          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(%r{^/}, '')
-            url_params[:controller] = subform_controller.controller_path
-            url_params[:scope] = scope
-            url_params[:parent_id] = params[:parent_id] || params[:id]
-          end
+        update_columns = column.update_columns&.flat_map { |col| col.is_a?(Hash) ? col.keys : col }
+        force = true if update_columns&.include?(:__root__)
 
+        if force || (form_columns && update_columns&.intersect?(form_columns))
+          url_params = url_options_for_render_field(column, record, scope, subform_controller, url_params)
           options[:class] = "#{options[:class]} update_form".strip
           options['data-update_url'] = url_for(url_params)
-          options['data-update_send_form'] = column.send_form_on_update_column
+          options['data-update_send_form'] = column.update_columns&.any?(Hash) || column.send_form_on_update_column
           options['data-update_send_form_selector'] = column.options[:send_form_selector] if column.options[:send_form_selector]
           options['data-skip-disable-form'] = !column.disable_on_update_column
         end
@@ -203,13 +224,18 @@ module ActiveScaffold
         end
       end
 
+      def column_description(column, record, scope = nil)
+        desc = column.description(record, scope)
+        content_tag(:span, h(desc) + content_tag(:span, nil, class: 'close'), class: 'description') if desc.present?
+      end
+
       def form_attribute(column, record, scope = nil, only_value = false, col_class = nil)
         column_options = active_scaffold_input_options(column, scope, object: record)
         collapsible_id = column_options.delete :collapsible_id
         attributes = field_attributes(column, record)
         attributes[:class] = "#{attributes[:class]} #{col_class}" if col_class.present?
         if only_value
-          field = content_tag(:span, get_column_value(record, column), column_options.except(:name, :object))
+          field = content_tag(:span, show_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
@@ -221,8 +247,8 @@ module ActiveScaffold
         end
         if field
           field << loading_indicator_tag(action: :render_field, id: params[:id]) if column.update_columns
-          desc = column.description(record, scope)
-          field << content_tag(:span, desc, class: 'description') if desc.present?
+          desc = column_description(column, record, scope)
+          field << desc if desc.present?
         end
 
         label = label_tag(label_for(column, column_options), form_column_label(column, record, scope))
@@ -352,7 +378,6 @@ module ActiveScaffold
             collection_select(:record, method, select_options, :id, ui_options[:label_method] || :to_label, options, html_options)
           end
         html << active_scaffold_refresh_link(column, html_options, record, ui_options) if ui_options[:refresh_link]
-        html << active_scaffold_add_new(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
         html
       end
 
@@ -368,19 +393,7 @@ module ActiveScaffold
 
       def active_scaffold_add_new(column, record, html_options, ui_options: column.options, skip_link: false)
         options = ui_options[:add_new] == true ? {} : ui_options[:add_new]
-        if options.is_a?(Array)
-          ActiveScaffold.deprecator.warn "use add_new: {types: #{options.inspect}} instead of add_new: #{options.inspect}"
-          options = {types: options}
-        end
-        if ui_options[:hide_subgroups] && !options.key?(:hide_subgroups)
-          ActiveScaffold.deprecator.warn "use add_new: {hide_subgroups: #{ui_options[:hide_subgroups]}} instead of hide_subgroups: #{ui_options[:hide_subgroups]}"
-          options[:hide_subgroups] = ui_options[:hide_subgroups]
-        end
-        if ui_options[:layout] && !options.key?(:layout)
-          ActiveScaffold.deprecator.warn "use add_new: {layout: #{ui_options[:layout]}} instead of layout: #{ui_options[:layout]}"
-          options[:layout] = ui_options[:layout]
-        end
-
+        options[:mode] = :popup if column.association&.collection?
         case options[:mode]
         when nil, :subform
           active_scaffold_new_record_subform(column, record, html_options, options: options, skip_link: skip_link)
@@ -461,31 +474,32 @@ module ActiveScaffold
         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, ui_options: column.options, &block)
+      def active_scaffold_file_with_content(column, options, content, remove_file_prefix, controls_class, ui_options: column.options)
         options = active_scaffold_input_text_options(options.merge(ui_options))
+        options[:style] = 'display: none' if content
+        field = file_field(:record, column.name, options)
+
         if content
-          active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class, &block)
+          content = [content, ' | ']
+          content << yield if block_given?
+          object_name, method = options[:name].split(/\[(#{column.name})\]/)
+          method.sub!(/#{column.name}/, "#{remove_file_prefix}\\0")
+          content << hidden_field(object_name, method, value: 'false', class: 'remove_file')
+          active_scaffold_file_with_remove_link(safe_join(content), options, controls_class) { field }
         else
-          file_field(:record, column.name, options)
+          field
         end
       end
 
-      def active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class)
+      def active_scaffold_file_with_remove_link(content, options, controls_class, link_key = nil)
         required = options.delete(:required)
-        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;"
-
-        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_(link_key), href: '#', onclick: js_remove_file_code)]
-          end << content_tag(:div, input, style: 'display: none')
+        link_key ||= options[:multiple] ? :remove_files : :remove_file
+        content_tag(:div, class: "#{controls_class} file-input-controls", data: {required: required}) do
+          content_line = content_tag(:div) do
+            safe_join [content, content_tag(:a, as_(link_key), href: '#', class: 'remove-file-btn')]
+          end
+          content_line << yield if block_given?
+          content_line
         end
       end
 
@@ -533,7 +547,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_draggable(column, options, ui_options: column.options)
-        active_scaffold_input_plural_association(column, options.merge(draggable_lists: true), ui_options: ui_options)
+        active_scaffold_input_select(column, options.merge(draggable_lists: true), ui_options: ui_options)
       end
 
       def active_scaffold_checkbox_option(option, label_method, associated_ids, checkbox_options, li_options = {})
@@ -594,13 +608,20 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_select(column, html_options, ui_options: column.options)
-        if column.association&.singular?
-          active_scaffold_input_singular_association(column, html_options, ui_options: ui_options)
-        elsif column.association&.collection?
-          active_scaffold_input_plural_association(column, html_options, ui_options: ui_options)
-        else
-          active_scaffold_input_enum(column, html_options, ui_options: ui_options)
+        record = html_options[:object]
+        html =
+          if column.association&.singular?
+            active_scaffold_input_singular_association(column, html_options, ui_options: ui_options)
+          elsif column.association&.collection?
+            active_scaffold_input_plural_association(column, html_options, ui_options: ui_options)
+          else
+            active_scaffold_input_enum(column, html_options, ui_options: ui_options)
+          end
+        if ui_options[:add_new]
+          html = content_tag(:div, html, class: 'select-field') <<
+                 active_scaffold_add_new(column, record, html_options, ui_options: ui_options)
         end
+        html
       end
 
       def active_scaffold_input_select_multiple(column, options, ui_options: column.options)
@@ -639,8 +660,11 @@ module ActiveScaffold
         selected_id = selected&.id
         if options.present?
           if ui_options[:add_new]
-            html_options[:data] ||= {}
-            html_options[:data][:subform_id] = active_scaffold_subform_attributes(column, ui_options: ui_options)[:id]
+            add_new_subform = ui_options[:add_new] == true || ui_options[:add_new][:mode].in?([nil, :subform])
+            if add_new_subform
+              html_options[:data] ||= {}
+              html_options[:data][:subform_id] = active_scaffold_subform_attributes(column, ui_options: ui_options)[:id]
+            end
             radio_html_options = html_options.merge(class: "#{html_options[:class]} hide-new-subform")
           else
             radio_html_options = html_options
@@ -655,7 +679,7 @@ module ActiveScaffold
             radios.prepend content_tag(:label, radio_button(:record, column.name, '', html_options.merge(id: radio_id)) + label)
           end
           if ui_options[:add_new]
-            if ui_options[:add_new] == true || ui_options[:add_new][:mode].in?([nil, :subform])
+            if add_new_subform
               create_new = content_tag(:label) do
                 radio_button_tag(html_options[:name], '', selected&.new_record?, html_options.merge(
                   id: "#{html_options[:id]}-create_new", class: "#{html_options[:class]} show-new-subform"
@@ -679,7 +703,10 @@ module ActiveScaffold
         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_add_new(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
+          if ui_options[:add_new]
+            html = content_tag(:div, html, class: 'select-field') <<
+                   active_scaffold_add_new(column, record, html_options, ui_options: ui_options)
+          end
           html
         end
       end
@@ -851,9 +878,9 @@ module ActiveScaffold
         end
       end
 
-      def column_scope(column, scope = nil, record = nil)
+      def column_scope(column, scope = nil, record = nil, generated_id = nil)
         if column.association&.collection?
-          "#{scope}[#{column.name}][#{record.id || generate_temporary_id(record)}]"
+          "#{scope}[#{column.name}][#{record.id || generate_temporary_id(record, generated_id)}]"
         else
           "#{scope}[#{column.name}]"
         end