active_scaffold 3.7.12 → 4.0.0.rc1

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -2,10 +2,6 @@ module ActiveScaffold
   module Helpers
     # Helpers that assist with the rendering of a List Column
     module ListColumnHelpers
-      def list_record_view
-        'list_record'
-      end
-
       def get_column_value(record, column)
         record = record.send(column.delegated_association.name) if column.delegated_association
         if record
@@ -19,7 +15,7 @@ module ActiveScaffold
         else
           value = nil
         end
-        value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6 # rubocop:disable Rails/OutputSafety
+        value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6
         value
       rescue StandardError => e
         logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}, record: #{record.inspect}"
@@ -37,7 +33,7 @@ module ActiveScaffold
           # second, check if the dev has specified a valid list_ui for this column
           elsif column.list_ui && (method = override_column_ui(column.list_ui))
             [method, true]
-          elsif column.column && (method = override_column_ui(column.column_type))
+          elsif column.column && (method = override_column_ui(column.column_type)) # rubocop:disable Lint/DuplicateBranch
             method
           else
             :format_column_value
@@ -53,9 +49,9 @@ module ActiveScaffold
           associated = record.send(column.association.name) if column.association
           authorized = link.action.nil?
           authorized, reason = column_link_authorized?(link, column, record, associated) unless authorized
-          render_action_link(link, record, :link => text, :authorized => authorized, :not_authorized_reason => reason)
+          render_action_link(link, record, link: text, authorized: authorized, not_authorized_reason: reason)
         elsif inplace_edit?(record, column)
-          active_scaffold_inplace_edit(record, column, :formatted_column => text)
+          active_scaffold_inplace_edit(record, column, formatted_column: text)
         elsif column_wrap_tag
           content_tag column_wrap_tag, text
         else
@@ -68,6 +64,7 @@ module ActiveScaffold
 
       def column_wrap_tag
         return @_column_wrap_tag if defined? @_column_wrap_tag
+
         @_column_wrap_tag = (active_scaffold_config.list.wrap_tag if active_scaffold_config.actions.include?(:list))
       end
 
@@ -78,8 +75,8 @@ module ActiveScaffold
       #
       # Why is it not a configuration option? Because it seems like a somewhat rare request. But it
       # could eventually be an option in config.list (and config.show, I guess).
-      def clean_column_value(v)
-        h(v)
+      def clean_column_value(value)
+        h(value)
       end
 
       ##
@@ -95,12 +92,12 @@ module ActiveScaffold
       end
 
       def active_scaffold_column_marked(record, column, ui_options: column.options)
-        options = {:id => nil, :object => record}
-        content_tag(:span, check_box(:record, column.name, options), :class => 'in_place_editor_field', :data => {:ie_id => record.to_param})
+        options = {id: nil, object: record}
+        content_tag(:span, check_box(:record, column.name, options), class: 'in_place_editor_field', data: {ie_id: record.to_param})
       end
 
       def active_scaffold_column_checkbox(record, column, ui_options: column.options)
-        options = {:disabled => true, :id => nil, :object => record}
+        options = {disabled: true, id: nil, object: record}
         options.delete(:disabled) if inplace_edit?(record, column)
         check_box(:record, column.name, options)
       end
@@ -141,6 +138,7 @@ module ActiveScaffold
       def active_scaffold_column_telephone(record, column, ui_options: column.options)
         phone = record.send column.name
         return if phone.blank?
+
         phone = number_to_phone(phone) unless ui_options[:format] == false
         tel_to phone
       end
@@ -241,6 +239,7 @@ module ActiveScaffold
         column_value = column&.association_join_text
         return column_value if column_value
         return @_association_join_text if defined? @_association_join_text
+
         @_association_join_text = active_scaffold_config.list.association_join_text
       end
 
@@ -285,7 +284,7 @@ module ActiveScaffold
           if column_empty?(column_value)
             empty_field_text
           elsif column_value.is_a?(Time) || column_value.is_a?(Date)
-            l(column_value, :format => options[:format] || :default)
+            l(column_value, format: options[:format] || :default)
           elsif !!column_value == column_value # rubocop:disable Style/DoubleNegation fast check for boolean
             as_(column_value.to_s.to_sym)
           else
@@ -318,11 +317,12 @@ module ActiveScaffold
       # ==========
 
       def inplace_edit?(record, column)
-        return unless column.inplace_edit
+        return false unless column.inplace_edit
         if controller.respond_to?(:update_authorized?, true)
           return Array(controller.send(:update_authorized?, record, column.name))[0]
         end
-        record.authorized_for?(:crud_type => :update, :column => column.name)
+
+        record.authorized_for?(crud_type: :update, column: column.name)
       end
 
       def inplace_edit_cloning?(column)
@@ -335,30 +335,27 @@ module ActiveScaffold
           element_cell_id(id: '--ID--', action: 'update_column', name: column.name.to_s)
         end
         tag_options = {id: cell_id.sub('--ID--', record.id.to_s), class: 'in_place_editor_field',
-                       title: @_inplace_edit_title, data: {:ie_id => record.to_param}}
+                       title: @_inplace_edit_title, data: {ie_id: record.to_param}}
         tag_options[:data][:ie_update] = column.inplace_edit if column.inplace_edit != true
         tag_options
       end
 
       def active_scaffold_inplace_edit(record, column, options = {})
         formatted_column = options[:formatted_column] || format_column_value(record, column)
-        @_inplace_edit_handle ||= content_tag(:span, as_(:inplace_edit_handle), :class => 'handle')
+        @_inplace_edit_handle ||= content_tag(:span, as_(:inplace_edit_handle), class: 'handle')
         span = content_tag(:span, formatted_column, active_scaffold_inplace_edit_tag_options(record, column))
         @_inplace_edit_handle + span
       end
 
       def inplace_edit_control(column)
         return unless inplace_edit?(active_scaffold_config.model, column) && inplace_edit_cloning?(column)
-        unless ActiveScaffold.threadsafe
-          column = column.dup
-          column.options = column.options.dup
-        end
+
         column.form_ui = :select if column.association && column.form_ui.nil?
-        options = active_scaffold_input_options(column).merge(:object => column.active_record_class.new)
+        options = active_scaffold_input_options(column).merge(object: column.active_record_class.new)
         options[:class] = "#{options[:class]} inplace_field"
-        options[:"data-id"] = options[:id]
+        options[:'data-id'] = options[:id]
         options[:id] = nil
-        content_tag(:div, active_scaffold_input_for(column, nil, options), :style => 'display:none;', :class => inplace_edit_control_css_class)
+        content_tag(:div, active_scaffold_input_for(column, nil, options), style: 'display:none;', class: inplace_edit_control_css_class)
       end
 
       def inplace_edit_control_css_class
@@ -368,7 +365,7 @@ module ActiveScaffold
       INPLACE_EDIT_PLURAL_FORM_UI = %i[select record_select].freeze
       def inplace_edit_data(column)
         data = {}
-        data[:ie_url] = url_for(params_for(:action => 'update_column', :column => column.name, :id => '__id__'))
+        data[:ie_url] = url_for(params_for(action: 'update_column', column: column.name, id: '__id__'))
         data[:ie_cancel_text] = column.options[:cancel_text] || as_(:cancel)
         data[:ie_loading_text] = column.options[:loading_text] || as_(:loading)
         data[:ie_save_text] = column.options[:save_text] || as_(:update)
@@ -383,7 +380,7 @@ module ActiveScaffold
         elsif inplace_edit_cloning?(column)
           data[:ie_mode] = :clone
         elsif column.inplace_edit == :ajax
-          url = url_for(params_for(:controller => params_for[:controller], :action => 'render_field', :id => '__id__', :update_column => column.name))
+          url = url_for(params_for(controller: params_for[:controller], action: 'render_field', id: '__id__', update_column: column.name))
           plural = column.association&.collection? && !override_form_field?(column) && INPLACE_EDIT_PLURAL_FORM_UI.include?(column.form_ui)
           data[:ie_render_url] = url
           data[:ie_mode] = :ajax
@@ -396,7 +393,7 @@ module ActiveScaffold
 
       def all_marked?
         if active_scaffold_config.mark.mark_all_mode == :page
-          @page.items.detect { |record| !marked_records.include?(record.id) }.nil?
+          @page.items.all? { |record| marked_records.key?(record.id) }
         else
           marked_records.length >= @page.pager.count.to_i
         end
@@ -404,8 +401,8 @@ module ActiveScaffold
 
       def mark_column_heading
         tag_options = {
-          :id => "#{controller_id}_mark_heading",
-          :class => 'mark_heading in_place_editor_field'
+          id: "#{controller_id}_mark_heading",
+          class: 'mark_heading in_place_editor_field'
         }
         content_tag(:span, check_box_tag("#{controller_id}_mark_heading_span_input", '1', all_marked?), tag_options)
       end
@@ -413,15 +410,15 @@ module ActiveScaffold
       # COLUMN HEADINGS
 
       def column_heading_attributes(column, sorting, sort_direction)
-        {:id => active_scaffold_column_header_id(column), :class => column_heading_class(column, sorting), :title => strip_tags(column.description).presence}
+        {id: active_scaffold_column_header_id(column), class: column_heading_class(column, sorting), title: strip_tags(column.description).presence}
       end
 
       def render_column_heading(column, sorting, sort_direction)
         tag_options = column_heading_attributes(column, sorting, sort_direction)
         if column.name == :as_marked
           tag_options[:data] = {
-            :ie_mode => :inline_checkbox,
-            :ie_url => url_for(params_for(:action => 'mark', :id => '__id__'))
+            ie_mode: :inline_checkbox,
+            ie_url: url_for(params_for(action: 'mark', id: '__id__'))
           }
         elsif column.inplace_edit
           tag_options[:data] = inplace_edit_data(column)
@@ -433,15 +430,15 @@ module ActiveScaffold
         if column.name == :as_marked
           mark_column_heading
         elsif column.sortable?
-          options = {:id => nil, :class => 'as_sort',
+          options = {id: nil, class: 'as_sort',
                      'data-page-history' => controller_id,
-                     :remote => true, :method => :get}
+                     remote: true, method: :get}
           url_options = {action: :index, page: 1, sort: column.name, sort_direction: sort_direction}
           # :id needed because rails reuse it even if it was deleted from params (like do_refresh_list does)
           url_options[:id] = nil if @remove_id_from_list_links
           url_options = params_for(url_options)
-          unless active_scaffold_config.store_user_settings
-            url_options[:search] = search_params if respond_to?(:search_params) && search_params.present?
+          if !active_scaffold_config.store_user_settings && respond_to?(:search_params) && search_params.present?
+            url_options[:search] = search_params
           end
           link_to column_heading_label(column), url_options, options
         else
@@ -459,7 +456,7 @@ module ActiveScaffold
         if column.calculate.instance_of? Proc
           column.calculate.call(@records)
         else
-          calculate_query(id_condition).calculate(column.calculate, column.name)
+          calculate_query(id_condition: id_condition).calculate(column.calculate, column.name)
         end
       end
 

data/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -2,7 +2,7 @@ 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')
+        link_to page_number, url_options.merge(page: page_number), options.merge(class: 'as_paginate')
       end
 
       def pagination_url_options(url_options = nil)
@@ -27,7 +27,7 @@ module ActiveScaffold
 
         html = []
         if current_page.number == 1
-          last_page = 0
+          last_page = 0 # rubocop:disable Lint/UselessAssignment
         else
           last_page = 1
           last_page.upto([last_page + outer_window, current_page.number - 1].min) do |num|
@@ -36,7 +36,7 @@ module ActiveScaffold
           end
         end
         if current_page.pager.infinite?
-          offsets.reverse.each do |offset|
+          offsets.reverse_each do |offset|
             page = current_page.number - offset
             next unless page < start_number && page > last_page
 
@@ -49,7 +49,7 @@ module ActiveScaffold
 
         [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')
+                    content_tag(:span, num.to_s, class: 'as_paginate current')
                   else
                     pagination_ajax_link(num, url_options, options)
                   end

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -6,10 +6,8 @@ module ActiveScaffold
       # It does not do any rendering. It only decides which method is responsible for rendering.
       def active_scaffold_search_for(column, options = nil)
         options ||= active_scaffold_search_options(column)
-        if active_scaffold_config.field_search.update_columns
-          search_columns = active_scaffold_config.field_search.columns.visible_columns_names
-          options = update_columns_options(column, nil, options, form_columns: search_columns, url_params: {form_action: :field_search})
-        end
+        search_columns = active_scaffold_config.field_search.columns.visible_columns_names
+        options = update_columns_options(column, nil, options, form_columns: search_columns, url_params: {form_action: :field_search})
         record = options[:object]
         if column.delegated_association
           record = record.send(column.delegated_association.name) || column.active_record_class.new
@@ -21,26 +19,19 @@ module ActiveScaffold
           send(method, record, options)
 
         # second, check if the dev has specified a valid search_ui for this column, using specific ui for searches
-        elsif column.search_ui && (method = override_search(column.search_ui))
-          send(method, column, options, ui_options: column.search_ui_options || column.options)
-
-        # third, check if the dev has specified a valid search_ui for this column, using generic ui for forms
-        elsif column.search_ui && (method = override_input(column.search_ui))
+        # or generic ui for forms
+        elsif column.search_ui && (method = override_search(column.search_ui) || override_input(column.search_ui))
           send(method, column, options, ui_options: column.search_ui_options || column.options)
 
-        # fourth, check if the dev has created an override for this specific field
-        elsif (method = override_form_field(column))
+        # third, check if the dev has created an override for this specific field
+        elsif (method = override_form_field(column)) # rubocop:disable Lint/DuplicateBranch
           send(method, record, options)
 
         # fallback: we get to make the decision
         elsif column.association || column.virtual?
           active_scaffold_search_text(column, options)
 
-        elsif (method = override_search(column.column_type))
-          # if we (or someone else) have created a custom render option for the column type, use that
-          send(method, column, options)
-
-        elsif (method = override_input(column.column_type))
+        elsif (method = override_search(column.column_type) || override_input(column.column_type))
           # if we (or someone else) have created a custom render option for the column type, use that
           send(method, column, options)
 
@@ -60,7 +51,7 @@ module ActiveScaffold
       end
 
       def search_attribute(column, record)
-        column_options = active_scaffold_search_options(column).merge(:object => 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))
@@ -165,7 +156,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)), 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
@@ -183,6 +174,7 @@ module ActiveScaffold
 
       def active_scaffold_group_column
         return if active_scaffold_config.field_search.group_options.blank?
+
         @_active_scaffold_group_column ||= begin
           column = ActiveScaffold::DataStructures::Column.new(:active_scaffold_group, active_scaffold_config.model)
           column.label = :group_by
@@ -194,12 +186,13 @@ module ActiveScaffold
         select_options = []
         select_options << [as_(:_select_), nil]
         select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
-        select_tag(options[:name], options_for_select(select_options, options[:value]), :id => options[:id])
+        select_tag(options[:name], options_for_select(select_options, options[:value]), id: options[:id])
       end
 
       def field_search_params_range_values(column)
         values = field_search_params[column.name.to_s]
         return nil unless values.is_a? Hash
+
         [values['opt'], values['from'].presence, values['to'].presence]
       end
 
@@ -220,13 +213,14 @@ module ActiveScaffold
       end
 
       def active_scaffold_search_select_comparator_options(column, ui_options: column.options)
-        select_options = [[as_('='.to_sym), '=']]
+        select_options = [[as_(:'='), '=']]
         select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
         select_options
       end
 
       def include_null_comparators?(column, ui_options: column.options)
         return ui_options[:null_comparators] if ui_options.key? :null_comparators
+
         if column.association
           !column.association.belongs_to? || active_scaffold_config.columns[column.association.foreign_key].null?
         else
@@ -244,8 +238,8 @@ module ActiveScaffold
         to_value = controller.class.condition_value_for_numeric(column, to_value)
         from_value = format_number_value(from_value, ui_options) if from_value.is_a?(Numeric)
         to_value = format_number_value(to_value, ui_options) if to_value.is_a?(Numeric)
-        from_options = active_scaffold_input_text_options(input_options.merge(:id => options[:id], :size => text_field_size))
-        to_options = from_options.merge(:id => "#{options[:id]}_to")
+        from_options = active_scaffold_input_text_options(input_options.merge(id: options[:id], size: text_field_size))
+        to_options = from_options.merge(id: "#{options[:id]}_to")
 
         from_field = send(input_method, "#{options[:name]}[from]", from_value, input_options)
         to_field = send(input_method, "#{options[:name]}[to]", to_value, to_options)
@@ -289,7 +283,7 @@ module ActiveScaffold
           active_scaffold_search_datetime_numeric_tag(column, options, current_search, ui_options: ui_options, field_ui: field_ui),
           active_scaffold_search_datetime_range_tag(column, options, current_search)
         ]
-        safe_join tags, '&nbsp;'.html_safe # rubocop:disable Rails/OutputSafety
+        safe_join tags, '&nbsp;'.html_safe
       end
 
       def active_scaffold_search_timestamp(column, options, ui_options: column.options)
@@ -328,8 +322,8 @@ module ActiveScaffold
           end
         ]
         content_tag('span', safe_join(numeric_controls),
-                    :id => "#{options[:id]}_numeric", :class => 'search-date-numeric',
-                    :style => ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(current_search['opt']) ? nil : 'display: none')
+                    id: "#{options[:id]}_numeric", class: 'search-date-numeric',
+                    style: ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(current_search['opt']) ? nil : 'display: none')
       end
 
       def active_scaffold_search_datetime_trend_tag(column, options, current_search)
@@ -361,11 +355,7 @@ module ActiveScaffold
       end
 
       def column_datetime?(column)
-        (!column.column.nil? && %i[datetime time].include?(column.column_type))
-      end
-
-      def field_search_datetime_value(value)
-        Time.zone.local(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
+        !column.column.nil? && %i[datetime time].include?(column.column_type)
       end
 
       def active_scaffold_search_datetime_field(column, options, current_search, name, ui_options: column.options)
@@ -373,7 +363,7 @@ module ActiveScaffold
         type = "#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
         field_name = "#{options[:name]}[#{name}]"
         if options[:use_select]
-          send("select_#{type}", current_search[name], options.reverse_merge(include_blank: true, prefix: field_name))
+          send(:"select_#{type}", current_search[name], options.reverse_merge(include_blank: true, prefix: field_name))
         else
           helper = "#{type}#{'_local' if type == 'datetime'}_field_tag"
           send(helper, field_name, current_search[name], options.except(:name, :object, :use_select).merge(id: "#{options[:id]}_#{name}"))
@@ -381,11 +371,11 @@ module ActiveScaffold
       end
 
       def active_scaffold_search_date_field(column, options, current_search, name, ui_options: column.options)
-        active_scaffold_search_datetime_field(column, options.merge!(:discard_time => true), current_search, name, ui_options: ui_options)
+        active_scaffold_search_datetime_field(column, options.merge!(discard_time: true), current_search, name, ui_options: ui_options)
       end
 
       def active_scaffold_search_time_field(column, options, current_search, name, ui_options: column.options)
-        active_scaffold_search_datetime_field(column, options.merge!(:discard_date => true), current_search, name, ui_options: ui_options)
+        active_scaffold_search_datetime_field(column, options.merge!(discard_date: true), current_search, name, ui_options: ui_options)
       end
 
       ##
@@ -409,8 +399,9 @@ module ActiveScaffold
       def visibles_and_hiddens(search_config)
         visibles = []
         hiddens = []
-        search_config.columns.each_column do |column|
+        search_config.columns.each_column(flatten: true) do |column|
           next unless column.search_sql
+
           if search_config.optional_columns.include?(column.name) && !searched_by?(column)
             hiddens << column
           else

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -5,6 +5,7 @@ module ActiveScaffold
       def show_column_value(record, column)
         value_record = column.delegated_association ? record.send(column.delegated_association.name) : record
         return get_column_value(record, column) unless value_record
+
         # check for an override helper
         if (method = show_column_override(column))
           # we only pass the record as the argument. we previously also passed the formatted_value,
@@ -14,10 +15,10 @@ module ActiveScaffold
         # second, check if the dev has specified a valid list_ui for this column
         elsif column.show_ui && (method = override_show_column_ui(column.show_ui))
           send(method, value_record, column, ui_options: column.show_ui_options || column.options)
-        elsif column.column && (method = override_show_column_ui(column.column_type))
+        elsif column.column && (method = override_show_column_ui(column.column_type)) # rubocop:disable Lint/DuplicateBranch
           send(method, value_record, column)
         else
-          get_column_value(record, column)
+          get_column_value(value_record, column)
         end
       end
 
@@ -27,12 +28,14 @@ module ActiveScaffold
 
       def active_scaffold_show_horizontal(record, column, ui_options: column.options)
         raise ':horizontal show_ui must be used on association column' unless column.association
-        render :partial => 'show_association', :locals => {:column => column, :parent_record => record, :show_partial => :horizontal}
+
+        render partial: 'show_association', locals: {column: column, parent_record: record, show_partial: :horizontal}
       end
 
       def active_scaffold_show_vertical(record, column, ui_options: column.options)
         raise ':vertical show_ui must be used on association column' unless column.association
-        render :partial => 'show_association', :locals => {:column => column, :parent_record => record, :show_partial => :vertical}
+
+        render partial: 'show_association', locals: {column: column, parent_record: record, show_partial: :vertical}
       end
 
       def show_columns_for(record, parent_column = nil, hash = {})

data/lib/active_scaffold/helpers/tabs_helpers.rb

@@ -0,0 +1,88 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with rendering of tabs in forms
+    module TabsHelpers
+      def active_scaffold_tabbed_by(column, record, scope, subsection_id, &block)
+        add_tab_url = params_for(action: 'render_field', tabbed_by: column.tabbed_by, id: record.to_param, column: column.label)
+        refresh_opts = {refresh_link: {text: 'Add tab', class: 'refresh-link add-tab'}}
+        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, &block)
+      end
+
+      def active_scaffold_input_for_tabbed(column, record, subsection_id, tab_options, used_tabs)
+        hidden_style = 'display: none;'
+        blank_choice = content_tag(:option, as_(:_select_), value: '')
+        option_tags = tab_options.inject(blank_choice) do |html, (label, value, tab_record)|
+          used = used_tabs.include?(tab_record || value)
+          html << content_tag(:option, label, value: value, style: (hidden_style if used))
+        end
+        select_tag(nil, option_tags, class: "#{column.tabbed_by}-input", id: "#{subsection_id}_input")
+      end
+
+      def active_scaffold_current_tabs(column, record, tab_options)
+        used_choices = Set.new
+        column.each_column do |col|
+          tabbed_by = col.options[:tabbed_by] || column.tabbed_by
+          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
+        used_choices
+      end
+
+      def active_scaffold_tab_options(column, record)
+        subform_column = column.first
+        if subform_column
+          tabbed_by = subform_column.options[:tabbed_by] || column.tabbed_by
+          if tabbed_by_association(subform_column, tabbed_by)
+            subform_record = record.send(subform_column.name).first_or_initialize
+            tab_column = active_scaffold_config_for(subform_column.association.klass).columns[tabbed_by]
+          end
+        end
+        if tab_column
+          label_method = (tab_column.form_ui_options || tab_column.options)[:label_method] || :to_label
+          sorted_association_options_find(tab_column.association, nil, subform_record).map do |opt_record|
+            [opt_record.send(label_method), opt_record.id, opt_record]
+          end
+        else
+          []
+        end
+      end
+
+      def active_scaffold_tab(label, tab_id, active)
+        content_tag :li, class: "nav-item #{:active if active}" do
+          link_to(label, "##{tab_id}", class: 'nav-link', data: {toggle: :tab})
+        end
+      end
+
+      def active_scaffold_tab_content(tab_id, active, content)
+        content_tag(:div, content, class: "tab-pane fade#{' in active' if active}", id: tab_id)
+      end
+
+      def active_scaffold_tabs_for(column, record, subsection_id, tab_options, used_tabs)
+        used_tabs = used_tabs.map { |value, value_id| [value, clean_id(value_id || value.to_s)] }
+        content_tag(:div, class: 'tabbed') do
+          content_tag(:ul, class: 'nav nav-tabs') do
+            tabs = used_tabs.map.with_index do |(tab_value, id), i|
+              active_scaffold_tab tab_options.find { |_, value, tab_record| tab_value == (tab_record || value) }&.first, "#{subsection_id}-#{id}-tab", i.zero?
+            end
+            safe_join tabs
+          end << content_tag(:div, class: 'tab-content') do
+            tabs = used_tabs.map.with_index do |(tab_value, id), i|
+              active_scaffold_tab_content("#{subsection_id}-#{id}-tab", i.zero?, yield(tab_value, id))
+            end
+            safe_join(tabs)
+          end
+        end
+      end
+    end
+  end
+end