plutonium 0.64.0 → 0.65.0

data/lib/plutonium/translation.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Plutonium
+  # Translation lookups for everything Plutonium renders.
+  #
+  # All of Plutonium's own strings live under the `plutonium.*` namespace in
+  # `config/locales`, loaded at the lowest precedence so a package, portal or
+  # the host application can override any key. Beyond the fixed strings, this
+  # module resolves the *derived* text a definition never declares (field
+  # placeholders and hints, action / scope / filter labels, kanban columns,
+  # wizard steps) by convention, with a portal-specific layer on top:
+  #
+  #   plutonium.portals.<portal>.fields.<model>.<attr>.placeholder
+  #   plutonium.fields.<model>.<attr>.placeholder
+  #
+  # `<portal>` is the package namespace (`admin_portal`), `<model>` the
+  # `model_name.i18n_key` (`blogging/article`), walked up `lookup_ancestors`
+  # the way `human_attribute_name` does. Every lookup is a plain hash probe on
+  # the I18n backend and returns nil when nothing is defined, so a missing key
+  # costs a few microseconds and renders exactly what it did before.
+  #
+  # Not named `Plutonium::I18n` on purpose: that constant would shadow `::I18n`
+  # inside every `module Plutonium` body.
+  module Translation
+    extend self
+
+    # Request-local portal, set by the controller so lookups deep in the query
+    # layer (filter labels, kanban rejections) see the same portal the view does.
+    class Current < ActiveSupport::CurrentAttributes
+      attribute :portal, :value_labels
+    end
+
+    # Kinds of derived labels resolved by convention. The value is the key
+    # segment under `plutonium.` (and under `plutonium.portals.<portal>.`).
+    LABEL_KINDS = {
+      action: "actions",
+      scope: "scopes",
+      filter: "filters",
+      kanban_column: "kanban_columns",
+      wizard_step: "wizard_steps"
+    }.freeze
+
+    # Field slots resolved by convention when the definition leaves them blank.
+    FIELD_SLOTS = %i[placeholder hint description].freeze
+
+    # Plain translation of a fixed Plutonium string. Full keys only; there is
+    # no lazy-lookup prefix, so every call site is greppable.
+    def t(key, **options)
+      ::I18n.t(key, **options)
+    end
+    alias_method :translate, :t
+
+    # Translate a Pagy dictionary key with the current I18n locale. Pagy keeps
+    # its own (faster) dictionaries and a thread-local locale; sync the locale
+    # per call so a host that switches `I18n.locale` per request is honoured.
+    def pagy(key, **options)
+      ::Pagy::I18n.locale = ::I18n.locale.to_s
+      ::Pagy::I18n.translate(key, **options)
+    end
+
+    # Resolve an option value that may be a lazy translation (a proc built by
+    # {Lazy#t}) or any other zero-arity callable.
+    def resolve(value)
+      value.is_a?(Proc) ? value.call : value
+    end
+
+    # The i18n key segment for a package / portal module, or nil for the main app.
+    def portal_key(package)
+      return if package.nil?
+
+      (package.respond_to?(:name) ? package.name : package.to_s).underscore
+    end
+
+    # Text for a field slot (:placeholder, :hint, :description) resolved by
+    # convention. Returns nil when no key is defined.
+    #
+    #   field_text(Blogging::Article, :title, :placeholder)
+    #   # => plutonium.portals.<portal>.fields.blogging/article.title.placeholder
+    #   #    plutonium.fields.blogging/article.title.placeholder
+    #   #    helpers.placeholder.blogging/article.title   (placeholder only)
+    def field_text(klass, attribute, slot, portal: Current.portal)
+      raise ArgumentError, "unknown field slot #{slot.inspect}" unless FIELD_SLOTS.include?(slot)
+
+      model_keys_for(klass).each do |model_key|
+        [portal_scope(portal, "fields"), "plutonium.fields"].compact.each do |scope|
+          value = probe("#{scope}.#{model_key}.#{attribute}.#{slot}")
+          return value if value
+        end
+
+        next unless slot == :placeholder
+
+        value = probe("helpers.placeholder.#{model_key}.#{attribute}")
+        return value if value
+      end
+
+      nil
+    end
+
+    # Whether the locale defines one/other forms for the model's name
+    # (`activerecord.models.<model>: {one:, other:}`), on it or an ancestor.
+    def locale_plural?(klass)
+      return false unless klass.respond_to?(:i18n_scope)
+
+      model_keys_for(klass).any? { |key| ::I18n.t("#{klass.i18n_scope}.models.#{key}", default: nil).is_a?(Hash) }
+    end
+
+    # Fill the convention text into `options` for each slot the definition
+    # left blank, e.g. `fill_field_text(opts, Blogging::Post, :title, :placeholder, :hint)`.
+    def fill_field_text(options, klass, attribute, *slots)
+      slots.each do |slot|
+        next if options.key?(slot)
+
+        text = field_text(klass, attribute, slot)
+        options = options.merge(slot => text) if text
+      end
+      options
+    end
+
+    # Label for a derived key (an action, scope, filter, kanban column or
+    # wizard step) resolved by convention. Returns nil when no key is defined,
+    # so callers keep their `humanize` fallback.
+    #
+    #   label_for(:action, Blogging::Article, :publish)
+    #   # => plutonium.portals.<portal>.actions.blogging/article.publish
+    #   #    plutonium.actions.blogging/article.publish
+    def label_for(kind, klass, key, portal: Current.portal)
+      segment = LABEL_KINDS.fetch(kind) { raise ArgumentError, "unknown label kind #{kind.inspect}" }
+
+      model_keys_for(klass).each do |model_key|
+        [portal_scope(portal, segment), "plutonium.#{segment}"].compact.each do |scope|
+          value = probe("#{scope}.#{model_key}.#{key}")
+          return value if value
+        end
+      end
+
+      nil
+    end
+
+    # Text for a dashboard or one of its cards, resolved by convention with the
+    # same portal layering as {#label_for}. Returns nil when nothing is defined.
+    #
+    #   dashboard_text(SalesDashboard, :label)
+    #   # => plutonium.portals.<portal>.dashboards.sales.label
+    #   #    plutonium.dashboards.sales.label
+    #   dashboard_text(SalesDashboard, :cards, :orders, :label)
+    #   # => plutonium.portals.<portal>.dashboards.sales.cards.orders.label
+    #   #    plutonium.dashboards.sales.cards.orders.label
+    def dashboard_text(dashboard_class, *path, portal: Current.portal)
+      return if dashboard_class.nil?
+
+      suffix = [dashboard_class.i18n_key, *path].join(".")
+      [portal_scope(portal, "dashboards"), "plutonium.dashboards"].compact.each do |scope|
+        value = probe("#{scope}.#{suffix}")
+        return value if value
+      end
+
+      nil
+    end
+
+    # Label for an enum-like value rendered by a badge or filter, resolved the
+    # way Rails resolves enum attribute values:
+    #
+    #   activerecord.attributes.<model>.<attribute>/<value>   (Rails convention)
+    #   plutonium.values.<model>.<attribute>.<value>
+    #
+    # Badges render once per cell, so the answer is memoised for the request.
+    def value_label(klass, attribute, value, portal: Current.portal)
+      return if value.nil? || klass.nil?
+
+      cache = (Current.value_labels ||= {})
+      cache.fetch([::I18n.locale, portal_key(portal), klass, attribute, value.to_s]) do |cache_key|
+        cache[cache_key] = uncached_value_label(klass, attribute, value, portal)
+      end
+    end
+
+    def uncached_value_label(klass, attribute, value, portal)
+      model_keys_for(klass).each do |model_key|
+        [portal_scope(portal, "values"), "plutonium.values"].compact.each do |scope|
+          found = probe("#{scope}.#{model_key}.#{attribute}.#{value}")
+          return found if found
+        end
+
+        if klass.respond_to?(:human_attribute_name)
+          found = probe("#{klass.i18n_scope}.attributes.#{model_key}.#{attribute}/#{value}")
+          return found if found
+        end
+      end
+
+      nil
+    end
+
+    # Class-level `t` for definitions, interactions and wizards. Returns a lazy
+    # proc so the lookup runs on every render in the request's locale rather
+    # than once, in whatever locale was active when the class loaded.
+    #
+    #   input :email, placeholder: t("forms.shared.email_placeholder")
+    #   action :publish, label: t("plutonium.actions.blogging/article.publish")
+    module Lazy
+      def t(key, **options)
+        -> { ::I18n.t(key, **options) }
+      end
+    end
+
+    private :uncached_value_label
+
+    private
+
+    def probe(key)
+      value = ::I18n.t(key, default: nil)
+      value.is_a?(String) ? value : nil
+    end
+
+    def portal_scope(portal, segment)
+      key = portal_key(portal)
+      key && "plutonium.portals.#{key}.#{segment}"
+    end
+
+    # `blogging/article`, then each STI / abstract ancestor that has a model
+    # name, mirroring ActiveModel::Translation#human_attribute_name.
+    def model_keys_for(klass)
+      return [] unless klass.respond_to?(:model_name)
+
+      ancestors = klass.respond_to?(:lookup_ancestors) ? klass.lookup_ancestors : [klass]
+      ancestors.filter_map { |k| k.model_name.i18n_key if k.respond_to?(:model_name) }
+    end
+  end
+end

data/lib/plutonium/ui/actions_dropdown.rb

@@ -26,8 +26,8 @@ module Plutonium
           aria: {expanded: "false", haspopup: "true"},
           data: {resource_drop_down_target: "trigger"}
         ) do
-          span(class: "sr-only") { "Open actions menu" }
-          plain "Actions"
+          span(class: "sr-only") { t("plutonium.ui.actions_dropdown.open_menu") }
+          plain t("plutonium.ui.actions_dropdown.actions")
           render Phlex::TablerIcons::ChevronDown.new(class: "w-4 h-4 ml-1")
         end
       end

data/lib/plutonium/ui/breadcrumbs.rb

@@ -23,7 +23,7 @@ module Plutonium
         # instant before the controller's first reflow.
         nav(
           class: "flex min-w-0 py-3 mb-2 overflow-hidden",
-          aria_label: "Breadcrumb",
+          aria_label: t("plutonium.ui.breadcrumbs.label"),
           data: {controller: "breadcrumbs"}
         ) do
           ol(
@@ -87,7 +87,7 @@ module Plutonium
                   "m19.707 9.293-2-2-7-7a1 1 0 0 0-1.414 0l-7 7-2 2a1 1 0 0 0 1.414 1.414L2 10.414V18a2 2 0 0 0 2 2h3a1 1 0 0 0 1-1v-4a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v4a1 1 0 0 0 1 1h3a2 2 0 0 0 2-2v-7.586l.293.293a1 1 0 0 0 1.414-1.414Z"
               )
             end
-            span(class: "sr-only sm:not-sr-only") { plain "Dashboard" }
+            span(class: "sr-only sm:not-sr-only") { plain t("plutonium.ui.breadcrumbs.home") }
           end
         end
       end
@@ -193,7 +193,7 @@ module Plutonium
       def render_overflow_trigger
         button(
           type: "button",
-          aria: {label: "Show collapsed breadcrumbs", haspopup: "true", expanded: "false"},
+          aria: {label: t("plutonium.ui.breadcrumbs.show_collapsed"), haspopup: "true", expanded: "false"},
           data: {resource_drop_down_target: "trigger"},
           class: "flex items-center justify-center ms-1 w-6 h-6 rounded-[var(--pu-radius-md)] " \
                  "text-[var(--pu-text-muted)] hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)] transition-colors"

data/lib/plutonium/ui/color_mode_selector.rb

@@ -16,7 +16,7 @@ module Plutonium
           class: BUTTON_CLASSES,
           data_controller: "color-mode",
           data_action: "click->color-mode#toggleMode",
-          title: "Toggle color mode"
+          title: t("plutonium.ui.color_mode.toggle")
         ) do
           render Phlex::TablerIcons::DeviceDesktop.new(size: ICON_SIZE, stroke: ICON_STROKE, class: "color-mode-icon-auto")
           render Phlex::TablerIcons::Sun.new(size: ICON_SIZE, stroke: ICON_STROKE, class: "color-mode-icon-light hidden")

data/lib/plutonium/ui/component/behaviour.rb

@@ -10,6 +10,20 @@ module Plutonium
         include Kit
         include Tokens
 
+        # Phlexi field-builder options that configure the field itself, not the
+        # rendered tag. Each surface routes its OWN keys to `field()` (displays
+        # say :description, forms say :hint) and strips the UNION from the tag
+        # attributes, so a key declared on the wrong surface is dropped rather
+        # than leaked as an HTML attribute.
+        DISPLAY_FIELD_LEVEL_KEYS = %i[label description placeholder].freeze
+        FORM_FIELD_LEVEL_KEYS = %i[hint label placeholder].freeze
+        FIELD_LEVEL_KEYS = (DISPLAY_FIELD_LEVEL_KEYS | FORM_FIELD_LEVEL_KEYS).freeze
+
+        # Table-column options that configure the header, not the cell. They may
+        # be declared on `field`, `display` or `column` and flow to the column
+        # without making the column "render alone" (see Table::Resource).
+        COLUMN_FIELD_LEVEL_KEYS = %i[label align].freeze
+
         if Rails.env.development?
           def around_template(&)
             comment { "open:#{self.class.name}" }
@@ -20,6 +34,38 @@ module Plutonium
 
         protected
 
+        # Translate one of Plutonium's own strings. Full keys only
+        # (`t("plutonium.ui.table.filters")`), so every call site is greppable.
+        def t(key, **options)
+          Plutonium::Translation.t(key, **options)
+        end
+
+        # Resolve proc-valued help / header options (label, hint, description,
+        # placeholder, align) for this render, so `label: t("...")` and other
+        # lazy values work on displays, tables and forms alike. Other option
+        # keys are left alone: a `formatter:` or `condition:` proc is a
+        # callback, not a value. Same arity rule as Form::Resource: a zero-arity
+        # proc keeps its own binding, a one-arity proc receives this component.
+        def resolve_field_level_procs(options)
+          resolvable_keys = FIELD_LEVEL_KEYS | COLUMN_FIELD_LEVEL_KEYS
+          resolve_option_procs(options) { |key| resolvable_keys.include?(key) }
+        end
+
+        # Resolve every proc-valued option the block admits (all but
+        # `condition:` by default), by the one arity rule: a zero-arity proc is
+        # called plainly and keeps its own binding, a one-arity proc receives
+        # this component for `object` / `params` / helpers.
+        def resolve_option_procs(options)
+          return options if options.blank?
+
+          options.to_h do |key, value|
+            resolvable = value.is_a?(Proc) && (block_given? ? yield(key) : key != :condition)
+            [key, resolvable ? call_option_proc(value) : value]
+          end
+        end
+
+        def call_option_proc(value) = value.arity.zero? ? value.call : value.call(self)
+
         def phlexi_render(arg, &)
           return unless arg
           raise ArgumentError, "phlexi_render requires a default render block" unless block_given?

data/lib/plutonium/ui/component/methods.rb

@@ -58,6 +58,10 @@ module Plutonium
           :authorized_resource_scope,
           :allowed_to?,
           :registered_resources,
+          :registered_dashboards,
+          :dashboard_path_for,
+          :dashboard_card_path,
+          :current_dashboard,
           :root_path,
           :make_page_title,
           :resource_logo_tag,

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # 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.
+      class Board < Plutonium::UI::Component::Base
+        include Phlex::Rails::Helpers::TurboFrameTag
+
+        # The grid is 12 columns on large screens, 2 on tablets and 1 on
+        # phones. Written out in full so Tailwind's scanner sees every class it
+        # must emit; a span is picked from this table, never interpolated.
+        GRID_CLASSES = "pu-dashboard grid grid-cols-1 gap-4 md:grid-cols-2 lg:grid-cols-12"
+
+        SPAN_CLASSES = {
+          1 => "lg:col-span-1",
+          2 => "lg:col-span-2",
+          3 => "lg:col-span-3",
+          4 => "lg:col-span-4",
+          5 => "lg:col-span-5",
+          6 => "md:col-span-2 lg:col-span-6",
+          7 => "md:col-span-2 lg:col-span-7",
+          8 => "md:col-span-2 lg:col-span-8",
+          9 => "md:col-span-2 lg:col-span-9",
+          10 => "md:col-span-2 lg:col-span-10",
+          11 => "md:col-span-2 lg:col-span-11",
+          12 => "md:col-span-2 lg:col-span-12"
+        }.freeze
+
+        def initialize(dashboard:)
+          @dashboard = dashboard
+        end
+
+        def view_template
+          cards = dashboard.visible_cards
+          return EmptyCard(t("plutonium.dashboard.no_cards")) if cards.empty?
+
+          div(class: GRID_CLASSES, data: {dashboard: dashboard.class.i18n_key}) do
+            cards.each { |card| render_slot(card) }
+          end
+        end
+
+        private
+
+        attr_reader :dashboard
+
+        def render_slot(card)
+          if card.lazy?
+            turbo_frame_tag(
+              card.frame_id,
+              src: dashboard_card_path(card),
+              loading: "lazy",
+              refresh: "morph",
+              class: tokens("block", span_classes(card)),
+              **refresh_attributes(card)
+            ) { render Skeleton.new(card:) }
+          else
+            div(class: span_classes(card)) { render Card.for(dashboard:, card:) }
+          end
+        end
+
+        # On a tablet's two columns a card half the desktop row or wider takes
+        # the full row; anything narrower takes one column.
+        def span_classes(card) = SPAN_CLASSES.fetch(card.span)
+
+        # `refresh` wires the `frame-refresh` controller, which reloads the
+        # frame every N seconds while the tab is visible.
+        def refresh_attributes(card)
+          seconds = dashboard.refresh_for(card)
+          return {} unless seconds
+
+          {data: {controller: "frame-refresh", frame_refresh_interval_value: seconds}}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # The card chrome every kind shares: a `pu-card` with an optional icon,
+      # the title (linked when the card has an `href:`), an optional
+      # description, and a body the subclass fills in.
+      #
+      # The body is rendered under a guard: outside local-request mode a
+      # card whose block raises logs and reports the error and renders a short
+      # notice in place, so one broken query never takes the whole dashboard down.
+      class Card < Plutonium::UI::Component::Base
+        include Phlex::Rails::Helpers::LinkTo
+
+        # The component class for a declared card.
+        def self.for(dashboard:, card:)
+          component = case card.kind
+          when :metric then Metric
+          when :chart then Chart
+          else Custom
+          end
+          component.new(dashboard:, card:)
+        end
+
+        def initialize(dashboard:, card:)
+          @dashboard = dashboard
+          @card = card
+        end
+
+        def view_template
+          Block(class: tokens("pu-dashboard-card flex flex-col h-full", card_classes)) do
+            render_header
+            div(class: "pu-dashboard-card-body") { guarded { render_body } }
+          end
+        end
+
+        private
+
+        attr_reader :dashboard, :card
+
+        def render_body
+          raise NotImplementedError, "#{self.class}#render_body"
+        end
+
+        # Extra classes a kind adds to the card surface.
+        def card_classes = nil
+
+        def render_header
+          div(class: "pu-dashboard-card-header") do
+            render_icon if card.icon
+            div(class: "min-w-0 flex-1") do
+              h3(class: "pu-dashboard-card-title") { render_title }
+              if (description = card.description).present?
+                p(class: "pu-dashboard-card-description") { description }
+              end
+            end
+            render_link if href
+          end
+        end
+
+        def render_icon
+          div(class: "pu-dashboard-card-icon") { render card.icon.new(class: "size-5") }
+        end
+
+        def render_title
+          if href
+            a(href:, class: "hover:underline") { card.label }
+          else
+            card.label
+          end
+        end
+
+        def render_link
+          a(href:, class: "pu-dashboard-card-link", aria: {label: t("plutonium.dashboard.open")}) do
+            render Phlex::TablerIcons::ArrowUpRight.new(class: "size-4")
+          end
+        end
+
+        def href
+          return @href if defined?(@href)
+
+          @href = card.href_for(dashboard)
+        end
+
+        # Render the body into a string first, so a failure leaves no
+        # half-written markup behind before the notice replaces it.
+        def guarded(&)
+          html = capture(&)
+          raw(safe(html))
+        rescue => e
+          raise if raise_card_errors?
+
+          report_error(e)
+          render_error
+        end
+
+        # Logged as well as reported: `Rails.error.report` writes nothing to
+        # the log, so with no error subscriber (Sentry, Honeybadger, ...) a
+        # swallowed card failure would otherwise leave no trace at all.
+        def report_error(error)
+          Rails.logger.error do
+            "[plutonium.dashboard] #{dashboard.class.name}##{card.key} failed to load: " \
+              "#{error.class}: #{error.message}\n#{error.backtrace&.first(10)&.join("\n")}"
+          end
+          Rails.error.report(
+            error,
+            handled: true,
+            source: "plutonium.dashboard",
+            context: {dashboard: dashboard.class.name, card: card.key.to_s}
+          )
+        end
+
+        def raise_card_errors?
+          Rails.application.config.consider_all_requests_local
+        end
+
+        def render_error
+          div(class: "pu-dashboard-card-error", role: "alert") do
+            render Phlex::TablerIcons::AlertCircle.new(class: "size-4 shrink-0")
+            span { t("plutonium.dashboard.card_error") }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # A Chartkick chart. The card's block returns Chartkick data (a
+      # `{label => value}` hash, an array of pairs, or an array of
+      # `{name:, data:}` series); this component serialises it onto a
+      # `data-controller="chart"` element and the Stimulus controller draws it
+      # once the on-demand charts bundle has loaded.
+      class Chart < Card
+        def initialize(dashboard:, card:, script_url: nil)
+          super(dashboard:, card:)
+          @script_url = script_url
+        end
+
+        private
+
+        def render_body
+          data = card.evaluate(dashboard)
+
+          div(
+            class: "pu-chart",
+            style: "height: #{card.options[:height]};",
+            data: {
+              controller: "chart",
+              chart_type_value: card.chart_class,
+              chart_data_value: data.to_json,
+              chart_options_value: card.chart_options.to_json,
+              chart_script_value: script_url
+            }
+          ) do
+            span(class: "pu-chart-loading") { t("plutonium.ui.loading") }
+          end
+        end
+
+        def script_url
+          @script_url || view_context.resource_charts_script_url
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # A free-form card. The block is `instance_exec`ed here, in Phlex, so it
+      # emits markup directly (`ul { ... }`, `render SomeComponent.new`); any
+      # method it calls that this component lacks is forwarded to the
+      # dashboard instance, so a dashboard's own helpers and `current_user`
+      # are in scope.
+      class Custom < Card
+        private
+
+        def render_body
+          instance_exec(&card.block)
+        end
+
+        def method_missing(name, ...)
+          if dashboard.respond_to?(name, true)
+            dashboard.send(name, ...)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          dashboard.respond_to?(name, true) || super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Dashboard
+      # What the card endpoint renders: the card inside the turbo frame the
+      # board is waiting on. Wrapped unconditionally, so a direct visit to the
+      # card URL shows the same card inside the full layout.
+      class Frame < Plutonium::UI::Component::Base
+        include Phlex::Rails::Helpers::TurboFrameTag
+
+        def initialize(dashboard:, card:)
+          @dashboard = dashboard
+          @card = card
+        end
+
+        def view_template
+          turbo_frame_tag(@card.frame_id, class: "block") do
+            render Card.for(dashboard: @dashboard, card: @card)
+          end
+        end
+      end
+    end
+  end
+end