Read a route's version, anchor and requirements from its pattern

`version`, `anchor` and `requirements` are the attributes that shape the
matcher — they are passed to `Grape::Router::Pattern` to build the
mustermann pattern. They were also passed a second time to
`Grape::Router::Route` and stored as ivars, purely to back the readers.

Expose them on `Pattern` instead (`attr_reader`) and delegate the
`BaseRoute` readers to `@pattern`, alongside the existing `path`/`origin`
delegation. `to_routes` no longer passes them to `Route.new`. Metadata
that does not shape matching — `namespace`, `prefix`, `settings` — stays
as route keyword arguments.

grape-swagger already passes these to `Pattern.new` and none of them to
`Route.new`, so its routes' readers become correct rather than `nil`.

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

Author: ericproulx

lib/grape/endpoint.rb

@@ -304,7 +304,7 @@ def to_routes
             version:,
             requirements:
           )
-          Grape::Router::Route.new(self, method, pattern, route_options, forward_match:, version:, namespace:, prefix:, requirements:, anchor:, settings:)
+          Grape::Router::Route.new(self, method, pattern, route_options, forward_match:, namespace:, prefix:, settings:)
         end
       end
     end

lib/grape/router/base_route.rb

@@ -7,19 +7,18 @@ class BaseRoute
 
       delegate_missing_to :@options
 
-      attr_reader :options, :pattern, :version, :prefix, :requirements, :anchor, :settings, :namespace
+      attr_reader :options, :pattern, :prefix, :settings, :namespace
 
-      def_delegators :@pattern, :path, :origin
+      # +version+, +anchor+ and +requirements+ shape the matcher, so they are
+      # read from the pattern rather than stored again on the route.
+      def_delegators :@pattern, :path, :origin, :version, :anchor, :requirements
       def_delegators :@options, :description, *Grape::Util::ApiDescription::DSL_METHODS
 
-      def initialize(pattern, options = {}, version: nil, namespace: nil, prefix: nil, requirements: nil, anchor: nil, settings: nil)
+      def initialize(pattern, options = {}, namespace: nil, prefix: nil, settings: nil)
         @pattern = pattern
         @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
-        @version = version
         @namespace = namespace
         @prefix = prefix
-        @requirements = requirements
-        @anchor = anchor
         @settings = settings
       end
 

lib/grape/router/pattern.rb

@@ -7,14 +7,17 @@ class Pattern
 
       DEFAULT_CAPTURES = %w[format version].freeze
 
-      attr_reader :origin, :path, :pattern, :to_regexp
+      attr_reader :origin, :path, :pattern, :to_regexp, :anchor, :version, :requirements
 
       def_delegators :pattern, :params
       def_delegators :to_regexp, :===
       alias match? ===
 
       def initialize(origin:, suffix:, anchor:, params:, version:, requirements:, format: nil)
         @origin = origin
+        @anchor = anchor
+        @version = version
+        @requirements = requirements
         @path = PatternCache[[build_path_from_pattern(@origin, anchor), suffix]]
         @pattern = MustermannPattern.new(@path, uri_decode: true, params:, capture: extract_capture(format, version, requirements))
         @to_regexp = @pattern.to_regexp

spec/grape/router/pattern_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Grape::Router::Pattern do
+  describe 'match-parameter readers' do
+    subject(:pattern) do
+      described_class.new(origin: '/x', suffix: '', anchor: false, params: {}, version: 'v1', requirements: { id: /\d+/ })
+    end
+
+    it 'exposes anchor, version and requirements' do
+      expect(pattern.anchor).to be(false)
+      expect(pattern.version).to eq('v1')
+      expect(pattern.requirements).to eq(id: /\d+/)
+    end
+  end
+end

spec/grape/router/route_spec.rb

@@ -22,24 +22,20 @@
     it { is_expected.to be_a(Grape::Router::BaseRoute) }
   end
 
-  describe 'route attributes' do
+  describe 'metadata attributes (namespace, prefix, settings)' 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 })
+                                                            namespace: '/things', prefix: '/api', 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|
+      %i[namespace prefix settings].each do |key|
         expect(route.options).not_to have_key(key)
       end
     end
@@ -48,16 +44,27 @@
       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 parameters delegated to the pattern (version, anchor, requirements)' do
+    subject(:route) { described_class.new(endpoint, :get, pattern, options, forward_match: false) }
+
+    let(:pattern) do
+      Grape::Router::Pattern.new(origin: '/mounty', suffix: '', anchor: false, params: {}, version: 'v1', requirements: { id: /\d+/ })
+    end
+
+    it 'reads them from the pattern' do
+      expect(route.version).to eq('v1')
+      expect(route.anchor).to be(false)
+      expect(route.requirements).to eq(id: /\d+/)
+    end
+  end
+
   describe '#match?' do
     subject { instance.match?(input) }