plutonium 0.37.0 → 0.39.0

data/docs/reference/policy/index.md

@@ -36,12 +36,16 @@ Inside a policy, you have access to:
 | `user` | Current authenticated user (required) |
 | `record` | Resource being authorized |
 | `entity_scope` | Current scoped entity (for multi-tenancy) |
+| `parent` | Parent record for nested resources (nil if not nested) |
+| `parent_association` | Association name on parent (e.g., `:comments`) |
 
 ```ruby
 def update?
-  user          # => Current user
-  record        # => The Post instance
-  entity_scope  # => Organization for multi-tenant portals
+  user               # => Current user
+  record             # => The Post instance
+  entity_scope       # => Organization for multi-tenant portals
+  parent             # => Parent record (for nested routes)
+  parent_association # => :comments (association name)
 end
 ```
 
@@ -218,9 +222,29 @@ class PostPolicy < Plutonium::Resource::Policy
 end
 ```
 
-### With Entity Scoping
+### With Parent Scoping (Nested Resources)
 
-Call `super` to preserve automatic entity scoping for multi-tenancy:
+Call `super` to apply automatic parent scoping for nested resources:
+
+```ruby
+relation_scope do |relation|
+  relation = super(relation)  # Applies parent scoping automatically
+
+  if user.admin?
+    relation
+  else
+    relation.where(approved: true)
+  end
+end
+```
+
+**Parent scoping takes precedence over entity scoping.** When a parent is present:
+- For `has_many` associations: scopes via `parent.association_name`
+- For `has_one` associations: scopes via `where(foreign_key: parent.id)`
+
+### With Entity Scoping (Multi-tenancy)
+
+When no parent is present, `super` applies entity scoping:
 
 ```ruby
 relation_scope do |relation|
@@ -234,7 +258,54 @@ relation_scope do |relation|
 end
 ```
 
-The default `relation_scope` automatically applies `relation.associated_with(entity_scope)` when an entity scope is present.
+The default `relation_scope` automatically applies `relation.associated_with(entity_scope)` when an entity scope is present and no parent is set.
+
+### default_relation_scope is Required
+
+Plutonium verifies that `default_relation_scope` is called in every `relation_scope`. This prevents accidental multi-tenancy leaks when overriding scopes.
+
+```ruby
+# ❌ This will raise an error
+relation_scope do |relation|
+  relation.where(published: true)  # Missing default_relation_scope!
+end
+
+# ✅ Correct - call default_relation_scope
+relation_scope do |relation|
+  default_relation_scope(relation).where(published: true)
+end
+
+# ✅ Also correct - super calls default_relation_scope
+relation_scope do |relation|
+  super(relation).where(published: true)
+end
+```
+
+When overriding an inherited scope:
+
+```ruby
+class AdminPostPolicy < PostPolicy
+  relation_scope do |relation|
+    # Replace inherited scope but keep Plutonium's parent/entity scoping
+    default_relation_scope(relation)
+  end
+end
+```
+
+This method applies parent scoping (for nested resources) or entity scoping (for multi-tenancy) directly, bypassing any inherited scope customizations.
+
+### Skipping Default Scoping
+
+If you intentionally need to bypass scoping, call `skip_default_relation_scope!`:
+
+```ruby
+relation_scope do |relation|
+  skip_default_relation_scope!
+  relation  # No parent/entity scoping applied
+end
+```
+
+This should be rare - consider using a separate portal with different scoping rules instead.
 
 ## Portal-Specific Policies
 

data/gemfiles/rails_7.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.34.1)
+    plutonium (0.38.0)
       action_policy (~> 0.7.0)
       listen (~> 3.8)
       pagy (~> 9.0)
@@ -11,8 +11,8 @@ PATH
       phlex-tabler_icons
       phlexi-display (>= 0.2.0)
       phlexi-field (>= 0.2.0)
-      phlexi-form (>= 0.10.0)
-      phlexi-menu (>= 0.4.0)
+      phlexi-form (>= 0.14.1)
+      phlexi-menu (>= 0.4.1)
       phlexi-table (>= 0.2.0)
       rabl (~> 0.16.1)
       rails (>= 7.2)
@@ -230,12 +230,12 @@ GEM
       fiber-local
       phlex (~> 2.0)
       zeitwerk
-    phlexi-form (0.11.0)
+    phlexi-form (0.14.1)
       activesupport
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk
-    phlexi-menu (0.4.0)
+    phlexi-menu (0.4.1)
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk

data/gemfiles/rails_8.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.34.1)
+    plutonium (0.38.0)
       action_policy (~> 0.7.0)
       listen (~> 3.8)
       pagy (~> 9.0)
@@ -11,8 +11,8 @@ PATH
       phlex-tabler_icons
       phlexi-display (>= 0.2.0)
       phlexi-field (>= 0.2.0)
-      phlexi-form (>= 0.10.0)
-      phlexi-menu (>= 0.4.0)
+      phlexi-form (>= 0.14.1)
+      phlexi-menu (>= 0.4.1)
       phlexi-table (>= 0.2.0)
       rabl (~> 0.16.1)
       rails (>= 7.2)
@@ -209,12 +209,12 @@ GEM
       fiber-local
       phlex (~> 2.0)
       zeitwerk
-    phlexi-form (0.11.0)
+    phlexi-form (0.14.1)
       activesupport
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk
-    phlexi-menu (0.4.0)
+    phlexi-menu (0.4.1)
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk

data/gemfiles/rails_8.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    plutonium (0.34.1)
+    plutonium (0.38.0)
       action_policy (~> 0.7.0)
       listen (~> 3.8)
       pagy (~> 9.0)
@@ -11,8 +11,8 @@ PATH
       phlex-tabler_icons
       phlexi-display (>= 0.2.0)
       phlexi-field (>= 0.2.0)
-      phlexi-form (>= 0.10.0)
-      phlexi-menu (>= 0.4.0)
+      phlexi-form (>= 0.14.1)
+      phlexi-menu (>= 0.4.1)
       phlexi-table (>= 0.2.0)
       rabl (~> 0.16.1)
       rails (>= 7.2)
@@ -211,12 +211,12 @@ GEM
       fiber-local
       phlex (~> 2.0)
       zeitwerk
-    phlexi-form (0.11.0)
+    phlexi-form (0.14.1)
       activesupport
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk
-    phlexi-menu (0.4.0)
+    phlexi-menu (0.4.1)
       phlex (~> 2.0)
       phlexi-field (~> 0.2.0)
       zeitwerk

data/lib/generators/pu/rodauth/install_generator.rb

@@ -1,20 +1,13 @@
 require "rails/generators/base"
 require "rails/generators/active_record/migration"
 require "securerandom"
+require "plutonium/auth/sequel_adapter"
 
 module Pu
   module Rodauth
     class InstallGenerator < ::Rails::Generators::Base
       include ::ActiveRecord::Generators::Migration
 
-      SEQUEL_ADAPTERS = {
-        "postgresql" => (RUBY_ENGINE == "jruby") ? "postgresql" : "postgres",
-        "mysql2" => (RUBY_ENGINE == "jruby") ? "mysql" : "mysql2",
-        "sqlite3" => "sqlite",
-        "oracle_enhanced" => "oracle",
-        "sqlserver" => (RUBY_ENGINE == "jruby") ? "mssql" : "tinytds"
-      }
-
       source_root "#{__dir__}/templates"
 
       desc "Install rodauth-rails"
@@ -61,15 +54,18 @@ module Pu
 
       private
 
+      # Delegates to the SequelAdapter module to avoid code duplication.
       def sequel_adapter
-        SEQUEL_ADAPTERS[activerecord_adapter] || activerecord_adapter
+        Plutonium::Auth::SequelAdapter.sequel_adapter
       end
 
+      # Delegates to the SequelAdapter module's internal ActiveRecord adapter detection.
+      # We still provide this method for use in create_install_migration.
       def activerecord_adapter
         if ActiveRecord::Base.respond_to?(:connection_db_config)
-          ActiveRecord::Base.connection_db_config.adapter
+          ActiveRecord::Base.connection_db_config&.adapter
         else
-          ActiveRecord::Base.connection_config.fetch(:adapter)
+          ActiveRecord::Base.connection_config&.fetch(:adapter, nil)
         end
       end
     end

data/lib/generators/pu/rodauth/templates/app/rodauth/rodauth_plugin.rb.tt

@@ -1,4 +1,5 @@
 require "sequel/core"
+require "plutonium/auth/sequel_adapter"
 
 class RodauthPlugin < Rodauth::Rails::Auth
   attr_accessor :url_options
@@ -17,11 +18,8 @@ class RodauthPlugin < Rodauth::Rails::Auth
     # ==> General
 
     # Initialize Sequel and have it reuse Active Record's database connection.
-<% if RUBY_ENGINE == "jruby" -%>
-    db Sequel.connect("jdbc:<%= sequel_adapter %>://", extensions: :activerecord_connection, keep_reference: false)
-<% else -%>
-    db Sequel.<%= sequel_adapter %>(extensions: :activerecord_connection, keep_reference: false)
-<% end -%>
+    # The adapter is detected dynamically at runtime to support database changes.
+    db Plutonium::Auth::SequelAdapter.db
 
     # Change prefix of table and foreign key column names from default "account"
     # accounts_table :users

data/lib/plutonium/auth/sequel_adapter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "sequel/core"
+
+module Plutonium
+  module Auth
+    # Provides runtime detection of the database adapter for Sequel configuration.
+    # This module dynamically detects the ActiveRecord adapter and returns the
+    # corresponding Sequel adapter, allowing users to change their database
+    # without needing to regenerate rodauth files.
+    module SequelAdapter
+      # Maps ActiveRecord adapter names to their corresponding Sequel adapter names.
+      # JRuby uses JDBC adapters which have different naming conventions.
+      SEQUEL_ADAPTERS = {
+        "postgresql" => (RUBY_ENGINE == "jruby") ? "postgresql" : "postgres",
+        "mysql2" => (RUBY_ENGINE == "jruby") ? "mysql" : "mysql2",
+        "sqlite3" => "sqlite",
+        "oracle_enhanced" => "oracle",
+        "sqlserver" => (RUBY_ENGINE == "jruby") ? "mssql" : "tinytds"
+      }.freeze
+
+      class << self
+        # Returns a Sequel database connection that reuses ActiveRecord's connection.
+        # Automatically detects the correct adapter based on the current ActiveRecord config.
+        #
+        # @return [Sequel::Database] configured Sequel database connection
+        # @raise [RuntimeError] if the Sequel adapter initialization fails
+        def db
+          adapter = sequel_adapter
+          begin
+            if RUBY_ENGINE == "jruby"
+              Sequel.connect("jdbc:#{adapter}://", extensions: :activerecord_connection, keep_reference: false)
+            else
+              Sequel.public_send(adapter, extensions: :activerecord_connection, keep_reference: false)
+            end
+          rescue => e
+            raise "Failed to initialize Sequel with adapter '#{adapter}'. " \
+                  "Please ensure your database configuration is correct and the required " \
+                  "database gems are installed. Original error: #{e.message}"
+          end
+        end
+
+        # Returns the Sequel adapter name based on the current ActiveRecord adapter.
+        # If the ActiveRecord adapter is not in the SEQUEL_ADAPTERS mapping, the
+        # ActiveRecord adapter name is returned as-is, which may work for adapters
+        # where the names match between ActiveRecord and Sequel.
+        #
+        # @return [String] the Sequel adapter name
+        def sequel_adapter
+          SEQUEL_ADAPTERS[activerecord_adapter] || activerecord_adapter
+        end
+
+        private
+
+        # Returns the current ActiveRecord adapter name.
+        #
+        # @return [String] the ActiveRecord adapter name
+        # @raise [RuntimeError] if the ActiveRecord adapter cannot be determined
+        def activerecord_adapter
+          adapter = if ActiveRecord::Base.respond_to?(:connection_db_config)
+            ActiveRecord::Base.connection_db_config&.adapter
+          else
+            ActiveRecord::Base.connection_config&.fetch(:adapter, nil)
+          end
+
+          unless adapter
+            raise "Unable to determine the ActiveRecord database adapter. " \
+                  "Please ensure ActiveRecord is properly configured with a database connection."
+          end
+
+          adapter
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/core/controller.rb

@@ -5,12 +5,26 @@ module Plutonium
       include Plutonium::Core::Controllers::Bootable
       include Plutonium::Core::Controllers::EntityScoping
       include Plutonium::Core::Controllers::Authorizable
+      include Plutonium::Core::Controllers::AssociationResolver
 
       included do
         add_flash_types :success, :warning, :error
 
         protect_from_forgery with: :null_session, if: -> { request.headers["Authorization"].present? }
 
+        rescue_from ::ActionPolicy::Unauthorized do |exception|
+          respond_to do |format|
+            format.any(:html, :turbo_stream) do
+              raise exception
+            end
+            format.any do
+              @errors = ActiveModel::Errors.new(exception.policy.record)
+              @errors.add(:base, :unauthorized, message: exception.result.message)
+              render "errors", status: :forbidden
+            end
+          end
+        end
+
         before_action do
           next unless defined?(ActiveStorage)
 
@@ -60,33 +74,154 @@ module Plutonium
       # `resource_url_args_for @post`                  => `entity_user_post_*`
       # `resource_url_args_for @post, action: :edit`   => `edit_entity_user_post_*`
       #
-      # @param [Class, ApplicationRecord] *args arguments you would normally pass to `url_for`
+      # - with explicit association (for multiple associations to same class)
+      #
+      # `resource_url_args_for :authored_posts, parent: @user` => `entity_user_authored_posts_*`
+      #
+      # @param [Class, ApplicationRecord, Symbol] *args arguments you would normally pass to `url_for`.
+      #   When parent is specified, can be a Symbol to explicitly name the association.
       # @param [Symbol] action optional action to invoke, e.g., :new, :edit
       # @param [ApplicationRecord] parent the parent record for nested routes, if any
+      # @param [Symbol] association explicit association name (when multiple associations to same class)
       # @param [Hash] kwargs additional keyword arguments to pass to `url_for`
       #
       # @return [Hash] args to pass to `url_for`
       #
-      def resource_url_args_for(*args, action: nil, parent: nil, **kwargs)
+      def resource_url_args_for(*args, action: nil, parent: nil, association: nil, package: nil, **kwargs)
+        target_package = package || current_package
+
+        # For nested resources, use named route helpers to avoid Rails param recall ambiguity
+        if parent.present?
+          assoc_name = if args.first.is_a?(Symbol)
+            args.first
+          else
+            association || resolve_association(args.first, parent)
+          end
+
+          nested_route_key = "#{parent.class.model_name.plural}/#{assoc_name}"
+          route_config = current_engine.routes.resource_route_config_for(nested_route_key)[0]
+
+          if route_config
+            return build_nested_resource_url_args(
+              args.first,
+              parent: parent,
+              association_name: assoc_name,
+              route_config: route_config,
+              action: action,
+              **kwargs
+            )
+          end
+        end
+
+        # Top-level resource: build controller/action hash for url_for
+        build_top_level_resource_url_args(*args, action: action, parent: parent, association: association, package: target_package, **kwargs)
+      end
+
+      def resource_url_for(*args, package: nil, **kwargs)
+        url_args = resource_url_args_for(*args, package: package, **kwargs)
+        url_helpers = route_url_helpers_for(package)
+
+        if url_args[:_named_route]
+          url_helpers.send(url_args[:_named_route], *url_args[:_args], **url_args[:_options])
+        else
+          url_helpers.url_for(url_args)
+        end
+      end
+
+      def route_url_helpers_for(package = nil)
+        pkg = package || current_package
+        pkg.present? ? send(pkg.name.underscore.to_sym) : current_engine.routes.url_helpers
+      end
+
+      private
+
+      def build_nested_resource_url_args(element, parent:, association_name:, route_config:, action: nil, **kwargs)
+        prefix = Plutonium::Routing::NESTED_ROUTE_PREFIX
+        is_singular = route_config[:route_type] == :resource
+
+        # For singular resources (has_one), Class/Symbol/nil without action means "no record exists" -> default to :new
+        if is_singular && (element.is_a?(Class) || element.is_a?(Symbol) || element.nil?) && action.nil?
+          action = :new
+        end
+
+        # Build the named helper: e.g., "blogging_post_nested_post_metadata_path"
+        parent_singular = parent.model_name.singular
+        nested_resource_name = "#{prefix}#{association_name}"
+
+        # Determine if this is a collection action (no specific record)
+        no_record = element.is_a?(Class) || element.is_a?(Symbol) || element.nil?
+
+        # Determine the helper name based on action and route type
+        # For singular routes (has_one), always use the association name as-is (no singularize)
+        # For plural routes (has_many):
+        #   - :index action uses plural (blogging_post_nested_comments)
+        #   - :new action uses singular (new_blogging_post_nested_comment)
+        #   - member actions (show/edit/destroy) use singular (blogging_post_nested_comment)
+        helper_base = if is_singular
+          "#{parent_singular}_#{nested_resource_name}"
+        elsif action == :index || (no_record && action != :new)
+          "#{parent_singular}_#{nested_resource_name}"
+        else
+          "#{parent_singular}_#{nested_resource_name.to_s.singularize}"
+        end
+
+        helper_suffix = case action
+        when :show, nil then ""
+        else "#{action}_"
+        end
+
+        helper_name = :"#{helper_suffix}#{helper_base}_path"
+
+        # Build the arguments for the helper
+        helper_args = [parent.to_param]
+        # Include element ID for plural routes (has_many) when we have a record instance
+        unless is_singular || no_record
+          helper_args << element.to_param
+        end
+
+        # Build URL options
+        url_options = kwargs.dup
+        if !url_options.key?(:format) && request.present? && request.format.present? && !request.format.symbol.in?([:html, :turbo_stream])
+          url_options[:format] = request.format.symbol
+        end
+
+        {_named_route: helper_name, _args: helper_args, _options: url_options}
+      end
+
+      def build_top_level_resource_url_args(*args, action: nil, parent: nil, association: nil, package: nil, **kwargs)
         url_args = {**kwargs, action: action}.compact
 
-        controller_chain = [current_package&.to_s].compact
+        controller_chain = [package&.to_s].compact
         [*args].compact.each_with_index do |element, index|
-          if element.is_a?(Class)
+          if element.is_a?(Symbol)
+            raise ArgumentError, "parent is required when using symbol association name" unless parent
+
+            assoc = parent.class.reflect_on_association(element)
+            raise ArgumentError, "Unknown association :#{element} on #{parent.class}" unless assoc
+
+            controller_chain << assoc.klass.to_s.pluralize
+            url_args[:action] ||= :index if index == args.length - 1
+          elsif element.is_a?(Class)
             controller_chain << element.to_s.pluralize
+            url_args[:action] ||= :index if index == args.length - 1 && parent.present?
           else
-            # For STI models, use the base class for routing if the specific class isn't registered
             model_class = element.class
             if model_class.respond_to?(:base_class) && model_class != model_class.base_class
-              # Check if the STI model is registered, if not use base class
               route_configs = current_engine.routes.resource_route_config_for(model_class.model_name.plural)
               model_class = model_class.base_class if route_configs.empty?
             end
 
             controller_chain << model_class.to_s.pluralize
             if index == args.length - 1
-              resource_route_config = current_engine.routes.resource_route_config_for(model_class.model_name.plural)[0]
-              url_args[:id] = element.to_param unless resource_route_config[:route_type] == :resource
+              route_key = if parent.present?
+                assoc_name = association || resolve_association(element, parent)
+                "#{parent.class.model_name.plural}/#{assoc_name}"
+              else
+                model_class.model_name.plural
+              end
+              resource_route_config = current_engine.routes.resource_route_config_for(route_key)[0]
+              is_singular = resource_route_config&.dig(:route_type) == :resource
+              url_args[:id] = element.to_param unless is_singular
               url_args[:action] ||= :show
             else
               url_args[model_class.to_s.underscore.singularize.to_sym] = element.to_param
@@ -100,8 +235,6 @@ module Plutonium
           url_args[scoped_entity_param_key] = current_scoped_entity
         end
 
-        # Preserve the request format unless explicitly specified
-        # Don't preserve turbo_stream as it's for streaming updates, not page navigation
         if !url_args.key?(:format) && request.present? && request.format.present? && !request.format.symbol.in?([:html, :turbo_stream])
           url_args[:format] = request.format.symbol
         end
@@ -109,15 +242,6 @@ module Plutonium
         url_args
       end
 
-      def resource_url_for(...)
-        args = resource_url_args_for(...)
-        if current_package.present?
-          send(current_package.name.underscore.to_sym).url_for(args)
-        else
-          url_for(args)
-        end
-      end
-
       def root_path(*)
         return send(:"#{scoped_entity_param_key}_root_path", *) if scoped_to_entity? && scoped_entity_strategy == :path
 

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Core
+    module Controllers
+      # Resolves target classes/instances to association names on a parent model.
+      #
+      # This module handles the mapping between resource classes and their association
+      # names when generating nested resource URLs. It supports:
+      # - Explicit association names (symbols)
+      # - Class-based resolution with namespace fallback
+      # - Instance-based resolution
+      #
+      # @example Explicit association
+      #   resolve_association(:comments, @post) # => :comments
+      #
+      # @example Class-based resolution
+      #   resolve_association(Comment, @post) # => :comments
+      #
+      # @example Namespaced class resolution
+      #   resolve_association(Blogging::Comment, @post) # => :comments (tries :blogging_comments first)
+      #
+      module AssociationResolver
+        class AmbiguousAssociationError < StandardError; end
+
+        # Resolves a target to an association name on the parent
+        #
+        # @param target [Class, Object, Symbol] The target class, instance, or association name
+        # @param parent [Object] The parent instance
+        # @return [Symbol] The resolved association name
+        # @raise [ArgumentError] If no matching association is found
+        # @raise [AmbiguousAssociationError] If multiple associations match
+        def resolve_association(target, parent)
+          return target if target.is_a?(Symbol)
+
+          target_class = target.is_a?(Class) ? target : target.class
+          candidates = association_candidates_for(target_class)
+
+          matching = candidates.filter_map do |assoc_name|
+            assoc = parent.class.reflect_on_association(assoc_name)
+            assoc_name if assoc && assoc.klass >= target_class
+          end
+
+          case matching.size
+          when 0
+            raise ArgumentError,
+              "No association found for #{target_class} on #{parent.class}. " \
+              "Tried: #{candidates.join(", ")}"
+          when 1
+            matching.first
+          else
+            raise AmbiguousAssociationError,
+              "Multiple associations to #{target_class} on #{parent.class}: #{matching.join(", ")}. " \
+              "Please specify explicitly using a symbol: resource_url_for(:association_name, parent: ...)"
+          end
+        end
+
+        private
+
+        # Returns candidate association names for a class
+        #
+        # For Blogging::Comment, returns [:blogging_comments, :comments]
+        # For Comment, returns [:comments]
+        #
+        # @param klass [Class] The target class
+        # @return [Array<Symbol>] Candidate association names in priority order
+        def association_candidates_for(klass)
+          candidates = []
+
+          # Full namespaced name: Blogging::Comment => :blogging_comments
+          full_name = klass.model_name.plural.to_sym
+          candidates << full_name
+
+          # Demodulized name: Blogging::Comment => :comments
+          demodulized = klass.name.demodulize
+          if demodulized != klass.name
+            short_name = demodulized.underscore.pluralize.to_sym
+            candidates << short_name unless candidates.include?(short_name)
+          end
+
+          candidates
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/helpers/display_helper.rb

@@ -14,6 +14,18 @@ module Plutonium
         resource_name resource_class, 2
       end
 
+      # Returns a human-readable name for a nested collection using the association name.
+      # Falls back to resource_name_plural if not in a nested context.
+      # Uses I18n via human_attribute_name for proper localization.
+      # e.g., "Authored Comments" for has_many :authored_comments
+      def nestable_resource_name_plural(resource_class)
+        if current_parent && current_nested_association
+          current_parent.class.human_attribute_name(current_nested_association).titleize
+        else
+          resource_name_plural(resource_class)
+        end
+      end
+
       def display_field(value:, helper: nil, **options)
         return "-" unless value.present?