active_scaffold 4.3.2 → 4.4.1

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 = safe_join([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 = safe_join([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 = safe_join([field, description].compact) 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

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -431,6 +431,24 @@ module ActiveScaffold
         data
       end
 
+      def local_sorting?
+        @page&.pager&.number_of_pages == 1 && active_scaffold_config.list.local_sorting
+      end
+
+      def column_sort_value(record, column)
+        value = record.send(column.name)
+        return if value.nil?
+
+        case column.column.type
+        when :time, :datetime, Time then value.to_i
+        when :boolean then value ? 1 : 0
+        when :binary then nil
+        when :integer then value
+        when :float, :decimal then (value % 1).zero? ? value.to_i : value
+        else value.to_s
+        end
+      end
+
       # MARK
 
       def all_marked?
@@ -465,6 +483,7 @@ module ActiveScaffold
         elsif column.inplace_edit
           tag_options[:data] = inplace_edit_data(column)
         end
+
         content_tag(:th, column_heading_value(column, sorting, sort_direction) + inplace_edit_control(column), tag_options)
       end
 

data/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -3,8 +3,13 @@
 module ActiveScaffold
   module Helpers
     module PaginationHelpers
-      def pagination_ajax_link(page_number, url_options, options)
-        link_to page_number, url_options.merge(page: page_number), options.merge(class: 'as_paginate')
+      def pagination_ajax_link(page_number, url_options, options, text: nil)
+        attributes = as_element_attributes(
+          :pagination_link,
+          proc_options: {page_number: page_number, text: text},
+          **options.smart_merge(class: 'as_paginate')
+        )
+        link_to text ? as_(text) : page_number, url_options.merge(page: page_number), attributes
       end
 
       def pagination_url_options(url_options = nil)
@@ -17,6 +22,22 @@ module ActiveScaffold
         url_options
       end
 
+      def pagination_active_page(page_number, url_options, options)
+        attributes = options.slice(:id, :class).smart_merge(class: 'as_paginate current')
+        as_element :pagination_active_page, page_number,
+                   proc_options: {page_number: page_number}, **attributes
+      end
+
+      def pagination_gap(options)
+        '..'
+      end
+
+      # Wraps the complete pagination sequence, including previous and next links.
+      # UI adapters may override this method and call +super+ to add nested markup.
+      def pagination_html(&)
+        capture(&)
+      end
+
       def pagination_ajax_links(current_page, url_options, options, inner_window, outer_window)
         start_number = current_page.number - inner_window
         end_number = current_page.number + inner_window
@@ -42,16 +63,16 @@ module ActiveScaffold
             page = current_page.number - offset
             next unless page < start_number && page > last_page
 
-            html << '..' if page > last_page + 1
+            html << pagination_gap(options) if page > last_page + 1
             html << pagination_ajax_link(page, url_options, options)
             last_page = page
           end
         end
-        html << '..' if start_number > last_page + 1
+        html << pagination_gap(options) if start_number > last_page + 1
 
         [start_number, last_page + 1].max.upto(end_number) do |num|
           html << if current_page.number == num
-                    content_tag(:span, num.to_s, class: 'as_paginate current')
+                    pagination_active_page(num, url_options, options)
                   else
                     pagination_ajax_link(num, url_options, options)
                   end
@@ -59,10 +80,10 @@ module ActiveScaffold
 
         if current_page.pager.infinite?
           offsets.each do |offset|
-            html << '..' << pagination_ajax_link(current_page.number + offset, url_options, options)
+            html << pagination_gap(options) << pagination_ajax_link(current_page.number + offset, url_options, options)
           end
         else
-          html << '..' unless end_number >= current_page.pager.last.number - outer_window - 1
+          html << pagination_gap(options) unless end_number >= current_page.pager.last.number - outer_window - 1
           [end_number + 1, current_page.pager.last.number - outer_window].max.upto(current_page.pager.last.number) do |num|
             html << pagination_ajax_link(num, url_options, options)
           end

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -50,14 +50,29 @@ module ActiveScaffold
 
       # the standard active scaffold options used for class, name and scope
       def active_scaffold_search_options(column)
-        {name: "search[#{column.name}]", class: "#{column.name}-input", id: "search_#{column.name}", value: field_search_params[column.name.to_s]}
+        attributes = {
+          name: "search[#{column.name}]",
+          class: "#{column.name}-input",
+          id: "search_#{column.name}",
+          value: field_search_params[column.name.to_s]
+        }
+        as_element_attributes(:search_control, proc_options: {column: column, search_ui: column.search_ui}, **attributes)
       end
 
       def search_attribute(column, record)
         column_options = active_scaffold_search_options(column).merge(object: record)
-        content_tag :dl do
-          content_tag(:dt, label_tag(search_label_for(column, column_options), search_column_label(column, record))) <<
-            content_tag(:dd, active_scaffold_search_for(column, column_options))
+        search_attribute_html(
+          column,
+          label_tag(search_label_for(column, column_options), search_column_label(column, record)),
+          active_scaffold_search_for(column, column_options)
+        )
+      end
+
+      def search_attribute_html(column, label, field)
+        context = {column: column}
+        as_element :search_attribute, proc_options: context do
+          as_element(:search_attribute_label, label, proc_options: context) <<
+            as_element(:search_attribute_field, field, proc_options: context)
         end
       end
 
@@ -156,7 +171,7 @@ module ActiveScaffold
         select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
         select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 
-        select_tag(options[:name], options_for_select(select_options, ActiveScaffold::Core.column_type_cast(options[:value], column.column)), id: options[:id])
+        select_tag(options[:name], options_for_select(select_options, ActiveScaffold::Core.column_type_cast(options[:value], column.column, column.model)), id: options[:id])
       end
       # we can't use checkbox ui because it's not possible to decide whether search for this field or not
       alias active_scaffold_search_checkbox active_scaffold_search_boolean
@@ -296,6 +311,7 @@ module ActiveScaffold
       def active_scaffold_search_timestamp(column, options, ui_options: column.options)
         active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :datetime)
       end
+      alias active_scaffold_search_timestamptz active_scaffold_search_timestamp
 
       def active_scaffold_search_time(column, options, ui_options: column.options)
         active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :time)
@@ -425,6 +441,17 @@ module ActiveScaffold
         [visibles, hiddens]
       end
 
+      def render_field_search_column(column, record)
+        column_css_class = column.css_class unless column.css_class.is_a?(Proc)
+        if column.respond_to? :each_column
+          as_element :field_search_subsection, class: column_css_class do
+            render_subsection column, record, nil, :field_search, partial: 'field_search_columns'
+          end
+        else
+          as_element :field_search_element, search_attribute(column, record), class: "form-element #{column_css_class}"
+        end
+      end
+
       def searched_by?(column)
         value = field_search_params[column.name.to_s]
         case value

data/lib/active_scaffold/helpers/tabs_helpers.rb

@@ -10,9 +10,11 @@ module ActiveScaffold
         tab_options = send(override_helper_per_model(:active_scaffold_tab_options, record.class), column, record)
         used_tabs = send(override_helper_per_model(:active_scaffold_current_tabs, record.class), column, record, tab_options)
         input_helper = override_helper_per_model(:active_scaffold_input_for_tabbed, record.class)
-        send(input_helper, column, record, subsection_id, tab_options, used_tabs.map(&:first)) <<
-          active_scaffold_refresh_link(nil, {'data-update_url' => url_for(add_tab_url)}, record, refresh_opts) <<
-          active_scaffold_tabs_for(column, record, subsection_id, tab_options, used_tabs, &)
+        safe_join([
+                    send(input_helper, column, record, subsection_id, tab_options, used_tabs.map { |v, _| v }),
+                    active_scaffold_refresh_link(nil, {'data-update_url' => url_for(add_tab_url)}, record, refresh_opts),
+                    active_scaffold_tabs_for(column, record, subsection_id, tab_options, used_tabs, &)
+                  ])
       end
 
       def active_scaffold_input_for_tabbed(column, record, subsection_id, tab_options, used_tabs)
@@ -32,8 +34,6 @@ module ActiveScaffold
           tab_values = record.send(col.name).map(&tabbed_by).compact
           if tabbed_by_association(col, tabbed_by)
             tab_values.map! { |value| [value, value.id.to_s] }
-          else
-            tab_values.map! { |value| [tab_options.find { |_, tab_value, _| value == tab_value }&.first || value, value] }
           end
           used_choices.merge tab_values
         end
@@ -41,7 +41,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_tab_options(column, record)
-        subform_column = column.first
+        subform_column = column.visible_columns.first
         if subform_column
           tabbed_by = subform_column.options[:tabbed_by] || column.tabbed_by
           if tabbed_by_association(subform_column, tabbed_by)
@@ -51,7 +51,7 @@ module ActiveScaffold
         end
         if tab_column
           label_method = (tab_column.form_ui_options || tab_column.options)[:label_method] || :to_label
-          helper_method = association_helper_method(column.association, :sorted_association_options_find)
+          helper_method = association_helper_method(tab_column.association, :sorted_association_options_find)
           send(helper_method, tab_column.association, nil, subform_record).map do |opt_record|
             [opt_record.send(label_method), opt_record.id, opt_record]
           end

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -18,6 +18,7 @@ module ActiveScaffold
       include ActiveScaffold::Helpers::SearchColumnHelpers
       include ActiveScaffold::Helpers::HumanConditionHelpers
       include ActiveScaffold::Helpers::FilterHelpers
+      include ActiveScaffold::Helpers::FrameworkUiHelpers
 
       ##
       ## Delegates
@@ -31,6 +32,12 @@ module ActiveScaffold
       ## Uncategorized
       ##
 
+      # UI adapters may override this method and call +super+ to wrap the table,
+      # for example in a responsive-table container.
+      def list_table_html(&)
+        capture(&)
+      end
+
       def handle_exception_on_column(exception, column, record = nil)
         raise exception if exception.instance_variable_get(:@_active_scaffold_wrapped)
 
@@ -126,6 +133,7 @@ module ActiveScaffold
       def column_heading_class(column, sorting)
         classes = "#{column.name}-column_heading "
         classes << "sorted #{sorting.direction_of(column).downcase} " if sorting.sorts_on? column
+        classes << 'skip-local-sorting' if column.skip_local_sorting?
         classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
         classes
       end
@@ -140,6 +148,10 @@ module ActiveScaffold
         params[:eid] ? {eid: id_from_controller(params[:eid])} : {}
       end
 
+      def server_error_msg(content = nil, **attributes, &)
+        as_element :server_error, content, **attributes, &
+      end
+
       def column_empty?(column_value)
         @_empty_values ||= ['&nbsp;', empty_field_text].compact
         empty = column_value.nil?

data/lib/active_scaffold/tableless.rb

@@ -24,16 +24,19 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
 
   class Column < ActiveRecord::ConnectionAdapters::Column
     def initialize(name, default, type, null = true, *, **) # rubocop:disable Style/OptionalBooleanParameter,Metrics/ParameterLists
-      if Rails.version >= '8.1'
-        if type.is_a?(Symbol)
-          cast_type = ActiveRecord::Type.lookup(type)
-        else
-          metadata = ActiveRecord::Base.connection.send :fetch_type_metadata, type
-          cast_type = ActiveRecord::Type.lookup(metadata.type)
-        end
+      connection = ActiveRecord::Base.connection
+      sql_type = type.is_a?(Symbol) ? connection.type_to_sql(type) : type.to_s
+      cast_type = connection.send(:lookup_cast_type, sql_type)
+      metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
+        sql_type: sql_type,
+        type: cast_type.type,
+        limit: cast_type.limit,
+        precision: cast_type.precision,
+        scale: cast_type.scale
+      )
+      if ActiveRecord.version >= Gem::Version.new('8.1')
         super(name, cast_type, default, metadata, null, *, **)
       else
-        metadata = ActiveRecord::Base.connection.send :fetch_type_metadata, type.to_s
         super(name, default, metadata, null, *, **)
       end
     end

data/lib/active_scaffold/version.rb

@@ -3,8 +3,8 @@
 module ActiveScaffold
   module Version
     MAJOR = 4
-    MINOR = 3
-    PATCH = 2
+    MINOR = 4
+    PATCH = 1
     FIX = nil
 
     STRING = [MAJOR, MINOR, PATCH, FIX].compact.join('.')