plutonium 0.64.0 → 0.65.0

data/lib/generators/pu/pkg/portal/templates/config/locales/en.yml.tt

@@ -0,0 +1,30 @@
+# Wording specific to the <%= package_name %> portal.
+#
+# This file is loaded automatically (the portal is a Rails engine) ahead of the
+# host app's config/locales: anything here overrides Plutonium's defaults for
+# this portal, and the app's own locale files override this.
+#
+# Portal-specific text for a resource goes under
+# plutonium.portals.<%= package_namespace %>, mirroring the global keys:
+#
+#   en:
+#     plutonium:
+#       portals:
+#         <%= package_namespace %>:
+#           fields:
+#             blogging/post:
+#               title:
+#                 placeholder: "Working title"
+#                 hint: "Shown in the sidebar"
+#           actions:
+#             blogging/post:
+#               publish: "Publish to site"
+#           scopes:
+#             blogging/post:
+#               drafts: "Drafts"
+#
+# See https://radioactive-labs.github.io/plutonium-core/reference/i18n
+en:
+  plutonium:
+    portals:
+      <%= package_namespace %>: {}

data/lib/generators/pu/res/scaffold/scaffold_generator.rb

@@ -49,14 +49,6 @@ module Pu
         template "definition.rb", File.join("app/definitions", class_path, "#{file_name}_definition.rb")
       end
 
-      # def create_presenter
-      #   template "presenter.rb", File.join("app/presenters", class_path, "#{file_name}_presenter.rb")
-      # end
-
-      # def create_query_object
-      #   template "query_object.rb", File.join("app/query_objects", class_path, "#{file_name}_query_object.rb")
-      # end
-
       private
 
       def default_policy_attributes

data/lib/generators/pu/rodauth/concerns/feature_selector.rb

@@ -64,24 +64,6 @@ module Pu
           options[feature]
         end
 
-        # Creates a hash of options to pass down options to an invoked sub generator
-        def invoke_options
-          # These are custom options we want to track.
-          extra_options = %i[argon2 mails kitchen_sink defaults]
-          # Append them to all the available options from our configuration
-          valid_options = configuration.keys.map(&:to_sym).concat extra_options
-          # Index map the list with the selection value
-          opts = valid_options.map { |opt| [opt, send(:"#{opt}?")] }.to_h.compact
-          # True only options. We don't care if they are false.
-          %i[api_only force skip pretend quiet].each do |key|
-            next unless options[key]
-
-            opts[key] = options[key]
-          end
-
-          opts
-        end
-
         def all_selected
           @all_selected ||= configuration.keys.select { |feature| send(:"#{feature}?") }
         end

data/lib/plutonium/action/base.rb

@@ -6,11 +6,34 @@ module Plutonium
   module Action
     # Base class for all actions in the Plutonium framework.
     class Base
-      attr_reader :name, :label, :description, :icon, :route_options, :confirmation, :turbo, :color, :category, :position, :return_to, :condition, :link, :button
+      attr_reader :name, :icon, :route_options, :turbo, :color, :category, :position, :return_to, :condition, :link, :button
+
+      # `label:`, `description:` and `confirmation:` may be lazy translations
+      # (`t(...)` in a definition) or any zero-arity proc: resolve per read so
+      # the text follows the request locale rather than the class load.
+      def label
+        Plutonium::Translation.resolve(@label) ||
+          Plutonium::Translation.label_for(:action, @resource_class, @name) ||
+          @name.to_s.titleize
+      end
+
+      def description = Plutonium::Translation.resolve(@description)
+
+      # A copy of this action bound to `resource_class`, so its default label
+      # resolves through plutonium.actions.<model>.<action>. Returns self when
+      # already bound.
+      def for_resource(resource_class)
+        return self if @resource_class || resource_class.nil?
+
+        dup.tap { |copy| copy.instance_variable_set(:@resource_class, resource_class) }
+      end
+
+      def confirmation = Plutonium::Translation.resolve(@confirmation)
 
       def initialize(name, **options)
         @name = name.to_sym
-        @label = options[:label] || @name.to_s.titleize
+        @label = options[:label]
+        @resource_class = options[:resource_class]
         @description = options[:description]
         @icon = options[:icon] || Phlex::TablerIcons::ChevronRight
         @color = options[:color]
@@ -152,7 +175,8 @@ module Plutonium
           size: @modal_size,
           condition: @condition,
           link: @link,
-          button: @button
+          button: @button,
+          resource_class: @resource_class
         }
       end
 

data/lib/plutonium/action/interactive.rb

@@ -19,20 +19,33 @@ module Plutonium
         @interaction = interaction
         @immediate = immediate
 
-        options[:label] ||= interaction.label
-        options[:description] ||= interaction.description
         options[:icon] ||= interaction.icon
         options[:turbo_frame] = Plutonium::REMOTE_MODAL_FRAME unless options.key?(:turbo_frame)
 
         super(name, **options)
       end
 
+      # `label:` on the action, then the interaction's explicit `presents
+      # label:`, then plutonium.actions.<model>.<action>, then the
+      # interaction's class-name default. Resolved per read so lazy
+      # translations follow the request locale.
+      def label
+        Plutonium::Translation.resolve(@label) ||
+          Plutonium::Translation.resolve(interaction.presentation_metadata[:label]) ||
+          Plutonium::Translation.label_for(:action, @resource_class, @name) ||
+          interaction.label
+      end
+
+      def description
+        Plutonium::Translation.resolve(@description) || interaction.description
+      end
+
       # Get the confirmation message for the action
       #
       # @return [String, nil] The confirmation message or nil if not applicable
       def confirmation
-        return @confirmation unless @confirmation.nil?
-        @immediate ? "#{label}?" : nil
+        return Plutonium::Translation.resolve(@confirmation) unless @confirmation.nil?
+        @immediate ? Plutonium::Translation.t("plutonium.actions.confirm_default", label: label) : nil
       end
 
       protected

data/lib/plutonium/api_client/concerns/create_api_client.rb

@@ -27,7 +27,7 @@ module Plutonium
         include Plutonium::Interaction::Concerns::Scoping
 
         included do
-          presents label: "Create API Client", icon: Phlex::TablerIcons::Key
+          presents label: t("plutonium.api_client.create.label"), icon: Phlex::TablerIcons::Key
 
           attribute :login, :string
 
@@ -55,7 +55,7 @@ module Plutonium
             )
           )
         rescue ActiveRecord::RecordNotFound => e
-          failed(login: "Failed to create account: #{e.message}")
+          failed(login: I18n.t("plutonium.api_client.create.failed", error: e.message))
         rescue => e
           failed(login: e.message)
         end
@@ -173,16 +173,17 @@ module Plutonium
               end
 
               p(class: "text-green-700 dark:text-green-300") do
-                strong { "Important: " }
-                plain "Save these credentials now. The password cannot be retrieved later."
+                strong { t("plutonium.api_client.create.credentials.important_label") }
+                whitespace
+                plain t("plutonium.api_client.create.credentials.important_text")
               end
             end
           end
 
           def render_credentials_card
             div(class: "bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-6 space-y-4") do
-              render_credential_field("Login", @login)
-              render_credential_field("Password", @password)
+              render_credential_field(t("plutonium.api_client.create.credentials.login"), @login)
+              render_credential_field(t("plutonium.api_client.create.credentials.password"), @password)
             end
           end
 
@@ -201,13 +202,13 @@ module Plutonium
                   type: "button",
                   data: {action: "clipboard#copy"},
                   class: "px-3 py-2 text-sm bg-gray-100 dark:bg-gray-700 hover:bg-gray-200 dark:hover:bg-gray-600 rounded-md transition-colors"
-                ) { "Copy" }
+                ) { t("plutonium.api_client.create.credentials.copy") }
               end
             end
           end
 
           def render_action_buttons
-            credentials_text = "Login: #{@login}\nPassword: #{@password}"
+            credentials_text = t("plutonium.api_client.create.credentials.credentials_text", login: @login, password: @password)
 
             div(class: "mt-6 flex gap-4", data: {controller: "clipboard"}) do
               input(type: "hidden", value: credentials_text, data: {clipboard_target: "source"})
@@ -215,12 +216,12 @@ module Plutonium
                 type: "button",
                 data: {action: "clipboard#copy"},
                 class: "px-4 py-2 bg-gray-600 hover:bg-gray-700 text-white rounded-md transition-colors"
-              ) { "Copy All" }
+              ) { t("plutonium.api_client.create.credentials.copy_all") }
 
               a(
                 href: done_url,
                 class: "px-4 py-2 bg-primary-600 hover:bg-primary-700 text-white rounded-md transition-colors"
-              ) { "Done" }
+              ) { t("plutonium.api_client.create.credentials.done") }
             end
           end
 
@@ -242,7 +243,7 @@ module Plutonium
 
           # Override in subclass to customize
           def success_title
-            "API Client Created Successfully"
+            t("plutonium.api_client.create.credentials.success_title")
           end
 
           # Override in subclass to customize the done URL

data/lib/plutonium/api_client/concerns/disable_api_client.rb

@@ -20,8 +20,8 @@ module Plutonium
         extend ActiveSupport::Concern
 
         included do
-          presents label: "Disable",
-            description: "Disable this API client (cannot be undone)",
+          presents label: t("plutonium.api_client.disable.label"),
+            description: t("plutonium.api_client.disable.description"),
             icon: Phlex::TablerIcons::Ban,
             color: :danger
 
@@ -52,7 +52,7 @@ module Plutonium
         # @param login [String] the login of the disabled API client
         # @return [String]
         def success_message(login)
-          "API client '#{login}' has been disabled"
+          I18n.t("plutonium.api_client.disable.disabled", login: login)
         end
 
         def rodauth_instance

data/lib/plutonium/auth/sequel_adapter.rb

@@ -14,7 +14,7 @@ module Plutonium
         "mysql2" => (RUBY_ENGINE == "jruby") ? "mysql" : "mysql2",
         "sqlite3" => "sqlite",
         "oracle_enhanced" => "oracle",
-        "sqlserver" => (RUBY_ENGINE == "jruby") ? "mssql" : "tinytds"
+        "sqlserver" => (RUBY_ENGINE == "jruby") ? "sqlserver" : "tinytds"
       }.freeze
 
       class << self

data/lib/plutonium/configuration.rb

@@ -209,12 +209,17 @@ module Plutonium
       # @return [String] path to JavaScript file
       attr_accessor :script
 
+      # @return [String] path to the on-demand charts bundle (Chart.js +
+      #   Chartkick), loaded by the first chart card on a page
+      attr_accessor :charts_script
+
       # Initialize a new AssetConfiguration instance with default values
       def initialize
         @logo = "plutonium.png"
         @favicon = "plutonium.ico"
         @stylesheet = "plutonium.css"
         @script = "plutonium.min.js"
+        @charts_script = "plutonium-charts.min.js"
       end
     end
   end

data/lib/plutonium/core/controller.rb

@@ -32,6 +32,12 @@ module Plutonium
           end
         end
 
+        # Convention lookups (field placeholders, action labels...) layer a
+        # portal-specific key over the global one. Publish the portal once per
+        # request so lookups made outside a view (query object, kanban flash)
+        # resolve the same way the view does.
+        before_action { Plutonium::Translation::Current.portal = current_package }
+
         before_action do
           next unless defined?(ActiveStorage)
 
@@ -45,7 +51,7 @@ module Plutonium
 
         append_view_path File.expand_path("app/views", Plutonium.root)
         layout -> { turbo_frame_request? ? false : "resource" }
-        helper_method :registered_resources
+        helper_method :registered_resources, :registered_dashboards, :dashboard_path_for
 
         class_attribute :_rail_enabled, instance_writer: false, default: nil
         class_attribute :_shell, instance_writer: false, default: nil
@@ -402,6 +408,24 @@ module Plutonium
         current_engine.resource_register.resources
       end
 
+      # Dashboards mounted on the current engine with `register_dashboard`,
+      # in registration order.
+      def registered_dashboards
+        current_engine.dashboard_register.dashboards
+      end
+
+      # The page path of a registered dashboard, threading the entity scope
+      # segment through on a `:path`-scoped portal. Nil when the dashboard is
+      # not registered on the current engine.
+      def dashboard_path_for(dashboard_class)
+        name = Plutonium::Dashboard::RouteResolution.route_name(current_engine.routes, dashboard_class, action: "show")
+        return if name.nil?
+
+        options = {}
+        options[scoped_entity_param_key] = params[scoped_entity_param_key] if scoped_to_entity?
+        current_engine.routes.url_helpers.public_send(:"#{name}_path", **options)
+      end
+
       # Converts RouteOptions into a URL using the appropriate URL resolver.
       #
       # This method takes a RouteOptions object and generates a URL based on the url_resolver

data/lib/plutonium/core/controllers/authorizable.rb

@@ -20,7 +20,7 @@ module Plutonium
         # Use this instead of authorized_scope directly
         def authorized_resource_scope(resource, relation: nil, **options)
           unless resource.instance_of?(Class) && resource < ActiveRecord::Base
-            raise ArgumentError("Expected resource to be a class inheriting ActiveRecord::Base")
+            raise ArgumentError, "Expected resource to be a class inheriting ActiveRecord::Base"
           end
 
           options[:with] ||= ::ActionPolicy.lookup(resource, namespace: authorization_namespace)

data/lib/plutonium/dashboard/base.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Dashboard
+    # The base class every dashboard subclasses.
+    #
+    #   class SalesDashboard < Plutonium::Dashboard::Base
+    #     presents label: "Sales", description: "Orders and revenue at a glance"
+    #     refresh 60
+    #
+    #     metric(:orders, icon: Phlex::TablerIcons::ShoppingCart) { orders.count }
+    #     chart(:revenue, type: :area, span: 8) { orders.group_by_day(:created_at).sum(:total) }
+    #
+    #     private
+    #
+    #     def orders = authorized_resource_scope(Order)
+    #   end
+    #
+    # An instance is built per request with the view context, so card blocks
+    # run with `current_user`, `current_scoped_entity`, `params`,
+    # `authorized_resource_scope`, `resource_url_for` and the dashboard's own
+    # methods in scope. `authorize?` gates the page and every card endpoint.
+    class Base
+      extend Plutonium::Translation::Lazy
+      include Plutonium::Definition::Presentable
+      include DSL
+
+      attr_reader :view_context
+
+      # Everything a card block is likely to reach for, forwarded to the view
+      # context (which in turn exposes the controller's helper methods).
+      delegate :current_user, :current_scoped_entity, :scoped_to_entity?,
+        :params, :request, :controller, :current_engine,
+        :resource_url_for, :authorized_resource_scope, :allowed_to?, :policy_for,
+        :registered_resources, :root_path,
+        to: :view_context
+
+      class << self
+        # `plutonium.dashboards.<key>` locale segment and frame/DOM prefix:
+        # `AdminPortal::SalesDashboard` → `admin_portal/sales`.
+        def i18n_key
+          name.underscore.delete_suffix("_dashboard")
+        end
+
+        # Route slug used when `register_dashboard` gets no `as:` and mounts at
+        # the root: `SalesDashboard` → `sales`.
+        def route_name
+          name.demodulize.underscore.delete_suffix("_dashboard")
+        end
+
+        # Title: `presents label:`, then the `plutonium.dashboards.<key>.label`
+        # convention, then the class name minus "Dashboard".
+        def label
+          Plutonium::Translation.resolve(presentation_metadata[:label]) ||
+            Plutonium::Translation.dashboard_text(self, :label) ||
+            name.demodulize.delete_suffix("Dashboard").titleize
+        end
+
+        # Caption under the title: `presents description:`, then the
+        # `plutonium.dashboards.<key>.description` convention.
+        def description
+          Plutonium::Translation.resolve(presentation_metadata[:description]) ||
+            Plutonium::Translation.dashboard_text(self, :description)
+        end
+
+        # Sidebar icon: `presents icon:`, defaulting to a dashboard glyph.
+        def icon
+          presentation_metadata[:icon] || Phlex::TablerIcons::LayoutDashboard
+        end
+      end
+
+      def initialize(view_context)
+        @view_context = view_context
+      end
+
+      # Entry authorization. Authors override it; false → 403 on the page and
+      # on every card endpoint. Default allow: a portal already sits behind
+      # its auth constraint.
+      def authorize? = true
+
+      # The cards whose `condition:` passes for this request, in order.
+      def visible_cards
+        self.class.cards.select { |card| card.visible?(self) }
+      end
+
+      # The card the endpoint was asked for, if declared and visible.
+      # @raise [UnknownCardError]
+      def visible_card!(key)
+        card = self.class.find_card!(key)
+        raise UnknownCardError, "#{self.class.name} card #{key.inspect} is not visible" unless card.visible?(self)
+
+        card
+      end
+
+      # The refresh interval for a card: its own, else the dashboard default.
+      # A card declared `refresh: false` never refreshes.
+      def refresh_for(card)
+        return nil if card.refresh == false
+
+        card.refresh || self.class.refresh
+      end
+
+      # The view context, for helpers a card block wants by name
+      # (`helpers.number_to_currency`, route helpers, ...).
+      def helpers = view_context
+
+      private
+
+      def t(key, **options)
+        Plutonium::Translation.t(key, **options)
+      end
+    end
+  end
+end

data/lib/plutonium/dashboard/card.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Dashboard
+    # One declared card: its kind (`:metric`, `:chart` or `:custom`), the
+    # presentation options every kind shares, the kind-specific options and
+    # the block that produces its data (or, for a custom card, its markup).
+    #
+    # Built by {DSL} at class-load and frozen; everything request-dependent
+    # (label translation, `condition:`, `href:`) is resolved per render.
+    class Card
+      KINDS = %i[metric chart custom].freeze
+
+      # The dashboard grid is 12 columns wide, so halves, thirds and quarters
+      # all divide evenly. A card spans 1 to 12 of them; `:full` is 12.
+      GRID_COLUMNS = 12
+
+      # The width each kind reads well at when no `span:` is given: four
+      # metrics, two charts or two custom cards to a row.
+      DEFAULT_SPANS = {metric: 3, chart: 6, custom: 6}.freeze
+
+      METRIC_FORMATS = %i[number currency percentage human].freeze
+      METRIC_POSITIVE = %i[up down].freeze
+      CHART_TYPES = %i[line area column bar pie donut scatter].freeze
+
+      # Options every kind accepts.
+      COMMON_OPTIONS = %i[label description icon span lazy refresh condition href].freeze
+      METRIC_OPTIONS = %i[format precision unit prefix suffix positive change_label].freeze
+      CHART_OPTIONS = %i[type height].freeze
+
+      attr_reader :key, :kind, :icon, :span, :refresh, :condition, :href, :block, :options, :dashboard_class
+
+      def initialize(key, kind:, dashboard_class:, block:, **options)
+        @key = key.to_sym
+        @kind = kind
+        @dashboard_class = dashboard_class
+        @block = block
+
+        raise ArgumentError, "card #{@key.inspect}: unknown kind #{kind.inspect}" unless KINDS.include?(kind)
+        raise ArgumentError, "card #{@key.inspect} requires a block" if block.nil?
+
+        common = options.slice(*COMMON_OPTIONS)
+        specific = options.except(*COMMON_OPTIONS)
+
+        @label = common[:label]
+        @description = common[:description]
+        @icon = common[:icon]
+        @span = validate_span!(common.fetch(:span) { DEFAULT_SPANS.fetch(kind) })
+        @lazy = common.fetch(:lazy, true) ? true : false
+        @refresh = validate_refresh!(common[:refresh])
+        @condition = common[:condition]
+        @href = common[:href]
+        @options = validate_options!(specific).freeze
+
+        if @refresh && !@lazy
+          raise ArgumentError,
+            "card #{@key.inspect}: `refresh:` reloads the card's turbo frame, so it needs `lazy: true` (the default)"
+        end
+
+        freeze
+      end
+
+      def lazy? = @lazy
+      def metric? = kind == :metric
+      def chart? = kind == :chart
+      def custom? = kind == :custom
+      def full_width? = span == GRID_COLUMNS
+
+      # The card title, resolved per request: an explicit `label:` (lazy `t`
+      # procs included), then the `plutonium.dashboards.<dashboard>.cards.<key>.label`
+      # convention, then the key titleized.
+      def label
+        Plutonium::Translation.resolve(@label) ||
+          Plutonium::Translation.dashboard_text(dashboard_class, :cards, key, :label) ||
+          key.to_s.titleize
+      end
+
+      # Optional caption; `description:` first, then the locale convention.
+      def description
+        Plutonium::Translation.resolve(@description) ||
+          Plutonium::Translation.dashboard_text(dashboard_class, :cards, key, :description)
+      end
+
+      # Whether the card renders for this request. `condition:` is a proc
+      # evaluated on the dashboard instance (zero arity) or with it as the
+      # argument (one arity), or a symbol naming a dashboard method. It gates
+      # the page AND the card endpoint, so a hidden card cannot be fetched
+      # directly.
+      def visible?(dashboard)
+        return true if condition.nil?
+
+        result = case condition
+        when Symbol then dashboard.send(condition)
+        when Proc then evaluate_on(dashboard, condition)
+        else condition
+        end
+        result ? true : false
+      end
+
+      # The card's link target for this request, if any.
+      def href_for(dashboard)
+        href.is_a?(Proc) ? evaluate_on(dashboard, href) : href
+      end
+
+      # Runs the data block on the dashboard instance.
+      def evaluate(dashboard)
+        evaluate_on(dashboard, block)
+      end
+
+      # DOM id of the turbo frame hosting this card. One dashboard renders per
+      # page, so the card key is unique enough.
+      def frame_id
+        "#{FRAME_PREFIX}-#{key.to_s.dasherize}"
+      end
+
+      # Chart cards: the Chartkick constructor name for `type:`.
+      def chart_class
+        case options[:type]
+        when :area then "AreaChart"
+        when :column then "ColumnChart"
+        when :bar then "BarChart"
+        when :pie, :donut then "PieChart"
+        when :scatter then "ScatterChart"
+        else "LineChart"
+        end
+      end
+
+      # Chart cards: Chartkick options passed through to the JS constructor,
+      # with the `donut` flag derived from `type: :donut`.
+      def chart_options
+        passthrough = options.except(*CHART_OPTIONS)
+        passthrough = passthrough.merge(donut: true) if options[:type] == :donut
+        passthrough
+      end
+
+      private
+
+      def evaluate_on(dashboard, callable)
+        callable.arity.zero? ? dashboard.instance_exec(&callable) : dashboard.instance_exec(dashboard, &callable)
+      end
+
+      def validate_span!(span)
+        return GRID_COLUMNS if span == :full
+        return span if span.is_a?(Integer) && span.between?(1, GRID_COLUMNS)
+
+        raise ArgumentError, "card #{key.inspect}: span must be an integer from 1 to #{GRID_COLUMNS}, or :full, got #{span.inspect}"
+      end
+
+      # `false` is kept distinct from nil: nil inherits the dashboard's
+      # `refresh`, false opts this card out of it.
+      def validate_refresh!(refresh)
+        return refresh if refresh.nil? || refresh == false
+        return refresh.to_i if refresh.respond_to?(:to_i) && refresh.to_i.positive?
+
+        raise ArgumentError, "card #{key.inspect}: refresh must be a positive number of seconds or false, got #{refresh.inspect}"
+      end
+
+      def validate_options!(specific)
+        case kind
+        when :metric then validate_metric_options!(specific)
+        when :chart then validate_chart_options!(specific)
+        else validate_custom_options!(specific)
+        end
+      end
+
+      def validate_metric_options!(specific)
+        unknown = specific.keys - METRIC_OPTIONS
+        raise ArgumentError, "metric #{key.inspect}: unknown option(s) #{unknown.inspect}" if unknown.any?
+
+        format = specific[:format]
+        unless format.nil? || format.is_a?(Proc) || METRIC_FORMATS.include?(format)
+          raise ArgumentError,
+            "metric #{key.inspect}: format must be one of #{METRIC_FORMATS.inspect} or a proc, got #{format.inspect}"
+        end
+
+        positive = specific.fetch(:positive, :up)
+        unless METRIC_POSITIVE.include?(positive)
+          raise ArgumentError, "metric #{key.inspect}: positive must be :up or :down, got #{positive.inspect}"
+        end
+
+        specific.merge(positive:)
+      end
+
+      def validate_chart_options!(specific)
+        type = specific.fetch(:type, :line)
+        unless CHART_TYPES.include?(type)
+          raise ArgumentError, "chart #{key.inspect}: type must be one of #{CHART_TYPES.inspect}, got #{type.inspect}"
+        end
+
+        specific.merge(type:, height: specific.fetch(:height, "240px"))
+      end
+
+      def validate_custom_options!(specific)
+        raise ArgumentError, "card #{key.inspect}: unknown option(s) #{specific.keys.inspect}" if specific.any?
+
+        specific
+      end
+    end
+  end
+end