Promote route metadata to Route keyword arguments

`version`, `namespace`, `prefix`, `requirements`, `anchor` and `settings`
were computed in `Endpoint#prepare_default_route_attributes`, merged into
the route options Hash, and read back through `Grape::Router::BaseRoute`'s
`def_delegators :@options`. They are route metadata, not part of the
user-declared options bag grape-swagger consumes.

They are now passed to `Grape::Router::Route` as explicit keyword
arguments and exposed as plain readers on `BaseRoute`. `Endpoint#to_routes`
computes each as a local and passes `config.route_options` straight
through, so `prepare_default_route_attributes` (and the intermediate
`default_route_options`/`complete_route_options`) is gone. `Route`
forwards the attributes to `super` via `**route_attributes` to keep its
signature lean.

`route.options` now carries only what was declared for the route; the
`@options` delegation is down to `description` plus the documentation
`DSL_METHODS`. The readers are unchanged, so grape-swagger (which reads
`route.prefix` and `route.settings`) is unaffected. `requirements` and
`anchor` can still be declared as route options, so any explicit value
stays in `route.options`; the effective value comes from the reader.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: ericproulx

UPGRADING.md

@@ -37,6 +37,23 @@ Grape::Endpoint.new(settings, http_methods: :get, path: '/foo', api: my_api)
 
 The owning API is no longer carried on the endpoint's public `options` Hash — `endpoint.options[:for]` is gone. Use the new `endpoint.api` reader instead.
 
+#### Route metadata is exposed through readers, not the `options` Hash
+
+A route's computed metadata — `version`, `namespace`, `prefix`, `requirements`, `anchor` and `settings` — is now passed to `Grape::Router::Route` as explicit keyword arguments and exposed as plain readers, instead of being merged into the route's `options` Hash.
+
+The readers are unchanged — keep using them:
+
+```ruby
+route.version       # => 'v1'
+route.namespace     # => '/things'
+route.prefix        # => 'api'
+route.requirements  # => {}
+route.anchor        # => true
+route.settings      # => { ... }
+```
+
+What changed is the raw bag. `route.options` now holds only what was declared for the route, so it no longer carries the *computed* values for these keys — `route.options[:version]`, `[:namespace]`, `[:prefix]` and `[:settings]` return `nil`. Nothing in Grape or grape-swagger read them that way (grape-swagger uses the `route.prefix` and `route.settings` readers). For `requirements` and `anchor`, which can be supplied as route options (e.g. a mount's `anchor: false`), any explicitly declared value still appears in `route.options`; the effective value always comes from the reader.
+
 ### Upgrading to >= 3.3
 
 #### Minimum required Ruby is now 3.3

lib/grape/endpoint.rb

@@ -285,39 +285,31 @@ def compile!
 
     def to_routes
       route_options = config.route_options
-      default_route_options = prepare_default_route_attributes(route_options)
-      complete_route_options = route_options.merge(default_route_options)
       path_settings = prepare_default_path_settings
       forward_match = config.app && !config.app.respond_to?(:inheritable_setting)
+      version = prepare_version(inheritable_setting.namespace_inheritable[:version])
+      prefix = inheritable_setting.namespace_inheritable[:root_prefix]
+      requirements = prepare_routes_requirements(route_options[:requirements])
+      anchor = route_options.fetch(:anchor, true)
+      settings = inheritable_setting.route.except(:declared_params, :saved_validations)
 
       config.http_methods.flat_map do |method|
         config.path.map do |path|
-          prepared_path = Path.new(path, default_route_options[:namespace], path_settings)
+          prepared_path = Path.new(path, namespace, path_settings)
           pattern = Grape::Router::Pattern.new(
             origin: prepared_path.origin,
             suffix: prepared_path.suffix,
-            anchor: default_route_options[:anchor],
+            anchor:,
             params: route_options[:params],
             format: config.format,
-            version: default_route_options[:version],
-            requirements: default_route_options[:requirements]
+            version:,
+            requirements:
           )
-          Grape::Router::Route.new(self, method, pattern, complete_route_options, forward_match:)
+          Grape::Router::Route.new(self, method, pattern, route_options, forward_match:, version:, namespace:, prefix:, requirements:, anchor:, settings:)
         end
       end
     end
 
-    def prepare_default_route_attributes(route_options)
-      {
-        namespace:,
-        version: prepare_version(inheritable_setting.namespace_inheritable[:version]),
-        requirements: prepare_routes_requirements(route_options[:requirements]),
-        prefix: inheritable_setting.namespace_inheritable[:root_prefix],
-        anchor: route_options.fetch(:anchor, true),
-        settings: inheritable_setting.route.except(:declared_params, :saved_validations)
-      }
-    end
-
     def prepare_default_path_settings
       namespace_stackable_hash = inheritable_setting.namespace_stackable.to_hash
       namespace_inheritable_hash = inheritable_setting.namespace_inheritable.to_hash

lib/grape/router/base_route.rb

@@ -7,19 +7,20 @@ class BaseRoute
 
       delegate_missing_to :@options
 
-      attr_reader :options, :pattern
+      attr_reader :options, :pattern, :version, :prefix, :requirements, :anchor, :settings, :namespace
 
       def_delegators :@pattern, :path, :origin
-      def_delegators :@options, :description, :version, :requirements, :prefix, :anchor, :settings, *Grape::Util::ApiDescription::DSL_METHODS
+      def_delegators :@options, :description, *Grape::Util::ApiDescription::DSL_METHODS
 
-      def initialize(pattern, options = {})
+      def initialize(pattern, options = {}, version: nil, namespace: nil, prefix: nil, requirements: nil, anchor: nil, settings: nil)
         @pattern = pattern
         @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
-      end
-
-      # see https://github.com/ruby-grape/grape/issues/1348
-      def namespace
-        @namespace ||= @options[:namespace]
+        @version = version
+        @namespace = namespace
+        @prefix = prefix
+        @requirements = requirements
+        @anchor = anchor
+        @settings = settings
       end
 
       def regexp_capture_index

lib/grape/router/route.rb

@@ -12,8 +12,8 @@ class Route < BaseRoute
 
       def_delegators :@app, :call
 
-      def initialize(endpoint, method, pattern, options, forward_match:)
-        super(pattern, options)
+      def initialize(endpoint, method, pattern, options, forward_match:, **route_attributes)
+        super(pattern, options, **route_attributes)
         @app = endpoint
         @request_method = upcase_method(method)
         @match_function = forward_match ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD

spec/grape/api_spec.rb

@@ -3133,6 +3133,14 @@ def self.call(object, _env)
       it 'sets prefix' do
         expect(subject.routes[1].prefix).to eq('p')
       end
+
+      it 'does not carry computed attributes in the route options Hash' do
+        route = subject.routes[1]
+        expect(route.options).not_to have_key(:version)
+        expect(route.options).not_to have_key(:namespace)
+        expect(route.options).not_to have_key(:prefix)
+        expect(route.options).not_to have_key(:settings)
+      end
     end
 
     describe 'api structure with additional parameters' do

spec/grape/router/route_spec.rb

@@ -22,6 +22,42 @@
     it { is_expected.to be_a(Grape::Router::BaseRoute) }
   end
 
+  describe 'route attributes' do
+    subject(:route) do
+      described_class.new(endpoint, :get, pattern, options, forward_match: false,
+                                                            version: 'v1', namespace: '/things', prefix: '/api',
+                                                            requirements: { id: /\d+/ }, anchor: false, settings: { a: 1 })
+    end
+
+    it 'exposes them as readers' do
+      expect(route.version).to eq('v1')
+      expect(route.namespace).to eq('/things')
+      expect(route.prefix).to eq('/api')
+      expect(route.requirements).to eq(id: /\d+/)
+      expect(route.anchor).to be(false)
+      expect(route.settings).to eq(a: 1)
+    end
+
+    it 'does not leak them into the options Hash' do
+      %i[version namespace prefix requirements anchor settings].each do |key|
+        expect(route.options).not_to have_key(key)
+      end
+    end
+
+    context 'when omitted' do
+      subject(:route) { described_class.new(endpoint, :get, pattern, options, forward_match: false) }
+
+      it 'defaults to nil' do
+        expect(route.version).to be_nil
+        expect(route.namespace).to be_nil
+        expect(route.prefix).to be_nil
+        expect(route.requirements).to be_nil
+        expect(route.anchor).to be_nil
+        expect(route.settings).to be_nil
+      end
+    end
+  end
+
   describe '#match?' do
     subject { instance.match?(input) }