active_scaffold 4.3.2 → 4.4.0

data/lib/active_scaffold/data_structures/filter.rb

@@ -74,6 +74,10 @@ module ActiveScaffold::DataStructures
       end
     end
 
+    def security_method_set?
+      @security_method.present?
+    end
+
     protected
 
     # called during clone or dup. makes the clone/dup deeper.

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -17,6 +17,8 @@ module ActiveScaffold::DataStructures
     def initialize(model, params)
       @parent_scaffold = "#{params[:parent_scaffold].to_s.camelize}Controller".constantize
       @parent_model = @parent_scaffold.active_scaffold_config.model
+    rescue NameError => e
+      raise ActionController::BadRequest, e.message
     end
 
     def to_params
@@ -82,9 +84,14 @@ module ActiveScaffold::DataStructures
     def initialize(model, params)
       super
       column = parent_scaffold.active_scaffold_config.columns[params[:association].to_sym]
+      unless column&.association
+        raise ActionController::BadRequest,
+              "Invalid nested association #{params[:association].inspect} for #{parent_scaffold.active_scaffold_config.model.name}"
+      end
+
       @param_name = column.model.name.foreign_key.to_sym
       @parent_id = params[@param_name]
-      @association = column&.association
+      @association = column.association
       @child_association = association.reverse_association(model) if association
       setup_constrained_fields
     end

data/lib/active_scaffold/data_structures/sorting.rb

@@ -136,7 +136,7 @@ module ActiveScaffold::DataStructures
         sql = sql.to_sql if sql.respond_to?(:to_sql)
 
         parts = Array(sql).map do |column|
-          mongoid? ? [column, sort_direction] : "#{column} #{sort_direction}"
+          mongoid? ? [column, sort_direction] : {column => sort_direction}
         end
         order << parts
       end

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -162,7 +162,7 @@ module ActiveScaffold # :nodoc:
           content_tag(:div, class: 'active-scaffold-header') do
             content_tag(:h2) do
               label = options[:label] || remote_controller_config(remote_controller).list.label
-              link_to(label, url, remote: true, class: 'load-embedded', data: {error_msg: as_(:error_500)}) <<
+              link_to(label, url, remote: true, class: 'load-embedded', data: {error_msg: server_error_msg(as_(:error_500))}) <<
                 loading_indicator_tag(url_options)
             end
           end

data/lib/active_scaffold/finder.rb

@@ -2,8 +2,11 @@
 
 module ActiveScaffold
   module Finder
-    def self.like_operator
-      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name.in?(%w[PostgreSQL PostGIS]) ? 'ILIKE' : 'LIKE'
+    def self.like_operator(column = nil)
+      return column.like_operator if column&.like_operator
+
+      connection = column&.active_record_class&.connection || ::ActiveRecord::Base.connection
+      connection.adapter_name.in?(%w[PostgreSQL PostGIS]) ? 'ILIKE' : 'LIKE'
     end
 
     def self.logical_comparators
@@ -35,13 +38,14 @@ module ActiveScaffold
 
       def type_casted_tokens(tokens, columns, like_pattern)
         tokens.map do |value|
-          columns.each_with_object({}) do |column, column_tokens|
-            column_tokens[column.name] =
+          columns.to_h do |column|
+            casted_value =
               if column.text?
                 like_pattern.sub('?', column.active_record? ? column.active_record_class.sanitize_sql_like(value) : value)
               else
-                ActiveScaffold::Core.column_type_cast(value, column.column)
+                ActiveScaffold::Core.column_type_cast(value, column.column, column.model)
               end
+            [column.name, casted_value]
           end
         end
       end
@@ -51,7 +55,7 @@ module ActiveScaffold
           where_clauses = []
           columns.each do |column|
             column.search_sql.each do |search_sql|
-              where_clauses << "#{search_sql} #{column.text? ? ActiveScaffold::Finder.like_operator : '='} ?"
+              where_clauses << "#{search_sql} #{column.text? ? ActiveScaffold::Finder.like_operator(column) : '='} ?"
             end
           end
           phrase = where_clauses.join(' OR ')
@@ -170,7 +174,7 @@ module ActiveScaffold
           if value == 'null'
             condition_for_null_type(column, value)
           else
-            ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+            ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column, column.model) : value]
           end
         when :integer, :decimal, :float
           condition_for_numeric(column, value)
@@ -180,7 +184,7 @@ module ActiveScaffold
           else
             condition_for_single_value(column, value, like_pattern)
           end
-        when :date, :time, :datetime, :timestamp
+        when :date, :time, :datetime, :timestamp, :timestamptz
           condition_for_datetime(column, value)
         when :select, :select_multiple, :draggable, :multi_select, :country, :usa_state, :chosen, :multi_chosen
           if value.is_a?(Hash)
@@ -211,9 +215,9 @@ module ActiveScaffold
       def condition_for_single_value(column, value, like_pattern = nil)
         if column.text?
           value = column.active_record_class.sanitize_sql_like(value) if column.active_record?
-          ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+          ["%<search_sql>s #{ActiveScaffold::Finder.like_operator(column)} ?", like_pattern.sub('?', value)]
         else
-          ['%<search_sql>s = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
+          ['%<search_sql>s = ?', ActiveScaffold::Core.column_type_cast(value, column.column, column.model)]
         end
       end
 
@@ -228,7 +232,7 @@ module ActiveScaffold
         elsif ActiveScaffold::Finder::STRING_COMPARATORS.value?(value[:opt])
           text = column.active_record? ? column.active_record_class.sanitize_sql_like(value[:from]) : value[:from]
           [
-            "%<search_sql>s #{'NOT ' if value[:opt].start_with?('not_')}#{ActiveScaffold::Finder.like_operator} ?",
+            "%<search_sql>s #{'NOT ' if value[:opt].start_with?('not_')}#{ActiveScaffold::Finder.like_operator(column)} ?",
             value[:opt].sub('not_', '').sub('?', text)
           ]
         elsif value[:opt] == 'BETWEEN'
@@ -367,7 +371,7 @@ module ActiveScaffold
           end
         elsif conversion == :to_date
           parse_date_with_format(*format_for_date(column, value, column.send(ui_method), ui_options))
-        elsif value.include?('T')
+        elsif value.match?(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/) # iso8601 format
           Time.zone.parse(value)
         else # datetime
           time = parse_time_with_format(value, *format_for_datetime(column, value, column.send(ui_method), ui_options))
@@ -623,7 +627,6 @@ module ActiveScaffold
       search_conditions = all_conditions
 
       sorting = options[:sorting]&.clause
-      sorting = sorting.map { |part| Arel.sql(part) } if sorting && active_scaffold_config.active_record?
       # create a general-use options array that's compatible with Rails finders
       finder_options = {
         reorder: sorting,
@@ -647,6 +650,22 @@ module ActiveScaffold
       finder_options
     end
 
+    def add_order_expressions_to_select(query, sorting)
+      return query unless query.respond_to?(:distinct_value) && query.distinct_value &&
+                          active_scaffold_config.model.connection.needs_order_expressions_in_select?
+
+      order_expressions = order_select_expressions(sorting)
+      return query if order_expressions.empty?
+
+      select_columns = query.select_values
+      select_columns = ["#{active_scaffold_config.model.quoted_table_name}.*"] if select_columns.empty?
+      query.reselect(*(select_columns + order_expressions).uniq)
+    end
+
+    def order_select_expressions(sorting)
+      Array(sorting&.clause).flat_map { |order| order.is_a?(Hash) ? order.keys : [] }
+    end
+
     def count_items(query, find_options = {}, count_includes = nil)
       count_includes ||= find_options[:includes] if find_options[:conditions].present?
       options = find_options.except(:select, :reorder, :order)
@@ -671,31 +690,54 @@ module ActiveScaffold
       find_options = finder_options(options)
       query = filtered_query
       query = query.where(nil) if active_scaffold_config.active_record? # where(nil) is needed because we need a relation
+      count_query = query
 
       # NOTE: we must use :include in the count query, because some conditions may reference other tables
-      if options[:pagination] && options[:pagination] != :infinite
+      count_after_first_page = count_after_loading_first_page?(options)
+      if options[:pagination] && options[:pagination] != :infinite && !count_after_first_page
         count = count_items(query, find_options, options[:count_includes])
       end
 
       query = append_to_query(query, find_options)
+      query = add_order_expressions_to_select(query, options[:sorting])
+      first_page_items = load_page_for_delayed_count(query, options[:per_page]) if count_after_first_page
+      if first_page_items
+        count = first_page_items.size
+        count = count_items(count_query, find_options, options[:count_includes]) if count == options[:per_page]
+      end
       # we build the paginator differently for method- and sql-based sorting
       pager = if options[:sorting]&.sorts_by_method?
                 ::Paginator.new(count, options[:per_page]) do |offset, per_page|
                   calculate_last_modified(query)
                   sorted_collection = sort_collection_by_column(query.to_a, *options[:sorting].first)
-                  sorted_collection = sorted_collection.slice(offset, per_page) if options[:pagination]
+                  sorted_collection = sorted_collection.slice(offset, per_page) || [] if options[:pagination]
                   sorted_collection
                 end
               else
                 ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-                  query = append_to_query(query, offset: offset, limit: per_page) if options[:pagination]
-                  calculate_last_modified(query)
-                  query
+                  if first_page_items && offset.zero?
+                    first_page_items
+                  else
+                    page_query = options[:pagination] ? append_to_query(query, offset: offset, limit: per_page) : query
+                    calculate_last_modified(page_query)
+                    page_query
+                  end
                 end
               end
       pager.page(options[:page])
     end
 
+    def count_after_loading_first_page?(options)
+      active_scaffold_config.active_record? && options[:pagination] && options[:pagination] != :infinite && options[:page].to_i == 1 &&
+        !options[:sorting]&.sorts_by_method?
+    end
+
+    def load_page_for_delayed_count(query, per_page)
+      page_query = append_to_query(query, offset: 0, limit: per_page)
+      calculate_last_modified(page_query)
+      page_query.to_a
+    end
+
     def calculate_last_modified(query)
       return unless conditional_get_support? && ActiveScaffold::OrmChecks.columns_hash(query.klass)['updated_at']
 
@@ -730,8 +772,11 @@ module ActiveScaffold
           rel.send(k, v)
         end
       end
-      relation.distinct_value = true if options[:left_outer_joins].present? || options[:left_joins].present?
-      relation
+      distinct_query?(options) ? relation.distinct : relation
+    end
+
+    def distinct_query?(options)
+      options[:left_outer_joins].present? || options[:left_joins].present?
     end
 
     def joins_for_finder
@@ -759,7 +804,7 @@ module ActiveScaffold
     def sort_collection_by_column(collection, column, order)
       sorter = column.sort[:method]
       collection = collection.sort_by do |record|
-        value = sorter.is_a?(Proc) ? record.instance_exec(record, &sorter) : record.instance_eval(sorter.to_s)
+        value = sorter.is_a?(Proc) ? record.instance_exec(record, &sorter) : record.send(sorter)
         value = '' if value.nil?
         value
       end

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -26,8 +26,8 @@ module ActiveScaffold
         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 })
+        html = as_element :dynamic_action_group, **ul_options do
+          safe_join(links.map { |link| as_element :dynamic_action_group_element, link })
         end
         raw "ActiveScaffold.display_dynamic_action_group('#{get_action_link_id action_link, record}', '#{escape_javascript html}');" # rubocop:disable Rails/OutputSafety
       end
@@ -77,8 +77,7 @@ module ActiveScaffold
       end
 
       def display_action_link_separator(options)
-        tag = options[:level_0_tag] || :a if options[:level].zero?
-        content_tag(tag || :li, ' '.html_safe, class: 'separator')
+        as_element(:action_link_separator, ' '.html_safe, proc_options: options)
       end
 
       def display_click_menu_link(link, record, options)
@@ -99,25 +98,36 @@ module ActiveScaffold
 
       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'
-            group_tag = :div
-          else
-            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
-            content_tag(:div, link.label(record), class: link.css_class, title: options[:title]) << content_tag(:ul, content)
-          end
+          content = render_action_link_group(link, content, record, options)
         else
           content = render_action_link(link, record, options)
-          content = content_tag(:li, content, class: ('top' if options[:first_action])) unless options[:level].zero?
+          unless options[:level].zero?
+            context = {link: link, record: record, options: options}
+            content = as_element(
+              :action_link_item,
+              content,
+              proc_options: context,
+              class: ('top' if options[:first_action])
+            )
+          end
         end
         content = content_tag(options[:level_0_tag], content, options[:options_level_0_tag]) if options[:level].zero? && options[:level_0_tag]
         content
       end
 
+      def render_action_link_group(link, content, record, options, group_label: nil)
+        context = options.merge(link: link, record: record)
+        as_element(:action_link_group, proc_options: context) do
+          as_element(
+            :action_link_group_title,
+            group_label || link.label(record),
+            proc_options: context,
+            class: link.css_class,
+            title: options[:title]
+          ) << as_element(:action_link_group_content, content, proc_options: context)
+        end
+      end
+
       def render_action_link(link, record = nil, options = {})
         if link.action.nil? || link.column&.association&.polymorphic?
           link = action_link_to_inline_form(link, record) if link.column&.association
@@ -167,6 +177,7 @@ module ActiveScaffold
           class: html_class,
           title: cache ? '--REASON--' : options[:not_authorized_reason]
         }
+        html_options = action_link_element_attributes(link, record, options, html_options, authorized: false)
         html = action_link_html(link, nil, html_options, record)
         cache ? html.to_str : html
       end
@@ -175,10 +186,16 @@ module ActiveScaffold
         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_options = action_link_element_attributes(link, record, options, html_options, authorized: true)
         html = action_link_html(link, url, html_options, record)
         cache ? html.to_str : html
       end
 
+      def action_link_element_attributes(link, record, options, attributes, authorized:)
+        context = {link: link, record: record, options: options, authorized: authorized}
+        as_element_attributes(:action_link, proc_options: context, **attributes)
+      end
+
       # setup the action link to inline form
       def action_link_to_inline_form(link, record)
         link = link.dup
@@ -302,12 +319,20 @@ module ActiveScaffold
 
       def column_in_params_conditions?(key)
         if key.match?(/!$/)
-          conditions_from_params[1..].any? { |node| node.left.name.to_s == key[0..-2] }
+          conditions_from_params[1..].any? { |node| condition_node_for_column?(node, key[0..-2]) }
         else
           conditions_from_params[0].include?(key)
         end
       end
 
+      def condition_node_for_column?(node, column_name)
+        return node.name.to_s == column_name if node.is_a?(Arel::Attributes::Attribute)
+
+        %i[expr left right].any? do |child|
+          node.respond_to?(child) && condition_node_for_column?(node.public_send(child), column_name)
+        end
+      end
+
       def ignore_param_for_nested?(key)
         NESTED_PARAMS.include?(key) || column_in_params_conditions?(key) || (nested? && nested.param_name == key)
       end
@@ -335,7 +360,7 @@ module ActiveScaffold
           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
+          # pass the current path as return_to, for nested listing on singular association, so forms don't return to parent listing
           @query_string_params << :return_to
           non_nested_query_string_options[:return_to] = request.fullpath
         end

data/lib/active_scaffold/helpers/assets_helpers.rb

@@ -8,7 +8,7 @@ module ActiveScaffold
         js_tags << active_scaffold_javascript_config
         unless defined?(Importmap)
           # Without importmap, active_scaffold/load must be added to the layout too
-          js_tags << javascript_include_tag('active_scaffold/load')
+          js_tags << javascript_include_tag('active_scaffold/load', nonce: true)
         end
         safe_join js_tags
       end
@@ -22,16 +22,16 @@ module ActiveScaffold
           plugins: ActiveScaffold.javascripts.map { |asset| asset_path(asset, extname: '.js') }
         )
         if ActiveScaffold.jquery_ui_included?
-          config[:datepickerLocalization] = ActiveScaffold::Assets.active_scaffold_js_code(:jquery_ui)
+          config[:datepickerLocalization] = ActiveScaffold::Bridges[:date_picker].localization_data
         end
 
         if Object.const_defined?(:Jquery) && Jquery.const_defined?(:Ui)
           config[:jqueryUi] = ActiveScaffold::Assets::JqueryUiManifest.all_dependencies.map { |asset| asset_path(asset, extname: '.js') }
         end
 
-        javascript_tag <<~JS
+        javascript_tag(<<~JS, nonce: true)
           window.ActiveScaffold = window.ActiveScaffold || {};
-          window.ActiveScaffold.config = #{config.to_json};
+          window.ActiveScaffold.config = #{json_escape config.to_json};
         JS
       end
     end

data/lib/active_scaffold/helpers/filter_helpers.rb

@@ -5,8 +5,8 @@ module ActiveScaffold
     # 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
+        active_scaffold_config.list.filters.to_h do |filter|
+          [filter.name, nil]
         end
       end
 
@@ -14,7 +14,7 @@ module ActiveScaffold
         return unless filters_enabled?
 
         content = render_filters filters
-        content_tag :div, content, class: 'filters' if content.present?
+        as_element :filters, content if content.present?
       end
 
       def render_filters(filters)

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -79,14 +79,16 @@ module ActiveScaffold
       end
 
       def active_scaffold_subform_record_actions(association_column, record, locked, scope)
-        return unless association_column.association.collection? && !locked
+        # association_column nil when called for batch_create for example
+        return if locked || association_column&.association&.singular?
 
-        auth = %i[destroy delete_all delete].exclude?(association_column.association.dependent)
+        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')
+          attributes = as_element_attributes(:subform_record_remove, class: 'destroy')
+          link_to(as_(:remove), '#', attributes)
         else
-          content_tag :span, reason, class: 'destroy reason'
+          as_element(:subform_record_remove_reason, reason)
         end
       end
 
@@ -121,7 +123,9 @@ module ActiveScaffold
 
         collapsible_id = "container_#{id_control}" if (column.form_ui_options || column.options)[:collapsible]
 
-        {name: name, class: classes, id: id_control, collapsible_id: collapsible_id}.merge(options)
+        attributes = {name: name, class: classes, id: id_control, collapsible_id: collapsible_id}.merge(options)
+        context = {column: column, form_ui: column.form_ui}
+        as_element_attributes(:form_control, proc_options: context, **attributes)
       end
 
       def current_form_columns(record, scope, subform_controller = nil)
@@ -174,10 +178,10 @@ module ActiveScaffold
         {}
       end
 
-      def render_subsection(column, record, scope, form_action, partial: 'form')
-        subsection_id = sub_section_id(sub_section: column.label)
+      def render_subsection(column, record, scope, form_action, partial: 'form', subsection_id: nil, &)
+        subsection_id ||= sub_section_id(sub_section: column.label)
         locals = {columns: column, form_action: form_action, scope: scope}
-        header = content_tag(:h5) do
+        header = as_element(:form_subsection_header) do
           h(column.label) <<
             link_to_visibility_toggle(subsection_id, default_visible: !column.collapsed)
         end
@@ -188,6 +192,8 @@ module ActiveScaffold
               render partial, locals.merge(subsection_id: "#{subsection_id}-#{tab_id}", tab_id: tab_id, tab_value: tab_value)
             end
           end
+        elsif block_given?
+          header << capture(subsection_id, &)
         else
           header << render(partial, locals.merge(subsection_id: subsection_id))
         end
@@ -217,6 +223,8 @@ module ActiveScaffold
         end
       end
 
+      def form_ui_class(form_ui) = form_ui
+
       def form_column_is_hidden?(column, record, scope = nil) # rubocop:disable Naming/PredicateMethod
         if column.clear_form_column_if.nil?
           condition_to_hide = column.hide_form_column_if
@@ -238,35 +246,38 @@ module ActiveScaffold
 
       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?
+        as_element(:form_field_description, h(desc) + as_element(:form_field_description_close)) if desc.present?
       end
 
-      def form_attribute(column, record, scope = nil, only_value = false, col_class = nil, form_columns: nil)
+      def form_attribute(column, record, scope = nil, only_value = false, col_class = nil, form_columns: nil, field: 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, show_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
-            method = column.association ? column.association.foreign_key : column.name
-            field << hidden_field(:record, method, column_options)
+            field << hidden_field(:record, column.association&.foreign_key || column.name, column_options)
           end
         else
-          field = active_scaffold_input_for column, scope, column_options, form_columns: form_columns
-        end
-        if field
-          field << loading_indicator_tag(action: :render_field, id: params[:id]) if column.update_columns
-          desc = column_description(column, record, scope)
-          field << desc if desc.present?
+          field ||= active_scaffold_input_for column, scope, column_options, form_columns: form_columns
         end
+        field << loading_indicator_tag(action: :render_field, id: params[:id]) if field && column.update_columns
+        description = column_description(column, record, scope)
 
         label = label_tag(label_for(column, column_options), form_column_label(column, record, scope))
         label << h(' ') << link_to_visibility_toggle(collapsible_id) if collapsible_id
-        content_tag :dl, attributes do
-          content_tag(:dt, label) << content_tag(:dd, field, id: collapsible_id)
+        form_attribute_html(column, label, field, description, attributes, collapsible_id: collapsible_id)
+      end
+
+      def form_attribute_html(column, label, field, description, attributes, collapsible_id: nil)
+        (field ||= h('')) << description if description.present?
+        context = {column: column}
+        as_element :form_attribute, proc_options: context, **attributes do
+          as_element(:form_attribute_label, label, proc_options: context) <<
+            as_element(:form_attribute_field, field, proc_options: context, id: collapsible_id)
         end
       end
 
@@ -322,7 +333,8 @@ module ActiveScaffold
 
       # Should this column be displayed in the subform?
       def in_subform?(column, parent_record, parent_column)
-        return true unless column.association
+        # parent_column nil when called for batch_create for example
+        return true if parent_column.nil? || column.association.nil?
 
         if column.association.reverse.nil?
           # Polymorphic associations can't appear because they *might* be the reverse association

data/lib/active_scaffold/helpers/form_ui_helpers.rb

@@ -27,18 +27,23 @@ module ActiveScaffold
 
       def active_scaffold_input_singular_association(column, html_options, options = {}, ui_options: column.options)
         record = html_options.delete(:object)
-        associated = html_options.include?(:associated) ? html_options.delete(:associated) : record.send(column.association.name)
-
         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)
+
+        if html_options.include?(:associated)
+          options[:selected] ||= html_options.delete(:associated)
+        else
+          associated = record.send(column.association.name)
+          select_options.unshift(associated) if associated&.persisted? && select_options.exclude?(associated)
+          options[:selected] ||= associated&.id
+        end
 
         method = column.name
-        options.merge! selected: associated&.id, include_blank: as_(:_select_), object: record
+        options.reverse_merge! include_blank: as_(:_select_), object: record
 
         html_options.merge!(ui_options[:html_options] || {})
         options.merge!(ui_options)
-        html_options.delete(:multiple) # no point using multiple in a form for singular assoc, but may be set for field search
+        active_scaffold_select_name_with_multiple html_options # doesn't make sense most of time, but AS_batch use it
         active_scaffold_translate_select_options(options)
 
         html =
@@ -101,7 +106,7 @@ module ActiveScaffold
         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')
+        link_to(link_text, url_options, as_element_attributes(:field_add_new_popup, 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)
@@ -141,7 +146,7 @@ module ActiveScaffold
         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')
+        link_to(label, '#', as_element_attributes(:field_add_new_subform, data: data, class: 'show-new-subform'))
       end
 
       def active_scaffold_file_with_content(column, options, content, remove_file_prefix, controls_class, ui_options: column.options)
@@ -237,8 +242,8 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_checkbox_option(option, label_method, associated_ids, checkbox_options, li_options = {})
-        content_tag(:li, li_options) do
+      def active_scaffold_checkbox_option(option, label_method, associated_ids, checkbox_options, item_options = {})
+        content_tag(:li, item_options) do
           option_id = option.is_a?(Array) ? option[1] : option.id
           label = option.is_a?(Array) ? option[0] : option.send(label_method)
           check_box_tag(checkbox_options[:name], option_id, associated_ids.include?(option_id), checkbox_options) <<
@@ -261,7 +266,7 @@ module ActiveScaffold
         html << content_tag(:ul, options.merge(class: "#{options[:class]} checkbox-list#{' draggable-lists' if draggable}")) do
           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")
+            content << active_scaffold_checkbox_option(option, label_method, associated_ids, {name: "#{options[:name]}[]", id: "#{options[:id]}_#{i}_id"}, ui_options[:item_options] || {})
           end
           safe_join content
         end

data/lib/active_scaffold/helpers/framework_ui_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveScaffold
+  module Helpers
+    module FrameworkUiHelpers
+      def as_element(key, content = nil, proc_options: {}, **options, &)
+        tag, attributes = as_tag_and_attributes(key, options, proc_options)
+        content_tag(tag, content, attributes, &)
+      end
+
+      def as_element_attributes(key, proc_options: {}, **options)
+        as_tag_and_attributes(key, options, proc_options).last
+      end
+
+      def as_tag_and_attributes(key, options, proc_options = {})
+        tag, attributes, proc = ActiveScaffold.ui_elements[key]&.values_at(:tag, :attributes, :proc)
+        tag, attributes = instance_exec(proc_options, &proc) if proc
+        [tag, attributes&.smart_merge(options) || options&.as_html_attrs]
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -72,6 +72,7 @@ module ActiveScaffold
       alias active_scaffold_human_condition_time active_scaffold_human_condition_datetime
       alias active_scaffold_human_condition_date active_scaffold_human_condition_datetime
       alias active_scaffold_human_condition_timestamp active_scaffold_human_condition_datetime
+      alias active_scaffold_human_condition_timestamptz active_scaffold_human_condition_datetime
 
       def active_scaffold_human_condition_datetime_range_format(range_type, range)
         case range