active_scaffold 3.6.20 → 3.7.1

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -5,8 +5,13 @@ module ActiveScaffold
       def get_column_value(record, column)
         record = record.send(column.delegated_association.name) if column.delegated_association
         if record
-          method = get_column_method(record, column)
-          value = send(method, record, column)
+          method, list_ui = get_column_method(record, column)
+          value =
+            if list_ui
+              send(method, record, column, ui_options: column.list_ui_options || column.options)
+            else
+              send(method, record, column)
+            end
         else
           value = nil
         end
@@ -27,8 +32,8 @@ module ActiveScaffold
             method
           # 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
-          elsif column.column && (method = override_column_ui(column.column.type))
+            [method, true]
+          elsif column.column && (method = override_column_ui(column.column_type))
             method
           else
             :format_column_value
@@ -76,52 +81,63 @@ module ActiveScaffold
       ##
       ## Overrides
       ##
-      def active_scaffold_column_text(record, column)
+      def active_scaffold_column_text(record, column, ui_options: column.options)
         # `to_s` is necessary to convert objects in serialized columns to string before truncation.
-        clean_column_value(truncate(record.send(column.name).to_s, :length => column.options[:truncate] || 50))
+        clean_column_value(truncate(record.send(column.name).to_s, length: ui_options[:truncate] || 50))
       end
 
-      def active_scaffold_column_fulltext(record, column)
+      def active_scaffold_column_fulltext(record, column, ui_options: column.options)
         clean_column_value(record.send(column.name))
       end
 
-      def active_scaffold_column_marked(record, column)
+      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})
       end
 
-      def active_scaffold_column_checkbox(record, column)
+      def active_scaffold_column_checkbox(record, column, ui_options: column.options)
         options = {:disabled => true, :id => nil, :object => record}
         options.delete(:disabled) if inplace_edit?(record, column)
         check_box(:record, column.name, options)
       end
 
-      def active_scaffold_column_percentage(record, column)
-        options = column.options[:slider] || {}
+      def active_scaffold_column_boolean(record, column, ui_options: column.options)
+        value = record.send(column.name)
+        if value.nil? && ui_options[:include_blank]
+          value = ui_options[:include_blank]
+          value.is_a?(Symbol) ? as_(value) : value
+        else
+          format_column_value(record, column, value)
+        end
+      end
+
+      def active_scaffold_column_percentage(record, column, ui_options: column.options)
+        options = ui_options[:slider] || {}
         options = options.merge(min: record.send(options[:min_method])) if options[:min_method]
         options = options.merge(max: record.send(options[:max_method])) if options[:max_method]
         value = record.send(options[:value_method]) if options[:value_method]
         as_slider options.merge(value: value || record.send(column.name))
       end
 
-      def active_scaffold_column_month(record, column)
+      def active_scaffold_column_month(record, column, ui_options: column.options)
         l record.send(column.name), format: :year_month
       end
 
-      def active_scaffold_column_week(record, column)
+      def active_scaffold_column_week(record, column, ui_options: column.options)
         l record.send(column.name), format: :week
       end
 
       def tel_to(text)
-        groups = text.to_s.scan(/(?:^\+)?\d+/)
-        extension = groups.pop if text.to_s =~ /\s*[^\d\s]+\s*\d+$/
+        text = text.to_s
+        groups = text.scan(/(?:^\+)?\d+/)
+        extension = groups.pop if text.match?(/\s*[^\d\s]+\s*\d+$/)
         link_to text, "tel:#{[groups.join('-'), extension].compact.join(',')}"
       end
 
-      def active_scaffold_column_telephone(record, column)
+      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 column.options[:format] == false
+        phone = number_to_phone(phone) unless ui_options[:format] == false
         tel_to phone
       end
 
@@ -146,8 +162,9 @@ module ActiveScaffold
       def format_column_value(record, column, value = nil)
         value ||= record.send(column.name) unless record.nil?
         if column.association.nil?
-          if FORM_UI_WITH_OPTIONS.include?(column.form_ui) && column.options[:options]
-            text, val = column.options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
+          form_ui_options = column.form_ui_options || column.options if FORM_UI_WITH_OPTIONS.include?(column.form_ui)
+          if form_ui_options&.dig(:options)
+            text, val = form_ui_options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
             value = active_scaffold_translated_option(column, text, val).first if text
           end
           if grouped_search? && column == search_group_column && search_group_function
@@ -302,7 +319,7 @@ module ActiveScaffold
       end
 
       def inplace_edit_cloning?(column)
-        column.inplace_edit != :ajax && (override_form_field?(column) || column.form_ui || (column.column && override_input?(column.column.type)))
+        column.inplace_edit != :ajax && (override_form_field?(column) || column.form_ui || (column.column && override_input?(column.column_type)))
       end
 
       def active_scaffold_inplace_edit_tag_options(record, column)

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -6,6 +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)
+        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
@@ -18,11 +20,11 @@ module ActiveScaffold
 
         # 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)
+          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))
-          send(method, column, options)
+          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))
@@ -32,18 +34,17 @@ module ActiveScaffold
         elsif column.association || column.virtual?
           active_scaffold_search_text(column, options)
 
-        elsif (method = override_search(column.column.type))
+        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_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)
 
         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)
+          options = active_scaffold_input_text_options(options) if column.text? || column.number?
           text_field(:record, column.name, options.merge(column.options))
         end
       rescue StandardError => e
@@ -72,28 +73,28 @@ module ActiveScaffold
       ## Search input methods
       ##
 
-      def active_scaffold_search_multi_select(column, options)
+      def active_scaffold_search_multi_select(column, options, ui_options: column.options)
         record = options.delete(:object)
         associated = options.delete :value
         associated = [associated].compact unless associated.is_a? Array
 
         if column.association
           associated.collect!(&:to_i)
-          method = column.options[:label_method] || :to_label
+          method = ui_options[:label_method] || :to_label
           select_options = sorted_association_options_find(column.association, nil, record).collect do |r|
             [r.send(method), r.id]
           end
         else
-          select_options = column.options[:options].collect do |text, value|
+          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
         return as_(:no_options) if select_options.empty?
 
-        active_scaffold_checkbox_list(column, select_options, associated, options)
+        active_scaffold_checkbox_list(column, select_options, associated, options, ui_options: ui_options)
       end
 
-      def active_scaffold_search_select(column, html_options, options = {})
+      def active_scaffold_search_select(column, html_options, options = {}, ui_options: column.options)
         record = html_options.delete(:object)
         associated = html_options.delete :value
         if column.association
@@ -102,13 +103,13 @@ module ActiveScaffold
           select_options = sorted_association_options_find(column.association, false, record)
         else
           method = column.name
-          select_options = active_scaffold_enum_options(column, record).collect do |text, value|
+          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
 
-        options = options.merge(:selected => associated).merge column.options
-        html_options.merge! column.options[:html_options] || {}
+        options = options.merge(selected: associated).merge ui_options
+        html_options.merge! ui_options[:html_options] || {}
         if html_options[:multiple]
           active_scaffold_select_name_with_multiple html_options
         else
@@ -119,21 +120,34 @@ module ActiveScaffold
         if (optgroup = options.delete(:optgroup))
           select(:record, method, active_scaffold_grouped_options(column, select_options, optgroup), options, html_options)
         elsif column.association
-          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)
         else
           select(:record, method, select_options, options, html_options)
         end
       end
 
-      def active_scaffold_search_text(column, options)
+      def active_scaffold_search_select_multiple(column, options, ui_options: column.options)
+        active_scaffold_search_select(column, options.merge(multiple: true), ui_options: ui_options)
+      end
+
+      def active_scaffold_search_draggable(column, options, ui_options: column.options)
+        active_scaffold_search_multi_select(column, options.merge(draggable_lists: true), ui_options: ui_options)
+      end
+
+      def active_scaffold_search_text(column, options, ui_options: column.options)
         text_field :record, column.name, active_scaffold_input_text_options(options)
       end
 
       # we can't use active_scaffold_input_boolean because we need to have a nil value even when column can't be null
       # to decide whether search for this field or not
-      def active_scaffold_search_boolean(column, options)
+      def active_scaffold_search_boolean(column, options, ui_options: column.options)
         select_options = []
         select_options << [as_(:_select_), nil]
+        if column.null?
+          null_label = ui_options[:include_blank] || :null
+          null_label = as_(null_label) if null_label.is_a?(Symbol)
+          select_options << [null_label, 'null']
+        end
         select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
         select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 
@@ -162,7 +176,7 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_search_null(column, options)
+      def active_scaffold_search_null(column, options, ui_options: column.options)
         select_options = []
         select_options << [as_(:_select_), nil]
         select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
@@ -179,38 +193,38 @@ module ActiveScaffold
         column.text? || column.search_ui == :string
       end
 
-      def active_scaffold_search_range_comparator_options(column)
+      def active_scaffold_search_range_comparator_options(column, ui_options: column.options)
         select_options = ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
         if active_scaffold_search_range_string?(column)
           comparators = ActiveScaffold::Finder::STRING_COMPARATORS.collect { |title, comp| [as_(title), comp] }
           select_options.unshift(*comparators)
         end
-        if include_null_comparators? column
+        if include_null_comparators? column, ui_options: ui_options
           select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
         end
         select_options
       end
 
-      def include_null_comparators?(column)
-        return column.options[:null_comparators] if column.options.key? :null_comparators
+      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].column&.null
+          !column.association.belongs_to? || active_scaffold_config.columns[column.association.foreign_key].null?
         else
-          column.column&.null
+          column.null?
         end
       end
 
-      def active_scaffold_search_range(column, options, input_method = :text_field_tag, input_options = {})
+      def active_scaffold_search_range(column, options, input_method = :text_field_tag, input_options = {}, ui_options: column.options)
         opt_value, from_value, to_value = field_search_params_range_values(column)
 
-        select_options = active_scaffold_search_range_comparator_options(column)
+        select_options = active_scaffold_search_range_comparator_options(column, ui_options: ui_options)
         text_field_size = active_scaffold_search_range_string?(column) ? 15 : 10
         opt_value ||= select_options[0][1]
 
         from_value = controller.class.condition_value_for_numeric(column, from_value)
         to_value = controller.class.condition_value_for_numeric(column, to_value)
-        from_value = format_number_value(from_value, column.options) if from_value.is_a?(Numeric)
-        to_value = format_number_value(to_value, column.options) if to_value.is_a?(Numeric)
+        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)
         html = select_tag("#{options[:name]}[opt]", options_for_select(select_options, opt_value),
                           :id => "#{options[:id]}_opt", :class => 'as_search_range_option')
         from_options = active_scaffold_input_text_options(input_options.merge(:id => options[:id], :size => text_field_size))
@@ -227,51 +241,119 @@ module ActiveScaffold
       end
       alias active_scaffold_search_string active_scaffold_search_range
 
-      def active_scaffold_search_integer(column, options)
-        active_scaffold_search_range(column, options, :number_field_tag, step: '1')
+      def active_scaffold_search_integer(column, options, ui_options: column.options)
+        active_scaffold_search_range(column, options, :number_field_tag, {step: '1'}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
       end
 
-      def active_scaffold_search_decimal(column, options)
-        active_scaffold_search_range(column, options, :number_field_tag, step: :any)
+      def active_scaffold_search_decimal(column, options, ui_options: column.options)
+        active_scaffold_search_range(column, options, :number_field_tag, {step: :any}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
       end
       alias active_scaffold_search_float active_scaffold_search_decimal
 
+      def active_scaffold_search_datetime(column, options, ui_options: column.options, field_ui: column.search_ui || :datetime)
+        current_search = {'from' => nil, 'to' => nil, 'opt' => 'BETWEEN',
+                          'number' => 1, 'unit' => 'DAYS', 'range' => nil}
+        current_search.merge!(options[:value]) unless options[:value].nil?
+        tags = [
+          active_scaffold_search_datetime_comparator_tag(column, options, current_search),
+          active_scaffold_search_datetime_trend_tag(column, options, current_search),
+          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
+      end
+
+      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
+
+      def active_scaffold_search_time(column, options, ui_options: column.options)
+        active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :time)
+      end
+
+      def active_scaffold_search_date(column, options, ui_options: column.options)
+        active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :date)
+      end
+
+      def active_scaffold_search_datetime_comparator_options(column)
+        select_options = ActiveScaffold::Finder::DATE_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+        select_options + ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+      end
+
+      def active_scaffold_search_datetime_comparator_tag(column, options, current_search)
+        choices = options_for_select(active_scaffold_search_datetime_comparator_options(column), current_search['opt'])
+        select_tag("#{options[:name]}[opt]", choices, id: "#{options[:id]}_opt", class: 'as_search_range_option as_search_date_time_option')
+      end
+
+      def active_scaffold_search_datetime_numeric_tag(column, options, current_search, ui_options: column.options, field_ui: column.search_ui)
+        helper = "active_scaffold_search_#{field_ui}_field"
+        numeric_controls = [
+          send(helper, column, options, current_search, 'from', ui_options: ui_options),
+          content_tag(:span, id: "#{options[:id]}_between", class: 'as_search_range_between',
+                             style: ('display: none' unless current_search['opt'] == 'BETWEEN')) do
+            safe_join([' - ', send(helper, column, options, current_search, 'to', ui_options: ui_options)])
+          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')
+      end
+
+      def active_scaffold_search_datetime_trend_tag(column, options, current_search)
+        trend_controls = [
+          text_field_tag("#{options[:name]}[number]", current_search['number'], class: 'text-input', size: 10, autocomplete: 'off'),
+          select_tag("#{options[:name]}[unit]",
+                     options_for_select(active_scaffold_search_datetime_trend_units(column), current_search['unit']),
+                     class: 'text-input')
+        ]
+        content_tag('span', safe_join(trend_controls, ' '),
+                    id: "#{options[:id]}_trend", class: 'search-date-trend',
+                    style: ('display: none' unless current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE'))
+      end
+
+      def active_scaffold_search_datetime_trend_units(column)
+        options = ActiveScaffold::Finder::DATE_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] }
+        options = ActiveScaffold::Finder::TIME_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] } + options if column_datetime?(column)
+        options
+      end
+
+      def active_scaffold_search_datetime_range_tag(column, options, current_search)
+        values = ActiveScaffold::Finder::DATE_RANGES.collect { |range| [as_(range.downcase.to_sym), range] }
+        range_controls = select_tag("#{options[:name]}[range]",
+                                    options_for_select(values, current_search['range']),
+                                    class: 'text-input', id: nil)
+        content_tag('span', range_controls,
+                    id: "#{options[:id]}_range", class: 'search-date-range',
+                    style: ('display: none' unless current_search['opt'] == 'RANGE'))
+      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?
       end
 
-      def active_scaffold_search_datetime(column, options)
-        _, from_value, to_value = field_search_params_range_values(column)
-        options = column.options.merge(options)
+      def active_scaffold_search_datetime_field(column, options, current_search, name, ui_options: column.options)
+        options = ui_options.merge(options)
         type = "#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
-        use_select = options.delete(:use_select)
-        from_name = "#{options[:name]}[from]"
-        to_name = "#{options[:name]}[to]"
-        if use_select
-          helper = "select_#{type}"
-          fields = [
-            send(helper, field_search_datetime_value(from_value), options.reverse_merge(include_blank: true, prefix: from_name)),
-            send(helper, field_search_datetime_value(to_value), options.reverse_merge(include_blank: true, prefix: to_name))
-          ]
+        field_name = "#{options[:name]}[#{name}]"
+        if options[:use_select]
+          send("select_#{type}", current_search[name], options.reverse_merge(include_blank: true, prefix: field_name))
         else
           helper = "#{type}#{'_local' if type == 'datetime'}_field_tag"
-          fields = [
-            send(helper, from_name, field_search_datetime_value(from_value), options.except(:name, :object).merge(id: "#{options[:id]}_from")),
-            send(helper, to_name, field_search_datetime_value(to_value), options.except(:name, :object).merge(id: "#{options[:id]}_to"))
-          ]
+          send(helper, field_name, current_search[name], options.except(:name, :object, :use_select).merge(id: "#{options[:id]}_#{name}"))
         end
-
-        safe_join fields, ' - '
       end
 
-      def active_scaffold_search_date(column, options)
-        active_scaffold_search_datetime(column, options.merge!(:discard_time => true))
+      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)
       end
 
-      def active_scaffold_search_time(column, options)
-        active_scaffold_search_datetime(column, options.merge!(:discard_date => true))
+      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)
       end
-      alias active_scaffold_search_timestamp active_scaffold_search_datetime
 
       ##
       ## Search column override signatures

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -13,24 +13,24 @@ module ActiveScaffold
           send(method, value_record, column)
         # 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)
-        elsif column.column && (method = override_show_column_ui(column.column.type))
+          send(method, value_record, column, ui_options: column.show_ui_options || column.options)
+        elsif column.column && (method = override_show_column_ui(column.column_type))
           send(method, value_record, column)
         else
           get_column_value(record, column)
         end
       end
 
-      def active_scaffold_show_text(record, column)
-        simple_format(clean_column_value(record.send(column.name)))
+      def active_scaffold_show_text(record, column, ui_options: column.options)
+        simple_format(clean_column_value(record.send(column.name)), ui_options[:html_options], ui_options)
       end
 
-      def active_scaffold_show_horizontal(record, column)
+      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}
       end
 
-      def active_scaffold_show_vertical(record, column)
+      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}
       end

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -247,7 +247,7 @@ module ActiveScaffold
 
           message = options.include?(:message) ? options[:message] : as_('errors.template.body')
 
-          error_messages = objects.sum do |object|
+          error_messages = objects.sum([]) do |object|
             object.errors.full_messages.map do |msg|
               options[:list_type] != :br ? content_tag(:li, msg) : msg
             end

data/lib/active_scaffold/orm_checks.rb

@@ -82,6 +82,22 @@ module ActiveScaffold
           type_for_attribute(klass, column_name)
         end
       end
+
+      def default_value(klass, column_name)
+        if ActiveScaffold::OrmChecks.mongoid? klass
+          columns_hash(klass)[column_name]&.default_val
+        elsif ActiveScaffold::OrmChecks.active_record? klass
+          klass._default_attributes[column_name]&.value
+        end
+      end
+
+      def cast(klass, column_name, value)
+        if active_record? klass
+          type_for_attribute(klass, column_name).cast value
+        elsif mongoid? klass
+          type_for_attribute(klass, column_name)&.evolve value
+        end
+      end
     end
 
     %i[active_record? mongoid? tableless?].each do |method|
@@ -96,10 +112,14 @@ module ActiveScaffold
       end
     end
 
-    %i[type_for_attribute column_type].each do |method|
+    %i[type_for_attribute column_type default_value].each do |method|
       define_method method do |column_name|
         ActiveScaffold::OrmChecks.send method, active_record_class, column_name
       end
     end
+
+    def cast(column_name, value)
+      ActiveScaffold::OrmChecks.cast active_record_class, column_name, value
+    end
   end
 end

data/lib/active_scaffold/registry.rb

@@ -1,33 +1,28 @@
 module ActiveScaffold
   class Registry
-    extend ActiveSupport::PerThreadRegistry
-    attr_accessor :current_user_proc, :current_ability_proc, :marked_records
+    thread_mattr_accessor :current_user_proc, :current_ability_proc, :marked_records
 
-    def user_settings
-      @user_settings ||= {}
+    def self.user_settings
+      RequestStore.store[:attr_Registry_user_settings] ||= {}
     end
 
-    def constraint_columns
-      @constraint_columns ||= Hash.new { |h, k| h[k] = [] }
+    def self.constraint_columns
+      RequestStore.store[:attr_Registry_constraint_columns] ||= Hash.new { |h, k| h[k] = [] }
     end
 
-    def unauthorized_columns
-      @unauthorized_columns ||= Hash.new { |h, k| h[k] = [] }
+    def self.unauthorized_columns
+      RequestStore.store[:attr_Registry_unauthorized_columns] ||= Hash.new { |h, k| h[k] = [] }
     end
 
-    def cache(kind, key = nil, &block)
+    def self.cache(kind, key = nil, &block)
       unless key
         key = kind
         kind = :cache
       end
-      @cache ||= {}
-      cache = @cache[kind] ||= {}
+      RequestStore.store[:attr_Registry_cache] ||= {}
+      cache = RequestStore.store[:attr_Registry_cache][kind] ||= {}
       return cache[key] if cache.include? key
       cache[key] ||= yield
     end
-
-    def self.instance
-      RequestStore.store[@per_thread_registry_key] ||= new
-    end
   end
 end