madmin 2.5.1 → 3.0.0

data/config/locales/ko.yml

@@ -0,0 +1,84 @@
+ko:
+  madmin:
+    layout:
+      open_menu: 메뉴 열기
+      admin_suffix: 관리자
+    navigation:
+      dashboard: 대시보드
+      github: GitHub에서 Madmin 보기
+    dashboard:
+      title: Madmin 대시보드
+      hint_html: 대시보드를 원하는 대로 꾸미려면 <code>app/views/madmin/dashboard/show.html.erb</code> 파일을 생성하세요.
+    actions:
+      all: 전체
+      view: 보기
+      edit: 수정
+      delete: 삭제
+      new: 새로 만들기
+      remove: 제거
+      cancel: 취소
+    search:
+      placeholder: 검색
+    titles:
+      new: 새 %{name}
+      edit: "%{name} 수정"
+    form:
+      errors:
+        one: 제출한 내용에 오류가 1개 있습니다
+        other: 제출한 내용에 오류가 %{count}개 있습니다
+    confirmations:
+      delete: 정말 삭제하시겠습니까?
+      remove_with_changes: 정말 제거하시겠습니까? 다른 변경 사항도 함께 사라집니다.
+    nested_form:
+      add_new: "+ 새로 추가"
+    fields:
+      attachment:
+        one: "첨부파일 %{count}개"
+        other: "첨부파일 %{count}개"
+    missing_resource:
+      message: "%{resource}이(가) 존재하지 않습니다."
+      create_hint: "다음 명령어를 실행하여 생성하세요:"
+    pagination:
+      label: 페이지 탐색
+      previous: 이전
+      next: 다음
+      info: "%{count}개 중 %{from}-%{to} 표시"
+      empty: 레코드가 없습니다
+    filters:
+      button: "필터"
+      heading: "다음 조건의 레코드 표시"
+      add: "+ 필터 추가"
+      apply: "적용"
+      clear_all: "필터 지우기"
+      remove: "필터 제거"
+      column: "열"
+      operator: "조건"
+      value: "값"
+      operators:
+        string:
+          contains: "포함"
+          eq: "일치"
+          starts_with: "시작"
+          blank: "비어 있음"
+          present: "비어 있지 않음"
+        number:
+          eq: "="
+          gt: ">"
+          gte: "≥"
+          lt: "<"
+          lte: "≤"
+          blank: "비어 있음"
+        date:
+          eq: "당일"
+          gte: "이후(당일 포함)"
+          lte: "이전(당일 포함)"
+          blank: "비어 있음"
+        datetime:
+          gte: "이후"
+          lte: "이전"
+          blank: "비어 있음"
+        boolean:
+          "true": "참"
+          "false": "거짓"
+        array:
+          includes: "포함"

data/lib/madmin/field.rb

@@ -6,6 +6,10 @@ module Madmin
       to_s.split("::").last.underscore
     end
 
+    # The kind of index filter a field offers (:string, :number, :date,
+    # :datetime or :boolean), or nil for none
+    def self.filter_type = nil
+
     def initialize(attribute_name:, model:, resource:, options:)
       @attribute_name = attribute_name.to_sym
       @model = model
@@ -29,8 +33,18 @@ module Madmin
       attribute_name
     end
 
+    # Converts the submitted form value into the value assigned to the record
+    def cast(value)
+      value
+    end
+
+    # Whether the value returned by `cast` can be saved. The form is shown again with an error when it can't.
+    def accepts?(value)
+      true
+    end
+
     def label
-      options[:label].presence || attribute_name.to_s.titleize
+      options[:label].presence || model.human_attribute_name(attribute_name)
     end
 
     # Used for checking visibility of attribute on an view
@@ -62,6 +76,18 @@ module Madmin
       false
     end
 
+    def filter_type
+      self.class.filter_type if filterable?
+    end
+
+    private
+
+    # Only database columns can be filtered, and not encrypted ones since their
+    # stored values can't be compared. `filter: false` turns it off
+    def filterable?
+      options.fetch(:filter, true) && resource.model_column_names.include?(attribute_name.to_s) && !model.try(:encrypted_attributes)&.include?(attribute_name)
+    end
+
     ActiveSupport.run_load_hooks(:madmin_field, self)
   end
 end

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,8 +1,10 @@
 module Madmin
   module Fields
     class String < Field
+      def self.filter_type = :string
+
       def searchable?
-        options.fetch(:searchable, model.column_names.include?(attribute_name.to_s))
+        options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end
     end
   end

data/lib/madmin/fields/text.rb

@@ -1,8 +1,10 @@
 module Madmin
   module Fields
     class Text < Field
+      def self.filter_type = :string
+
       def searchable?
-        options.fetch(:searchable, model.column_names.include?(attribute_name.to_s))
+        options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end
     end
   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