active_scaffold 3.6.20 → 3.7.1

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -19,7 +19,7 @@ module ActiveScaffold
 
         # second, check if the dev has specified a valid form_ui for this column
         elsif column.form_ui && (method = override_input(column.form_ui))
-          send(method, column, options)
+          send(method, column, options, ui_options: (column.form_ui_options || column.options).except(:collapsible))
 
         elsif column.association
           # if we get here, it's because the column has a form_ui but not one ActiveScaffold knows about.
@@ -32,16 +32,15 @@ module ActiveScaffold
           options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
           active_scaffold_input_virtual(column, options)
 
-        elsif (method = override_input(column.column.type)) # regular model attribute column
+        elsif (method = override_input(column.column_type)) # regular model attribute column
           # if we (or someone else) have created a custom render option for the column type, use that
           send(method, column, options)
 
         else # final ultimate fallback: use rails' generic input method
           # for textual fields we pass different options
-          text_types = %i[text string integer float decimal]
-          options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
-          if column.column.type == :string && options[:maxlength].blank?
-            options[:maxlength] = column.column.limit
+          options = active_scaffold_input_text_options(options) if column.text? || column.number?
+          if column.column_type == :string && options[:maxlength].blank?
+            options[:maxlength] = column.type_for_attribute.limit
             options[:size] ||= options[:maxlength].to_i > 30 ? 30 : options[:maxlength]
           end
           options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
@@ -107,7 +106,11 @@ module ActiveScaffold
         classes = "#{column.name}-input"
         classes += ' numeric-input' if column.number?
 
-        {:name => name, :class => classes, :id => id_control}.merge(options)
+        if (column.form_ui_options || column.options)[:collapsible]
+          collapsible_id = "container_#{id_control}"
+        end
+
+        {name: name, class: classes, id: id_control, collapsible_id: collapsible_id}.merge(options)
       end
 
       def current_form_columns(record, scope, subform_controller = nil)
@@ -120,15 +123,15 @@ module ActiveScaffold
         end
       end
 
-      def update_columns_options(column, scope, options, force = false)
+      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
+          form_columns ||= @main_columns.visible_columns_names
         end
         form_columns ||= current_form_columns(record, scope, subform_controller)
         if force || (form_columns && column.update_columns && (column.update_columns & form_columns).present?)
-          url_params = params_for(:action => 'render_field', :column => column.name, :id => record.to_param)
+          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)
@@ -153,7 +156,14 @@ module ActiveScaffold
       end
 
       def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil) # rubocop:disable Metrics/ParameterLists
-        if (partial = override_form_field_partial(column))
+        if form_column_is_hidden?(column, record, scope)
+          # creates an element that can be replaced by the update_columns routine,
+          # but will not affect the value of the submitted form in this state:
+          # <dl><input type="hidden" class="<%= column.name %>-input"></dl>
+          content_tag :dl, style: 'display: none' do
+            hidden_field_tag(nil, nil, :class => "#{column.name}-input")
+          end
+        elsif (partial = override_form_field_partial(column))
           render :partial => partial, :locals => {:column => column, :only_value => only_value, :scope => scope, :col_class => col_class, :record => record}
         elsif renders_as == :field || override_form_field?(column)
           form_attribute(column, record, scope, only_value, col_class)
@@ -164,8 +174,19 @@ module ActiveScaffold
         end
       end
 
+      def form_column_is_hidden?(column, record, scope = nil)
+        if column.hide_form_column_if&.respond_to?(:call)
+          column.hide_form_column_if.call(record, column, scope)
+        elsif column.hide_form_column_if&.is_a?(Symbol)
+          record.send(column.hide_form_column_if)
+        else
+          column.hide_form_column_if
+        end
+      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
@@ -181,12 +202,14 @@ module ActiveScaffold
         end
         if field
           field << loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns
-          field << content_tag(:span, column.description, :class => 'description') if column.description.present?
+          desc = column.description(record, scope)
+          field << content_tag(:span, desc, :class => 'description') if desc.present?
         end
 
+        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_tag(label_for(column, column_options), form_column_label(column))) <<
-            content_tag(:dd, field)
+          content_tag(:dt, label) << content_tag(:dd, field, id: collapsible_id)
         end
       end
 
@@ -194,8 +217,8 @@ module ActiveScaffold
         options[:id] unless column.form_ui == :select && column.association&.collection?
       end
 
-      def form_column_label(column)
-        column.label
+      def form_column_label(column, record = nil, scope = nil)
+        column.label(record, scope)
       end
 
       def subform_label(column, hidden)
@@ -286,7 +309,7 @@ module ActiveScaffold
         options[:name] = "#{options[:name]}[]"
       end
 
-      def active_scaffold_input_singular_association(column, html_options, options = {})
+      def active_scaffold_input_singular_association(column, html_options, options = {}, ui_options: column.options)
         record = html_options.delete(:object)
         associated = record.send(column.association.name)
 
@@ -296,27 +319,27 @@ module ActiveScaffold
         method = column.name
         options.merge! :selected => associated&.id, :include_blank => as_(:_select_), :object => record
 
-        html_options.merge!(column.options[:html_options] || {})
-        options.merge!(column.options)
-        active_scaffold_select_name_with_multiple html_options
+        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_translate_select_options(options)
 
         html =
           if (optgroup = options.delete(:optgroup))
             select(:record, method, active_scaffold_grouped_options(column, select_options, optgroup), options, html_options)
           else
-            collection_select(:record, method, select_options, :id, column.options[:label_method] || :to_label, options, html_options)
+            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) if column.options[:refresh_link]
-        html << active_scaffold_new_record_subform(column, record, html_options) if column.options[:add_new]
+        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
       end
 
-      def active_scaffold_new_record_subform(column, record, html_options, new_record_attributes: nil, locals: {}, skip_link: false) # rubocop:disable Metrics/ParameterLists
+      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? && (column.options[:add_new] == true || type.in?(column.options[:add_new]))
+            column.association.klass(record) if type.present? && (ui_options[:add_new] == true || type.in?(ui_options[:add_new]))
           else
             column.association.klass
           end
@@ -331,8 +354,8 @@ 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), locals: locals)
-        if column.options[:hide_subgroups]
+        subform = render(partial: subform_partial_for_column(column, klass, ui_options: ui_options), locals: locals)
+        if ui_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
@@ -347,8 +370,8 @@ 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, &block) # rubocop:disable Metrics/ParameterLists
-        options = active_scaffold_input_text_options(options.merge(column.options))
+      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, ui_options: column.options, &block) # rubocop:disable Metrics/ParameterLists
+        options = active_scaffold_input_text_options(options.merge(ui_options))
         if content
           active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class, &block)
         else
@@ -381,7 +404,7 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_refresh_link(column, html_options, record)
+      def active_scaffold_refresh_link(column, html_options, record, ui_options = {})
         link_options = {:object => record}
         if html_options['data-update_url']
           link_options['data-update_send_form'] = html_options['data-update_send_form']
@@ -391,7 +414,12 @@ module ActiveScaffold
           link_options = update_columns_options(column, scope.presence, link_options, true)
         end
         link_options[:class] = 'refresh-link'
-        link_to(as_(:refresh), link_options.delete('data-update_url') || html_options['data-update_url'], link_options)
+        if ui_options[:refresh_link].is_a?(Hash)
+          text = ui_options.dig(:refresh_link, :text)
+          text = as_(text) if text.is_a?(Symbol)
+          link_options.merge! ui_options[:refresh_link].except(:text)
+        end
+        link_to(text || as_(:refresh), link_options.delete('data-update_url') || html_options['data-update_url'], link_options.except(:object))
       end
 
       def active_scaffold_plural_association_options(column, record = nil)
@@ -399,21 +427,29 @@ module ActiveScaffold
         [associated_options, associated_options | sorted_association_options_find(column.association, nil, record)]
       end
 
-      def active_scaffold_input_plural_association(column, options)
+      def active_scaffold_input_plural_association(column, options, ui_options: column.options)
         record = options.delete(:object)
         associated_options, select_options = active_scaffold_plural_association_options(column, record)
 
         html =
-          if select_options.empty?
+          if options[:multiple] || ui_options.dig(:html_options, :multiple)
+            html_options = options.merge(ui_options[:html_options] || {})
+            active_scaffold_select_name_with_multiple html_options
+            collection_select(:record, column.name, select_options, :id, ui_options[:label_method] || :to_label, ui_options.merge(object: record), html_options)
+          elsif select_options.empty?
             content_tag(:span, as_(:no_options), :class => "#{options[:class]} no-options", :id => options[:id]) <<
               hidden_field_tag("#{options[:name]}[]", '', :id => nil)
           else
-            active_scaffold_checkbox_list(column, select_options, associated_options.collect(&:id), options)
+            active_scaffold_checkbox_list(column, select_options, associated_options.collect(&:id), options, ui_options: ui_options)
           end
-        html << active_scaffold_refresh_link(column, options, record) if column.options[:refresh_link]
+        html << active_scaffold_refresh_link(column, options, record, ui_options) if ui_options[:refresh_link]
         html
       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)
+      end
+
       def active_scaffold_checkbox_option(option, label_method, associated_ids, checkbox_options, li_options = {})
         content_tag(:li, li_options) do
           option_id = option.is_a?(Array) ? option[1] : option.id
@@ -423,10 +459,11 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_checkbox_list(column, select_options, associated_ids, options)
-        label_method = column.options[:label_method] || :to_label
+      def active_scaffold_checkbox_list(column, select_options, associated_ids, options, ui_options: column.options)
+        label_method = ui_options[:label_method] || :to_label
         html = hidden_field_tag("#{options[:name]}[]", '', :id => nil)
-        html << content_tag(:ul, options.merge(:class => "#{options[:class]} checkbox-list#{' draggable-lists' if column.options[:draggable_lists]}")) do
+        draggable = options.delete(:draggable_lists) || ui_options[:draggable_lists]
+        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")
@@ -441,37 +478,43 @@ module ActiveScaffold
         [(text.is_a?(Symbol) ? column.active_record_class.human_attribute_name(text) : text), value]
       end
 
-      def active_scaffold_enum_options(column, record = nil)
-        column.options[:options]
+      def active_scaffold_enum_options(column, record = nil, ui_options: column.options)
+        ui_options[:options]
       end
 
-      def active_scaffold_input_enum(column, html_options, options = {})
+      def active_scaffold_input_enum(column, html_options, options = {}, ui_options: column.options)
         record = html_options.delete(:object)
         options[:selected] = record.send(column.name)
         options[:object] = record
-        options_for_select = active_scaffold_enum_options(column, record).collect do |text, value|
+        options_for_select = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
           active_scaffold_translated_option(column, text, value)
         end
-        html_options.merge!(column.options[:html_options] || {})
-        options.merge!(column.options)
+        html_options.merge!(ui_options[:html_options] || {})
+        options.merge!(ui_options)
         active_scaffold_select_name_with_multiple html_options
         active_scaffold_translate_select_options(options)
-        select(:record, column.name, options_for_select, options, html_options)
+        html = select(:record, column.name, options_for_select, options, html_options)
+        html << active_scaffold_refresh_link(column, html_options, record, ui_options) if ui_options[:refresh_link]
+        html
       end
 
-      def active_scaffold_input_select(column, html_options)
+      def active_scaffold_input_select(column, html_options, ui_options: column.options)
         if column.association&.singular?
-          active_scaffold_input_singular_association(column, html_options)
+          active_scaffold_input_singular_association(column, html_options, ui_options: ui_options)
         elsif column.association&.collection?
-          active_scaffold_input_plural_association(column, html_options)
+          active_scaffold_input_plural_association(column, html_options, ui_options: ui_options)
         else
-          active_scaffold_input_enum(column, html_options)
+          active_scaffold_input_enum(column, html_options, ui_options: ui_options)
         end
       end
 
-      def active_scaffold_radio_option(option, selected, column, radio_options)
+      def active_scaffold_input_select_multiple(column, options, ui_options: column.options)
+        active_scaffold_input_select(column, options.merge(multiple: true), ui_options: ui_options)
+      end
+
+      def active_scaffold_radio_option(option, selected, column, radio_options, ui_options: column.options)
         if column.association
-          label_method = column.options[:label_method] || :to_label
+          label_method = ui_options[:label_method] || :to_label
           text = option.send(label_method)
           value = option.id
           checked = {:checked => selected == value}
@@ -485,20 +528,20 @@ module ActiveScaffold
         content_tag(:label, radio_button(:record, column.name, value, radio_options) + text)
       end
 
-      def active_scaffold_input_radio(column, html_options)
+      def active_scaffold_input_radio(column, html_options, ui_options: column.options)
         record = html_options[:object]
-        html_options.merge!(column.options[:html_options] || {})
+        html_options.merge!(ui_options[:html_options] || {})
         options =
           if column.association
             sorted_association_options_find(column.association, nil, record)
           else
-            active_scaffold_enum_options(column, record)
+            active_scaffold_enum_options(column, record, ui_options: ui_options)
           end
 
         selected = record.send(column.association.name) if column.association
         selected_id = selected&.id
         if options.present?
-          if column.options[:add_new]
+          if ui_options[:add_new]
             html_options[:data] ||= {}
             html_options[:data][:subform_id] = active_scaffold_subform_attributes(column)[:id]
             radio_html_options = html_options.merge(class: html_options[:class] + ' hide-new-subform')
@@ -506,37 +549,37 @@ module ActiveScaffold
             radio_html_options = html_options
           end
           radios = options.map do |option|
-            active_scaffold_radio_option(option, selected_id, column, radio_html_options)
+            active_scaffold_radio_option(option, selected_id, column, radio_html_options, ui_options: ui_options)
           end
-          if column.options[:include_blank]
-            label = column.options[:include_blank]
-            label = as_(column.options[:include_blank]) if column.options[:include_blank].is_a?(Symbol)
+          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)
           end
-          if column.options[:add_new]
-            create_new_button = radio_button_tag(html_options[:name], '', selected&.new_record?, html_options.merge(id: nil, class: html_options[:class] + ' show-new-subform'))
+          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, skip_link: true)
+              active_scaffold_new_record_subform(column, record, html_options, ui_options: ui_options, skip_link: true)
           end
           safe_join radios
         else
           html = content_tag(:span, as_(:no_options), :class => "#{html_options[:class]} no-options", :id => html_options[:id])
           html << hidden_field_tag(html_options[:name], '', :id => nil)
-          html << active_scaffold_new_record_subform(column, record, html_options) if column.options[:add_new]
+          html << active_scaffold_new_record_subform(column, record, html_options, ui_options: ui_options) if ui_options[:add_new]
           html
         end
       end
 
-      def active_scaffold_input_checkbox(column, options)
-        check_box(:record, column.name, options.merge(column.options))
+      def active_scaffold_input_checkbox(column, options, ui_options: column.options)
+        check_box(:record, column.name, options.merge(ui_options))
       end
 
-      def active_scaffold_input_password(column, options)
-        active_scaffold_text_input :password_field, column, options.reverse_merge(autocomplete: 'new-password')
+      def active_scaffold_input_password(column, options, ui_options: column.options)
+        active_scaffold_text_input :password_field, column, options.reverse_merge(autocomplete: 'new-password'), ui_options: ui_options
       end
 
-      def active_scaffold_input_textarea(column, options)
-        text_area(:record, column.name, options.merge(:cols => column.options[:cols], :rows => column.options[:rows], :size => column.options[:size]))
+      def active_scaffold_input_textarea(column, options, ui_options: column.options)
+        text_area(:record, column.name, options.merge(cols: ui_options[:cols], rows: ui_options[:rows], size: ui_options[:size]))
       end
 
       def active_scaffold_input_virtual(column, options)
@@ -547,55 +590,55 @@ module ActiveScaffold
       # Sadly, many of them lacks browser support
 
       # A text box, that accepts only valid email address (in-browser validation)
-      def active_scaffold_input_email(column, options)
-        active_scaffold_text_input :email_field, column, options
+      def active_scaffold_input_email(column, options, ui_options: column.options)
+        active_scaffold_text_input :email_field, column, options, ui_options: ui_options
       end
 
       # A text box, that accepts only valid URI (in-browser validation)
-      def active_scaffold_input_url(column, options)
-        active_scaffold_text_input :url_field, column, options
+      def active_scaffold_input_url(column, options, ui_options: column.options)
+        active_scaffold_text_input :url_field, column, options, ui_options: ui_options
       end
 
       # A text box, that accepts only valid phone-number (in-browser validation)
-      def active_scaffold_input_telephone(column, options)
-        active_scaffold_text_input :telephone_field, column, options, :format
+      def active_scaffold_input_telephone(column, options, ui_options: column.options)
+        active_scaffold_text_input :telephone_field, column, options, :format, ui_options: ui_options
       end
 
       # A spinbox control for number values (in-browser validation)
-      def active_scaffold_input_number(column, options)
-        active_scaffold_number_input :number_field, column, options, :format
+      def active_scaffold_input_number(column, options, ui_options: column.options)
+        active_scaffold_number_input :number_field, column, options, :format, ui_options: ui_options
       end
 
       # A slider control for number values (in-browser validation)
-      def active_scaffold_input_range(column, options)
-        active_scaffold_number_input :range_field, column, options, :format
+      def active_scaffold_input_range(column, options, ui_options: column.options)
+        active_scaffold_number_input :range_field, column, options, :format, ui_options: ui_options
       end
 
       # A slider control for number values (in-browser validation)
-      def active_scaffold_number_input(method, column, options, remove_options = nil)
+      def active_scaffold_number_input(method, column, options, remove_options = nil, ui_options: column.options)
         options = numerical_constraints_for_column(column, options)
-        active_scaffold_text_input method, column, options, remove_options
+        active_scaffold_text_input method, column, options, remove_options, ui_options: ui_options
       end
 
-      def active_scaffold_text_input(method, column, options, remove_options = nil)
+      def active_scaffold_text_input(method, column, options, remove_options = nil, ui_options: column.options)
         options = active_scaffold_input_text_options(options)
-        options = options.merge(column.options)
+        options = options.merge(ui_options)
         options = options.except(*remove_options) if remove_options.present?
         send method, :record, column.name, options
       end
 
       # A color picker
-      def active_scaffold_input_color(column, options)
+      def active_scaffold_input_color(column, options, ui_options: column.options)
         html = []
         options = active_scaffold_input_text_options(options)
-        if column.column&.null
+        if column.null?
           no_color = options[:object].send(column.name).nil?
           method = no_color ? :hidden_field : :color_field
-          html << content_tag(:label, check_box_tag('disable', '1', no_color, id: nil, name: nil, class: 'no-color') << " #{as_ column.options[:no_color] || :no_color}")
+          html << content_tag(:label, check_box_tag('disable', '1', no_color, id: nil, name: nil, class: 'no-color') << " #{as_ ui_options[:no_color] || :no_color}")
         else
           method = :color_field
         end
-        html << send(method, :record, column.name, options.merge(column.options).except(:format, :no_color))
+        html << send(method, :record, column.name, options.merge(ui_options).except(:format, :no_color))
         safe_join html
       end
 
@@ -603,34 +646,37 @@ module ActiveScaffold
       # Column.type-based inputs
       #
 
-      def active_scaffold_input_boolean(column, options)
-        record = options.delete(:object)
-        select_options = []
-        select_options << [as_(:_select_), nil] if !column.virtual? && column.column.null
-        select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
-        select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
+      def active_scaffold_input_boolean(column, html_options, ui_options: column.options)
+        record = html_options.delete(:object)
+        html_options.merge!(ui_options[:html_options] || {})
 
-        select_tag(options[:name], options_for_select(select_options, record.send(column.name)), options)
+        options = {selected: record.send(column.name), object: record}
+        options[:include_blank] = :_select_ if column.null?
+        options.merge!(ui_options)
+        active_scaffold_translate_select_options(options)
+
+        options_for_select = [[as_(:true), true], [as_(:false), false]] # rubocop:disable Lint/BooleanSymbol
+        select(:record, column.name, options_for_select, options, html_options)
       end
 
-      def active_scaffold_input_date(column, options)
-        active_scaffold_text_input :date_field, column, options
+      def active_scaffold_input_date(column, options, ui_options: column.options)
+        active_scaffold_text_input :date_field, column, options, ui_options: ui_options
       end
 
-      def active_scaffold_input_time(column, options)
-        active_scaffold_text_input :time_field, column, options
+      def active_scaffold_input_time(column, options, ui_options: column.options)
+        active_scaffold_text_input :time_field, column, options, ui_options: ui_options
       end
 
-      def active_scaffold_input_datetime(column, options)
-        active_scaffold_text_input :datetime_local_field, column, options
+      def active_scaffold_input_datetime(column, options, ui_options: column.options)
+        active_scaffold_text_input :datetime_local_field, column, options, ui_options: ui_options
       end
 
-      def active_scaffold_input_month(column, options)
-        active_scaffold_text_input :month_field, column, options
+      def active_scaffold_input_month(column, options, ui_options: column.options)
+        active_scaffold_text_input :month_field, column, options, ui_options: ui_options
       end
 
-      def active_scaffold_input_week(column, options)
-        active_scaffold_text_input :week_field, column, options
+      def active_scaffold_input_week(column, options, ui_options: column.options)
+        active_scaffold_text_input :week_field, column, options, ui_options: ui_options
       end
 
       ##
@@ -669,8 +715,8 @@ module ActiveScaffold
       end
       alias override_input? override_input
 
-      def subform_partial_for_column(column, klass = nil)
-        subform_partial = "#{column.options[:layout] || active_scaffold_config_for(klass || column.association.klass).subform.layout}_subform"
+      def subform_partial_for_column(column, klass = nil, ui_options: column.options)
+        subform_partial = "#{ui_options[:layout] || active_scaffold_config_for(klass || column.association.klass).subform.layout}_subform"
         override_subform_partial(column, subform_partial) || subform_partial
       end
 
@@ -740,7 +786,7 @@ module ActiveScaffold
 
         # find minimum and maximum from validators
         # we can safely modify :min and :max by 1 for :greater_tnan or :less_than value only for integer values
-        only_integer = column.column.type == :integer if column.column
+        only_integer = column.column_type == :integer if column.column
         only_integer ||= validators.find { |v| v.options[:only_integer] }.present?
         margin = only_integer ? 1 : 0
 

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -5,7 +5,7 @@ module ActiveScaffold
       def active_scaffold_human_condition_for(column)
         return if (value = field_search_params[column.name.to_s]).nil?
         search_ui = column.search_ui
-        search_ui ||= column.column.type if column.column
+        search_ui ||= column.column_type if column.column
         if override_human_condition_column?(column)
           send(override_human_condition_column(column), value, {})
         elsif search_ui && override_human_condition?(search_ui)
@@ -26,6 +26,7 @@ module ActiveScaffold
         attribute = column.active_record_class.human_attribute_name(column.name)
         opt ||= :between if from && to
         opt ||= from ? '>=' : '<='
+        from = to = nil if opt&.in? %w[null not_null]
         "#{attribute} #{as_(opt).downcase} #{from} #{to}"
       end
 
@@ -37,28 +38,61 @@ module ActiveScaffold
       alias active_scaffold_human_condition_decimal active_scaffold_human_condition_integer
       alias active_scaffold_human_condition_float active_scaffold_human_condition_integer
 
-      def active_scaffold_human_condition_string(column, value)
+      def active_scaffold_human_condition_range(column, value)
         opt = ActiveScaffold::Finder::STRING_COMPARATORS.key(value['opt']) || value['opt']
         to = "- #{value['to']}" if opt == 'BETWEEN'
         format_human_condition column, opt, "'#{value['from']}'", to
       end
+      alias active_scaffold_human_condition_string active_scaffold_human_condition_range
 
-      def active_scaffold_human_condition_date(column, value)
-        conversion = column.column.type == :date ? :to_date : :to_time
-        from = controller.class.condition_value_for_datetime(column, value['from'], conversion)
-        from = I18n.l from if from
-        to = controller.class.condition_value_for_datetime(column, value['to'], conversion) if value['opt'] == 'BETWEEN' || (value['opt'].nil? && value['to'])
-        to = "- #{I18n.l to}" if to
-        format_human_condition column, value['opt'], from, to
+      def active_scaffold_human_condition_datetime(column, value)
+        case value['opt']
+        when 'RANGE'
+          range_type, range = value['range'].downcase.split('_')
+          format = active_scaffold_human_condition_datetime_range_format(range_type, range)
+          from, = controller.class.datetime_from_to(column, value)
+          "#{column.active_record_class.human_attribute_name(column.name)} = #{as_(value['range'].downcase).downcase} (#{I18n.l(from, :format => format)})"
+        when 'PAST', 'FUTURE'
+          from, to = controller.class.datetime_from_to(column, value)
+          "#{column.active_record_class.human_attribute_name(column.name)} #{as_('BETWEEN'.downcase).downcase} #{I18n.l(from)} - #{I18n.l(to)}"
+        else
+          from, to = controller.class.datetime_from_to(column, value)
+          "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value['opt'].downcase).downcase} #{I18n.l(from)} #{value['opt'] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
+        end
+      end
+      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
+
+      def active_scaffold_human_condition_datetime_range_format(range_type, range)
+        case range
+        when 'week'
+          first_day_of_week = I18n.translate 'active_scaffold.date_picker_options.firstDay'
+          if first_day_of_week == 1
+            '%W %Y'
+          else
+            '%U %Y'
+          end
+        when 'month'
+          '%b %Y'
+        when 'year'
+          '%Y'
+        else
+          I18n.translate 'date.formats.default'
+        end
       end
-      alias active_scaffold_human_condition_time active_scaffold_human_condition_date
-      alias active_scaffold_human_condition_datetime active_scaffold_human_condition_date
-      alias active_scaffold_human_condition_timestamp active_scaffold_human_condition_date
+      # def active_scaffold_human_condition_date(column, value)
+      #   conversion = column.column_type == :date ? :to_date : :to_time
+      #   from = controller.class.condition_value_for_datetime(column, value['from'], conversion)
+      #   from = I18n.l from if from
+      #   to = controller.class.condition_value_for_datetime(column, value['to'], conversion) if value['opt'] == 'BETWEEN' || (value['opt'].nil? && value['to'])
+      #   to = "- #{I18n.l to}" if to
+      #   format_human_condition column, value['opt'], from, to
+      # end
 
       def active_scaffold_human_condition_boolean(column, value)
         attribute = column.active_record_class.human_attribute_name(column.name)
-        label = as_(ActiveScaffold::Core.column_type_cast(value, column.column) ? :true : :false) # rubocop:disable Lint/BooleanSymbol
-        as_(:boolean, :scope => :human_conditions, :column => attribute, :value => label)
+        as_(:boolean, :scope => :human_conditions, :column => attribute, :value => as_(value))
       end
       alias active_scaffold_human_condition_checkbox active_scaffold_human_condition_boolean