crud_components 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3039812d78a4d8677f871959497a18eb9f2236627a84a0d046b72a520c0ba34c
-  data.tar.gz: 70b36787f0e28e2f51af0cfdf3361dc860fcdfb048d90365ddf4ebf128759372
+  metadata.gz: 6507798a0f053a225223897f37877c6fd10f3ba553edb7c446cb49554033d828
+  data.tar.gz: 66da668cd27252924532484e8a3b81eb6ee0ad94d5616edc08ee7e9cf7dffe1e
 SHA512:
-  metadata.gz: 7af65ee9f9aea26c3e6fc132fbe29ad3fbf2a3c8e931e209ee72dd7cb2a57cab670875a3c14fad3907ea316138a58d272729bfd6239d68be9cacf360b4e94fa9
-  data.tar.gz: 7a220eec077f9845b682c3a081e971d2a488a7d09a7bacfb6f514023fff92a3340000420d5bca17b648dfd424522c1f32a31f505eb81c2eb3331c2718fddbf87
+  metadata.gz: bb019084e1d48b34133874cbffe5c19c9a80b7f2d7b13fc7d07d832015a52c6a2a9d1d457597a43bed9d2c5c50dd67b43b53fb763bee642f60d4b4208217e2b1
+  data.tar.gz: '08a9b30a374459df1ab0d034c5e260b5e9c5a4e2ff2f2639b38d9d2cd002250b4683f5550fb660597ff377e527b2c5df9febe0c34f316daf48e9e61a397199db'

data/CHANGELOG.md

@@ -5,6 +5,23 @@ This project follows [semantic versioning](https://semver.org).
 
 ## Unreleased
 
+## v0.3.0 — 2026-08-13
+
+### Added
+
+- **An optional, mountable admin UI.** `mount CrudComponents::Admin::Engine => '/admin'` gives every model an index, a record view and working forms, derived from the same `crud_structure` your own pages use — no scaffold per model and no second rendering path. The engine draws real conventional `resources` routes per model, which is why every existing link (derived actions, association links, `+n more`, `crud_form`'s inferred URL) resolves inside it unchanged. Models are discovered automatically; framework tables, HABTM join models and STI subclasses are skipped. Who may in is one line in the ability you already have — `can :access, :crud_admin` — and it decides exactly that one thing: past the door your ordinary rules keep deciding, model by model and action by action, so an operator with no rule for a model gets an admin without it. Where there is no CanCanCan, `auth_with { … }` takes a gate of your own and `auth_with :none` serves without one on purpose. Beyond the gate `accessible_by`, `if:`/`editable:` and the derived permit list apply exactly as they do elsewhere. Includes a sidebar whose group headings go through i18n (`crud_components.admin.groups.*`, ordered by the declared name so the order holds in every locale) and counts, nested indexes per to-many association, bulk delete, and German/English strings. ([#45](https://github.com/itadventurer/crud_components/issues/45)–[#51](https://github.com/itadventurer/crud_components/issues/51), [#69](https://github.com/itadventurer/crud_components/issues/69), [#73](https://github.com/itadventurer/crud_components/issues/73))
+- `admin` in `crud_structure` — the per-model half of that: `admin false` keeps a model out entirely, `admin actions: %i[index show]` makes it read-only (the write routes are never drawn, so a hand-crafted `POST` 404s), plus `group:`, `label:`, `fieldset:` and `scope:`. Inert when the admin engine isn't loaded.
+- `app_path { |book| … }` in `crud_structure`, and the `crud_app_path(record)` helper: the host application's own page for a record, for when it is not the conventional route. Backs the admin's "Show in app" button.
+- `crud_admin_path(record, action = :show)` — the way back in, from an ordinary page to the mounted admin. Finds the mount point itself; nil when the admin isn't mounted or that action isn't enabled for the model.
+- **The admin's delete goes through a confirmation page** that counts what the delete would take with it: associations declaring `dependent: :destroy`/`:delete_all` (with a marker when those cascade further), Active Storage attachments, what `:nullify` would orphan, and what `:restrict_with_*` blocks — the Delete button stays disabled while anything blocks. Each group **names** its records rather than only counting them: the first ten, each a link to its own page (an attachment names its file and links to it), then a link to the index holding the rest. **Delete selected** reaches the same page for the whole selection — one record is a selection of one, so it is literally the same template and the same code path — with the ticked records named and their dependents counted across all of them, instead of deleting behind a browser dialog. A group the ability would not let you delete one by one is marked as such — a cascade takes it either way. Delete buttons follow the ability too: what is refused is not offered. A browser dialog cannot say any of that.
+- `crud_collection` and `crud_record` take `except_actions:` — action names one render drops, whatever the model declares. The admin uses it to replace the derived `:destroy` button with a link to that page.
+- `crud_collection` and `crud_record` take `extra_actions:` — row (or selection) actions appended for one render, for a button that belongs to the surface rather than to the model. Same permission check and route resolution as declared actions.
+
+### Fixed
+
+- A declared action whose `path` block names a route helper that does not exist in the current route set now omits the button instead of raising — the rule derived actions already followed. Only for names ending in `_path`/`_url`, so a typo in an app's own block still raises loudly.
+- The bundled playground (`test/dummy`) boots on hosts without the native libvips — the demo image is one, and so is any checkout that installed the gems but not the library. Active Storage's variant processor is switched off when libvips is missing, so attachments show as icon + filename instead of aborting the boot with `LoadError: Could not open library 'libvips.so.42'`. Nothing in the gem itself changes.
+
 ## v0.2.1 — 2026-08-01
 
 ### Changed

data/README.md

@@ -102,6 +102,38 @@ A single record and a standalone filter form work the same way:
 The rest of this README is a short "now I want to…" tour. Every step is optional; nothing below is
 required for any view above to work. Each section links to its in-depth reference.
 
+## …and a whole admin, if you want one
+
+The same one-line idea, one level up: mount the optional admin engine and **every** model
+has a backend — index, record view, forms, delete.
+
+```ruby
+# config/routes.rb
+mount CrudComponents::Admin::Engine => '/admin'
+```
+
+![The admin dashboard: a sidebar listing every model, grouped and iconed, and a card per model with its record count](docs/screenshots/admin-dashboard.png)
+
+It renders from the same `crud_structure` your own pages use — no scaffold per model, no
+second rendering path — and who may in is **one line in the ability you already have**
+(past the door your ordinary rules keep deciding, model by model):
+
+```ruby
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    can :access, :crud_admin if user&.admin?   # may open the admin
+  end
+end
+```
+
+No CanCanCan? `config.auth_with { … }` takes a gate of your own.
+
+`admin false` keeps a model out, `admin actions: %i[index show]` makes it read-only (the
+write routes are never drawn), and every record links back to the page a visitor would see.
+→ [The admin UI](docs/admin.md)
+
 ## The tour
 
 ### Choose the columns
@@ -411,11 +443,15 @@ map plus a few partials, never a fork. → [Extending → styling](docs/extendin
 
 ```ruby
 crud_collection(records, fieldset: nil, layout: :table, query: :auto, param_prefix: nil,
-                actions: true, group_by: nil, extra_columns: nil, picker: false, picked_columns: :auto)
-crud_record(record, fieldset: nil, actions: true, layout: :record, picked_columns: :auto)
+                actions: true, group_by: nil, extra_columns: nil, picker: false, picked_columns: :auto,
+                extra_actions: nil)
+crud_record(record, fieldset: nil, actions: true, layout: :record, picked_columns: :auto,
+            extra_actions: nil)
 crud_filter(model, fieldset: nil, query: nil, param_prefix: nil, layout: :filter)
 crud_form(record, fieldset: nil, action: nil, url: nil, method: nil, layout: :form)
 crud_actions(record_or_model, fieldset: nil)
+crud_app_path(record)                 # the host app's own page for a record, or nil
+crud_admin_path(record, :show)        # the mounted admin's page for it, or nil
 ```
 
 `crud_collection` takes a **relation** (`@books`, `Book.all`, or an authorized scope),
@@ -475,6 +511,7 @@ CrudComponents.configure { |config| … }     # css/icon maps, select_limit, def
 | [docs/security.md](docs/security.md)       | Permissions (`if:`/`editable:`), the whitelist, and the injection-safe URL model |
 | [docs/extending.md](docs/extending.md)     | Partials/renderers/layouts, progressive enhancement, styling, i18n               |
 | [docs/performance.md](docs/performance.md) | Eager-loading, the belongs_to select→text threshold, pagination                  |
+| [docs/admin.md](docs/admin.md)             | The optional mountable admin UI: discovery, authorization, Show in App           |
 
 
 ## Dependencies

data/app/assets/stylesheets/crud_components_admin.css

@@ -0,0 +1,13 @@
+/* crud_components admin — the few rules the bundled layout needs beyond
+ * Bootstrap. Loaded only inside the mounted admin.
+ */
+
+/* A wide table scrolls inside the content column instead of pushing the
+ * sidebar out of the row. */
+.crud-admin-main { min-width: 0; }
+.crud-admin-main .card-body { overflow-x: auto; }
+
+.crud-admin-sidebar { --crud-admin-sidebar-top: 1rem; }
+.crud-admin-sidebar > .crud-admin-sidebar-inner { position: sticky; top: var(--crud-admin-sidebar-top); }
+
+.crud-admin-nav .nav-link { border-radius: .25rem; }

data/app/controllers/crud_components/admin/application_controller.rb

@@ -0,0 +1,100 @@
+module CrudComponents
+  module Admin
+    # Base for the engine's controllers. Inherits from the host's controller
+    # (see `config.parent_controller`), so `current_user`, the session and any
+    # `rescue_from` are the app's own.
+    class ApplicationController < CrudComponents::Admin.config.parent_controller_class
+      # Active Storage's route helpers live in the application's route set, not
+      # in an isolated engine's — attachment cells call them by bare name.
+      ACTIVE_STORAGE_HELPERS = %i[
+        rails_blob_path rails_blob_url rails_representation_path rails_representation_url
+        rails_storage_proxy_path rails_storage_proxy_url
+        rails_storage_redirect_path rails_storage_redirect_url
+      ].freeze
+
+      layout -> { CrudComponents::Admin.config.layout }
+      helper CrudComponents::Admin::ViewHelpers
+
+      helper do
+        ACTIVE_STORAGE_HELPERS.each do |helper_name|
+          define_method(helper_name) do |*args, **options|
+            main_app.public_send(helper_name, *args, **options)
+          end
+        end
+      end
+
+      before_action :run_admin_gate!
+
+      rescue_from CrudComponents::Admin::ForbiddenError do |error|
+        render plain: error.message, status: :forbidden
+      end
+
+      helper_method :admin_config, :admin_registry, :admin_entries, :admin_entry_groups
+
+      private
+
+      def admin_config = CrudComponents::Admin.config
+
+      def admin_registry = CrudComponents::Admin.registry
+
+      # The models the navigation offers: routed, allowed, and with a table
+      # behind them (a half-migrated database leaves one out rather than
+      # offering a link that only errors).
+      def admin_entries
+        @admin_entries ||= admin_registry.entries.select do |entry|
+          CrudComponents::Admin.path_for(entry.model, :index) && readable?(entry) && table?(entry)
+        end
+      end
+
+      def table?(entry)
+        entry.model.table_exists?
+      rescue ActiveRecord::ActiveRecordError
+        true
+      end
+
+      def admin_entry_groups = admin_registry.groups(admin_entries)
+
+      def readable?(entry)
+        ability = admin_ability
+        ability.nil? || ability.can?(:index, entry.model)
+      end
+
+      # The entry's relation, narrowed by the ability when one can scope.
+      def admin_scope(entry)
+        scope = entry.scope
+        ability = cancan_ability
+        return scope unless ability && scope.respond_to?(:accessible_by)
+
+        scope.accessible_by(ability)
+      end
+
+      def run_admin_gate!
+        gate = Gate.new(admin_config, admin_ability)
+
+        case gate.verdict
+        when :block then instance_exec(&admin_config.auth_block)
+        when :unauthorized then raise UnauthorizedError, gate.unauthorized_message
+        when :forbidden
+          # Through the host's `authorize!` first, so its own `rescue_from` decides.
+          authorize!(Gate::ACTION, admin_config.auth_subject) if respond_to?(:authorize!, true)
+          raise ForbiddenError, gate.forbidden_message
+        end
+      end
+
+      # Whatever answers `can?` here: a CanCanCan ability, else the controller
+      # itself when the host defined `can?` on it, else nothing.
+      def admin_ability
+        return @admin_ability if defined?(@admin_ability)
+
+        @admin_ability = if respond_to?(:current_ability, true) then current_ability
+                         elsif respond_to?(:can?, true) then self
+                         end
+      end
+
+      # Only a real CanCanCan ability can scope a relation.
+      def cancan_ability
+        current_ability if respond_to?(:current_ability, true)
+      end
+    end
+  end
+end

data/app/controllers/crud_components/admin/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module CrudComponents
+  module Admin
+    # The mount root: what there is to administer.
+    class DashboardController < ApplicationController
+      def show
+        @counts = admin_entries.to_h { |entry| [entry.name, admin_scope(entry).count] } if admin_config.counts
+      end
+    end
+  end
+end

data/app/controllers/crud_components/admin/resources_controller.rb

@@ -0,0 +1,184 @@
+module CrudComponents
+  module Admin
+    # Every registered model's CRUD, in one controller. The model comes from the
+    # route's `crud_model` default, so a request can only ever name a model the
+    # registry drew a route for.
+    class ResourcesController < ApplicationController
+      before_action :set_entry
+      before_action :set_record, only: %i[show edit update destroy delete]
+      before_action :build_record, only: %i[new create]
+      before_action :authorize_action!
+
+      def index
+        @owner = owner
+        @query = CrudComponents::Query.new(@model, params, fieldset: @entry.fieldset, ability: admin_ability)
+        @records = paginate(@query.apply(base_scope))
+      end
+
+      def show; end
+
+      def new; end
+
+      def edit; end
+
+      def create
+        @record.assign_attributes(record_params(:create))
+        if @record.save
+          redirect_to after_save_path(@record), notice: saved_notice(:created)
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        if @record.update(record_params(:update))
+          redirect_to after_save_path(@record), notice: saved_notice(:updated)
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      # The confirmation step, for one record or for the ticked rows: which they
+      # are, and what goes with them.
+      def delete
+        @records = [@record]
+        @dependents = Dependents::Selection.new(@records)
+      end
+
+      def delete_selected
+        @records = selected_records
+        @dependents = Dependents::Selection.new(@records)
+        render :delete
+      end
+
+      def destroy
+        @record.destroy!
+        redirect_to index_path, notice: saved_notice(:destroyed)
+      rescue ActiveRecord::InvalidForeignKey, ActiveRecord::DeleteRestrictionError => e
+        redirect_to after_save_path(@record), alert: e.message
+      end
+
+      def destroy_selected
+        records = selected_records
+        records.each(&:destroy!)
+        redirect_to index_path,
+                    notice: t('crud_components.admin.notices.destroyed_selected', count: records.size,
+                              default: '%{count} deleted.')
+      rescue ActiveRecord::InvalidForeignKey, ActiveRecord::DeleteRestrictionError => e
+        redirect_to index_path, alert: e.message
+      end
+
+      private
+
+      # The ticked rows, each checked against the ability on its own.
+      def selected_records
+        CrudComponents.selected(base_scope, params).select { |record| allowed?(:destroy, record) }
+      end
+
+      def set_entry
+        @entry = admin_registry[params[:crud_model]]
+        raise ActiveRecord::RecordNotFound, "no admin entry for #{params[:crud_model].inspect}" unless @entry
+
+        @model = @entry.model
+      end
+
+      # A nested index (`/admin/publishers/tor-books/books`) renders the owner's
+      # association; everything else renders the model's own scope.
+      def base_scope
+        return admin_scope(@entry) unless owner
+
+        owner.public_send(params[:crud_association])
+      end
+
+      def owner_entry
+        return @owner_entry if defined?(@owner_entry)
+
+        @owner_entry = params[:crud_owner] && admin_registry[params[:crud_owner]]
+      end
+
+      def owner
+        return @owner if defined?(@owner)
+
+        entry = owner_entry
+        return @owner = nil unless entry
+
+        record = find_record(admin_scope(entry), params["#{entry.singular_route_key}_id"], entry)
+        raise ForbiddenError, "not allowed to show this #{entry.model.model_name.human}" unless allowed?(:show, record)
+
+        @owner = record
+      end
+
+      def set_record
+        @record = find_record(base_scope, params[:id])
+      end
+
+      def build_record
+        @record = @model.new
+      end
+
+      # A URL segment matches `identify_by` first, then the primary key — so a
+      # model whose `to_param` is a slug and one that uses ids both resolve.
+      def find_record(scope, param, entry = @entry)
+        key = entry.param_key
+        found = key.to_s == 'id' ? nil : scope.find_by(key => param)
+        found ||= scope.find_by(entry.model.primary_key => param)
+        raise ActiveRecord::RecordNotFound, "#{entry.model}: no record for #{param.inspect}" unless found
+
+        found
+      end
+
+      # The engine's own actions, mapped to the RESTful one an ability knows.
+      ACTION_PERMISSIONS = { destroy_selected: :destroy, delete_selected: :destroy, delete: :destroy }.freeze
+
+      # Otherwise the action the request performs is the one authorized.
+      # CanCanCan aliases :new to :create and :edit to :update, so a rule
+      # written either way still applies; an ability that tells them apart is
+      # asked the narrower question of the two.
+      def authorize_action!
+        subject = @record || @model
+        permission = ACTION_PERMISSIONS.fetch(action_name.to_sym, action_name.to_sym)
+        return if allowed?(permission, subject)
+
+        # Through the host's `authorize!` first, so its own `rescue_from` decides.
+        authorize!(permission, subject) if respond_to?(:authorize!, true)
+
+        raise ForbiddenError, "not allowed to #{permission} this #{@model.model_name.human}"
+      end
+
+      def allowed?(permission, subject)
+        ability = admin_ability
+        ability.nil? || ability.can?(permission, subject)
+      end
+
+      def record_params(action)
+        permitted = CrudComponents.permitted_attributes(@model, action: action, ability: admin_ability)
+        return {} if permitted.empty?
+
+        params.require(@model.model_name.param_key).permit(*permitted)
+      end
+
+      def paginate(scope)
+        return scope unless scope.respond_to?(:page)
+
+        scope = scope.page(params[:page])
+        scope.respond_to?(:per) ? scope.per(admin_config.per_page) : scope
+      end
+
+      # One controller serves every model, so `url_for(action:)` cannot tell the
+      # resources apart — go through the entry's own named helpers.
+      def index_path = public_send("#{@entry.route_key}_path")
+
+      def after_save_path(record)
+        return public_send("#{@entry.singular_route_key}_path", record) if @entry.allows?(:show)
+        return public_send("edit_#{@entry.singular_route_key}_path", record) if @entry.allows?(:edit)
+
+        index_path
+      end
+
+      def saved_notice(key)
+        t("crud_components.admin.notices.#{key}", model: @model.model_name.human,
+                                                  default: "%{model} #{key}.")
+      end
+    end
+  end
+end

data/app/views/crud_components/admin/_sidebar.html.erb

@@ -0,0 +1,20 @@
+<%# The model navigation. Rendered by the bundled layout; render it yourself
+    (`render 'crud_components/admin/sidebar'`) when the admin runs in a layout
+    of your own. %>
+<nav class="crud-admin-nav" aria-label="<%= t('crud_components.admin.models', default: 'Models') %>">
+  <% admin_entry_groups.each do |heading, entries| %>
+    <% if heading %>
+      <div class="text-uppercase text-muted small fw-semibold px-2 mt-3 mb-1"><%= heading %></div>
+    <% end %>
+    <ul class="nav nav-pills flex-column mb-1">
+      <% entries.each do |entry| %>
+        <li class="nav-item">
+          <%= link_to admin_index_path(entry),
+                      class: "nav-link py-1 px-2 #{'active' if admin_current_entry?(entry)}" do %>
+            <%= admin_icon(entry.icon, css_class: 'me-1') %><%= entry.label %>
+          <% end %>
+        </li>
+      <% end %>
+    </ul>
+  <% end %>
+</nav>

data/app/views/crud_components/admin/dashboard/show.html.erb

@@ -0,0 +1,22 @@
+<h1 class="h4 mb-3"><%= admin_title %></h1>
+
+<% admin_entry_groups.each do |group, entries| %>
+  <% if group %>
+    <h2 class="h6 text-uppercase text-muted mt-4"><%= group %></h2>
+  <% end %>
+
+  <div class="row row-cols-1 row-cols-sm-2 row-cols-lg-4 g-3">
+    <% entries.each do |entry| %>
+      <div class="col">
+        <%= link_to admin_index_path(entry), class: 'card h-100 text-decoration-none text-reset' do %>
+          <div class="card-body d-flex justify-content-between align-items-center gap-2">
+            <span><%= admin_icon(entry.icon, css_class: 'me-1') %><%= entry.label %></span>
+            <% if (count = @counts&.dig(entry.name)) %>
+              <span class="badge text-bg-light"><%= number_with_delimiter(count) %></span>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    <% end %>
+  </div>
+<% end %>

data/app/views/crud_components/admin/resources/_dependent_records.html.erb

@@ -0,0 +1,16 @@
+<%# Locals: owner, item — the records this item stands for, named: the first
+    few as links, then the index holding the rest. %>
+<%- if item.records.present? -%>
+  <ul class="list-unstyled small ms-3 mb-0">
+    <%- item.records.each do |dependent| -%>
+      <li><%= admin_dependent_link(dependent, owner: owner) %></li>
+    <%- end -%>
+    <%- if item.unnamed.positive? -%>
+      <% more = t('crud_components.more', count: item.unnamed, default: '+%{count} more') %>
+      <% index_path = admin_dependents_path(owner, item) %>
+      <li>
+        <%= index_path ? link_to(more, index_path, class: 'text-muted') : tag.span(more, class: 'text-muted') %>
+      </li>
+    <%- end -%>
+  </ul>
+<%- end -%>

data/app/views/crud_components/admin/resources/delete.html.erb

@@ -0,0 +1,98 @@
+<%# One record or a ticked selection: the same page, differing only in how many
+    records it is about. @record is set for the member route, nil for the
+    collection one; @records holds them either way. %>
+<% one = @records.one? && @record %>
+<% selection = admin_selection_item(@model, @records) %>
+<% title = t('crud_components.admin.delete.title', count: @records.size, model: selection.human_name,
+             default: 'Delete these %{count} %{model}?') %>
+<% content_for :title, title %>
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb">
+    <li class="breadcrumb-item"><%= link_to @entry.label, admin_index_path(@entry) %></li>
+    <%- if one -%>
+      <li class="breadcrumb-item"><%= link_to crud_label(@record), url_for(@record) %></li>
+    <%- end -%>
+    <li class="breadcrumb-item active" aria-current="page"><%= t('crud_components.actions.destroy', default: 'Delete') %></li>
+  </ol>
+</nav>
+
+<div class="card border-danger">
+  <div class="card-body">
+    <h1 class="h5 mb-3"><%= title %></h1>
+
+    <%- if @records.empty? -%>
+      <p class="text-muted"><%= t('crud_components.admin.delete.none_selected', default: 'Nothing was selected.') %></p>
+    <%- else -%>
+      <%= render 'crud_components/admin/resources/dependent_records', owner: nil, item: selection %>
+
+      <% blockers = @dependents.blockers %>
+      <%- if blockers.any? -%>
+        <div class="alert alert-warning mt-3">
+          <p class="mb-1"><%= t('crud_components.admin.delete.blocked', count: @records.size,
+                                default: 'This cannot be deleted while it still has:') %></p>
+          <ul class="mb-0">
+            <%- blockers.each do |item| -%>
+              <li>
+                <%= item.count %> <%= item.human_name %>
+                <%= render 'crud_components/admin/resources/dependent_records', owner: @record, item: item %>
+              </li>
+            <%- end -%>
+          </ul>
+        </div>
+      <%- end -%>
+
+      <% goes = @dependents.items.select(&:destroys?) %>
+      <% nullified = @dependents.items.select(&:nullifies?) %>
+
+      <%- if goes.any? -%>
+        <p class="mb-1 mt-3"><%= t('crud_components.admin.delete.also_deleted', default: 'These go with it:') %></p>
+        <ul>
+          <%- goes.each do |item| -%>
+            <li>
+              <strong><%= number_with_delimiter(item.count) %></strong> <%= item.human_name %>
+              <%- if item.cascades -%>
+                <span class="text-muted"><%= t('crud_components.admin.delete.cascades',
+                                               default: '(and whatever depends on those)') %></span>
+              <%- end -%>
+              <%- unless admin_may_destroy?(item.model) -%>
+                <span class="text-warning-emphasis"><%= t('crud_components.admin.delete.beyond_you',
+                                                          default: '(not deletable on their own)') %></span>
+              <%- end -%>
+              <%= render 'crud_components/admin/resources/dependent_records', owner: @record, item: item %>
+            </li>
+          <%- end -%>
+        </ul>
+      <%- end -%>
+
+      <%- if nullified.any? -%>
+        <p class="mb-1 mt-3"><%= t('crud_components.admin.delete.kept', default: 'These stay, but lose the reference:') %></p>
+        <ul>
+          <%- nullified.each do |item| -%>
+            <li>
+              <strong><%= number_with_delimiter(item.count) %></strong> <%= item.human_name %>
+              <%= render 'crud_components/admin/resources/dependent_records', owner: @record, item: item %>
+            </li>
+          <%- end -%>
+        </ul>
+      <%- end -%>
+
+      <%- if goes.empty? && nullified.empty? && blockers.empty? -%>
+        <p class="text-muted mt-3"><%= t('crud_components.admin.delete.nothing_else', count: @records.size,
+                                         default: 'Nothing else depends on it.') %></p>
+      <%- end -%>
+    <%- end -%>
+
+    <div class="d-flex gap-2 mt-4">
+      <%- if @records.any? -%>
+        <%= button_to t('crud_components.actions.destroy', default: 'Delete'),
+                      one ? url_for(@record) : public_send("destroy_selected_#{@entry.route_key}_path"),
+                      method: :delete, class: 'btn btn-danger', disabled: blockers.any?,
+                      params: one ? {} : { selected: admin_selected_values(@records) } %>
+      <%- end -%>
+      <%= link_to t('crud_components.admin.delete.cancel', default: 'Cancel'),
+                  one ? url_for(@record) : admin_index_path(@entry),
+                  class: 'btn btn-outline-secondary' %>
+    </div>
+  </div>
+</div>

data/app/views/crud_components/admin/resources/edit.html.erb

@@ -0,0 +1,14 @@
+<% content_for :title, crud_label(@record) %>
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb">
+    <li class="breadcrumb-item"><%= link_to @entry.label, admin_index_path(@entry) %></li>
+    <li class="breadcrumb-item active" aria-current="page"><%= crud_label(@record) %></li>
+  </ol>
+</nav>
+
+<div class="card">
+  <div class="card-body">
+    <%= crud_form @record %>
+  </div>
+</div>

data/app/views/crud_components/admin/resources/index.html.erb

@@ -0,0 +1,26 @@
+<% content_for :title, @entry.label %>
+
+<% if @owner %>
+  <nav aria-label="breadcrumb">
+    <ol class="breadcrumb">
+      <li class="breadcrumb-item"><%= link_to @owner_entry.label, admin_index_path(@owner_entry) %></li>
+      <li class="breadcrumb-item"><%= link_to crud_label(@owner), url_for(@owner) %></li>
+      <li class="breadcrumb-item active" aria-current="page"><%= @entry.label %></li>
+    </ol>
+  </nav>
+<% end %>
+
+<h1 class="h4 mb-3">
+  <%= admin_icon(@entry.icon) %> <%= @entry.label %>
+  <% if @owner %><small class="text-muted fs-6">— <%= crud_label(@owner) %></small><% end %>
+</h1>
+
+<div class="card">
+  <div class="card-body">
+    <%= crud_collection @records, query: @query, fieldset: @entry.fieldset, picker: true,
+                        extra_actions: [admin_show_in_app_action,
+                                        admin_delete_action(@entry),
+                                        admin_destroy_selected_action(@entry)].compact,
+                        except_actions: %i[destroy] %>
+  </div>
+</div>

data/app/views/crud_components/admin/resources/new.html.erb

@@ -0,0 +1,14 @@
+<% content_for :title, t('crud_components.admin.new', model: @model.model_name.human, default: 'New %{model}') %>
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb">
+    <li class="breadcrumb-item"><%= link_to @entry.label, admin_index_path(@entry) %></li>
+    <li class="breadcrumb-item active" aria-current="page"><%= content_for(:title) %></li>
+  </ol>
+</nav>
+
+<div class="card">
+  <div class="card-body">
+    <%= crud_form @record %>
+  </div>
+</div>

data/app/views/crud_components/admin/resources/show.html.erb

@@ -0,0 +1,16 @@
+<% content_for :title, crud_label(@record) %>
+
+<nav aria-label="breadcrumb">
+  <ol class="breadcrumb">
+    <li class="breadcrumb-item"><%= link_to @entry.label, admin_index_path(@entry) %></li>
+    <li class="breadcrumb-item active" aria-current="page"><%= crud_label(@record) %></li>
+  </ol>
+</nav>
+
+<div class="card">
+  <div class="card-body">
+    <%= crud_record @record, fieldset: @entry.fieldset,
+                    extra_actions: [admin_show_in_app_action, admin_delete_action(@entry)].compact,
+                    except_actions: %i[destroy] %>
+  </div>
+</div>