madmin 2.6.0 → 3.1.0

data/lib/madmin/fields/array.rb

@@ -0,0 +1,16 @@
+module Madmin
+  module Fields
+    # PostgreSQL array columns, shown and edited as comma separated values
+    class Array < Field
+      def self.filter_type = :array
+
+      def text(record)
+        value(record)&.join(", ")
+      end
+
+      def cast(value)
+        value.to_s.split(",").map(&:strip).compact_blank
+      end
+    end
+  end
+end

data/lib/madmin/fields/attachment.rb

@@ -1,6 +1,13 @@
 module Madmin
   module Fields
     class Attachment < Field
+      # Path for removing the attachment, or nil when the attachment resource
+      # or its destroy route has been removed from the app
+      def remove_path(attachment)
+        resource = Madmin.resource_for(attachment)
+        resource.show_path(attachment) if resource.route?(:destroy)
+      rescue MissingResource
+      end
     end
   end
 end

data/lib/madmin/fields/belongs_to.rb

@@ -3,7 +3,7 @@ module Madmin
     class BelongsTo < Field
       def options_for_select(record)
         current_value = record.send(attribute_name)
-        records = [current_value].compact + associated_resource.model.excluding(current_value).limit(25)
+        records = [current_value].compact + model.reflect_on_association(attribute_name).klass.excluding(current_value).limit(25)
         records.map { [Madmin.resource_for(_1).display_name(_1), _1.id] }
       end
 
@@ -13,6 +13,7 @@ module Madmin
 
       def index_path(format: :json)
         associated_resource&.index_path(format: format)
+      rescue MissingRoute
       end
 
       def associated_resource

data/lib/madmin/fields/boolean.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Boolean < Field
+      def self.filter_type = :boolean
     end
   end
 end

data/lib/madmin/fields/currency.rb

@@ -1,12 +1,19 @@
 module Madmin
   module Fields
     class Currency < Field
+      def self.filter_type = :number
+
       def value(record)
         value = record.public_send(attribute_name)
         value /= 100.0 if value && options.minor_units
         value
       end
 
+      # Filter values are in major units, which minor_units columns don't store
+      def filter_type
+        super unless options.minor_units
+      end
+
       def searchable?
         options.fetch(:searchable, model.column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/fields/date.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Date < Field
+      def self.filter_type = :date
     end
   end
 end

data/lib/madmin/fields/date_time.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class DateTime < Field
+      def self.filter_type = :datetime
     end
   end
 end

data/lib/madmin/fields/decimal.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Decimal < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/float.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Float < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/has_many.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class HasMany < Field
+      include Madmin::Pagination
+
       def options_for_select(record)
         if (records = record.send(attribute_name))
           return [] unless records.first
@@ -17,6 +19,7 @@ module Madmin
 
       def index_path(format: :json)
         associated_resource&.index_path(format: format)
+      rescue MissingRoute
       end
 
       def associated_resource
@@ -33,29 +36,9 @@ module Madmin
         true
       end
 
-      if Gem::Version.new(Pagy::VERSION) >= Gem::Version.new("43.0.0.rc")
-        include Pagy::Method
-
-        def paginated_value(record, params)
-          page_key = "#{attribute_name}_page"
-          request = {
-            params: {
-              "#{attribute_name}_page" => [params[page_key].to_i, 1].max
-            }
-          }
-          pagy value(record), page_key: page_key, request: request
-        rescue Pagy::OptionError
-        end
-      else
-        include Pagy::Backend
-
-        def paginated_value(record, params)
-          page_key = "#{attribute_name}_page"
-          page = [params[page_key].to_i, 1].max
-          pagy value(record), page: page, page_param: page_key
-        rescue Pagy::OverflowError, Pagy::VariableError
-          pagy value, page: 1, page_param: page_key
-        end
+      def paginated_value(record, params)
+        page_key = "#{attribute_name}_page"
+        paginate value(record), page: params[page_key], param: page_key
       end
     end
   end

data/lib/madmin/fields/integer.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Integer < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/json.rb

@@ -1,6 +1,27 @@
 module Madmin
   module Fields
     class Json < Field
+      # Text that isn't JSON is shown as it is, so it can be corrected in the form
+      def json(record)
+        value = value(record)
+
+        if value.nil? || value.is_a?(::String)
+          value
+        else
+          JSON.pretty_generate(value)
+        end
+      end
+
+      def cast(value)
+        JSON.parse(value) if value.present?
+      rescue JSON::ParserError
+        value
+      end
+
+      # Still being text after the cast means it could not be parsed
+      def accepts?(value)
+        !value.is_a?(::String)
+      end
     end
   end
 end

data/lib/madmin/fields/nested_has_many.rb

@@ -7,7 +7,7 @@ module Madmin
       end
 
       def resource
-        "#{to_model.name}Resource".constantize
+        Madmin.resource_by_name(to_model)
       end
 
       def to_param
@@ -23,7 +23,7 @@ module Madmin
       end
 
       def to_model
-        attribute_name.to_s.singularize.classify.constantize
+        model.reflect_on_association(attribute_name).klass
       end
 
       def paginateable?

data/lib/madmin/fields/nested_has_one.rb

@@ -0,0 +1,48 @@
+module Madmin
+  module Fields
+    class NestedHasOne < HasOne
+      DEFAULT_ATTRIBUTES = %w[_destroy id].freeze
+
+      def nested_attributes
+        resource.attributes.except(*skipped_fields)
+      end
+
+      def resource
+        Madmin.resource_by_name(to_model)
+      end
+
+      def to_param
+        {"#{attribute_name}_attributes": permitted_fields}
+      end
+
+      # Index and show link to the record like a has_one, and the form shares
+      # its fields with nested_has_many
+      def to_partial_path(name)
+        case name.to_s
+        when "index", "show"
+          "/madmin/fields/has_one/#{name}"
+        when "form"
+          "/madmin/fields/nested_has_one/form"
+        when "fields"
+          "/madmin/fields/nested_has_many/fields"
+        else
+          raise ArgumentError, "`partial` must be 'index', 'show', 'form' or 'fields'"
+        end
+      end
+
+      def to_model
+        model.reflect_on_association(attribute_name).klass
+      end
+
+      private
+
+      def permitted_fields
+        (resource.permitted_params - skipped_fields + DEFAULT_ATTRIBUTES).uniq
+      end
+
+      def skipped_fields
+        options[:skip] || []
+      end
+    end
+  end
+end

data/lib/madmin/fields/polymorphic.rb

@@ -9,10 +9,15 @@ module Madmin
         end
       end
 
+      # `type` is no longer used, but customized form partials may still submit it
       def to_param
         {attribute_name => %i[type value]}
       end
 
+      def cast(value)
+        GlobalID::Locator.locate(value[:value])
+      end
+
       def associated_resource_for(object)
         Madmin.resource_for(object)
       rescue MissingResource

data/lib/madmin/fields/string.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class String < Field
+      def self.filter_type = :string
+
       def searchable?
         options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/fields/text.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class Text < Field
+      def self.filter_type = :string
+
       def searchable?
         options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/filter.rb

@@ -0,0 +1,96 @@
+module Madmin
+  # One condition from the index filters, like `created_at gte 2026-08-15T09:00`
+  class Filter
+    OPERATORS = {
+      string: %w[contains eq starts_with blank present],
+      number: %w[eq gt gte lt lte blank],
+      date: %w[eq gte lte blank],
+      datetime: %w[gte lte blank],
+      boolean: %w[true false],
+      array: %w[includes]
+    }.freeze
+
+    WITHOUT_VALUE = %w[blank present true false].freeze
+
+    attr_reader :field, :operator, :value
+
+    # Skips conditions for unknown columns or operators, and values that don't
+    # cast to the column's type
+    def self.from_params(resource, params)
+      params.map { |param| new(resource.get_attribute(param[:column].to_s.to_sym)&.field, param[:operator].to_s, param[:value].to_s) }.select(&:valid?)
+    end
+
+    # A new row in the filters form, for the first filterable column
+    def self.blank(resource)
+      field = resource.filterable_attributes.first.field
+      new(field, OPERATORS.fetch(field.filter_type).first, "")
+    end
+
+    def initialize(field, operator, value)
+      @field = field
+      @operator = operator
+      @value = value
+    end
+
+    def column
+      field.attribute_name.to_s
+    end
+
+    def type
+      field.filter_type
+    end
+
+    def value?
+      WITHOUT_VALUE.exclude?(operator)
+    end
+
+    def valid?
+      field&.filter_type.present? && OPERATORS[type].include?(operator) && (typed_value.present? || !value?)
+    end
+
+    def apply(scope)
+      attribute = scope.arel_table[column]
+
+      case operator
+      when "contains" then scope.where(attribute.matches("%#{escaped_value}%"))
+      when "starts_with" then scope.where(attribute.matches("#{escaped_value}%"))
+      when "eq" then scope.where(column => typed_value)
+      when "gt" then scope.where(attribute.gt(typed_value))
+      when "gte" then scope.where(attribute.gteq(typed_value))
+      when "lt" then scope.where(attribute.lt(typed_value))
+      when "lte" then scope.where(attribute.lteq(typed_value))
+      when "blank" then scope.where(column => blank_values)
+      when "present" then scope.where.not(column => blank_values)
+      when "true" then scope.where(column => true)
+      when "false" then scope.where(column => false)
+      when "includes" then scope.where(Arel::Nodes.build_quoted(typed_value).eq(Arel::Nodes::NamedFunction.new("ANY", [attribute])))
+      end
+    end
+
+    # The params for this filter, used to keep it in links
+    def to_h
+      {column: column, operator: operator, value: value}
+    end
+
+    # The value in the column's type, or its element type for arrays. Datetimes are parsed in Time.zone, like form input
+    def typed_value
+      @typed_value ||= value.presence && value_type.cast(value)
+    end
+
+    private
+
+    # Arrays filter by their elements
+    def value_type
+      attribute_type = field.model.type_for_attribute(column)
+      (type == :array) ? attribute_type.subtype : attribute_type
+    end
+
+    def escaped_value
+      field.model.sanitize_sql_like(value)
+    end
+
+    def blank_values
+      (type == :string) ? [nil, ""] : nil
+    end
+  end
+end

data/lib/madmin/menu.rb

@@ -36,8 +36,9 @@ module Madmin
           @children[parent] ||= Item.new(label: parent)
           @children[parent].add options
         else
+          key = options.delete(:key)
           item = Item.new(**options)
-          @children[item.label] = item
+          @children[key || item.label] = item
         end
       end
 

data/lib/madmin/page.rb

@@ -0,0 +1,61 @@
+module Madmin
+  # Holds the numbers for a single page of results. Knows nothing about the database.
+  #
+  # Non-ActiveRecord adapters overriding `paginate_collection` can return one of
+  # these (or any object responding to the same methods) alongside their records.
+  class Page
+    SERIES_SLOTS = 7
+
+    attr_reader :count, :page, :per_page, :param
+
+    def initialize(count:, page: 1, per_page: Madmin.per_page, param: :page)
+      @count = count.to_i
+      @per_page = [per_page.to_i, 1].max
+      @page = [page.to_i, 1].max
+      @param = param.to_s
+    end
+
+    def last
+      [(count.to_f / per_page).ceil, 1].max
+    end
+
+    # Pages past the end are served empty rather than raising or clamping
+    def overflow?
+      page > last
+    end
+
+    def offset
+      (page - 1) * per_page
+    end
+
+    def from
+      (count.zero? || overflow?) ? 0 : offset + 1
+    end
+
+    def to
+      overflow? ? 0 : [offset + per_page, count].min
+    end
+
+    def prev
+      [page - 1, last].min if page > 1
+    end
+
+    def next
+      page + 1 if page < last
+    end
+
+    # Page numbers to link to, with :gap where pages are skipped
+    #   [1, :gap, 9, 10, 11, :gap, 20]
+    def series(slots: SERIES_SLOTS)
+      return (1..last).to_a if last <= slots
+
+      start = (page - (slots - 1) / 2).clamp(1, last - slots + 1)
+      pages = (start...(start + slots)).to_a
+      pages[0] = 1
+      pages[1] = :gap unless pages[1] == 2
+      pages[-1] = last
+      pages[-2] = :gap unless pages[-2] == last - 1
+      pages
+    end
+  end
+end

data/lib/madmin/pagination.rb

@@ -0,0 +1,50 @@
+module Madmin
+  # Paginates ActiveRecord relations using only the relation API (count, order,
+  # offset, limit) so the SQL is generated by whichever database adapter is in use.
+  module Pagination
+    private
+
+    # Returns [Madmin::Page, records]
+    def paginate(collection, page: 1, per_page: Madmin.per_page, param: :page)
+      page = Madmin::Page.new(count: count_for(collection), page: page, per_page: per_page, param: param)
+      [page, with_tiebreaker(collection).offset(page.offset).limit(page.per_page)]
+    end
+
+    def count_for(collection)
+      # count(:all) keeps custom selects valid, and ordering is irrelevant to a count
+      count = collection.unscope(:order).count(:all)
+
+      # Grouped relations return a Hash of counts per group
+      count.is_a?(Hash) ? count.size : count
+    end
+
+    # Appends the primary key to the ordering so rows with equal sort values keep
+    # a stable position across pages. It follows the direction of the existing
+    # ordering so indexes on the sort column can still be used.
+    def with_tiebreaker(collection)
+      return collection if collection.group_values.any? || collection.distinct_value
+
+      primary_keys = Array(collection.klass.primary_key).map(&:to_s)
+      return collection if primary_keys.empty?
+
+      orders = collection.order_values
+      return collection if orders.any? { |order| orders_by?(order, primary_keys) }
+
+      direction = descending?(orders.last) ? :desc : :asc
+      table = collection.klass.arel_table
+      collection.order(primary_keys.map { |key| table[key].public_send(direction) })
+    end
+
+    def orders_by?(order, column_names)
+      order.is_a?(Arel::Nodes::Ordering) && order.expr.respond_to?(:name) && column_names.include?(order.expr.name.to_s)
+    end
+
+    def descending?(order)
+      case order
+      when Arel::Nodes::Descending then true
+      when String then order.match?(/\bdesc\s*\z/i)
+      else false
+      end
+    end
+  end
+end

data/lib/madmin/resource.rb

@@ -37,6 +37,13 @@ module Madmin
         scopes << name
       end
 
+      # Label for a scope button on the index. Looks up
+      # madmin.scopes.<param_key>.<name>, then madmin.scopes.<name> in I18n,
+      # falling back to the humanized scope name. Override for custom labels.
+      def scope_label(name)
+        I18n.t("madmin.scopes.#{param_key}.#{name}", default: [:"madmin.scopes.#{name}", name.to_s.humanize])
+      end
+
       def get_attribute(name)
         attributes[name]
       end
@@ -76,8 +83,21 @@ module Madmin
 
       # Returns singular name
       # For example: "Forum::Post" -> "Forum / Post"
+      #
+      # Uses the model's translation (`activerecord.models.forum/post`) when there is one
       def friendly_name
-        model_name.split("::").map { |part| part.underscore.humanize }.join(" / ").titlecase
+        translated_name || model_name.split("::").map { |part| part.underscore.humanize }.join(" / ").titlecase
+      end
+
+      # Returns plural name
+      # For example: "Forum::Post" -> "Forum / Posts"
+      def friendly_plural_name
+        singular = translated_name
+        return friendly_name.pluralize unless singular
+
+        # A translation without `one` / `other` forms is the same for every count
+        return translated_name(count: 2) if plural_translation? || !locale_inflections?
+        singular.pluralize(I18n.locale)
       end
 
       # Support for isolated namespaces
@@ -91,19 +111,28 @@ module Madmin
       end
 
       def index_path(options = {})
-        url_helpers.polymorphic_path([:madmin, route_namespace, model], options)
+        route_path([:madmin, route_namespace, model], options)
       end
 
       def new_path
-        url_helpers.polymorphic_path([:madmin, route_namespace, model], action: :new)
+        route_path([:madmin, route_namespace, model], action: :new)
       end
 
       def show_path(record)
-        url_helpers.polymorphic_path([:madmin, route_namespace, becomes(record)])
+        route_path([:madmin, route_namespace, becomes(record)])
       end
 
       def edit_path(record)
-        url_helpers.polymorphic_path([:madmin, route_namespace, becomes(record)], action: :edit)
+        route_path([:madmin, route_namespace, becomes(record)], action: :edit)
+      end
+
+      # Whether a route is drawn for the given action on this resource's controller
+      # For example: PostResource.route?(:destroy)
+      def route?(action)
+        controller = "madmin/#{model.model_name.collection}"
+        Rails.application.routes.routes.any? do |route|
+          route.defaults[:controller] == controller && route.defaults[:action] == action.to_s
+        end
       end
 
       def becomes(record)
@@ -142,6 +171,10 @@ module Madmin
         attributes.values.select { |a| a.field.searchable? }
       end
 
+      def filterable_attributes
+        attributes.values.select { |a| a.field&.filter_type }
+      end
+
       def member_action(collection: false, &block)
         member_actions << MemberAction.new(collection: collection, &block)
       end
@@ -157,6 +190,7 @@ module Madmin
 
       def field_for_type(type)
         {
+          array: Fields::Array,
           binary: Fields::String,
           blob: Fields::Text,
           boolean: Fields::Boolean,
@@ -216,7 +250,8 @@ module Madmin
           has_many: Fields::HasMany,
           has_one: Fields::HasOne,
           rich_text: Fields::RichText,
-          nested_has_many: Fields::NestedHasMany
+          nested_has_many: Fields::NestedHasMany,
+          nested_has_one: Fields::NestedHasOne
         }[type]
       end
 
@@ -227,6 +262,8 @@ module Madmin
           column_type = model.attribute_types[name_string]
           if column_type.is_a? ::ActiveRecord::Enum::EnumType
             :enum
+          elsif model.columns_hash[name_string].try(:array?)
+            :array
           else
             column_type.type || :string
           end
@@ -265,6 +302,26 @@ module Madmin
         @url_helpers ||= Rails.application.routes.url_helpers
       end
 
+      # Raises MissingRoute with instructions instead of a NoMethodError for
+      # the undefined route helper when the resource's routes aren't drawn
+      def route_path(components, options = {})
+        url_helpers.polymorphic_path(components, options)
+      rescue NoMethodError => error
+        raise unless error.name.to_s.end_with?("_path")
+
+        *namespaces, resources = model.model_name.collection.split("/")
+        routes = namespaces.reverse.inject("resources :#{resources}") do |body, namespace|
+          "namespace :#{namespace} do\n#{body.indent(2)}\nend"
+        end
+
+        raise MissingRoute, [
+          "`#{error.name}` is not defined, so #{name} has no route for this page.",
+          "Add the route inside `namespace :madmin` in your routes:",
+          routes.indent(4),
+          "To hide the resource from the menu instead, add `menu false` to #{name}."
+        ].join("\n\n")
+      end
+
       def model_store_accessors
         return [] unless model.respond_to?(:stored_attributes)
 
@@ -279,7 +336,28 @@ module Madmin
       def menu_options
         return false if @menu_options == false
         @menu_options ||= {}
-        @menu_options.with_defaults(label: friendly_name.pluralize, url: index_path)
+        # The default label follows the locale, so the menu tracks the item by resource instead
+        @menu_options.with_defaults(key: @menu_options[:label] || name, label: friendly_plural_name, url: index_path)
+      end
+
+      private
+
+      def translated_name(count: 1)
+        model.model_name.human(count: count, default: "").presence
+      end
+
+      # Whether the model's translation spells out its own `one` / `other` forms
+      def plural_translation?
+        model.lookup_ancestors.each do |klass|
+          translation = I18n.t(klass.model_name.i18n_key, scope: [klass.i18n_scope, :models], default: "")
+          return translation.is_a?(Hash) if translation.present?
+        end
+        false
+      end
+
+      # Locales without inflection rules of their own (most non-English ones) are left unpluralized
+      def locale_inflections?
+        ActiveSupport::Inflector::Inflections.instance(I18n.locale).plurals.any?
       end
     end