active_scaffold 4.0.13 → 4.1.0

data/lib/active_scaffold/data_structures/filter.rb

@@ -0,0 +1,85 @@
+module ActiveScaffold::DataStructures
+  class Filter
+    include Enumerable
+
+    attr_reader :name, :default_option
+    attr_writer :label, :description
+    attr_accessor :type, :weight, :css_class, :security_method
+
+    def initialize(name, type)
+      raise ArgumentError, 'Filter name must use only word characters (a-zA-Z0-9_)' unless name.match?(/\A\w+\z/)
+
+      @label = @name = name.to_sym
+      @type = type
+      @options = []
+      @weight = 0
+    end
+
+    # adds a FilterOption, creating one from the arguments if need be
+    def add(name, options = {})
+      if name.is_a?(ActiveScaffold::DataStructures::FilterOption)
+        option = name
+        name = option.name
+      end
+      existing = self[name]
+      raise ArgumentError, "there is a filter option with '#{name}' name" if existing
+
+      option ||= ActiveScaffold::DataStructures::FilterOption.new(@name, name, options)
+      @default_option ||= option.name
+      @options << option
+      self
+    end
+    alias << add
+
+    def default_option=(name)
+      option = self[name]
+      raise ArgumentError, "'#{name}' option not found" unless option
+
+      @default_option = option.name
+    end
+
+    # finds a FilterOption by matching the name
+    def [](option_name)
+      @options.find { |option| option.name.to_s == option_name.to_s }
+    end
+
+    def delete(option_name)
+      @options.delete self[option_name]
+    end
+
+    # iterates over the links, possibly by type
+    def each(&)
+      @options.each(&)
+    end
+
+    def empty?
+      @options.empty?
+    end
+
+    def label(*)
+      case @label
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) }
+      else
+        @label
+      end
+    end
+
+    def description
+      case @description
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @description) { as_(@description) }
+      else
+        @description
+      end
+    end
+
+    protected
+
+    # called during clone or dup. makes the clone/dup deeper.
+    def initialize_copy(from)
+      @options = []
+      from.each { |option| @options << option.clone }
+    end
+  end
+end

data/lib/active_scaffold/data_structures/filter_option.rb

@@ -0,0 +1,32 @@
+module ActiveScaffold::DataStructures
+  class FilterOption < ActionLink
+    attr_reader :name, :filter_name
+    attr_writer :description
+    attr_accessor :conditions
+
+    def initialize(filter_name, name, options = {})
+      @filter_name = filter_name
+      @label = @name = name.to_sym
+      super(
+        :index,
+        options.merge(
+          action: :index,
+          type: :collection,
+          method: :get,
+          position: false,
+          toggle: true
+        )
+      )
+      parameters.merge!(filter_name => name)
+    end
+
+    def description
+      case @description
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @description) { as_(@description) }
+      else
+        @description
+      end
+    end
+  end
+end

data/lib/active_scaffold/data_structures/filters.rb

@@ -0,0 +1,51 @@
+module ActiveScaffold::DataStructures
+  class Filters
+    include Enumerable
+
+    def initialize
+      @set = []
+      @default_type = self.class.default_type
+    end
+
+    # adds a FilterOption, creating one from the arguments if need be
+    def add(name, &block)
+      if name.is_a?(ActiveScaffold::DataStructures::Filter)
+        filter = name
+        name = filter.name
+      end
+      existing = self[name]
+      raise ArgumentError, "there is a filter with '#{name}' name" if existing
+
+      filter ||= ActiveScaffold::DataStructures::Filter.new(name, default_type)
+      @set << filter
+      block&.call filter
+      self
+    end
+    alias << add
+
+    # finds a Filter by matching the name
+    def [](name)
+      @set.find { |filter| filter.name.to_s == name.to_s }
+    end
+
+    def delete(name)
+      @set.delete self[name]
+    end
+
+    # iterates over the links, possibly by type
+    def each(&)
+      @set.each(&)
+    end
+
+    def empty?
+      @set.empty?
+    end
+
+    # default filter type for all app filters, can be :links or :select
+    cattr_accessor :default_type
+    @@default_type = :links
+
+    # default filter type for all filters in this set, can be :links or :select
+    attr_accessor :default_type
+  end
+end

data/lib/active_scaffold/data_structures/set.rb

@@ -47,8 +47,8 @@ module ActiveScaffold::DataStructures
     end
     alias [] find_by_name
 
-    def each(&block)
-      @set.each(&block)
+    def each(&)
+      @set.each(&)
     end
 
     # returns the number of items in the set

data/lib/active_scaffold/data_structures/sorting.rb

@@ -106,8 +106,8 @@ module ActiveScaffold::DataStructures
     end
 
     # iterate over the clauses
-    def each(&block)
-      @clauses.each(&block)
+    def each(&)
+      @clauses.each(&)
     end
 
     def each_column

data/lib/active_scaffold/extensions/action_controller_rendering.rb

@@ -1,14 +1,14 @@
 # wrap the action rendering for ActiveScaffold controllers
 module ActiveScaffold
   module ActionController # :nodoc:
-    def render(*args, &block)
+    def render(*args, &)
       if self.class.uses_active_scaffold? && params[:adapter] && @rendering_adapter.nil? && request.xhr?
         @rendering_adapter = true # recursion control
         # if we need an adapter, then we render the actual stuff to a string and insert it into the adapter template
         opts = args.any? ? args.first : {}
 
         render partial: params[:adapter][1..],
-               locals: {payload: render_to_string(opts.merge(layout: false), &block).html_safe}, # rubocop:disable Rails/OutputSafety
+               locals: {payload: render_to_string(opts.merge(layout: false), &).html_safe}, # rubocop:disable Rails/OutputSafety
                use_full_path: true, layout: false, content_type: :html
         @rendering_adapter = nil # recursion control
       else

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -35,7 +35,7 @@ module ActiveScaffold # :nodoc:
     #
     # options[:xhr] force to load embedded scaffold with AJAX even when render_component gem is installed.
     #
-    def render(*args, &block)
+    def render(*args, &)
       if args.first.is_a?(Hash) && args.first[:active_scaffold]
         render_embedded args.first
       elsif args.first == :super
@@ -103,9 +103,9 @@ module ActiveScaffold # :nodoc:
     def update_view_paths
       last_view_path =
         if @lookup_context # rails 6
-          File.expand_path(File.dirname(File.dirname(@lookup_context.last_template.short_identifier.to_s)), Rails.root)
+          File.expand_path(File.dirname(@lookup_context.last_template.short_identifier.to_s, 2), Rails.root)
         else
-          File.expand_path(File.dirname(File.dirname(lookup_context.last_template.inspect)), Rails.root)
+          File.expand_path(File.dirname(lookup_context.last_template.inspect, 2), Rails.root)
         end
       new_view_paths = view_paths.drop(view_paths.find_index { |path| path.to_s == last_view_path } + 1)
       if @lookup_context # rails 6

data/lib/active_scaffold/finder.rb

@@ -502,7 +502,7 @@ module ActiveScaffold
 
     protected
 
-    attr_writer :active_scaffold_conditions, :active_scaffold_preload, :active_scaffold_habtm_joins, :active_scaffold_outer_joins, :active_scaffold_references
+    attr_writer :active_scaffold_conditions, :active_scaffold_preload, :active_scaffold_joins, :active_scaffold_outer_joins, :active_scaffold_references
 
     def active_scaffold_conditions
       @active_scaffold_conditions ||= []
@@ -512,8 +512,18 @@ module ActiveScaffold
       @active_scaffold_preload ||= []
     end
 
+    def active_scaffold_joins
+      @active_scaffold_joins ||= []
+    end
+
     def active_scaffold_habtm_joins
-      @active_scaffold_habtm_joins ||= []
+      ActiveScaffold.deprecator.warn 'use active_scaffold_joins'
+      active_scaffold_joins
+    end
+
+    def active_scaffold_habtm_joins=(value)
+      ActiveScaffold.deprecator.warn 'use active_scaffold_joins='
+      self.active_scaffold_joins = value
     end
 
     def active_scaffold_outer_joins
@@ -559,7 +569,7 @@ module ActiveScaffold
     # returns a single record (the given id) but only if it's allowed for the specified security options.
     # security options can be a hash for authorized_for? method or a value to check as a :crud_type
     # accomplishes this by checking model.#{action}_authorized?
-    def find_if_allowed(id, security_options, klass = beginning_of_chain)
+    def find_if_allowed(id, security_options, klass = filtered_query)
       record = klass.find(id)
       security_options = {crud_type: security_options.to_sym} unless security_options.is_a? Hash
       raise ActiveScaffold::RecordNotAllowed, "#{klass} with id = #{id}" unless record.authorized_for? security_options
@@ -623,7 +633,7 @@ module ActiveScaffold
       options[:page] ||= 1
 
       find_options = finder_options(options)
-      query = beginning_of_chain
+      query = filtered_query
       query = query.where(nil) if active_scaffold_config.active_record? # where(nil) is needed because we need a relation
 
       # NOTE: we must use :include in the count query, because some conditions may reference other tables
@@ -663,7 +673,7 @@ module ActiveScaffold
       left_joins = active_scaffold_outer_joins
       left_joins += includes if includes
       primary_key = active_scaffold_config.primary_key
-      subquery = append_to_query(beginning_of_chain, conditions: conditions, joins: joins_for_finder, left_joins: left_joins, select: active_scaffold_config.columns[primary_key].field)
+      subquery = append_to_query(filtered_query, conditions: conditions, joins: joins_for_finder, left_joins: left_joins, select: active_scaffold_config.columns[primary_key].field)
       subquery.unscope(:order)
     end
 
@@ -690,7 +700,7 @@ module ActiveScaffold
         joins_for_collection
       else
         []
-      end + active_scaffold_habtm_joins
+      end + active_scaffold_joins
     end
 
     def apply_conditions(relation, *conditions)

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -1,7 +1,6 @@
 module ActiveScaffold
   module Helpers
-    # All extra helpers that should be included in the View.
-    # Also a dumping ground for uncategorized helpers.
+    # Helpers rendering action links
     module ActionLinkHelpers
       # params which mustn't be copying to nested links
       NESTED_PARAMS = %i[eid embedded association parent_scaffold].freeze
@@ -62,9 +61,9 @@ module ActiveScaffold
         output
       end
 
-      def display_action_link_group(link, record, options, &block)
+      def display_action_link_group(link, record, options, &)
         options[:level] += 1
-        content = display_action_links(link, record, options, &block)
+        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
@@ -85,7 +84,7 @@ module ActiveScaffold
             group_tag = :li
           end
           content = content_tag(group_tag, class: html_classes.presence, onclick: ('' if hover_via_click?)) do
-            content_tag(:div, as_(link.label(record)), class: link.css_class) << content_tag(:ul, content)
+            content_tag(:div, link.label(record), class: link.css_class, title: options[:title]) << content_tag(:ul, content)
           end
         else
           content = render_action_link(link, record, options)
@@ -341,14 +340,23 @@ module ActiveScaffold
       end
 
       def action_link_selected?(link, record)
-        missing_options, url_options = replaced_action_link_url_options(link, record)
-        safe_params = params.to_unsafe_h
-        (url_options - safe_params.to_a).blank? && missing_options.all? { |k, _| params[k].nil? }
+        if link.respond_to?(:filter_name)
+          if params[link.filter_name]
+            params[link.filter_name].to_s == link.name.to_s
+          else
+            active_scaffold_config.list.filters[link.filter_name].default_option == link.name
+          end
+        else
+          missing_options, url_options = replaced_action_link_url_options(link, record)
+          safe_params = params.to_unsafe_h
+          (url_options - safe_params.to_a).blank? && missing_options.all? { |k, _| params[k].nil? }
+        end
       end
 
       def action_link_html_options(link, record, options)
         link_id = get_action_link_id(link, record)
-        html_options = link.html_options.merge(class: [link.html_options[:class], link.action.to_s].compact.join(' '))
+        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)
 
         # Needs to be in html_options to as the adding _method to the url is no longer supported by Rails
@@ -363,6 +371,10 @@ module ActiveScaffold
           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_required] = true if link.prompt_required?
+          end
           html_options[:remote] = true
         end
 
@@ -376,14 +388,6 @@ module ActiveScaffold
           html_options[:rel] = [html_options[:rel], 'noopener noreferrer'].compact.join(' ')
         end
         html_options[:id] = link_id
-        if link.dhtml_confirm?
-          unless link.inline?
-            html_options[:class] << ' as_action'
-            html_options[:page_link] = 'true'
-          end
-          html_options[:dhtml_confirm] = link.dhtml_confirm.value
-          html_options[:onclick] = link.dhtml_confirm.onclick_function(controller, link_id)
-        end
         html_options
       end
 

data/lib/active_scaffold/helpers/filter_helpers.rb

@@ -0,0 +1,36 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers rendering filters
+    module FilterHelpers
+      def clear_filters_params
+        active_scaffold_config.list.filters.each_with_object({}) do |filter, url_options|
+          url_options[filter.name] = nil
+        end
+      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?
+      end
+
+      def display_filter(filter)
+        return if filter.security_method && !controller.send(filter.security_method)
+
+        options = filter.reject { |option| option.security_method_set? && !controller.send(option.security_method) }
+        send :"display_filter_as_#{filter.type}", filter, options if options.present?
+      end
+
+      def display_filter_as_links(filter, options)
+        content = options.map { |option| display_action_link(option, nil, nil, authorized: true, level: 1) }
+        display_action_link(filter, safe_join(content), nil, level: 0, title: filter.description) if content.present?
+      end
+
+      def display_filter_as_select(filter, options)
+        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?
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -129,7 +129,7 @@ module ActiveScaffold
           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?)
+        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)
@@ -146,6 +146,7 @@ module ActiveScaffold
           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]
+          options['data-skip-disable-form'] = !column.disable_on_update_column
         end
         options
       end
@@ -332,8 +333,9 @@ module ActiveScaffold
         record = html_options.delete(:object)
         associated = html_options.include?(:associated) ? html_options.delete(: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)
+        helper_method = association_helper_method(column.association, :sorted_association_options_find)
+        select_options = send(helper_method, column.association, nil, record)
+        select_options.unshift(associated) if associated&.persisted? && select_options.exclude?(associated)
 
         method = column.name
         options.merge! selected: associated&.id, include_blank: as_(:_select_), object: record
@@ -350,21 +352,80 @@ 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_new_record_subform(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
+        html << active_scaffold_add_new(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
         html
       end
 
-      def active_scaffold_new_record_subform(column, record, html_options, ui_options: column.options, new_record_attributes: nil, locals: {}, skip_link: false)
-        klass =
-          if column.association.polymorphic? && column.association.belongs_to?
-            type = record.send(column.association.foreign_type)
-            column.association.klass(record) if type.present? && (ui_options[:add_new] == true || type.in?(ui_options[:add_new]))
-          else
-            column.association.klass
-          end
+      def active_scaffold_new_record_klass(column, record, **options)
+        if column.association.polymorphic? && column.association.belongs_to?
+          type = record.send(column.association.foreign_type)
+          type_options = options[:types]
+          column.association.klass(record) if type.present? && (type_options.nil? || type_options.include?(type))
+        else
+          column.association.klass
+        end
+      end
+
+      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
+
+        case options[:mode]
+        when nil, :subform
+          active_scaffold_new_record_subform(column, record, html_options, options: options, skip_link: skip_link)
+        when :popup
+          active_scaffold_new_record_popup(column, record, html_options, options: options) unless skip_link
+        else
+          raise ArgumentError, "unsupported mode for add_new: #{options[:mode].inspect}"
+        end
+      end
+
+      def active_scaffold_new_record_url_options(column, record)
+        if column.association.reverse
+          constraint = [record.id]
+          constraint.unshift record.class.name if column.association.reverse_association.polymorphic?
+          {embedded: {constraints: {column.association.reverse => constraint}}}
+        else
+          raise "can't add constraint to create new record with :popup, no reverse association for " \
+                "\"#{column.name}\" in #{column.association.klass}, add the reverse association " \
+                'or override active_scaffold_new_record_url_options helper.'
+        end
+      end
+
+      def active_scaffold_new_record_popup(column, record, html_options, options: {})
+        klass = send(override_helper_per_model(:active_scaffold_new_record_klass, record.class), column, record, **options)
+        klass = nil if options[:security_method] && !controller.send(options[:security_method])
+        klass = nil if klass && options[:security_method].nil? && !klass.authorized_for?(crud_type: :create)
+        return h('') unless klass
+
+        link_text = active_scaffold_add_new_text(options, :add_new_text, :add)
+        url_options_helper = override_helper_per_model(:active_scaffold_new_record_url_options, record.class)
+        url_options = send(url_options_helper, column, record)
+        url_options[:controller] ||= active_scaffold_controller_for(klass).controller_path
+        url_options[:action] ||= :new
+        url_options[:from_field] ||= html_options[:id]
+        url_options[:parent_model] ||= record.class.name
+        url_options[:parent_column] ||= column.name
+        url_options.reverse_merge! options[:url_options] if options[:url_options]
+        link_to(link_text, url_options, remote: true, data: {position: :popup}, class: 'as_action')
+      end
+
+      def active_scaffold_new_record_subform(column, record, html_options, options: {}, new_record_attributes: nil, locals: {}, skip_link: false)
+        klass = send(override_helper_per_model(:active_scaffold_new_record_klass, record.class), column, record, **options)
         return content_tag(:div, '') unless klass
 
-        subform_attrs = active_scaffold_subform_attributes(column, nil, klass, ui_options: ui_options)
+        subform_attrs = active_scaffold_subform_attributes(column, nil, klass, ui_options: options)
         if record.send(column.name)&.new_record?
           new_record = record.send(column.name)
         else
@@ -374,19 +435,28 @@ module ActiveScaffold
         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, ui_options: ui_options), locals: locals)
-        if ui_options[:hide_subgroups]
+        subform = render(partial: subform_partial_for_column(column, klass, ui_options: options), locals: locals)
+        if 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])
+        html << active_scaffold_show_new_subform_link(column, record, html_options[:id], subform_attrs[:id], options: options)
+      end
+
+      def active_scaffold_add_new_text(options, key, default)
+        text = options[key] unless options == true
+        return text if text.is_a? String
+
+        as_(text || default)
       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)}
+      def active_scaffold_show_new_subform_link(column, record, select_id, subform_id, options: {})
+        add_existing = active_scaffold_add_new_text(options, :add_existing_text, :add_existing)
+        create_new = active_scaffold_add_new_text(options, :add_new_text, :create_new)
+        data = {select_id: select_id, subform_id: subform_id, subform_text: add_existing, select_text: create_new}
         label = data[record.send(column.name)&.new_record? ? :subform_text : :select_text]
         link_to(label, '#', data: data, class: 'show-new-subform')
       end
@@ -439,7 +509,8 @@ module ActiveScaffold
 
       def active_scaffold_plural_association_options(column, record = nil)
         associated_options = record.send(column.association.name)
-        [associated_options, associated_options | sorted_association_options_find(column.association, nil, record)]
+        helper_method = association_helper_method(column.association, :sorted_association_options_find)
+        [associated_options, associated_options | send(helper_method, column.association, nil, record)]
       end
 
       def active_scaffold_input_plural_association(column, options, ui_options: column.options)
@@ -557,7 +628,8 @@ module ActiveScaffold
         html_options.merge!(ui_options[:html_options] || {})
         options =
           if column.association
-            sorted_association_options_find(column.association, nil, record)
+            helper_method = association_helper_method(column.association, :sorted_association_options_find)
+            send(helper_method, column.association, nil, record)
           else
             enum_options_method = override_helper_per_model(:active_scaffold_enum_options, record.class)
             send(enum_options_method, column, record, ui_options: ui_options)
@@ -579,18 +651,35 @@ module ActiveScaffold
           if ui_options[:include_blank]
             label = ui_options[:include_blank]
             label = as_(ui_options[:include_blank]) if ui_options[:include_blank].is_a?(Symbol)
-            radios.prepend content_tag(:label, radio_button(:record, column.name, '', html_options.merge(id: nil)) + label)
+            radio_id = "#{html_options[:id]}-"
+            radios.prepend content_tag(:label, radio_button(:record, column.name, '', html_options.merge(id: radio_id)) + label)
           end
           if ui_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").except(:object))
-            radios << content_tag(:label, create_new_button << as_(:create_new)) <<
-              active_scaffold_new_record_subform(column, record, html_options, ui_options: ui_options, skip_link: true)
+            if ui_options[:add_new] == true || ui_options[:add_new][:mode].in?([nil, :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"
+                ).except(:object)) <<
+                  active_scaffold_add_new_text(ui_options[:add_new], :add_new_text, :create_new)
+              end
+              radios << create_new
+              skip_link = true
+            else
+              ui_options = ui_options.merge(add_new: ui_options[:add_new].merge(
+                url_options: {
+                  parent_scope: html_options[:name].gsub(/^record|\[[^\]]*\]$/, '').presence,
+                  radio_data: html_options.slice(*html_options.keys.grep(/^data-update_/))
+                }
+              ))
+              radios << content_tag(:span, '', class: 'new-radio-container', id: html_options[:id])
+            end
+            radios << active_scaffold_add_new(column, record, html_options, ui_options: ui_options, skip_link: skip_link)
           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, ui_options: ui_options) if ui_options[:add_new]
+          html << active_scaffold_add_new(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
           html
         end
       end
@@ -778,7 +867,8 @@ module ActiveScaffold
           options.merge!(active_scaffold_input_text_options)
           record_select_field(options[:name], nil, options)
         else
-          select_options = sorted_association_options_find(nested.association, nil, record)
+          helper_method = association_helper_method(column.association, :sorted_association_options_find)
+          select_options = send(helper_method, 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', (content_tag(:option, as_(:_select_), value: '') + select_options) unless select_options.empty?

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -16,6 +16,10 @@ module ActiveScaffold
         end
       end
 
+      def active_scaffold_human_filter_for(filter_option)
+        filter_option.label
+      end
+
       def active_scaffold_grouped_by_label
         text, = active_scaffold_config.field_search.group_options.find do |text, value|
           (value || text).to_s == field_search_params['active_scaffold_group']