plutonium 0.67.0 → 0.69.0

data/lib/plutonium/interaction/async/run.rb

@@ -27,6 +27,15 @@ module Plutonium
         IN_PROGRESS_STATES = %w[pending running].freeze
         FAILURE_POLICIES = %i[halt continue transactional].freeze
 
+        # Tags the errors_log entries a pre_check rejection writes, which is what
+        # #outcome reads "rejected" from. A key in the existing JSON rather than a
+        # column: older entries simply lack it.
+        PRE_CHECK_STAGE = "pre_check"
+
+        # Raised by #reject called anywhere but inside pre_check, where nothing
+        # would collect the rejection.
+        class RejectOutsidePreCheckError < StandardError; end
+
         # Routes, paths and helpers are all derived from model_name, and the
         # default would spell the gem's own namespace out in every URL
         # (/admin/plutonium/interaction/runs) and every helper
@@ -65,6 +74,7 @@ module Plutonium
 
         scope :in_progress, -> { where(state: IN_PROGRESS_STATES) }
         scope :for_target, ->(klass) { where(target_type: klass.to_s) }
+        scope :finished_since, ->(time) { where.not(state: IN_PROGRESS_STATES).where(finished_at: time..) }
 
         # In progress with no recorded activity since +before+ — see
         # Async::ReapJob. +last_activity_at+ is nil until a job actually claims
@@ -130,9 +140,17 @@ module Plutonium
         #
         # @return [String]
         def outcome
+          return "rejected" if rejected?
+
           (state == "completed" && errors_log.any?) ? "completed_with_errors" : state
         end
 
+        # Failed because its pre_check refused the input, as opposed to failing
+        # while doing the work. Nothing was processed. state stays "failed", so
+        # every reader keyed on state (ReapJob, in_progress, the banner) is
+        # unaffected.
+        def rejected? = state == "failed" && errors_log.any? { |entry| entry["stage"] == PRE_CHECK_STAGE }
+
         # @return [Integer] recorded target failures, run-level entries included
         def error_count = errors_log.size
 
@@ -153,23 +171,42 @@ module Plutonium
 
         # Runs have no name or title, so Labeling would fall back to
         # "Async run #12" — true but silent about the only thing that
-        # distinguishes one row from the next.
-        #
-        # Demodulized: a host's run class is as likely to be
-        # Billing::ReissueInvoicesRun as a top-level one, and the namespace adds
-        # nothing to a label that already sits under the run's own breadcrumb.
-        #
-        # Except when demodulizing is what throws the name away. A run declared
-        # by Dispatchable#async is Blogging::ArchivePosts::Run, and every
-        # one of them would render "Run #12" — the failure mode this method
-        # exists to avoid, reintroduced for the shape most authors will write.
-        # For those, the enclosing segment IS the name, so it is folded back in.
+        # distinguishes one row from the next. The dispatching interaction's
+        # label is that thing: "Import Posts #12".
         #
         # @return [String]
         def to_label
-          parts = self.class.name.split("::")
-          name = (parts.last == "Run" && parts.size > 1) ? "#{parts[-2]}Run" : parts.last
-          I18n.t("plutonium.async.run.label", name: name.titleize, id: to_param)
+          I18n.t("plutonium.async.run.label", name: interaction_label, id: to_param)
+        end
+
+        # The interaction's label (its `presents label:`), or a name derived from
+        # the run class for a run with no interaction behind it.
+        #
+        # @return [String]
+        def interaction_label
+          interaction_class&.label || run_class_label
+        end
+
+        # The interaction this run belongs to. A run declared by
+        # Dispatchable#async is <Interaction>::Run, so it is the enclosing class.
+        # nil for a standalone run class, which may be shared by several
+        # interactions and so belongs to none of them.
+        #
+        # @return [Class, nil]
+        def interaction_class
+          parent = self.class.module_parent
+          parent if parent < Plutonium::Interaction::Base
+        end
+
+        # The index's progress cell: "1 / 4", or nil for opaque work. Two
+        # counter columns showed opaque work as "0" done of nothing, which reads
+        # as a run that did nothing rather than one with no count to report.
+        #
+        # @return [String, nil]
+        def progress
+          return nil if progress_total.nil?
+
+          I18n.t("plutonium.async.run.progress", done: progress_done, total: progress_total)
         end
 
         # nil means INDETERMINATE, not zero: opaque work has no denominator, and
@@ -222,6 +259,53 @@ module Plutonium
           )
         end
 
+        # Fails the run with its pre_check's rejections, in ONE write, for the
+        # reason record_target_failures! gives: a crash between two writes must
+        # not leave a failed run without its reasons, or reasons on a run still
+        # marked running. Entries carry the run-level nil target_id, so progress
+        # and handled_target_ids are untouched: nothing was processed.
+        #
+        # @param messages [Array<String>] the rejections that were stored
+        # @param overflow [Integer] how many more were rejected past max_rejections
+        def reject_run!(messages, overflow: 0)
+          entries = messages.map { |message| pre_check_entry(message) }
+          entries << pre_check_entry(I18n.t("plutonium.async.executor.rejections_truncated", count: overflow)) if overflow.positive?
+
+          now = Time.current
+          update!(errors_log: errors_log + entries, state: "failed", finished_at: now, last_activity_at: now)
+        end
+
+        # Runs the block with #reject live, and closes it again afterwards.
+        # Called by Async::Executor around pre_check.
+        #
+        # @return [Array(Array<String>, Integer)] the stored messages, and how
+        #   many more were rejected past max_rejections
+        def collect_rejections
+          @rejections = []
+          @rejection_count = 0
+          yield
+          [@rejections, @rejection_count - @rejections.size]
+        ensure
+          @rejections = @rejection_count = nil
+        end
+
+        # Records one problem with the run's input and returns, so a check can
+        # report every bad row in one pass. Only live inside pre_check: a
+        # rejection from perform would be collected by nothing.
+        #
+        # Counts past max_rejections but stores no more than that, so memory
+        # stays bounded and the "and N more" count is exact.
+        #
+        # @param message [String]
+        # @return [void]
+        def reject(message)
+          raise RejectOutsidePreCheckError, I18n.t("plutonium.async.run.reject_outside_pre_check", run_class: self.class) if @rejections.nil?
+
+          @rejection_count += 1
+          @rejections << message.to_s if @rejections.size < Plutonium.configuration.async_interactions.max_rejections
+          nil
+        end
+
         # Target ids not yet dispositioned — what a resumed run still has to
         # do. See {#record_target_failures!} and Async::Executor#advance!, which
         # are what populate handled_target_ids.
@@ -232,6 +316,16 @@ module Plutonium
           target_ids.reject { |id| handled.include?(id.to_s) }
         end
 
+        # Whether an earlier pass got as far as applying a target, which it can
+        # only have done after its pre_check passed. A handled id with no
+        # errors_log entry was applied; failures (unresolved or raised) all carry one.
+        #
+        # @return [Boolean]
+        def any_target_applied?
+          failed = errors_log.filter_map { |entry| entry["target_id"]&.to_s }.to_set
+          handled_target_ids.any? { |id| !failed.include?(id.to_s) }
+        end
+
         # The interaction's validated inputs, with the types dispatch put in.
         #
         # The column is JSON, so Dispatchable#dispatch_options writes it through
@@ -377,8 +471,28 @@ module Plutonium
             "#perform_on(record) for work over targets, or #perform for opaque work"
         end
 
+        # Checks the run's input before any work, and refuses it with #reject.
+        # Optional: the default checks nothing. Override it as
+        # +pre_check(records)+ in a run with +perform_on+ (it receives the
+        # resolved, authorized records), or +pre_check+ for opaque work.
+        # See Async::Executor#pre_check_passed?.
+        def pre_check(*) = nil
+
         private
 
+        def pre_check_entry(message) = {"target_id" => nil, "message" => message, "stage" => PRE_CHECK_STAGE}
+
+        # For a standalone run class, passed as `async Billing::ReissueInvoicesRun`,
+        # which has no interaction around it to take a label from. Demodulized,
+        # since the namespace adds nothing under the run's own breadcrumb. A
+        # <Something>::Run that is not inside an interaction keeps the enclosing
+        # segment, or every one of them would read "Run".
+        def run_class_label
+          parts = self.class.name.split("::")
+          name = (parts.last == "Run" && parts.size > 1) ? "#{parts[-2]}Run" : parts.last
+          name.titleize
+        end
+
         # Not swallowed: after_commit runs synchronously, so re-raising here
         # still surfaces to the dispatching request rather than leaving a
         # permanently invisible, un-enqueued ghost.

data/lib/plutonium/interaction/async/run_definition.rb

@@ -25,19 +25,20 @@ module Plutonium
         # neither a type to infer nor a badge to infer one from (`state` is a
         # plain string column with an inclusion validation, not a Rails enum).
         #
-        # `running` and `completed_with_errors` are coloured explicitly: neither
-        # is in the badge component's semantic table, and its fallback is a
+        # `running`, `completed_with_errors` and `rejected` are coloured explicitly:
+        # none is in the badge component's semantic table, and its fallback is a
         # stable-but-meaningless colour.
         field :outcome, as: :string
         display :outcome, as: :badge,
-          colors: {running: :info, completed_with_errors: :warning}
+          colors: {running: :info, completed_with_errors: :warning, rejected: :warning}
         # Declared for the table too: the index is where an operator scans for the
         # run that did not do what it was asked, and a bare
         # "completed_with_errors" string is the one place that reads worse than
         # the badge.
         column :outcome, as: :badge,
-          colors: {running: :info, completed_with_errors: :warning}
+          colors: {running: :info, completed_with_errors: :warning, rejected: :warning}
 
+        field :interaction_label, label: t("plutonium.async.run.interaction")
         field :target_label, label: t("plutonium.async.run.target_type")
 
         # The details tab, with the live panel above the fields.

data/lib/plutonium/interaction/async/run_policy.rb

@@ -63,22 +63,22 @@ module Plutonium
         # unreadably.
         def permitted_attributes_for_read
           %i[
-            type outcome progress_done progress_total
+            interaction_label outcome progress
             target_label initiator started_at finished_at created_at
           ]
         end
 
-        # The show page drops the progress COUNTERS, for the reason errors_log
+        # The show page drops the progress cell, for the reason errors_log
         # is absent above: the panel already renders them, as "5 of 5 targets
         # (100%)" over a bar. Two renderings of one number is the same report
         # twice — and they disagree, because only the panel is inside the polled
         # frame. A page that says "Completed" and "0 done" at once is worse than
         # either alone.
         #
-        # The INDEX keeps them. There is no progress bar in a table row, so the
-        # counters are the only progress it can show.
+        # The INDEX keeps it. There is no progress bar in a table row, so the
+        # cell is the only progress it can show.
         def permitted_attributes_for_show
-          permitted_attributes_for_read - %i[progress_done progress_total]
+          permitted_attributes_for_read - %i[progress]
         end
       end
     end

data/lib/plutonium/interaction/response/redirect.rb

@@ -24,10 +24,13 @@ module Plutonium
             # appending the options hash raises ArgumentError rather than
             # producing a formatted URL. A caller handing over a complete URL has
             # already decided what it points at.
+            #
+            # Also skipped for a turbo-stream request: it is answered below with a
+            # visit, and a visit wants the page, not a .turbo_stream URL.
             fully_formed_url = redirect_args.size == 1 && redirect_args.first.is_a?(String)
 
             url_options = redirect_args.last.is_a?(Hash) ? redirect_args.last : {}
-            if !fully_formed_url && !url_options.key?(:format) && request.format.symbol != :html
+            if !fully_formed_url && !url_options.key?(:format) && !request.format.symbol.in?(%i[html turbo_stream])
               url_options = url_options.merge(format: request.format.symbol)
               redirect_args = [*redirect_args[0...-1], url_options] if redirect_args.last.is_a?(Hash)
               redirect_args = [*redirect_args, url_options] unless redirect_args.last.is_a?(Hash)
@@ -36,14 +39,23 @@ module Plutonium
             url = fully_formed_url ? redirect_args.first : url_for(*redirect_args)
 
             respond_to do |format|
+              # Answered with a stream action wherever the form lives, the way
+              # every other Plutonium success path answers a turbo-stream post.
+              # A plain redirect_to here is followed by fetch and its page
+              # rendered into whatever frame submitted the form.
+              #
+              # turbo_stream_redirect is a client-side visit, so it skips the
+              # open-redirect check redirect_to applies. It is applied here the
+              # same way, with redirect_to's own default for allow_other_host:
+              # resolved up front from raise_on_open_redirects before Rails 8.1,
+              # left nil from 8.1 on, where the check resolves it and nil also
+              # drives action_on_open_redirect (:log / :notify).
               format.turbo_stream do
-                if helpers.current_turbo_frame == Plutonium::REMOTE_MODAL_FRAME
-                  render turbo_stream: [
-                    helpers.turbo_stream_redirect(url)
-                  ]
-                else
-                  redirect_to(url, **redirect_options)
+                allow_other_host = redirect_options.fetch(:allow_other_host) do
+                  _allow_other_host if ActionPack.gem_version < Gem::Version.new("8.1")
                 end
+                _enforce_open_redirect_protection(url, allow_other_host:)
+                render turbo_stream: helpers.turbo_stream_redirect(url)
               end
 
               format.any { redirect_to(url, **redirect_options) }

data/lib/plutonium/resource/query_object.rb

@@ -36,6 +36,12 @@ module Plutonium
         Plutonium::Translation.label_for(:filter, resource_class, name) || name.to_s.humanize
       end
 
+      # Display label for a scope: the plutonium.scopes.<model>.<name>
+      # convention, else the humanized name.
+      def scope_label(name)
+        Plutonium::Translation.label_for(:scope, resource_class, name) || name.to_s.humanize
+      end
+
       def initialize(resource_class, params, request_path, &)
         @resource_class = resource_class
         @params = params

data/lib/plutonium/routing/dashboard_registration.rb

@@ -114,6 +114,11 @@ module Plutonium
         # the portal's again, last, so bare helpers (`root_path` in the
         # sidebar) resolve against the engine like a source-defined controller.
         klass.include(namespace.railtie_routes_url_helpers) if namespace != Object
+        # The same anonymous `inherited` hook boots the controller before it
+        # has a name, so it never prepends the portal's views and a portal's
+        # own partials (an ejected sidebar) lose to the gem's. Boot it again
+        # now that it is named.
+        klass.boot
 
         if concern_name && (concern = concern_name.safe_constantize)
           klass.include concern

data/lib/plutonium/ui/avatar.rb

@@ -56,7 +56,7 @@ module Plutonium
           value.attached? ? value.url : nil
         elsif value.respond_to?(:url)     # bare Shrine::UploadedFile, CarrierWave, ...
           value.url
-        elsif value.is_a?(String) && value.start_with?("http", "/")
+        elsif value.is_a?(String) && value.start_with?("http", "/", "data:image/")
           value
         end
       rescue ArgumentError, URI::InvalidURIError
@@ -72,7 +72,7 @@ module Plutonium
         # A URL-shaped positional subject is really an image, not an identity:
         # route it to src so Avatar("https://…/p.png") shows the image rather
         # than hashing the URL into a seed.
-        if src.nil? && subject.is_a?(String) && subject.start_with?("http", "/")
+        if src.nil? && subject.is_a?(String) && subject.start_with?("http", "/", "data:image/")
           src = subject
           subject = nil
         end

data/lib/plutonium/ui/breadcrumbs.rb

@@ -48,10 +48,24 @@ module Plutonium
       def breadcrumb_items
         @breadcrumb_items ||= [].tap do |items|
           collect_parent_breadcrumbs(items) if current_parent.present?
-          collect_resource_breadcrumbs(items) if resource_record?
+          if resource_record?
+            collect_resource_breadcrumbs(items)
+          elsif collection_page?
+            collect_resource_index_breadcrumb(items)
+          end
         end
       end
 
+      # A page that hangs off the resource list without being about one record:
+      # a resource action (import), a wizard launched from the index, or a
+      # custom collection route (calendar). It has no record to name, but the
+      # list it came from is still a level up. The index itself is excluded
+      # because its page title already says where you are, and a singular
+      # resource has no index to point back to.
+      def collection_page?
+        action_name != "index" && !singular_resource_context?
+      end
+
       # The segments eligible to be folded into the overflow menu. The last one
       # is never foldable — it is the deepest thing the trail knows about, which
       # is the record on new/edit pages but the resource index on show pages,
@@ -151,21 +165,25 @@ module Plutonium
       end
 
       def collect_plural_resource_breadcrumbs(items)
+        collect_resource_index_breadcrumb(items)
+
+        # Record itself (for non-singular routes only)
+        return unless resource_record!.persisted? && action_name != "show"
+
+        items << segment(display_name_of(resource_record!), resource_url_for(resource_record!))
+      end
+
+      def collect_resource_index_breadcrumb(items)
         # No `parent:` here on purpose: Resource::Controller#resource_url_args_for
         # already defaults it to `current_parent` (and supplies
-        # `current_nested_association` with it), so both links nest themselves
+        # `current_nested_association` with it), so the link nests itself
         # when the request arrived through a nesting. Passing it explicitly reads
-        # like it changes something; it doesn't. The parent segments above pass
+        # like it changes something; it doesn't. The parent segments pass
         # `parent: nil` precisely to opt OUT of that default.
         items << segment(
           nestable_resource_name_plural(resource_class),
           resource_url_for(resource_class)
         )
-
-        # Record itself (for non-singular routes only)
-        return unless resource_record!.persisted? && action_name != "show"
-
-        items << segment(display_name_of(resource_record!), resource_url_for(resource_record!))
       end
 
       # Stands in for whatever the controller folded away, the way GitHub

data/lib/plutonium/ui/dashboard/board.rb

@@ -6,7 +6,9 @@ module Plutonium
       # The card grid. Every lazy card is a `<turbo-frame src loading="lazy">`
       # holding a skeleton of its own shape, so the page paints at once and
       # each card's queries run in a separate request as it scrolls into
-      # view. A card declared `lazy: false` renders inline.
+      # view. A card declared `lazy: false` renders inline. Frames carry
+      # `target="_top"` so a link inside a card navigates the page, not the
+      # card's frame.
       class Board < Plutonium::UI::Component::Base
         include Phlex::Rails::Helpers::TurboFrameTag
 
@@ -54,6 +56,7 @@ module Plutonium
               src: dashboard_card_path(card),
               loading: "lazy",
               refresh: "morph",
+              target: "_top",
               class: tokens("block", span_classes(card)),
               **refresh_attributes(card)
             ) { render Skeleton.new(card:) }

data/lib/plutonium/ui/dashboard/frame.rb

@@ -15,7 +15,7 @@ module Plutonium
         end
 
         def view_template
-          turbo_frame_tag(@card.frame_id, class: "block") do
+          turbo_frame_tag(@card.frame_id, target: "_top", class: "block") do
             render Card.for(dashboard: @dashboard, card: @card)
           end
         end

data/lib/plutonium/ui/dashboard/metric.rb

@@ -9,7 +9,7 @@ module Plutonium
       #
       #   {value: 1_240}                                   # just the number
       #   {value: 1_240, previous: 1_100}                  # change computed: +12.7%
-      #   {value: 1_240, change: 12.7}                     # change in percentage points
+      #   {value: 1_240, change: 12.7}                     # +12.7% (+12.7 pts with change_unit: :points)
       #   {value: 1_240, change: "+140", trend: :up}       # change shown verbatim
       #   {value: 98.2, change_label: "vs. last week"}     # caption after the change
       #
@@ -36,13 +36,22 @@ module Plutonium
           data[:change_label] ||= card.options[:change_label]
 
           if !data.key?(:change) && data[:previous].is_a?(Numeric) && data[:value].is_a?(Numeric)
-            data[:change] = percent_change(data[:value], data[:previous])
+            data[:change] = points? ? data[:value] - data[:previous] : percent_change(data[:value], data[:previous])
           end
 
+          # Round to the precision the change is shown at, so float noise
+          # (0.3 against 0.1 + 0.2) reads as no change rather than "-0" heading
+          # down. `+ 0.0` turns a rounded -0.0 into 0.0.
+          data[:change] = data[:change].round(1) + 0.0 if data[:change].is_a?(Numeric)
+
+          # A `previous` of zero leaves a percent `change` nil but still sets
+          # the trend key, so a captioned row shows a neutral dash.
           data[:trend] ||= infer_trend(data[:change]) if data.key?(:change)
           data
         end
 
+        def points? = card.options[:change_unit] == :points
+
         def percent_change(value, previous)
           return nil if previous.zero?
 
@@ -65,9 +74,12 @@ module Plutonium
         end
 
         def render_change(data)
+          # A caption with no change or trend (a count of ratings, say) is
+          # not a trend: no icon, neutral tone.
+          trending = data.key?(:trend)
           trend = data[:trend] || :flat
-          div(class: tokens("pu-metric-change", change_tone_class(trend))) do
-            render_trend_icon(trend)
+          div(class: tokens("pu-metric-change", change_tone_class(trending ? trend : :flat))) do
+            render_trend_icon(trend) if trending
             span(class: "font-medium") { format_change(data[:change]) } if data[:change]
             span(class: "pu-metric-change-label") { data[:change_label] } if data[:change_label].present?
           end
@@ -93,7 +105,8 @@ module Plutonium
           case change
           when Numeric
             sign = change.positive? ? "+" : ""
-            "#{sign}#{number_to_rounded(change, precision: 1, strip_insignificant_zeros: true)}%"
+            rounded = number_to_rounded(change, precision: 1, strip_insignificant_zeros: true)
+            points? ? t("plutonium.dashboard.metric.points", change: "#{sign}#{rounded}") : "#{sign}#{rounded}%"
           else change.to_s
           end
         end

data/lib/plutonium/ui/dashboard/toolbar.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # The row above the card grid: each filter as a segmented control of
+      # links, so the choice is a plain URL that survives a reload and can be
+      # shared, and the dashboard's links on the right.
+      class Toolbar < Plutonium::UI::Component::Base
+        def initialize(dashboard:)
+          @dashboard = dashboard
+        end
+
+        def render?
+          dashboard.class.filters.any? || links.any?
+        end
+
+        def view_template
+          div(class: "pu-dashboard-toolbar mb-4 flex flex-wrap items-center justify-between gap-3") do
+            div(class: "flex flex-wrap items-center gap-3") do
+              dashboard.class.filters.each { |filter| render_filter(filter) }
+            end
+            div(class: "flex flex-wrap items-center gap-2") do
+              links.each { |link, href| render_link(link, href) }
+            end
+          end
+        end
+
+        private
+
+        attr_reader :dashboard
+
+        # Visible links paired with their href. A link whose `href:` resolves
+        # to nil (a proc that returns nothing for this user) is left out
+        # rather than rendered as a dead button.
+        def links
+          @links ||= dashboard.visible_links.filter_map do |link|
+            href = link.href_for(dashboard)
+            [link, href] if href.present?
+          end
+        end
+
+        def render_filter(filter)
+          current = dashboard.filter_value(filter.key)
+          nav(class: "pu-dashboard-filter inline-flex rounded-[var(--pu-radius-md)] border border-[var(--pu-border)] p-0.5",
+            aria: {label: filter.label}, data: {dashboard_filter: filter.key}) do
+            dashboard.filter_choices(filter).each do |value, label|
+              selected = value == current
+              a(
+                href: filter_url(filter, value),
+                class: tokens(
+                  "rounded-[var(--pu-radius-sm)] px-3 py-1 text-sm transition-colors",
+                  selected ? "bg-[var(--pu-surface-alt)] font-medium text-[var(--pu-text)]" : "text-[var(--pu-text-muted)] hover:text-[var(--pu-text)]"
+                ),
+                aria: {current: selected ? "true" : nil}
+              ) { Plutonium::Translation.resolve(label) }
+            end
+          end
+        end
+
+        def render_link(link, href)
+          a(href:, class: "pu-btn pu-btn-sm pu-btn-outline", data: {dashboard_link: link.key}) do
+            render link.icon.new(class: "size-4") if link.icon
+            span { link.label }
+          end
+        end
+
+        # The page with this filter set and the rest of the query string kept.
+        def filter_url(filter, value)
+          query = dashboard.request.query_parameters.merge(filter.key.to_s => value)
+          "#{dashboard.request.path}?#{query.to_query}"
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/base.rb

@@ -147,6 +147,26 @@ module Plutonium
           # has to be re-pointed explicitly or habtm skips the policy scope.
           alias_method :has_and_belongs_to_many_tag, :secure_association_tag
 
+          # List-style variants of the association input: one control per
+          # authorized record instead of a slim-select. Same policy scoping,
+          # SGID validation and inline "+" add button.
+          def secure_association_checkboxes_tag(**, &)
+            create_component(Components::SecureAssociationCheckboxes, :association_checkboxes, **, &)
+          end
+          alias_method :association_checkboxes_tag, :secure_association_checkboxes_tag
+
+          def secure_association_toggles_tag(**, &)
+            create_component(Components::SecureAssociationToggles, :association_toggles, **, &)
+          end
+          alias_method :association_toggles_tag, :secure_association_toggles_tag
+          alias_method :association_switches_tag, :secure_association_toggles_tag
+
+          def secure_association_radio_buttons_tag(**, &)
+            create_component(Components::SecureAssociationRadioButtons, :association_radio_buttons, **, &)
+          end
+          alias_method :association_radio_buttons_tag, :secure_association_radio_buttons_tag
+          alias_method :association_radios_tag, :secure_association_radio_buttons_tag
+
           def secure_polymorphic_association_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
             create_component(Components::SecurePolymorphicAssociation, :polymorphic_association, **attributes, &)