rails_admin 3.2.1 → 4.0.0.beta

data/lib/rails_admin/config/fields/base.rb

@@ -60,20 +60,39 @@ module RailsAdmin
           !virtual? || children_fields.first || false
         end
 
-        def sort_column
-          if sortable == true
-            "#{abstract_model.quoted_table_name}.#{abstract_model.quote_column_name(name)}"
-          elsif (sortable.is_a?(String) || sortable.is_a?(Symbol)) && sortable.to_s.include?('.') # just provide sortable, don't do anything smart
-            sortable
-          elsif sortable.is_a?(Hash) # just join sortable hash, don't do anything smart
+        # What to sort by, as a Criteria::Path wherever the configuration can be
+        # read as one. The adapter turns it into whatever its store needs.
+        #
+        # The table-qualified forms cannot be: their prefix is a table name, not
+        # an association name, so they are handed on untouched for the store to
+        # interpret.
+        def sort_order
+          case sortable
+          when true
+            RailsAdmin::Criteria::Path[name]
+          when Hash # <table> => <column>, passed through
+            # The key is interpolated as given, so it has to be a table name.
+            # searchable resolves a model class here, sortable never has; the
+            # asymmetry dates from 845f85ec, which introduced both.
             "#{sortable.keys.first}.#{sortable.values.first}"
-          elsif association? # use column on target table
-            "#{associated_model_config.abstract_model.quoted_table_name}.#{abstract_model.quote_column_name(sortable)}"
-          else # use described column in the field conf.
-            "#{abstract_model.quoted_table_name}.#{abstract_model.quote_column_name(sortable)}"
+          when String, Symbol
+            if sortable.to_s.include?('.') # "table.column", passed through
+              sortable
+            elsif association? # a column on the associated model
+              RailsAdmin::Criteria::Path[name, sortable]
+            else
+              RailsAdmin::Criteria::Path[sortable]
+            end
+          else
+            sortable
           end
         end
 
+        # Deprecated: use #sort_order, which does not commit to a store's syntax.
+        def sort_column
+          abstract_model.sort_expression(sort_order)
+        end
+
         register_instance_option :searchable do
           !virtual? || children_fields.first || false
         end
@@ -113,36 +132,39 @@ module RailsAdmin
           false
         end
 
-        # list of columns I should search for that field [{ column: 'table_name.column', type: field.type }, {..}]
+        # What to search for this field: [{column: <target>, type: <field type>}, ..]
+        #
+        # A target is a Criteria::Path wherever the configuration can be read as
+        # one, so that the adapter decides how to reach the attribute. The
+        # table-qualified forms cannot be read that way -- their prefix names a
+        # table, not an association -- so they stay strings and are handed to the
+        # store as they are. Overriding this option with strings keeps working.
         register_instance_option :searchable_columns do
           @searchable_columns ||=
             case searchable
             when true
-              [{column: "#{abstract_model.table_name}.#{name}", type: type}]
+              [{column: RailsAdmin::Criteria::Path[name], type: type}]
             when false
               []
             when :all # valid only for associations
-              table_name = associated_model_config.abstract_model.table_name
-              associated_model_config.list.fields.collect { |f| {column: "#{table_name}.#{f.name}", type: f.type} }
+              associated_model_config.list.fields.collect do |f|
+                {column: RailsAdmin::Criteria::Path[name, f.name], type: f.type}
+              end
             else
               [searchable].flatten.collect do |f|
-                if f.is_a?(String) && f.include?('.')                            #  table_name.column
-                  table_name, column = f.split '.'
-                  type = nil
-                elsif f.is_a?(Hash)                                              #  <Model|table_name> => <attribute|column>
+                if f.is_a?(String) && f.include?('.')                            #  table_name.column, passed through
+                  {column: f, type: :string}
+                elsif f.is_a?(Hash)                                              #  <Model|table_name> => <attribute|column>, passed through
                   am = AbstractModel.new(f.keys.first) if f.keys.first.is_a?(Class)
                   table_name = am&.table_name || f.keys.first
-                  column = f.values.first
                   property = am&.properties&.detect { |p| p.name == f.values.first.to_sym }
-                  type = property&.type
-                else                                                             #  <attribute|column>
+                  {column: "#{table_name}.#{f.values.first}", type: (property&.type || :string)}
+                else                                                             #  <attribute>
                   am = (association? ? associated_model_config.abstract_model : abstract_model)
-                  table_name = am.table_name
-                  column = f
                   property = am.properties.detect { |p| p.name == f.to_sym }
-                  type = property&.type
+                  path = association? ? RailsAdmin::Criteria::Path[name, f] : RailsAdmin::Criteria::Path[f]
+                  {column: path, type: (property&.type || :string)}
                 end
-                {column: "#{table_name}.#{column}", type: (type || :string)}
               end
             end
         end
@@ -180,7 +202,7 @@ module RailsAdmin
         #
         # @see RailsAdmin::AbstractModel.properties
         register_instance_option :label do
-          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name name
+          (@label ||= {})[::I18n.locale] ||= abstract_model.human_attribute_name name
         end
 
         register_instance_option :hint do
@@ -196,8 +218,11 @@ module RailsAdmin
 
         # Accessor for field's length restrictions per validations
         #
+        # Bounds given as a Proc (e.g. Devise's password length validation) are
+        # dropped, as they can't be compared against the column limit and are
+        # only meant to be resolved at validation time.
         register_instance_option :valid_length do
-          @valid_length ||= abstract_model.model.validators_on(name).detect { |v| v.kind == :length }.try(&:options) || {}
+          @valid_length ||= abstract_model.attribute_length_options(name).reject { |_, bound| bound.is_a?(Proc) }
         end
 
         register_instance_option :partial do
@@ -215,13 +240,8 @@ module RailsAdmin
               :nil
             end
 
-          (@required ||= {})[context] ||= !!([name] + children_fields).uniq.detect do |column_name|
-            abstract_model.model.validators_on(column_name).detect do |v|
-              !(v.options[:allow_nil] || v.options[:allow_blank]) &&
-                %i[presence numericality attachment_presence].include?(v.kind) &&
-                (v.options[:on] == context || v.options[:on].blank?) &&
-                (v.options[:if].blank? && v.options[:unless].blank?)
-            end
+          (@required ||= {})[context] ||= ([name] + children_fields).uniq.any? do |column_name|
+            abstract_model.attribute_required?(column_name, context)
           end
         end
 
@@ -264,8 +284,6 @@ module RailsAdmin
           false
         end
 
-        register_deprecated_instance_option :eager_load?, :eager_load
-
         def eager_load_values
           case eager_load
           when true
@@ -329,7 +347,7 @@ module RailsAdmin
 
         # Reader for field's value
         def value
-          bindings[:object].safe_send(name)
+          abstract_model.read(bindings[:object], name)
         rescue NoMethodError => e
           raise e.exception <<~ERROR
             #{e.message}

data/lib/rails_admin/config/fields/collection_association.rb

@@ -23,7 +23,7 @@ module RailsAdmin
             i = 0
             super.sort_by { |a| [selected.index(a[1]) || selected.size, i += 1] }
           else
-            value.map { |o| [o.send(associated_object_label_method), format_key(o.send(associated_primary_key))] }
+            value.map { |o| [associated_model_config.object_label(o), format_key(o.send(associated_primary_key))] }
           end
         end
 
@@ -40,7 +40,7 @@ module RailsAdmin
         end
 
         def parse_input(params)
-          return unless associated_model_config.abstract_model.primary_key.is_a?(Array)
+          return unless associated_model_config.abstract_model.primary_keys.many?
 
           if nested_form
             params[method_name].each_value do |value|

data/lib/rails_admin/config/fields/factories/carrierwave.rb

@@ -4,27 +4,42 @@ require 'rails_admin/config/fields'
 require 'rails_admin/config/fields/types'
 require 'rails_admin/config/fields/types/file_upload'
 
+RailsAdmin::AbstractModel.register_classifier do |model, property|
+  next unless defined?(::CarrierWave)
+  next unless model.is_a?(CarrierWave::Mount)
+
+  attachment_name = property.name.to_s.chomp('_file_name').to_sym
+  next unless model.uploaders.include?(attachment_name)
+
+  RailsAdmin::AbstractModel::Role.new(
+    kind: :carrierwave,
+    name: attachment_name,
+    children: [
+      model.uploader_options[attachment_name][:mount_on] || attachment_name,
+      :"#{attachment_name}_content_type",
+      :"#{attachment_name}_file_size",
+    ],
+  )
+end
+
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  model = parent.abstract_model.model
-  if defined?(::CarrierWave) && model.is_a?(CarrierWave::Mount) && model.uploaders.include?(attachment_name = properties.name.to_s.chomp('_file_name').to_sym)
-    columns = [model.uploader_options[attachment_name][:mount_on] || attachment_name, :"#{attachment_name}_content_type", :"#{attachment_name}_file_size"]
-    field = RailsAdmin::Config::Fields::Types.load(
-      %i[serialized json].include?(properties.type) ? :multiple_carrierwave : :carrierwave,
-    ).new(parent, attachment_name, properties)
-    fields << field
-    children_fields = []
-    columns.each do |children_column_name|
-      child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
-      next unless child_properties
+  role = properties.try(:role)
+  next false unless role&.kind == :carrierwave
+
+  field = RailsAdmin::Config::Fields::Types.load(
+    %i[serialized json].include?(properties.type) ? :multiple_carrierwave : :carrierwave,
+  ).new(parent, role.name, properties)
+  fields << field
+  children_fields = []
+  role.children.each do |children_column_name|
+    child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
+    next unless child_properties
 
-      children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
-      children_field.hide unless field == children_field
-      children_field.filterable(false) unless field == children_field
-      children_fields << children_field.name
-    end
-    field.children_fields(children_fields)
-    true
-  else
-    false
+    children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
+    children_field.hide unless field == children_field
+    children_field.filterable(false) unless field == children_field
+    children_fields << children_field.name
   end
+  field.children_fields(children_fields)
+  true
 end

data/lib/rails_admin/config/fields/factories/dragonfly.rb

@@ -4,25 +4,37 @@ require 'rails_admin/config/fields'
 require 'rails_admin/config/fields/types'
 require 'rails_admin/config/fields/types/file_upload'
 
+RailsAdmin::AbstractModel.register_classifier do |model, property|
+  next unless defined?(::Dragonfly)
+  next unless (match = /^(.+)_uid$/.match(property.name.to_s))
+  next unless model.respond_to?(:dragonfly_attachment_classes)
+
+  attachment_name = match[1].to_sym
+  next unless model.dragonfly_attachment_classes.collect(&:attribute).include?(attachment_name)
+
+  RailsAdmin::AbstractModel::Role.new(
+    kind: :dragonfly,
+    name: attachment_name,
+    children: %i[name uid].map { |ext| :"#{attachment_name}_#{ext}" },
+  )
+end
+
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  extensions = %i[name uid]
-  if (properties.name.to_s =~ /^(.+)_uid$/) && defined?(::Dragonfly) && parent.abstract_model.model.respond_to?(:dragonfly_attachment_classes) && parent.abstract_model.model.dragonfly_attachment_classes.collect(&:attribute).include?(attachment_name = Regexp.last_match[1].to_sym)
-    field = RailsAdmin::Config::Fields::Types.load(:dragonfly).new(parent, attachment_name, properties)
-    children_fields = []
-    extensions.each do |ext|
-      children_column_name = :"#{attachment_name}_#{ext}"
-      child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
-      next unless child_properties
+  role = properties.try(:role)
+  next false unless role&.kind == :dragonfly
+
+  field = RailsAdmin::Config::Fields::Types.load(:dragonfly).new(parent, role.name, properties)
+  children_fields = []
+  role.children.each do |children_column_name|
+    child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
+    next unless child_properties
 
-      children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
-      children_field.hide
-      children_field.filterable(false)
-      children_fields << children_field.name
-    end
-    field.children_fields(children_fields)
-    fields << field
-    true
-  else
-    false
+    children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
+    children_field.hide
+    children_field.filterable(false)
+    children_fields << children_field.name
   end
+  field.children_fields(children_fields)
+  fields << field
+  true
 end

data/lib/rails_admin/config/fields/factories/enum.rb

@@ -4,17 +4,23 @@ require 'rails_admin/config/fields'
 require 'rails_admin/config/fields/types/enum'
 require 'rails_admin/config/fields/types/active_record_enum'
 
-RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  model = parent.abstract_model.model
-  method_name = "#{properties.name}_enum"
+RailsAdmin::AbstractModel.register_classifier do |model, property|
+  method_name = "#{property.name}_enum"
 
-  # NOTICE: _method_name could be `to_enum` and this method defined in Object.
-  if !Object.respond_to?(method_name) && \
-     (model.respond_to?(method_name) || \
-         model.method_defined?(method_name))
+  # NOTICE: method_name could be `to_enum` and this method defined in Object.
+  if !Object.respond_to?(method_name) && (model.respond_to?(method_name) || model.method_defined?(method_name))
+    RailsAdmin::AbstractModel::Role.new(kind: :enum, name: property.name)
+  elsif model.respond_to?(:defined_enums) && model.defined_enums[property.name.to_s]
+    RailsAdmin::AbstractModel::Role.new(kind: :active_record_enum, name: property.name)
+  end
+end
+
+RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
+  case properties.try(:role)&.kind
+  when :enum
     fields << RailsAdmin::Config::Fields::Types::Enum.new(parent, properties.name, properties)
     true
-  elsif model.respond_to?(:defined_enums) && model.defined_enums[properties.name.to_s]
+  when :active_record_enum
     fields << RailsAdmin::Config::Fields::Types::ActiveRecordEnum.new(parent, properties.name, properties)
     true
   else

data/lib/rails_admin/config/fields/factories/paperclip.rb

@@ -4,26 +4,36 @@ require 'rails_admin/config/fields'
 require 'rails_admin/config/fields/types'
 require 'rails_admin/config/fields/types/file_upload'
 
+RailsAdmin::AbstractModel.register_classifier do |model, property|
+  next unless defined?(::Paperclip)
+  next unless (match = /^(.+)_file_name$/.match(property.name.to_s))
+
+  attachment_name = match[1].to_sym
+  next unless model.try(:attachment_definitions)&.key?(attachment_name)
+
+  RailsAdmin::AbstractModel::Role.new(
+    kind: :paperclip,
+    name: attachment_name,
+    children: %i[file_name content_type file_size updated_at fingerprint].map { |ext| :"#{attachment_name}_#{ext}" },
+  )
+end
+
 RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  extensions = %i[file_name content_type file_size updated_at fingerprint]
-  model = parent.abstract_model.model
-  if (properties.name.to_s =~ /^(.+)_file_name$/) && defined?(::Paperclip) && model.try(:attachment_definitions) && model.attachment_definitions.key?(attachment_name = Regexp.last_match[1].to_sym)
-    field = RailsAdmin::Config::Fields::Types.load(:paperclip).new(parent, attachment_name, properties)
-    children_fields = []
-    extensions.each do |ext|
-      children_column_name = :"#{attachment_name}_#{ext}"
-      child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
-      next unless child_properties
+  role = properties.try(:role)
+  next false unless role&.kind == :paperclip
+
+  field = RailsAdmin::Config::Fields::Types.load(:paperclip).new(parent, role.name, properties)
+  children_fields = []
+  role.children.each do |children_column_name|
+    child_properties = parent.abstract_model.properties.detect { |p| p.name.to_s == children_column_name.to_s }
+    next unless child_properties
 
-      children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
-      children_field.hide
-      children_field.filterable(false)
-      children_fields << children_field.name
-    end
-    field.children_fields(children_fields)
-    fields << field
-    true
-  else
-    false
+    children_field = fields.detect { |f| f.name == children_column_name } || RailsAdmin::Config::Fields.default_factory.call(parent, child_properties, fields)
+    children_field.hide
+    children_field.filterable(false)
+    children_fields << children_field.name
   end
+  field.children_fields(children_fields)
+  fields << field
+  true
 end

data/lib/rails_admin/config/fields/factories/shrine.rb

@@ -4,19 +4,30 @@ require 'rails_admin/config/fields'
 require 'rails_admin/config/fields/types'
 require 'rails_admin/config/fields/types/file_upload'
 
-RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
-  next false unless defined?(::Shrine)
+RailsAdmin::AbstractModel.register_classifier do |model, property|
+  next unless defined?(::Shrine)
+
+  attachment_names = model.ancestors.select { |ancestor| ancestor.is_a?(Shrine::Attachment) }.map { |a| a.instance_variable_get('@name') }
+  next if attachment_names.blank?
 
-  attachment_names = parent.abstract_model.model.ancestors.select { |m| m.is_a?(Shrine::Attachment) }.map { |a| a.instance_variable_get('@name') }
-  next false if attachment_names.blank?
+  attachment_name = attachment_names.detect { |name| name == property.name.to_s.chomp('_data').to_sym }
+  next unless attachment_name
 
-  attachment_name = attachment_names.detect { |a| a == properties.name.to_s.chomp('_data').to_sym }
-  next false unless attachment_name
+  RailsAdmin::AbstractModel::Role.new(
+    kind: :shrine,
+    name: attachment_name,
+    children: [:"#{attachment_name}_data"],
+  )
+end
+
+RailsAdmin::Config::Fields.register_factory do |parent, properties, fields|
+  role = properties.try(:role)
+  next false unless role&.kind == :shrine
 
-  field = RailsAdmin::Config::Fields::Types.load(:shrine).new(parent, attachment_name, properties)
+  field = RailsAdmin::Config::Fields::Types.load(:shrine).new(parent, role.name, properties)
   fields << field
 
-  data_field_name = :"#{attachment_name}_data"
+  data_field_name = role.children.first
   child_properties = parent.abstract_model.properties.detect { |p| p.name == data_field_name }
   next true unless child_properties
 

data/lib/rails_admin/config/fields/singular_association.rb

@@ -11,7 +11,7 @@ module RailsAdmin
         end
 
         register_instance_option :formatted_value do
-          (o = value) && o.send(associated_model_config.object_label_method)
+          (o = value) && associated_model_config.object_label(o)
         end
 
         register_instance_option :partial do
@@ -38,6 +38,11 @@ module RailsAdmin
           return unless nested_form && params[method_name].try(:[], :id).present?
 
           ids = associated_model_config.abstract_model.parse_id(params[method_name][:id])
+          # The composite_primary_keys gem wants its own representation of the key
+          # here; ActiveRecord has had composite keys of its own since 7.1 and
+          # takes the array as it is. This is the only place the gem is still
+          # supported, and it is only reachable below 7.1 -- so it goes when
+          # support for Rails 7.0 does.
           ids = ids.to_composite_keys.to_s if ids.respond_to?(:to_composite_keys)
           params[method_name][:id] = ids
         end

data/lib/rails_admin/config/fields/types/active_record_enum.rb

@@ -14,7 +14,7 @@ module RailsAdmin
           end
 
           register_instance_option :enum do
-            abstract_model.model.defined_enums[name.to_s]
+            abstract_model.attribute_enum_values(name)
           end
 
           register_instance_option :pretty_value do
@@ -32,7 +32,7 @@ module RailsAdmin
           def parse_value(value)
             return unless value.present?
 
-            abstract_model.model.attribute_types[name.to_s].serialize(value)
+            abstract_model.serialize_attribute(name, value)
           end
 
           def parse_input(params)
@@ -49,11 +49,7 @@ module RailsAdmin
         private
 
           def parse_input_value(value)
-            abstract_model.model.attribute_types[name.to_s].deserialize(value)
-          end
-
-          def type_cast_value(value)
-            abstract_model.model.column_types[name.to_s].type_cast_from_user(value)
+            abstract_model.deserialize_attribute(name, value)
           end
         end
       end

data/lib/rails_admin/config/fields/types/belongs_to_association.rb

@@ -10,7 +10,10 @@ module RailsAdmin
           RailsAdmin::Config::Fields::Types.register(self)
 
           register_instance_option :sortable do
-            @sortable ||= abstract_model.adapter_supports_joins? && associated_model_config.abstract_model.properties.collect(&:name).include?(associated_model_config.object_label_method) ? associated_model_config.object_label_method : {abstract_model.table_name => method_name}
+            # Sort by whatever labels the associated record, when that is an
+            # attribute the store knows about. Reaching it may take a join or may
+            # not be possible at all, but that is the adapter's problem now.
+            @sortable ||= associated_model_config.abstract_model.properties.collect(&:name).include?(associated_model_config.object_label_method) ? associated_model_config.object_label_method : {abstract_model.table_name => method_name}
           end
 
           register_instance_option :searchable do
@@ -27,9 +30,9 @@ module RailsAdmin
 
           def selected_id
             if association.foreign_key.is_a?(Array)
-              format_key(association.foreign_key.map { |attribute| bindings[:object].safe_send(attribute) })
+              format_key(association.foreign_key.map { |attribute| abstract_model.read(bindings[:object], attribute) })
             else
-              bindings[:object].safe_send(association.key_accessor)
+              abstract_model.read(bindings[:object], association.key_accessor)
             end
           end
 
@@ -37,7 +40,8 @@ module RailsAdmin
             return super if nested_form
             return unless params[method_name].present? && association.foreign_key.is_a?(Array)
 
-            association.foreign_key.zip(RailsAdmin.config.composite_keys_serializer.deserialize(params.delete(method_name))).each do |key, value|
+            keys = associated_model_config.abstract_model.parse_id(params.delete(method_name))
+            association.foreign_key.zip(keys).each do |key, value|
               params[key] = value
             end
           end

data/lib/rails_admin/config/fields/types/bson_object_id.rb

@@ -11,7 +11,7 @@ module RailsAdmin
           RailsAdmin::Config::Fields::Types.register(self)
 
           register_instance_option :label do
-            label = ((@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name name)
+            label = ((@label ||= {})[::I18n.locale] ||= abstract_model.human_attribute_name name)
             label = 'Id' if label == ''
             label
           end

data/lib/rails_admin/config/fields/types/datetime.rb

@@ -82,10 +82,6 @@ module RailsAdmin
             :form_datetime
           end
 
-          register_deprecated_instance_option :momentjs_format do
-            ActiveSupport::Deprecation.warn('The momentjs_format configuration option is deprecated, please use flatpickr_format with corresponding values here: https://flatpickr.js.org/formatting/')
-          end
-
           def form_value
             value&.in_time_zone&.strftime('%FT%T') || form_default_value
           end

data/lib/rails_admin/config/fields/types/dragonfly.rb

@@ -12,7 +12,7 @@ module RailsAdmin
           RailsAdmin::Config::Fields::Types.register(self)
 
           register_instance_option :image? do
-            if abstract_model.model.new.respond_to?("#{name}_name")
+            if abstract_model.dummy_record.respond_to?("#{name}_name")
               mime_type = Mime::Type.lookup_by_extension(bindings[:object].send("#{name}_name").to_s.split('.').last)
               mime_type.to_s.match?(/^image/)
             else

data/lib/rails_admin/config/fields/types/enum.rb

@@ -21,14 +21,23 @@ module RailsAdmin
           end
 
           register_instance_option :enum_method do
-            @enum_method ||= bindings[:object].class.respond_to?("#{name}_enum") || (bindings[:object] || abstract_model.model.new).respond_to?("#{name}_enum") ? "#{name}_enum" : name
+            # Fall back to the model when no object is bound, which is how the
+            # filters dropdown renders fields. Asking nil for its class used to
+            # look the method up on NilClass, hiding class-level enumerations.
+            @enum_method ||=
+              if (bindings[:object]&.class || abstract_model.model).respond_to?("#{name}_enum") ||
+                 (bindings[:object] || abstract_model.dummy_record).respond_to?("#{name}_enum")
+                "#{name}_enum"
+              else
+                name
+              end
           end
 
           register_instance_option :enum do
             if abstract_model.model.respond_to?(enum_method)
               abstract_model.model.send(enum_method)
             else
-              (bindings[:object] || abstract_model.model.new).send(enum_method)
+              (bindings[:object] || abstract_model.dummy_record).send(enum_method)
             end
           end
 

data/lib/rails_admin/config/fields/types/multiple_file_upload.rb

@@ -29,8 +29,6 @@ module RailsAdmin
               nil
             end
 
-            register_deprecated_instance_option :delete_key, :delete_value
-
             register_instance_option :pretty_value do
               if value.presence
                 v = bindings[:view]

data/lib/rails_admin/config/fields/types/polymorphic_association.rb

@@ -22,7 +22,7 @@ module RailsAdmin
           end
 
           register_instance_option :formatted_value do
-            (o = value) && o.send(RailsAdmin.config(o).object_label_method)
+            (o = value) && RailsAdmin.config(o).object_label(o)
           end
 
           register_instance_option :sortable do
@@ -69,13 +69,13 @@ module RailsAdmin
 
           def type_collection
             associated_model_config.collect do |config|
-              [config.label, config.abstract_model.model.name]
+              [config.label, config.abstract_model.model_name]
             end
           end
 
           def type_urls
             types = associated_model_config.collect do |config|
-              [config.abstract_model.model.name, config.abstract_model.to_param]
+              [config.abstract_model.model_name, config.abstract_model.to_param]
             end
             ::Hash[*types.collect { |v| [v[0], bindings[:view].index_path(v[1])] }.flatten]
           end
@@ -107,7 +107,7 @@ module RailsAdmin
 
           def parse_input(params)
             if (type_value = params[association.foreign_type.to_sym]).present?
-              config = associated_model_config.find { |c| type_value == c.abstract_model.model.name }
+              config = associated_model_config.find { |c| type_value == c.abstract_model.model_name }
               params[association.foreign_type.to_sym] = config.abstract_model.base_class.name if config
             end
           end

data/lib/rails_admin/config/fields/types/time.rb

@@ -10,7 +10,7 @@ module RailsAdmin
           RailsAdmin::Config::Fields::Types.register(self)
 
           def parse_value(value)
-            abstract_model.model.type_for_attribute(name.to_s).serialize(super)&.change(year: 2000, month: 1, day: 1)
+            abstract_model.serialize_attribute(name, super)&.change(year: 2000, month: 1, day: 1)
           end
 
           register_instance_option :filter_operators do