plutonium 0.64.0 → 0.66.0

data/lib/generators/pu/docker/install/install_generator.rb

@@ -11,6 +11,11 @@ module Pu
 
       desc "Set up docker for project"
 
+      # Fallbacks when the tool is not on PATH at generation time.
+      NODE_LTS_VERSION = "22.23.2"
+      YARN_CLASSIC_VERSION = "1.22.22"
+      BUN_VERSION = "1.4.2"
+
       def start
         in_root do
           template "Dockerfile", force: true
@@ -30,6 +35,59 @@ module Pu
       def ruby_version
         @ruby_version ||= File.read(".ruby-version").strip
       end
+
+      # The JavaScript toolchain is chosen the same way jsbundling-rails will
+      # choose it at `assets:precompile` inside the image, and versions come
+      # from the machine generating the Dockerfile (or NODE_VERSION /
+      # YARN_VERSION / BUN_VERSION), like Rails' own template.
+      def using_bun?
+        js_package_manager == :bun
+      end
+
+      def dockerfile_node_version
+        ENV.fetch("NODE_VERSION") { node_version || NODE_LTS_VERSION }
+      end
+
+      def dockerfile_yarn_version
+        ENV.fetch("YARN_VERSION") { yarn_version || YARN_CLASSIC_VERSION }
+      end
+
+      def dockerfile_bun_version
+        ENV.fetch("BUN_VERSION") { bun_version || BUN_VERSION }
+      end
+
+      # Yarn 2+ is installed through corepack, and its lockfile flag is
+      # --immutable rather than yarn 1's --frozen-lockfile.
+      def yarn_through_corepack?
+        js_package_manager == :yarn && dockerfile_yarn_version.to_i >= 2
+      end
+
+      def js_lockfile_copy
+        case js_package_manager
+        when :bun then "package.json bun.lock*"
+        when :pnpm then "package.json pnpm-lock.yaml"
+        when :npm then "package.json package-lock.json"
+        # .yarnrc.yml carries nodeLinker for yarn 2+; the glob keeps the COPY
+        # valid on yarn 1 apps that have none.
+        else "package.json yarn.lock .yarnrc.yml*"
+        end
+      end
+
+      def js_frozen_install_command
+        case js_package_manager
+        when :bun then "bun install --frozen-lockfile"
+        when :pnpm then "pnpm install --frozen-lockfile"
+        when :npm then "npm ci"
+        else "yarn install --#{yarn_through_corepack? ? "immutable" : "frozen-lockfile"}"
+        end
+      end
+
+      # docker-compose runs this on every container start. `npm ci` would wipe
+      # node_modules each boot and fails without a package-lock.json, so npm
+      # gets a plain install; the others already only sync what changed.
+      def js_dev_install_command
+        (js_package_manager == :npm) ? "npm install" : js_install_command
+      end
     end
   end
 end

data/lib/generators/pu/docker/install/templates/Dockerfile.dev.tt

@@ -11,13 +11,28 @@ RUN apt-get update -qq && \
     apt-get install --no-install-recommends -y build-essential curl git libpq-dev node-gyp pkg-config python-is-python3
 
 # Install JavaScript dependencies
-ARG NODE_VERSION=22.2.0
-ARG YARN_VERSION=1.22.22
+<% if using_bun? -%>
+ENV BUN_INSTALL=/usr/local/bun
+ENV PATH=/usr/local/bun/bin:$PATH
+ARG BUN_VERSION=<%= dockerfile_bun_version %>
+RUN curl -fsSL https://bun.sh/install | bash -s -- "bun-v${BUN_VERSION}"
+<% else -%>
+ARG NODE_VERSION=<%= dockerfile_node_version %>
 ENV PATH=/usr/local/node/bin:$PATH
 RUN curl -sL https://github.com/nodenv/node-build/archive/master.tar.gz | tar xz -C /tmp/ && \
     /tmp/node-build-master/bin/node-build "${NODE_VERSION}" /usr/local/node && \
-    npm install -g yarn@$YARN_VERSION && \
     rm -rf /tmp/node-build-master
+<% if js_package_manager == :yarn -%>
+ARG YARN_VERSION=<%= dockerfile_yarn_version %>
+<% if yarn_through_corepack? -%>
+RUN corepack enable && corepack install -g yarn@$YARN_VERSION
+<% else -%>
+RUN npm install -g yarn@$YARN_VERSION
+<% end -%>
+<% elsif js_package_manager == :pnpm -%>
+RUN corepack enable && corepack install -g pnpm@latest
+<% end -%>
+<% end -%>
 
 # Additional dependencies go here
 

data/lib/generators/pu/docker/install/templates/Dockerfile.tt

@@ -22,13 +22,28 @@ RUN apt-get update -qq && \
     apt-get install --no-install-recommends -y build-essential curl git libpq-dev node-gyp pkg-config python-is-python3
 
 # Install JavaScript dependencies
-ARG NODE_VERSION=22.2.0
-ARG YARN_VERSION=1.22.22
+<% if using_bun? -%>
+ENV BUN_INSTALL=/usr/local/bun
+ENV PATH=/usr/local/bun/bin:$PATH
+ARG BUN_VERSION=<%= dockerfile_bun_version %>
+RUN curl -fsSL https://bun.sh/install | bash -s -- "bun-v${BUN_VERSION}"
+<% else -%>
+ARG NODE_VERSION=<%= dockerfile_node_version %>
 ENV PATH=/usr/local/node/bin:$PATH
 RUN curl -sL https://github.com/nodenv/node-build/archive/master.tar.gz | tar xz -C /tmp/ && \
     /tmp/node-build-master/bin/node-build "${NODE_VERSION}" /usr/local/node && \
-    npm install -g yarn@$YARN_VERSION && \
     rm -rf /tmp/node-build-master
+<% if js_package_manager == :yarn -%>
+ARG YARN_VERSION=<%= dockerfile_yarn_version %>
+<% if yarn_through_corepack? -%>
+RUN corepack enable && corepack install -g yarn@$YARN_VERSION
+<% else -%>
+RUN npm install -g yarn@$YARN_VERSION
+<% end -%>
+<% elsif js_package_manager == :pnpm -%>
+RUN corepack enable && corepack install -g pnpm@latest
+<% end -%>
+<% end -%>
 
 # Install application gems
 COPY .ruby-version Gemfile Gemfile.lock ./
@@ -37,8 +52,8 @@ RUN bundle install && \
     bundle exec bootsnap precompile --gemfile
 
 # Install node modules
-COPY package.json yarn.lock ./
-RUN yarn install --frozen-lockfile
+COPY <%= js_lockfile_copy %> ./
+RUN <%= js_frozen_install_command %>
 
 # Copy application code
 COPY . .

data/lib/generators/pu/docker/install/templates/{docker-compose.yml → docker-compose.yml.tt}

@@ -22,7 +22,7 @@ x-app: &app
 services:
   web:
     <<: *app
-    command: /bin/sh -c "rm -f tmp/pids/server.pid && bundle && yarn && bin/dev" # web
+    command: /bin/sh -c "rm -f tmp/pids/server.pid && bundle && <%= js_dev_install_command %> && bin/dev" # web
     # web properties
     ports: # web
       - "3000:3000" # app

data/lib/generators/pu/gem/dotenv/dotenv_generator.rb

@@ -19,7 +19,7 @@ module Pu
 
           copy_file "config/initializers/001_ensure_required_env.rb"
 
-          gitignore "!/.env", "!/.env.template", "!/.env.local.template", "!/.env.test.local"
+          gitignore "!/.env", "!/.env.template", "!/.env.local.template"
 
           insert_into_file "Gemfile", "\ngem \"dotenv\", groups: %i[development test]\n", after: /^gem ["']rails["'].*\n/
           bundle!

data/lib/generators/pu/invites/invitable_generator.rb

@@ -22,7 +22,7 @@ module Pu
         desc: "The user model name"
 
       class_option :membership_model, type: :string,
-        desc: "The membership model name (defaults to EntityUser)"
+        desc: "The membership model name (e.g. OrganizationUser). When omitted, the generated interaction has no membership_class override and you must implement it yourself"
 
       class_option :dest, type: :string, default: "main_app",
         desc: "Destination package for the interaction"
@@ -51,6 +51,23 @@ module Pu
         end
       end
 
+      def warn_membership_model_default
+        return if behavior == :revoke
+        return if options[:membership_model].present?
+
+        say_status :warning,
+          "No --membership-model specified — generated interaction will not include a membership_class override.",
+          :yellow
+        say <<~MSG.indent(2)
+
+          The generated #{model_class}::InviteUserInteraction raises
+          NotImplementedError from #membership_class at runtime until you either:
+            - re-run with --membership-model=NAME (e.g. --membership-model=OrganizationUser), or
+            - manually override #membership_class to return your membership join model.
+
+        MSG
+      end
+
       def create_interaction
         template "invitable/invite_user_interaction.rb",
           interaction_path

data/lib/generators/pu/lib/plutonium_generators/concerns/actions.rb

@@ -29,101 +29,6 @@ module PlutoniumGenerators
         end
       end
 
-      # #
-      # # Adds a new gem into the Gemfile
-      # # Existing directives are updated if they do not match
-      # # When `:group` is specified, the gem is inserted into the approriate gem group.
-      # #
-      # # @param [String] name the name of the gem
-      # # @param [Hash] **kwargs set of options to append see #super
-      # #
-      # # @return [void]
-      # #
-      # def gem(name, **kwargs)
-      #   groups = Array(kwargs.delete(:group))
-
-      #   in_root do
-      #     begin
-      #       # Create a temp gemfile
-      #       File.rename("Gemfile", "Gemfile.bak")
-      #       File.write("Gemfile", "")
-      #       # Generate the directive
-      #       super
-      #       # Get the generated directive
-      #       directive = gemfile.strip
-      #     ensure
-      #       # Restore our gemfile
-      #       File.delete "Gemfile"
-      #       File.rename "Gemfile.bak", "Gemfile"
-      #     end
-
-      #     pattern = /^# gem ['"]#{name}['"].*/
-      #     if gemfile.match(pattern)
-      #       # Replace commented out directive
-      #       gsub_file("Gemfile", pattern, directive)
-      #       break
-      #     end
-
-      #     # Remove existing directive
-      #     remove_gem name
-
-      #     # Insert the new directive
-      #     if groups != []
-      #       str = groups.sort.map(&:inspect).join(", ")
-      #       after_sentinel = "group #{str} do\n"
-
-      #       unless File.read("Gemfile").match?(/^#{after_sentinel}/)
-      #         inject_into_file "Gemfile", "\n#{after_sentinel}end\n"
-      #       end
-      #     else
-      #       after_sentinel = "# Project gems\n\n"
-      #       unless File.read("Gemfile").match?(/^#{after_sentinel}/)
-      #         inject_into_file "Gemfile", "\n#{after_sentinel}", after: /^ruby .*\n/
-      #       end
-      #     end
-
-      #     inject_into_file "Gemfile", "#{directive}\n", after: /^#{after_sentinel}/
-      #   end
-      # end
-
-      # #
-      # # Removes a gem and any preceeding comments from the Gemfile
-      # #
-      # # @param gem [String] the name of the gem to remove
-      # #
-      # # @return [void]
-      # #
-      # def remove_gem(gem)
-      #   log :remove_gem, gem
-      #   gsub_file "Gemfile", /(:?^.*#.*\n)*.*gem ['"]#{gem}['"].*\n/, "", verbose: false
-      # end
-
-      # #
-      # # Evaluates the given template and merges it with the project's docker-compose.yml
-      # #
-      # # @param [String] source the template filename
-      # #
-      # # @return [void]
-      # #
-      # def docker_compose(source)
-      #   log :docker_compose, source
-
-      #   in_root do
-      #     compose_file = "docker-compose.yml"
-      #     compose_definition = YAML.load_file(compose_file) if File.exist?(compose_file)
-      #     compose_definition ||= {
-      #       version: "3.7",
-      #       services: {}
-      #     }
-      #     compose_definition.deep_stringify_keys!
-
-      #     new_definition = YAML.load template_eval("docker-compose/#{source}.yml.tt")
-      #     compose_definition.deep_merge! new_definition.deep_stringify_keys
-
-      #     create_file compose_file, YAML.dump(compose_definition), force: true
-      #   end
-      # end
-
       def managed_compose(file = "docker-compose.yml")
         @managed_compose ||= {}
 

data/lib/generators/pu/lib/plutonium_generators/concerns/js_package_manager.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+begin
+  # jsbundling-rails `main` ships the detector its build task uses (unreleased
+  # as of 1.3.1).
+  require "jsbundling/package_manager"
+rescue LoadError
+  # Older jsbundling-rails, or an app without it: fall back to the same rules.
+end
+
+module PlutoniumGenerators
+  module Concerns
+    # Detects the host app's JavaScript package manager and builds the matching
+    # shell commands, so generators never hardcode `yarn`.
+    #
+    # Detection follows what `rails javascript:build` consults at precompile
+    # time. Installing with the same tool keeps a single lockfile: the lockfile
+    # decides, and with no lockfile the first executable on PATH among bun,
+    # yarn, pnpm and npm wins (yarn when none is found). `rails new -j esbuild`
+    # therefore yields a bun app on any machine that has bun installed, and
+    # this concern follows it rather than adding a yarn.lock next to bun.lock.
+    # When the app's jsbundling-rails provides Jsbundling::PackageManager, that
+    # detector is used as is (it skips yarn.lock and decides by PATH).
+    #
+    # Yarn 1 (classic) and Yarn 2+ (berry) share `add` but differ elsewhere;
+    # `yarn_berry?` distinguishes them by asking the yarn the app resolves to.
+    module JsPackageManager
+      ADD_COMMANDS = {
+        bun: "bun add %s",
+        pnpm: "pnpm add %s",
+        npm: "npm install %s",
+        yarn: "yarn add %s"
+      }.freeze
+
+      INSTALL_COMMANDS = {
+        bun: "bun install",
+        pnpm: "pnpm install",
+        npm: "npm ci",
+        yarn: "yarn install"
+      }.freeze
+
+      RUN_COMMANDS = {
+        bun: "bun run %s",
+        pnpm: "pnpm run %s",
+        npm: "npm run %s",
+        yarn: "yarn %s"
+      }.freeze
+
+      LOCKFILES = {
+        bun: %w[bun.lock bun.lockb],
+        pnpm: %w[pnpm-lock.yaml],
+        npm: %w[package-lock.json],
+        yarn: %w[yarn.lock]
+      }.freeze
+
+      protected
+
+      # @return [Symbol] one of :bun, :pnpm, :npm, :yarn
+      def js_package_manager
+        @js_package_manager ||= detect_js_package_manager
+      end
+
+      # One command that adds every package. `pkg@latest` and `pkg@^1.2.3`
+      # are understood identically by all four managers, which is why callers
+      # pass versions inline instead of running a separate upgrade step
+      # (yarn 1 `upgrade --latest` has no yarn 2+ equivalent).
+      def js_add_command(*packages)
+        format(ADD_COMMANDS.fetch(js_package_manager), packages.flatten.join(" "))
+      end
+
+      def js_install_command
+        INSTALL_COMMANDS.fetch(js_package_manager)
+      end
+
+      def js_run_command(script)
+        format(RUN_COMMANDS.fetch(js_package_manager), script)
+      end
+
+      # Yarn 2+ ("berry"). Asks the yarn the app resolves to, so corepack and
+      # a `packageManager` field are honoured.
+      def yarn_berry?
+        js_package_manager == :yarn && yarn_version.to_i >= 2
+      end
+
+      def yarn_version
+        @yarn_version ||= capture_tool_version("yarn --version")
+      end
+
+      def bun_version
+        @bun_version ||= capture_tool_version("bun --version")
+      end
+
+      def node_version
+        @node_version ||= capture_tool_version("node --version")
+      end
+
+      # Yarn 2+ defaults to Plug'n'Play, which Tailwind's PostCSS plugin cannot
+      # be loaded under (postcss-load-config's require() options are not
+      # supported by PnP). Pin the node-modules linker, which is what the rest
+      # of the Rails toolchain expects, unless the app already chose a linker.
+      def ensure_yarn_node_modules_linker
+        return unless yarn_berry?
+
+        yarnrc = ".yarnrc.yml"
+        existing = in_root_dir { File.exist?(yarnrc) ? File.read(yarnrc) : nil }
+
+        if existing.nil?
+          create_file yarnrc, "nodeLinker: node-modules\n"
+        elsif existing.match?(/^nodeLinker:/)
+          unless existing.match?(/^nodeLinker:\s*node-modules\b/)
+            warn "#{yarnrc} sets a nodeLinker other than node-modules; the Tailwind PostCSS plugin does not load under Plug'n'Play"
+          end
+        else
+          append_to_file yarnrc, "nodeLinker: node-modules\n"
+        end
+      end
+
+      private
+
+      def detect_js_package_manager
+        root = Pathname(destination_root)
+        return Jsbundling::PackageManager.detect(root) if defined?(Jsbundling::PackageManager)
+
+        LOCKFILES.each do |manager, files|
+          return manager if files.any? { |f| root.join(f).exist? }
+        end
+        return :bun if root.join("bun.config.js").exist?
+
+        %i[bun yarn pnpm npm].find { |exe| system("command -v #{exe} > /dev/null") } || :yarn
+      end
+
+      def capture_tool_version(command)
+        output = in_root_dir { `#{command} 2>/dev/null` }
+        output[/\d+\.\d+\.\d+/]
+      rescue SystemCallError
+        nil
+      end
+
+      # Thor's in_root returns the block value too, but only once the generator
+      # has a destination stack; this stays usable from plain unit tests.
+      def in_root_dir(&)
+        Dir.chdir(destination_root, &)
+      end
+    end
+  end
+end

data/lib/generators/pu/lib/plutonium_generators/generator.rb

@@ -5,10 +5,9 @@ require "tty-prompt"
 
 module PlutoniumGenerators
   module Generator
-    include Concerns::Config
     include Concerns::Logger
-    include Concerns::Serializer
     include Concerns::Actions
+    include Concerns::JsPackageManager
 
     # Finds the shared namespace prefix between two model names.
     # Used to derive association names when models share a namespace.
@@ -58,20 +57,5 @@ module PlutoniumGenerators
         TTY::Prompt.new
       end
     end
-
-    # def appname
-    #   defined?(Rails.application) ? Rails.application.class.module_parent.name : "PlutoniumGenerators"
-    # end
-
-    # def app_name
-    #   appname.underscore
-    # end
-
-    def pug_installed?(feature, version: nil)
-      installed_version = read_config(:installed, feature)
-      return false unless installed_version.present?
-
-      version.present? ? SemanticRange.satisfies?(installed_version, ">=#{version}") : true
-    end
   end
 end

data/lib/generators/pu/pkg/package/package_generator.rb

@@ -17,6 +17,7 @@ module Pu
         validate_package_name package_name
 
         template "lib/engine.rb", "packages/#{package_namespace}/lib/engine.rb"
+        template "config/locales/en.yml", "packages/#{package_namespace}/config/locales/en.yml"
 
         %w[controllers interactions models policies definitions].each do |dir|
           directory "app/#{dir}", "packages/#{package_namespace}/app/#{dir}/#{package_namespace}"

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

@@ -0,0 +1,28 @@
+# Wording for the <%= package_name %> package's resources.
+#
+# This file is loaded automatically (the package is a Rails engine) ahead of
+# the host app's config/locales, so the app can still override anything here.
+#
+# Model and attribute names follow the Rails convention; placeholders, hints
+# and derived labels follow Plutonium's:
+#
+#   en:
+#     activerecord:
+#       models:
+#         <%= package_namespace %>/post:
+#           one: "Post"
+#           other: "Posts"
+#       attributes:
+#         <%= package_namespace %>/post:
+#           title: "Title"
+#     plutonium:
+#       fields:
+#         <%= package_namespace %>/post:
+#           title:
+#             placeholder: "A short, descriptive title"
+#       actions:
+#         <%= package_namespace %>/post:
+#           publish: "Publish now"
+#
+# See https://radioactive-labs.github.io/plutonium-core/reference/i18n
+en: {}

data/lib/generators/pu/pkg/portal/portal_generator.rb

@@ -25,6 +25,7 @@ module Pu
 
         template "lib/engine.rb", "packages/#{package_namespace}/lib/engine.rb"
         template "config/routes.rb", "packages/#{package_namespace}/config/routes.rb"
+        template "config/locales/en.yml", "packages/#{package_namespace}/config/locales/en.yml"
 
         template "app/controllers/concerns/controller.rb",
           "packages/#{package_namespace}/app/controllers/#{package_namespace}/concerns/controller.rb"

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/profile/conn_generator.rb

@@ -65,6 +65,12 @@ module Pu
     user.#{profile_association}.nil?
   end
 
+  # The base update? delegates to create?, which is false once the profile
+  # exists. relation_scope already limits this to the user's own profile.
+  def update?
+    true
+  end
+
   def destroy?
     false
   end

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