administratum 0.2.4

data/app/controllers/administratum/resource.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Administratum
+  # Base class for resources declared in app/admin. A resource is a
+  # controller: the DSL configures it, the built-in actions provide CRUD, and
+  # any public method declared with member_action/collection_action is a
+  # custom action. Templates are looked up in app/views/admin/<route_key>
+  # first, then in the engine's defaults.
+  class Resource < ApplicationController
+    extend Administratum::DSL
+    include Pagy::Backend
+
+    before_action :load_parent
+    before_action :load_resource, if: :member_request?
+
+    helper_method :definition, :resource_class, :paths, :paths_for, :parent_record, :collection_path, :new_resource_path,
+                  :resource_path, :edit_resource_path, :action_path, :resource_form_path, :parent_path, :current_index_scope,
+                  :index_scope_count
+
+    def index
+      collection = current_index_scope ? current_index_scope.apply(scoped_collection) : scoped_collection
+      @search = collection.ransack(params[:q], auth_object: :administratum)
+      @search.sorts = definition.default_sort if @search.sorts.empty? && definition.default_sort
+
+      respond_to do |format|
+        format.html { @pagy, @resources = pagy(@search.result, limit: definition.per_page || Administratum.config.per_page) }
+        format.csv { send_data index_csv(@search.result), filename: "#{resource_class.route_key}.csv" } if definition.csv
+      end
+    end
+
+    def show; end
+
+    def new
+      @resource = build_resource
+    end
+
+    def edit; end
+
+    def create
+      @resource = build_resource(resource_params)
+
+      if @resource.save
+        redirect_to after_save_path(@resource), notice: t("administratum.flash.created", resource: resource_class.singular_label)
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @resource.update(resource_params)
+        redirect_to after_save_path(@resource), notice: t("administratum.flash.updated", resource: resource_class.singular_label)
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @resource.destroy!
+      redirect_to after_destroy_path, notice: t("administratum.flash.destroyed", resource: resource_class.singular_label)
+    end
+
+    # Resources defined in the host app live outside the engine's namespace,
+    # so Rails hands them the host's url helpers. Point them back at the engine.
+    def self.inherited(subclass)
+      super
+      subclass.include(Administratum::Engine.routes.url_helpers)
+      subclass.include(Administratum::Engine.routes.mounted_helpers)
+    end
+
+    def self.controller_path
+      name.nil? || abstract_resource? ? super : "administratum/resources/#{controller_id}"
+    end
+
+    private
+
+    # Templates for this resource live in app/views/<view_prefix>/<route_key>
+    # (app/views/admin/posts by default), falling back to the engine's defaults.
+    def _prefixes
+      @_prefixes ||= ["#{Administratum.config.view_prefix}/#{resource_class.route_key}", "administratum/resources"]
+    end
+
+    def resource_class
+      self.class
+    end
+
+    def definition
+      resource_class.definition
+    end
+
+    def model
+      definition.model
+    end
+
+    def parent_record
+      @parent
+    end
+
+    # Every query for this resource starts here. Override to add includes.
+    def scoped_collection
+      base = @parent ? @parent.public_send(definition.parent.association) : model.all
+      definition.scope_block ? definition.scope_block.call(base) : base
+    end
+
+    # The active index tab, from ?scope=, or nil when the resource declares none.
+    def current_index_scope
+      return @current_index_scope if defined?(@current_index_scope)
+
+      @current_index_scope = definition.index_scope(params[:scope])
+    end
+
+    # Records in a tab, with the current filters applied.
+    def index_scope_count(index_scope)
+      index_scope.apply(scoped_collection).ransack(params[:q], auth_object: :administratum).result.count
+    end
+
+    def build_resource(attributes = {})
+      @parent ? @parent.public_send(definition.parent.association).build(attributes) : model.new(attributes)
+    end
+
+    def resource_params
+      params.fetch(model.model_name.param_key, {}).permit(*definition.permitted_params)
+    end
+
+    def member_request?
+      definition.member_action_names.include?(action_name.to_sym)
+    end
+
+    def load_parent
+      parent = definition.parent
+      return unless parent && params[parent.param]
+
+      @parent = parent.model.find(params[parent.param])
+    end
+
+    # Non-shallow nested records are found through the parent; shallow ones
+    # get their parent from the record.
+    def load_resource
+      if @parent
+        @resource = scoped_collection.find(params[:id])
+      else
+        relation = definition.scope_block ? definition.scope_block.call(model.all) : model.all
+        @resource = relation.find(params[:id])
+        @parent = @resource.public_send(definition.parent.name) if definition.parent
+      end
+    end
+
+    def after_save_path(record)
+      if definition.action_enabled?(:show) then resource_path(record)
+      elsif definition.action_enabled?(:edit) then edit_resource_path(record)
+      else collection_path
+      end
+    end
+
+    # Resources without an index page (e.g. nested ones managed from their
+    # parent's page) go back to the parent, or the dashboard.
+    def after_destroy_path
+      return collection_path if definition.action_enabled?(:index)
+
+      parent_path || administratum.root_path
+    end
+
+    # Block columns run in a view context, as on the index page, and HTML
+    # they return is exported as its text. Columns declared csv: false are left out.
+    def index_csv(records)
+      columns = definition.index_columns.select(&:csv)
+      view = view_context
+      CSV.generate do |csv|
+        csv << columns.map { |column| view.column_label(column) }
+        records.find_each { |record| csv << columns.map { |column| csv_value(view, record, column) } }
+      end
+    end
+
+    def csv_value(view, record, column)
+      value = column.block ? view.instance_exec(record, &column.block) : record.public_send(column.name)
+
+      if value.is_a?(ActiveSupport::SafeBuffer) then Nokogiri::HTML5.fragment(value.to_s).text.strip
+      elsif value.is_a?(ActiveRecord::Base) then view.record_title(value)
+      else value
+      end
+    end
+
+    # Paths for this resource. See Administratum::Paths.
+    def paths
+      @paths ||= Administratum::Paths.new(resource_class, self)
+    end
+
+    def paths_for(resource)
+      Administratum::Paths.new(resource, self)
+    end
+
+    def collection_path(**)
+      paths.index(@parent, **)
+    end
+
+    def new_resource_path(**)
+      paths.new(@parent, **)
+    end
+
+    def resource_path(record = @resource, **)
+      paths.show(record, **)
+    end
+
+    def edit_resource_path(record = @resource, **)
+      paths.edit(record, **)
+    end
+
+    # Path for a custom action; member actions default to the current record.
+    def action_path(name, record = nil, **)
+      action = definition.custom_actions.fetch(name.to_sym)
+      paths.action(name, record || (action.member? ? @resource : @parent), **)
+    end
+
+    def resource_form_path(record = @resource)
+      paths.form(record, @parent)
+    end
+
+    def parent_path
+      return unless @parent
+
+      parent_resource = resource_class.parent_resource
+      Administratum::Paths.new(parent_resource, self).show(@parent) if parent_resource.definition.action_enabled?(:show)
+    end
+  end
+end

data/app/controllers/administratum/sessions_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Administratum
+  class SessionsController < ApplicationController
+    # remember_me lives here; Devise only mixes it into its own controllers.
+    include Devise::Controllers::Rememberable
+
+    layout "administratum/authentication"
+
+    skip_before_action :authenticate_admin!, only: %i[new create]
+
+    def new; end
+
+    def create
+      user = Administratum::User.find_for_authentication(email: params[:email].to_s)
+
+      if user&.valid_for_authentication? { user.valid_password?(params[:password].to_s) } && user.active_for_authentication?
+        sign_in(:administratum_user, user)
+        remember_me(user) if params[:remember_me] == "1"
+        redirect_to stored_location_for(:administratum_user) || administratum.root_path
+      else
+        flash.now[:alert] = t("administratum.sessions.invalid")
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    # Signs out only the admin scope, so a host app session survives.
+    def destroy
+      sign_out(:administratum_user)
+      redirect_to administratum.sign_in_path, notice: t("administratum.sessions.signed_out")
+    end
+  end
+end

data/app/helpers/administratum/application_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Administratum
+  module ApplicationHelper
+    include Pagy::Frontend
+    include Administratum::LayoutHelper
+    include Administratum::FormHelper
+    include Administratum::ResourceHelper
+    include Administratum::IslandHelper
+  end
+end

data/app/helpers/administratum/form_helper.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Administratum
+  module FormHelper
+    # form_with pointed at the right URL and method for the record, whether it
+    # is new or persisted, nested or not. Use it in custom form templates.
+    def administratum_form(record = @resource, **options, &)
+      options[:class] = class_names("adm-form", options[:class])
+      form_with(model: record, scope: record.model_name.param_key, url: resource_form_path(record),
+                method: record.persisted? ? :patch : :post, **options, &)
+    end
+
+    # Renders the DSL's form fields, or the subset named in `only`.
+    def render_fields(form, only: nil, except: nil)
+      fields = definition.fields
+      fields = fields.select { |field| Array(only).map(&:to_sym).include?(field.name) } if only
+      fields = fields.reject { |field| Array(except).map(&:to_sym).include?(field.name) } if except
+      safe_join(fields.map { |field| render_field(form, field) })
+    end
+
+    # Renders one field with its label, hint and errors. Pass a name declared
+    # in the DSL, or a name plus `as:` and options for an ad-hoc field.
+    def render_field(form, field, as: nil, **options)
+      field = resolve_field(form, field, as:, options:)
+      type = Administratum.field_types.fetch(field.type)
+      locals = { form:, field:, resource: form.object, value: form.object.try(field.name) }
+      input = render(partial: type.partial, locals:)
+      return input if field.type == :hidden || field.options[:wrapper] == false
+
+      render "administratum/fields/wrapper", locals.merge(input:)
+    end
+
+    # "tag_ids" reads as "Tags"; "category_id" is already "Category" in Rails.
+    def field_label(form, field)
+      return field.label if field.label
+
+      name = field.name.to_s
+      name = name.delete_suffix("_ids").pluralize if name.end_with?("_ids")
+      form.object.class.human_attribute_name(name)
+    end
+
+    # `required:` on the field wins; otherwise a presence validation marks it.
+    def field_required?(form, field)
+      field.options.fetch(:required) do
+        model = form.object.class
+        return false unless model.respond_to?(:validators_on)
+
+        attributes = [field.name, field.name.to_s.delete_suffix("_id").to_sym].uniq
+        attributes.any? { |attribute| model.validators_on(attribute).any?(ActiveModel::Validations::PresenceValidator) }
+      end
+    end
+
+    def field_errors(form, field)
+      attribute = field.name.to_s.delete_suffix("_id").delete_suffix("_ids")
+      (form.object.errors[field.name] + form.object.errors[attribute.to_sym]).uniq
+    end
+
+    # Options for select-style fields. `collection` may be an array, a
+    # relation, or a lambda (optionally receiving the record).
+    def field_collection(field, record)
+      collection = field.options[:collection]
+      collection = collection.arity.zero? ? instance_exec(&collection) : instance_exec(record, &collection) if collection.respond_to?(:call)
+      collection ||= association_collection(field, record)
+      collection = collection.to_a if collection.is_a?(ActiveRecord::Relation)
+      collection.map { |item| item.is_a?(ActiveRecord::Base) ? [record_title(item), item.id] : item }
+    end
+
+    # HTML options for a field's input: the partial's defaults, then the
+    # field's placeholder and hint wiring, then its input_html overrides.
+    def input_options(field, form: nil, **defaults)
+      defaults[:placeholder] = field.options[:placeholder] if field.options[:placeholder]
+      defaults[:aria] = { describedby: form.field_id(field.name, :hint) } if field.hint && form
+      defaults.merge(field.options.fetch(:input_html, {}))
+    end
+
+    # A text input that shows and accepts ISO 8601 dates (YYYY-MM-DD) in any
+    # browser locale, unlike the native date input. `value` defaults to the
+    # form object's attribute; options override the input's HTML attributes.
+    def adm_date_field(form, name, value: form.object.try(name), **options)
+      form.text_field name, { value: iso_value(value, "%Y-%m-%d"), placeholder: "YYYY-MM-DD",
+                              pattern: '\d{4}-\d{2}-\d{2}', inputmode: "numeric", class: "adm-input" }.merge(options)
+    end
+
+    # The same for datetimes (YYYY-MM-DD HH:MM). Rails parses the value in the
+    # app time zone on assignment.
+    def adm_datetime_field(form, name, value: form.object.try(name), **options)
+      form.text_field name, { value: iso_value(value, "%Y-%m-%d %H:%M"), placeholder: "YYYY-MM-DD HH:MM",
+                              pattern: '\d{4}-\d{2}-\d{2} \d{2}:\d{2}', class: "adm-input" }.merge(options)
+    end
+
+    private
+
+    def resolve_field(form, field, as:, options:)
+      return field if field.is_a?(Administratum::Definition::Field)
+
+      declared = definition.field(field) if respond_to?(:definition)
+      return declared.dup.tap { |copy| copy.options = copy.options.merge(options) } if declared && as.nil?
+
+      type = (as || Administratum.field_types.infer(form.object.class, field)).to_sym
+      Administratum::Definition::Field.new(name: field.to_sym, type:, options:)
+    end
+
+    def association_collection(field, record)
+      name = field.name.to_s.delete_suffix("_ids").delete_suffix("_id")
+      reflection = record.class.reflect_on_association(name.to_sym) || record.class.reflect_on_association(name.pluralize.to_sym)
+      reflection ? reflection.klass.all : []
+    end
+
+    # Dates and times are formatted; anything else (such as a submitted
+    # string that failed validation) is shown as typed.
+    def iso_value(value, format)
+      value.respond_to?(:strftime) ? value.strftime(format) : value
+    end
+  end
+end

data/app/helpers/administratum/island_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Administratum
+  module IslandHelper
+    # Renders a mount point for a JS island registered with
+    # Administratum.islands.register(name, (el, props) => teardown).
+    # Props are serialized as JSON; csrfToken is always included.
+    def island(name, props: {}, element: :div, **attributes)
+      props = { csrfToken: form_authenticity_token }.merge(props)
+      attributes[:data] = (attributes[:data] || {}).merge(administratum_island: name.to_s.dasherize)
+      content_tag(element, **attributes) do
+        tag.script(ERB::Util.json_escape(props.to_json).html_safe, type: "application/json") # rubocop:disable Rails/OutputSafety
+      end
+    end
+  end
+end

data/app/helpers/administratum/layout_helper.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Administratum
+  module LayoutHelper
+    def administratum_config
+      Administratum.config
+    end
+
+    def administratum_title
+      [content_for(:title).presence, administratum_config.app_name].compact.join(" · ")
+    end
+
+    def administratum_stylesheet_tag
+      stylesheet_link_tag("administratum") if administratum_config.stylesheet == :bundled
+    end
+
+    # Token overrides from config.theme / config.dark_theme as CSS variables.
+    def administratum_theme_style
+      light = theme_declarations(administratum_config.theme)
+      dark = theme_declarations(administratum_config.dark_theme)
+      return if light.empty? && dark.empty?
+
+      css = +""
+      css << ":root{#{light}}" if light.present?
+      css << ":root.dark{#{dark}}@media (prefers-color-scheme: dark){:root:not(.light){#{dark}}}" if dark.present?
+      tag.style(css.html_safe, nonce: content_security_policy_nonce) # rubocop:disable Rails/OutputSafety
+    end
+
+    # Puts .dark or .light on <html> before first paint: the stored choice, else
+    # the OS preference. Always setting a class gives host CSS a reliable
+    # `.dark` hook (Tailwind's class-based dark variant, editor styles…).
+    def administratum_color_scheme_script
+      javascript_tag(<<~JS, nonce: true)
+        (function(){var m=null;try{m=localStorage.getItem("administratum-theme")}catch(e){}if(m!=="dark"&&m!=="light"){m=window.matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"}document.documentElement.classList.add(m)})();
+      JS
+    end
+
+    def administratum_head
+      safe_join([
+        administratum_config.head&.call(self),
+        (render(administratum_config.head_partial) if administratum_config.head_partial)
+      ].compact)
+    end
+
+    def administratum_nav_items
+      Administratum.registry.navigation.map do |item|
+        path = item < Administratum::Page ? administratum.public_send(:"#{item.route_key}_page_path") : Administratum::Paths.new(item, self).index
+        { label: item.menu_label, path:, active: nav_active?(item) }
+      end
+    end
+
+    # Renders the page header: breadcrumbs, title and the block's buttons.
+    def page_header(title:, breadcrumbs: nil, &block)
+      content_for(:title, title)
+      render "administratum/shared/page_header", title:, breadcrumbs: breadcrumbs || default_breadcrumbs,
+                                                 actions: block ? capture(&block) : nil
+    end
+
+    def card(title: nil, footer: nil, flush: false, &)
+      render "administratum/shared/card", title:, footer:, flush:, body: capture(&)
+    end
+
+    private
+
+    def nav_active?(resource)
+      return controller.instance_of?(resource) if controller.is_a?(Administratum::Page)
+      return false unless controller.is_a?(Administratum::Resource)
+
+      current = controller.class
+      current = current.parent_resource while current.definition.parent && current.parent_resource && current != resource
+      current == resource
+    end
+
+    def theme_declarations(tokens)
+      tokens.map do |key, value|
+        name = key.to_s.start_with?("--") ? key.to_s : "--color-adm-#{key.to_s.dasherize}"
+        "#{name.gsub(/[^a-z0-9-]/i, '')}:#{value.to_s.gsub(/[;{}<>]/, '')};"
+      end.join
+    end
+  end
+end

data/app/helpers/administratum/resource_helper.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Administratum
+  module ResourceHelper
+    BUTTON_STYLES = {
+      primary: "adm-btn adm-btn-primary",
+      secondary: "adm-btn adm-btn-secondary",
+      danger: "adm-btn adm-btn-danger",
+      ghost: "adm-btn adm-btn-ghost"
+    }.freeze
+
+    # The display name of any record: its resource's title attribute, else to_s.
+    def record_title(record)
+      return "" if record.nil?
+
+      resource = Administratum.registry.for_model(record.class)
+      attribute = resource&.definition&.title
+      value = attribute ? record.public_send(attribute) : nil
+      value.presence&.to_s || "#{record.model_name.human} ##{record.id}"
+    end
+
+    def column_label(column)
+      column.label || definition.model.human_attribute_name(column.name)
+    end
+
+    def column_value(record, column)
+      return instance_exec(record, &column.block) if column.block
+
+      format_value(record.public_send(column.name), column.type)
+    end
+
+    def format_value(value, type = nil)
+      return tag.span("–", class: "adm-muted") if value.nil? || value == ""
+
+      case type
+      when :boolean then boolean_badge(value)
+      when :datetime then l(value, format: :short)
+      when :date then l(value)
+      when :association then link_to_record(value)
+      else
+        if value.is_a?(ActiveRecord::Base) then link_to_record(value)
+        elsif value == true || value == false then boolean_badge(value)
+        elsif value.is_a?(Hash) || value.is_a?(Array) then tag.code(truncate(value.to_json, length: 80), class: "adm-code")
+        else value.to_s
+        end
+      end
+    end
+
+    def boolean_badge(value)
+      if value
+        tag.span(t("administratum.yes"), class: "adm-badge adm-badge-success")
+      else
+        tag.span(t("administratum.no"), class: "adm-badge")
+      end
+    end
+
+    # Links to the record's show page when a resource manages its model.
+    def link_to_record(record)
+      resource = Administratum.registry.for_model(record.class)
+      return record_title(record) unless resource&.definition&.action_enabled?(:show) && resource.definition.parent.nil?
+
+      link_to record_title(record), Administratum::Paths.new(resource, self).show(record)
+    end
+
+    def default_breadcrumbs
+      crumbs = [[administratum_config.app_name, administratum.root_path]]
+      crumbs << [page_class.page_title, page_path] if controller.is_a?(Administratum::Page) && action_name != "index"
+      return crumbs unless controller.is_a?(Administratum::Resource)
+
+      if parent_record && (parent_resource = resource_class.parent_resource)
+        parent_paths = Administratum::Paths.new(parent_resource, self)
+        crumbs << [parent_resource.plural_label, (parent_paths.index if parent_resource.definition.action_enabled?(:index))]
+        crumbs << [record_title(parent_record), parent_path]
+      end
+      # Resources without an index (managed from their parent) get no crumb of their own.
+      crumbs << [resource_class.plural_label, collection_path] if definition.action_enabled?(:index)
+      crumbs << [record_title(@resource), (resource_path if definition.action_enabled?(:show))] if @resource&.persisted? && action_name != "show"
+      crumbs
+    end
+
+    # Buttons for a page: built-ins (new, edit, delete…) followed by the
+    # resource's custom buttons. `record` is required on :show, :edit and :row.
+    def buttons_for(page, record = @resource)
+      buttons = built_in_buttons(page.to_sym, record)
+      buttons += definition.buttons_for(page).filter_map { |button| render_button(button, record) }
+      safe_join(buttons, " ")
+    end
+
+    def render_button(button, record = @resource)
+      return unless button_visible?(button, record)
+
+      label = button.label || t("administratum.actions.#{button.name}", default: button.name.to_s.humanize)
+      classes = BUTTON_STYLES.fetch(button.style, BUTTON_STYLES[:secondary])
+
+      return panel_button(button, label, classes, record) if button.panel || button.upload
+
+      url, http_method = button_target(button, record)
+      administratum_button(label, url, method: http_method, confirm: button.confirm, class: classes)
+    end
+
+    # A link for GET, otherwise a one-button form (no rails-ujs needed).
+    def administratum_button(label, url, method: :get, confirm: nil, **options)
+      if method.to_sym == :get
+        link_to label, url, **options
+      else
+        form = { data: confirm ? { adm_confirm: confirm } : {} }
+        button_to label, url, method:, form:, form_class: "adm-inline-form", **options
+      end
+    end
+
+    # Tabs for the resource's index scopes. Switching tab keeps filters and sorting
+    # but goes back to the first page.
+    def index_scope_tabs
+      return if definition.index_scopes.empty?
+
+      query = request.query_parameters.except("page", "scope").symbolize_keys
+      tabs = definition.index_scopes.map do |index_scope|
+        active = index_scope == current_index_scope
+        label = safe_join([index_scope.display_label,
+                           (tag.span(number_with_delimiter(index_scope_count(index_scope)), class: "adm-tab-count") if index_scope.count)])
+        link_to label, collection_path(**query, scope: index_scope.name),
+                class: class_names("adm-tab", "adm-tab-active" => active), "aria-current": (active ? "page" : nil)
+      end
+      tag.nav(safe_join(tabs), class: "adm-tabs", "aria-label": t("administratum.scope_tabs"))
+    end
+
+    # Runs an `if:` lambda in the view, passing the record when it takes an argument.
+    def condition_met?(condition, record)
+      return true unless condition
+
+      condition.arity.zero? ? instance_exec(&condition) : instance_exec(record, &condition)
+    end
+
+    def filters?
+      definition.filters.any? && @search
+    end
+
+    def filter_collection(filter)
+      collection = filter.collection
+      collection = instance_exec(&collection) if collection.respond_to?(:call)
+      collection = collection.to_a if collection.is_a?(ActiveRecord::Relation)
+      collection.map { |item| item.is_a?(ActiveRecord::Base) ? [record_title(item), item.id] : item }
+    end
+
+    private
+
+    def built_in_buttons(page, record)
+      buttons = []
+      case page
+      when :index
+        buttons << link_to(t("administratum.actions.new", resource: resource_class.singular_label), new_resource_path, class: BUTTON_STYLES[:primary]) if definition.action_enabled?(:new)
+      when :show
+        buttons << link_to(t("administratum.actions.edit"), edit_resource_path(record), class: BUTTON_STYLES[:primary]) if definition.action_enabled?(:edit)
+        buttons << delete_button(record) if definition.action_enabled?(:destroy)
+      when :edit
+        buttons << link_to(t("administratum.actions.view"), resource_path(record), class: BUTTON_STYLES[:secondary]) if definition.action_enabled?(:show)
+        buttons << delete_button(record) if definition.action_enabled?(:destroy)
+      when :row
+        buttons << link_to(t("administratum.actions.view"), resource_path(record), class: "adm-btn adm-btn-ghost adm-btn-sm") if definition.action_enabled?(:show)
+        buttons << link_to(t("administratum.actions.edit"), edit_resource_path(record), class: "adm-btn adm-btn-ghost adm-btn-sm") if definition.action_enabled?(:edit)
+        buttons << delete_button(record, small: true) if definition.action_enabled?(:destroy)
+      end
+      buttons
+    end
+
+    def delete_button(record, small: false)
+      administratum_button(t("administratum.actions.destroy"), resource_path(record), method: :delete,
+                                                                                      confirm: t("administratum.confirm"),
+                                                                                      class: class_names("adm-btn adm-btn-danger", "adm-btn-sm" => small))
+    end
+
+    def button_visible?(button, record)
+      condition_met?(button.condition, record)
+    end
+
+    def button_target(button, record)
+      if button.to
+        url = button.to.arity.zero? ? instance_exec(&button.to) : instance_exec(record, &button.to)
+        return [url, button.http_method || :get]
+      end
+
+      action = definition.custom_actions.fetch(button.action) do
+        raise Administratum::Error, "Button :#{button.name} points at :#{button.action}, which is not a declared custom action"
+      end
+      [action_path(action.name, action.member? ? record : nil), button.http_method || action.http_method]
+    end
+
+    # Opens an offcanvas panel: either a custom partial, or a file upload form
+    # posting to the button's action.
+    def panel_button(button, label, classes, record)
+      panel_id = "adm-panel-#{button.name}#{"-#{record.id}" if record&.persisted?}"
+      content_for(:panels) do
+        render "administratum/shared/panel", id: panel_id, title: label, button:, record:,
+                                             target: (button_target(button, record).first unless button.panel)
+      end
+      tag.button(label, type: "button", class: classes, data: { adm_offcanvas_open: panel_id })
+    end
+  end
+end