layered-resource-rails 0.1.0

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+# `db:prepare` seeds, and the dummy app's seeds deliberately create more users
+# than Layered::Resource.filter_combobox_threshold so the switch to a combobox
+# is visible in bin/dev. Seeded rows in the test database would then change the
+# control a filter renders as, so the suite loads the schema into a purged test
+# database instead of inheriting whatever a previous `db:prepare` left behind.
+task test: "app:db:test:prepare"
+
+task default: :test

data/TRADEMARK.md

@@ -0,0 +1,31 @@
+# layered.ai Trademark and Brand Policy
+
+The layered.ai name, logo, domain names, and related brand assets are
+trademarks of LAYERED AI LIMITED (UK company number: 17056830).
+
+## Scope
+
+The layered.ai software is licensed under the Apache License 2.0.
+That license grants rights to use, modify, and distribute the software
+but does not grant rights to use the layered.ai name, logo, or branding.
+
+## Restrictions
+
+Without a separate written brand license from LAYERED AI LIMITED, you may not:
+
+- Use the name "layered.ai" to identify a fork, derivative work, or hosted service
+- Use the layered.ai logo or visual identity
+- Present a product or service as official or endorsed
+- Use confusingly similar names, logos, or domains
+
+## Forks and Redistribution
+
+Forks and redistributions must use a distinct name and branding.
+Statements such as "compatible with layered.ai" are allowed if they do
+not imply endorsement.
+
+## Brand Licenses
+
+Commercial use of the layered.ai name or marks requires a brand license.
+
+Contact: support@layered.ai

data/app/controllers/layered/resource/controller.rb

@@ -0,0 +1,284 @@
+module Layered
+  module Resource
+    # All the controller behaviour for a layered resource. Concern so that
+    # host engines can declare their own `ResourcesController` inheriting
+    # from their own ApplicationController and still pick up the full DSL:
+    #
+    #   class Layered::Assistant::ResourcesController < Layered::Assistant::ApplicationController
+    #     include Layered::Resource::Controller
+    #   end
+    #
+    # The default `Layered::Resource::ResourcesController < ::ApplicationController`
+    # exists for non-engine host apps that just want everything wired up.
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        include Internal::Routing
+        include Internal::Breadcrumbs
+        include Internal::Columns
+
+        helper Rails.application.routes.url_helpers
+        helper Layered::Ui::TableHelper
+        helper Layered::Ui::FormHelper
+        helper Layered::Ui::RansackHelper
+        helper Layered::Ui::PagyHelper
+        helper Layered::Ui::BreadcrumbsHelper
+        helper Layered::Resource::FiltersHelper
+
+        before_action :load_layered_resource
+        before_action :load_layered_member_record
+        before_action :require_layered_fields, only: %i[new create edit update]
+        before_action :set_layered_page_title
+
+        helper_method :layered_routes
+        helper_method :layered_collection_path
+        helper_method :layered_member_path
+        helper_method :layered_breadcrumbs
+        helper_method :resource_can?
+        helper_method :layered_record_label
+      end
+
+      def index
+        apply_layered_filter_defaults
+        @q = @resource.scope(self).ransack(params[:q], auth_object: @resource)
+        if @q.sorts.empty?
+          ds = @resource.default_sort
+          @q.sorts = "#{ds[:attribute]} #{ds[:direction]}"
+        end
+        scope = @q.result(distinct: @resource.requires_distinct?)
+
+        # Pagy rebuilds page links from the full request query; `fo` (the
+        # one-shot open-this-tag's-popover param from the add-filter link)
+        # must not ride along or paginating would reopen the popover.
+        @pagy, @records = pagy(scope, limit: @resource.per_page,
+                                      querify: ->(query) { query.delete("fo") })
+        decorate_columns
+      end
+
+      def show
+        @record = @resource.scope(self).find(params[:id])
+        authorize_layered_record(@record)
+        @page_title = layered_record_label(@record)
+      end
+
+      def new
+        @record = @resource.build_record(self)
+        authorize_layered_record(@record)
+        @form_url = layered_collection_path
+      end
+
+      def create
+        @record = @resource.build_record(self)
+        authorize_layered_record(@record)
+        @record.assign_attributes(layered_resource_params)
+
+        if @record.save
+          redirect_to @resource.after_save_path(self, @record),
+                      notice: t("layered.resource.flash.created", model: @resource.model.model_name.human)
+        else
+          @form_url = layered_collection_path
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit
+        @record = @resource.scope(self).find(params[:id])
+        authorize_layered_record(@record)
+        @form_url = layered_member_path(@record)
+        @page_title = "Edit #{layered_record_label(@record)}"
+      end
+
+      def update
+        @record = @resource.scope(self).find(params[:id])
+        authorize_layered_record(@record)
+        if @record.update(layered_resource_params)
+          redirect_to @resource.after_save_path(self, @record),
+                      notice: t("layered.resource.flash.updated", model: @resource.model.model_name.human)
+        else
+          @form_url = layered_member_path(@record)
+          @page_title = "Edit #{layered_record_label(@record)}"
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @record = @resource.scope(self).find(params[:id])
+        authorize_layered_record(@record)
+        redirect_path = @resource.after_save_path(self, @record)
+        model_name = @resource.model.model_name.human
+        begin
+          if @record.destroy
+            redirect_to redirect_path, notice: t("layered.resource.flash.deleted", model: model_name)
+          else
+            redirect_to redirect_path, alert: t("layered.resource.flash.not_deleted", model: model_name)
+          end
+        rescue ActiveRecord::InvalidForeignKey, ActiveRecord::DeleteRestrictionError
+          redirect_to redirect_path,
+                      alert: t("layered.resource.flash.dependent_records", model: model_name)
+        end
+      end
+
+      # Composes the route-exposure flag for an action with the per-record
+      # Pundit policy when `use_pundit` is enabled. `action` is one of
+      # `:new`, `:create`, `:show`, `:edit`, `:update`, `:destroy`. Each key
+      # gates the route of the same name and runs the matching Pundit query
+      # (`new?`, `create?`, etc.). Pass a `record` to gate on an individual
+      # record (e.g. inside the index row); omit it to fall back to the
+      # class-level policy (`policy(@resource.model)`). Without `use_pundit`
+      # this just returns the `@resource_can_*` flag.
+      def resource_can?(action, record = nil)
+        flag = case action
+               when :new     then @resource_can_new
+               when :create  then @resource_can_create
+               when :show    then @resource_can_show
+               when :edit    then @resource_can_edit
+               when :update  then @resource_can_update
+               when :destroy then @resource_can_destroy
+               else raise ArgumentError, "unknown action #{action.inspect}"
+               end
+        return false unless flag
+        return true unless @resource.pundit_enabled?
+
+        policy(record || @resource.model).public_send(:"#{action}?")
+      end
+
+      # View lookup chain:
+      #   1. layered/<resource_name>/                 — host-app per-resource override (e.g. `app/views/layered/posts/`)
+      #   2. <controller's own inheritance prefixes>  — host's own layout chain
+      #   3. layered/resource/resources/              — gem-shipped defaults (always last)
+      #
+      # The trailing default ensures custom subclasses (like
+      # `CustomNamespace::ResourcesController` including `Layered::Resource::Controller`)
+      # still find the gem's templates without re-declaring view paths.
+      def _prefixes
+        base = super
+        prefixes = []
+        prefixes << "layered/#{@layered_resource_name}" if @layered_resource_name
+        prefixes.concat(base)
+        prefixes << "layered/resource/resources" unless prefixes.include?("layered/resource/resources")
+        prefixes
+      end
+
+      private
+
+      # Looks up the resource class from the route registry and sets all
+      # the instance variables the views need (@resource, @model, @columns,
+      # @fields, and the @resource_can_* route-exposure flags).
+      def load_layered_resource
+        route_key = request.path_parameters.delete(:_layered_resource_route_key)
+        params.delete(:_layered_resource_route_key)
+        @_route_entry = Layered::Resource::Routing.lookup(route_key)
+        raise ActionController::RoutingError, "No layered resource registered for route" unless @_route_entry
+
+        @resource = @_route_entry[:resource].safe_constantize
+        unless @resource && @resource < Layered::Resource::Base
+          raise ActionController::RoutingError,
+                "#{@_route_entry[:resource]} is not a layered resource (must inherit from Layered::Resource::Base)"
+        end
+
+        @resource.configure_ransack if Layered::Resource.auto_configure_ransack
+
+        @model = @resource.model
+        @columns = @resource.columns
+        @layered_route_key = route_key
+        @layered_resource_name = @_route_entry[:resource_name].presence || route_key
+        @fields = @resource.resolved_fields
+        @crud_enabled = @fields.any?
+
+        resource_actions = @_route_entry[:actions]
+        @resource_can_new     = @crud_enabled && resource_actions.include?(:new)
+        @resource_can_create  = @crud_enabled && resource_actions.include?(:create)
+        @resource_can_edit    = @crud_enabled && resource_actions.include?(:edit)
+        @resource_can_update  = @crud_enabled && resource_actions.include?(:update)
+        @resource_can_destroy = resource_actions.include?(:destroy)
+        @resource_can_show    = resource_actions.include?(:show)
+      end
+
+      # For custom member actions declared in a `layered_resources` block,
+      # populate @record from params[:id] so action bodies don't have to
+      # repeat `@resource.scope(self).find(params[:id])`. Skip this with
+      # `skip_before_action :load_layered_member_record, only: [:foo]` if
+      # the action doesn't need the record (or shouldn't 404 on a missing
+      # one).
+      def load_layered_member_record
+        return unless @_route_entry
+        return unless params[:id]
+
+        member_actions = @_route_entry[:member_actions] || []
+        return unless member_actions.include?(action_name.to_sym)
+
+        @record = @resource.scope(self).find(params[:id])
+        authorize_layered_record(@record)
+      end
+
+      # No-op unless the resource opts into Pundit. Defers to the host's
+      # Pundit::Authorization mixin (typically included on ApplicationController).
+      def authorize_layered_record(record)
+        return unless @resource&.pundit_enabled?
+
+        authorize(record, :"#{action_name}?")
+      end
+
+      # Merges each filter's `default:` into params[:q] when the request
+      # carries none of that filter's keys, so both the Ransack query and the
+      # filter-bar helpers see the same effective state (the tag shows the
+      # default as active, and links/forms round-trip it explicitly). A key
+      # that is present-but-blank means the user explicitly cleared a
+      # defaulted filter — the remove/Clear links write blanks for exactly
+      # this reason — so the default must NOT re-apply.
+      def apply_layered_filter_defaults
+        q = params[:q].respond_to?(:to_unsafe_h) ? params[:q].to_unsafe_h.stringify_keys : {}
+        additions = {}
+
+        @resource.resolved_filters.each do |filter|
+          default = filter[:default]
+          next if default.nil?
+          next if filter[:param_keys].any? { |k| q.key?(k) }
+
+          default = default.call if default.respond_to?(:call)
+          if filter[:predicates]
+            bounds = default.is_a?(Hash) ? default.symbolize_keys : { from: default }
+            from_key, to_key = filter[:param_keys]
+            additions[from_key] = bounds[:from] unless bounds[:from].nil?
+            additions[to_key] = bounds[:to] unless bounds[:to].nil?
+          else
+            additions[filter[:param_keys].first] = filter[:multiple] ? Array(default) : default
+          end
+        end
+
+        params[:q] = q.merge(additions) if additions.any?
+      end
+
+      def require_layered_fields
+        return if @crud_enabled
+
+        raise ActionController::RoutingError,
+              "Define fields on #{@resource.name} to enable CRUD actions"
+      end
+
+      # Sets a default `@page_title` based on the action and resource model.
+      # `show` and `edit` actions refine this with the loaded record's label.
+      def set_layered_page_title
+        human = @model.model_name.human
+        @page_title = case action_name
+                      when "new", "create" then "New #{human}"
+                      when "edit", "update" then "Edit #{human}"
+                      when "show" then human
+                      else human.pluralize
+                      end
+      end
+
+      # Renders a record as a human label, via the resource's
+      # `label_attribute` (the primary column unless declared otherwise).
+      def layered_record_label(record)
+        @resource.record_label(record)
+      end
+
+      def layered_resource_params
+        params.require(@resource.model.model_name.param_key)
+              .permit(*@resource.permitted_params)
+      end
+    end
+  end
+end

data/app/controllers/layered/resource/internal/breadcrumbs.rb

@@ -0,0 +1,80 @@
+module Layered
+  module Resource
+    module Internal
+      # Builds breadcrumb entries from parent route params.
+      # Depends on @_route_entry being set by the controller's
+      # load_layered_resource before_action.
+      module Breadcrumbs
+        extend ActiveSupport::Concern
+
+        private
+
+        # e.g. a route scoped under users/:user_id will produce
+        # breadcrumbs like "Users" (linked) and "Alice" by looking up
+        # the parent model and its layered index route. A `root_breadcrumb`
+        # declared on the resource is prepended to the trail.
+        def layered_breadcrumbs
+          @_layered_breadcrumbs ||= begin
+            root_crumbs = [@resource.root_breadcrumb].compact
+            parent_param_keys = @_route_entry[:parent_params]
+            parent_collection_keys = @_route_entry[:parent_collection_keys] || {}
+
+            current_namespace = @_route_entry[:resource].to_s.deconstantize.presence
+
+            root_crumbs + parent_param_keys.flat_map do |key|
+              match = key.to_s.match(/\A(.+)_id\z/)
+              next [] unless match
+
+              model_name = match[1]
+
+              # Resolve the parent model class. Prefer the registered layered
+              # resource entry (authoritative) when the parent is itself a
+              # layered_resources. Otherwise try the current resource's
+              # namespace before falling back to a top-level constant — this
+              # lets a namespaced child have a plain `resources :provider`
+              # parent that lives in the same namespace.
+              collection_key = parent_collection_keys[key]
+              collection_entry = collection_key && Layered::Resource::Routing.lookup(collection_key)
+              model_class =
+                if collection_entry
+                  collection_entry[:resource].constantize.model
+                elsif current_namespace
+                  "#{current_namespace}::#{model_name.classify}".safe_constantize ||
+                    model_name.classify.safe_constantize
+                else
+                  model_name.classify.safe_constantize
+                end
+              next [] unless model_class
+
+              crumbs = []
+
+              # Link to the parent's layered index if a route exists
+              if collection_entry
+                rs = collection_entry[:routes] || Rails.application.routes
+                helper = :"#{collection_key}_path"
+                if rs.url_helpers.method_defined?(helper)
+                  ancestor_args = collection_entry[:parent_params].each_with_object({}) do |p, h|
+                    h[p] = params[p]
+                  end
+                  if ancestor_args.values.all?(&:present?)
+                    path = rs.url_helpers.send(helper, default_url_options.merge(ancestor_args))
+                    crumbs << { label: model_class.model_name.human.pluralize, path: path }
+                  end
+                end
+              end
+
+              # Add the specific record breadcrumb
+              record = model_class.find_by(id: params[key])
+              if record
+                label = record.try(:name) || record.try(:title) || "#{model_class.model_name.human} ##{record.id}"
+                crumbs << { label: label, path: nil }
+              end
+
+              crumbs
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/layered/resource/internal/columns.rb

@@ -0,0 +1,207 @@
+module Layered
+  module Resource
+    module Internal
+      # Decorates the column hashes set up by load_layered_resource with the
+      # render procs the index view needs. Depends on @columns being set by
+      # the controller's load_layered_resource before_action.
+      module Columns
+        extend ActiveSupport::Concern
+
+        private
+
+        # Walks @columns and installs the default render proc for any column
+        # that doesn't already have one, then wraps columns with a `link:`
+        # option in a link to the named route.
+        def decorate_columns
+          apply_column_sortability
+          apply_column_renderers
+          apply_column_links
+          apply_primary_column_link if action_name == "index"
+        end
+
+        # Marks columns sortable: false unless they map to a real DB column.
+        # Virtual / association-derived columns (e.g. :user_name on Post) can't
+        # be sorted by Ransack without the associated model also having
+        # ransackable_attributes configured for the underlying field, so
+        # leaving them sortable produces sort links that 500 when clicked.
+        # Resources can opt back in by setting sortable: true explicitly and
+        # are then responsible for the associated model's allowlist.
+        def apply_column_sortability
+          db_columns = @resource.model.column_names
+
+          @columns = @columns.map do |col|
+            next col if col.key?(:sortable)
+
+            col.merge(sortable: db_columns.include?(col[:attribute].to_s))
+          end
+        end
+
+        # Column rendering precedence:
+        #   1. render: proc — escape hatch. Procs with arity 1 receive only
+        #      the record. Anything else (fixed arity >= 2, or variadic /
+        #      optional-arg procs with negative arity such as
+        #      `->(record, view = nil)`) also receives view_context as a
+        #      second arg, letting escape-hatch procs emit HTML via link_to
+        #      / tag.* without ActionController::Base.helpers gymnastics.
+        #      Normalised to single-arity here so downstream helpers
+        #      (l_ui_table) keep calling proc.call(record).
+        #   2. as: <type> — dispatch to a partial. Lookup order:
+        #        a. app/views/layered/<resource_name>/columns/_<type>.html.erb
+        #        b. app/views/layered/resource/columns/_<type>.html.erb
+        #           (host-app override > gem default, via Rails view paths).
+        #      Partial locals: (record, value, options). options is the
+        #      column hash itself - partials read keys like :variants,
+        #      :true_label, :format.
+        #   3. Default: raw attribute value with a strftime fallback so
+        #      datetime columns render readably without ceremony.
+        def apply_column_renderers
+          view = view_context
+
+          @columns = @columns.map do |col|
+            if (user_render = col[:render])
+              arity = user_render.arity
+              if arity == 1
+                col
+              elsif arity >= 2 || arity < 0
+                col.merge(render: ->(record) { user_render.call(record, view) })
+              else
+                raise ArgumentError,
+                      "render: proc for column #{col[:attribute].inspect} must accept " \
+                      "(record) or (record, view_context); got arity #{arity}."
+              end
+            else
+              attr = col[:attribute]
+              type = col[:as] || infer_column_type(attr)
+              partial = resolve_column_partial(type)
+              options = col
+              col.merge(
+                render: ->(record) {
+                  view.render(partial: partial, locals: { record: record, value: record.public_send(attr), options: options })
+                }
+              )
+            end
+          end
+        end
+
+        # Picks a default column partial type from the model's schema:
+        # boolean → :boolean, date/time/datetime → :datetime, everything
+        # else (including virtual attributes with no DB column) → :text.
+        # Resources can pin a specific renderer with as:.
+        def infer_column_type(attr)
+          col = @resource.model.columns_hash[attr.to_s]
+          case col&.type
+          when :boolean then :boolean
+          when :datetime, :date, :time, :timestamp then :datetime
+          else :text
+          end
+        end
+
+        # Per-resource override wins; otherwise fall back to the host-wide
+        # path. The host-wide path resolves to the host app's override (if
+        # any) before the gem's built-in via the standard view-path chain.
+        # Raises if neither exists - typo'd `as:` types should fail loudly,
+        # not render an empty cell.
+        def resolve_column_partial(type)
+          per_resource = "layered/#{@layered_resource_name}/columns/#{type}"
+          shared = "layered/resource/columns/#{type}"
+
+          if lookup_context.exists?(type, ["layered/#{@layered_resource_name}/columns"], true)
+            per_resource
+          elsif lookup_context.exists?(type, ["layered/resource/columns"], true)
+            shared
+          else
+            raise ArgumentError,
+                  "No column partial found for as: #{type.inspect}. " \
+                  "Looked for #{per_resource} and #{shared}. " \
+                  "Run `rails g layered:resource:column #{type}` to scaffold one."
+          end
+        end
+
+        # Wraps the primary column's render proc to link the cell to the most
+        # useful per-record page: the edit page when editable, otherwise the
+        # show page when one exists. The default show view is a blank canvas,
+        # so the index links to edit (where you actually act on the record)
+        # and only falls back to show for read-only resources that still
+        # expose a detail page. The "primary" column is the one marked
+        # primary: true (or the first column if none is). Columns that already
+        # declare a custom link: are left alone.
+        def apply_primary_column_link
+          singular = @layered_route_key.singularize
+          helper = if @resource_can_edit
+                     :"edit_#{singular}_path"
+                   elsif @resource_can_show
+                     :"#{singular}_path"
+                   end
+          return unless helper
+
+          routes_proxy = layered_routes
+          return unless routes_proxy.respond_to?(helper)
+
+          primary_index = @columns.index { |c| c[:primary] } || 0
+          view = view_context
+
+          @columns = @columns.each_with_index.map do |col, i|
+            next col unless i == primary_index
+            next col if col[:link]
+
+            inner_render = col[:render]
+            col.merge(
+              render: ->(record) {
+                value = inner_render.call(record)
+                view.link_to value, routes_proxy.send(helper, record), data: { turbo_frame: "_top" }
+              }
+            )
+          end
+        end
+
+        # Rewrites columns with a `link:` option, e.g.:
+        #   { attribute: :posts_count, link: :users_posts }
+        #
+        # Raises if the named route hasn't been registered, has no parent
+        # params (so there's no way to pass the record id), or has no
+        # generated path helper. Silent failure here turns a typo into a
+        # mysterious unlinked column; better to surface it.
+        def apply_column_links
+          view = view_context
+          opts = default_url_options
+
+          @columns = @columns.map do |col|
+            next col unless col[:link]
+
+            linked_key = col[:link].to_s
+            linked_entry = Layered::Resource::Routing.lookup(linked_key) ||
+                           raise(ArgumentError, "Column #{col[:attribute].inspect} on #{@resource.name} has link: #{col[:link].inspect} but no layered_resources route is registered under that key")
+
+            rs = linked_entry[:routes] || Rails.application.routes
+            link_parent_params = linked_entry[:parent_params]
+            if link_parent_params.empty?
+              raise ArgumentError,
+                    "Column #{col[:attribute].inspect} on #{@resource.name} links to #{col[:link].inspect}, " \
+                    "but that route has no parent params - link: only works for nested layered_resources"
+            end
+
+            path_helper = :"#{linked_key}_path"
+            unless rs.url_helpers.method_defined?(path_helper)
+              raise ArgumentError,
+                    "Column #{col[:attribute].inspect} on #{@resource.name} links to #{col[:link].inspect}, " \
+                    "but #{path_helper} is not defined - does the route include :index?"
+            end
+
+            *ancestor_params, immediate_parent = link_parent_params
+            inner_render = col[:render]
+            col.merge(
+              render: ->(record) {
+                value = inner_render.call(record)
+                args = opts.dup
+                ancestor_params.each { |p| args[p] = record.public_send(p) }
+                args[immediate_parent] = record.id
+                path = rs.url_helpers.send(path_helper, args)
+                view.link_to value, path, data: { turbo_frame: "_top" }
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/layered/resource/internal/routing.rb

@@ -0,0 +1,60 @@
+module Layered
+  module Resource
+    module Internal
+      # Path generation for the current layered resource. Routes are
+      # registered with Rails-standard `:as` names (e.g. `user_posts_path`),
+      # so the helpers here can be backed either by named route lookup or
+      # `polymorphic_path` — they're equivalent. We use named lookup for
+      # the current resource's own paths because we already have the route
+      # entry in hand from `load_layered_resource`; views and breadcrumbs
+      # use polymorphic helpers when reaching across resources.
+      module Routing
+        extend ActiveSupport::Concern
+
+        # Returns an object that responds to the route helpers (e.g.
+        # users_posts_path) with parent params already filled in from
+        # the current request. Used by views/columns to generate links
+        # without needing to know the parent params.
+        def layered_routes
+          @_layered_routes ||= begin
+            rs = @_route_entry[:routes] || Rails.application.routes
+            proxy = Object.new
+            proxy.singleton_class.include(rs.url_helpers)
+            ctrl = self
+            parent_values = request.path_parameters.slice(*@_route_entry[:parent_params])
+            proxy.singleton_class.remove_method(:default_url_options) if proxy.singleton_class.method_defined?(:default_url_options)
+            proxy.define_singleton_method(:default_url_options) { ctrl.send(:default_url_options).merge(parent_values) }
+            proxy
+          end
+        end
+
+        # Path to the current resource's collection (or one of its
+        # collection-scoped actions, e.g. `:new`).
+        def layered_collection_path(action: nil)
+          base = action ? :"#{action}_#{@layered_route_key.singularize}" : @layered_route_key.to_sym
+          helper = :"#{base}_path"
+          unless layered_routes.respond_to?(helper)
+            raise ActionController::RoutingError,
+                  "No #{action || 'collection'} route registered for #{@layered_route_key}. " \
+                  "Include the matching action in only:."
+          end
+          layered_routes.send(helper)
+        end
+
+        # Path to a member of the current resource (or a member-scoped
+        # action like `:edit`).
+        def layered_member_path(record, action: nil)
+          singular = @layered_route_key.singularize
+          base = action ? :"#{action}_#{singular}" : singular.to_sym
+          helper = :"#{base}_path"
+          unless layered_routes.respond_to?(helper)
+            raise ActionController::RoutingError,
+                  "No #{action || 'member'} route registered for #{@layered_route_key}. " \
+                  "Include the matching action in only:."
+          end
+          layered_routes.send(helper, record)
+        end
+      end
+    end
+  end
+end