grape 2.4.0 → 4.0.1

data/lib/grape/router/pattern/path.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class Pattern
+      # Assembles the path template a {Pattern} compiles into a matcher. It turns
+      # a raw path plus the path-settings snapshot taken by
+      # {Grape::Util::InheritableSetting#path_settings} (mount paths, root
+      # prefix, path-versioning and format) into an +origin+ (the route prefix)
+      # and a +suffix+ (the format segment). {Pattern.build} is the entry point
+      # that wires this into pattern construction.
+      class Path
+        DEFAULT_FORMAT_SEGMENT = '(/.:format)'
+        NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT = '(.:format)'
+        VERSION_SEGMENT = ':version'
+
+        attr_reader :origin, :suffix
+
+        def initialize(raw_path, raw_namespace, settings)
+          @origin = PartsCache[build_parts(raw_path, raw_namespace, settings)]
+          @suffix = build_suffix(raw_path, raw_namespace, settings)
+        end
+
+        def to_s
+          "#{origin}#{suffix}"
+        end
+
+        private
+
+        def build_suffix(raw_path, raw_namespace, settings)
+          return "(.#{settings.format})" if uses_specific_format?(settings)
+          return NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT if !uses_path_versioning?(settings) || valid_part?(raw_namespace) || valid_part?(raw_path)
+
+          DEFAULT_FORMAT_SEGMENT
+        end
+
+        def build_parts(raw_path, raw_namespace, settings)
+          parts = []
+          add_part(parts, settings.mount_path)
+          add_part(parts, settings.root_prefix)
+          parts << VERSION_SEGMENT if uses_path_versioning?(settings)
+          add_part(parts, raw_namespace)
+          add_part(parts, raw_path)
+          parts
+        end
+
+        def add_part(parts, value)
+          parts << value if value && not_slash?(value)
+        end
+
+        def not_slash?(value)
+          value != '/'
+        end
+
+        def uses_specific_format?(settings)
+          settings.format && Array(settings.content_types).size == 1
+        end
+
+        def uses_path_versioning?(settings)
+          settings.version && settings.version_options&.using == :path
+        end
+
+        def valid_part?(part)
+          part&.match?(/\A\S/) && not_slash?(part)
+        end
+
+        class PartsCache < Grape::Util::Cache
+          def initialize
+            super
+            @cache = Hash.new do |h, parts|
+              h[parts] = Grape::Util::PathNormalizer.call(parts.join('/'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -7,17 +7,43 @@ module Grape
 
       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, options)
+      # Build a Pattern from a raw path, namespace and the API's inheritable
+      # settings. {Path} owns the settings-aware assembly of +origin+/+suffix+;
+      # the Pattern itself stays value-based (see {#initialize}).
+      def self.build(path:, namespace:, settings:, anchor:, params:, version:, requirements:)
+        built_path = Path.new(path, namespace, settings)
+        new(origin: built_path.origin, suffix: built_path.suffix, anchor:, params:, version:, requirements:)
+      end
+
+      def initialize(origin:, suffix:, anchor:, params:, version:, requirements:)
         @origin = origin
-        @path = build_path(origin, options[:anchor], suffix)
-        @pattern = build_pattern(@path, options[:params], options[:format], options[:version], options[:requirements])
+        @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(version, requirements))
         @to_regexp = @pattern.to_regexp
+        @captures = @to_regexp.names.any?
+      end
+
+      # True when the compiled pattern has named captures to extract from a
+      # matched path. A fully static path has none — not even +format+, which
+      # the suffix spells as a literal — so asking Mustermann for its params
+      # would run the regexp a second time (the router's union already matched
+      # it) only to hand back an empty Hash.
+      #
+      # Resolved once here rather than per request: +Regexp#names+ builds an
+      # Array and a String per capture, and Ruby offers no predicate that skips
+      # that (+named_captures+ builds a Hash, and scanning the source for
+      # <tt>(?<</tt> would count lookbehinds, which name nothing).
+      def captures?
+        @captures
       end
 
       def captures_default
@@ -28,44 +54,46 @@ module Grape
 
       private
 
-      def build_pattern(path, params, format, version, requirements)
-        Mustermann::Grape.new(
-          path,
-          uri_decode: true,
-          params: params,
-          capture: extract_capture(format, version, requirements)
-        )
-      end
-
-      def build_path(pattern, anchor, suffix)
-        PatternCache[[build_path_from_pattern(pattern, anchor), suffix]]
-      end
-
-      def extract_capture(format, version, requirements)
-        capture = {}.tap do |h|
-          h[:format] = map_str(format) if format.present?
-          h[:version] = map_str(version) if version.present?
-        end
+      # The declared versions constrain the +:version+ capture. They are handed
+      # to Mustermann as one alternation Regexp rather than as the Array of
+      # Strings they arrive in, because an Array capture makes Mustermann build
+      # a *converter* for the capture -- and for an Array of plain Strings that
+      # converter is the identity function (Mustermann only derives one from a
+      # Class or a Symbol, so every entry contributes nothing and the lambda
+      # falls through to `|| string`).
+      #
+      # A non-empty converter table costs every request on the route: it makes
+      # Mustermann's +identity_params?+ fast path unreachable, so +params+
+      # rebuilds the capture Hash through +map_param+ and calls the do-nothing
+      # lambda on each value. Passing a Regexp registers no converter at all.
+      #
+      # The generated matcher differs in one respect: Mustermann expands an
+      # Array entry the way it expands a path literal, so each character also
+      # matches its own percent-encoding (+v1+ as <tt>(?:v|%76)(?:1|%31)</tt>).
+      # A Regexp is inserted verbatim, so a percent-encoded version segment no
+      # longer matches the route. It never reached the endpoint anyway --
+      # {Versioner::Base#potential_version_match?} compares the raw segment
+      # against the declared versions, so +/api/%76%31/x+ was matched here and
+      # then rejected as an unknown version, ending in the same cascading 404
+      # the router now returns directly.
+      #
+      # +Regexp.union+ takes Strings and Regexps only, and +version+ accepts
+      # Symbols and Integers too, so the entries are coerced first. A lone one
+      # would survive without it -- the single-argument path goes through
+      # +Regexp.escape+, which does accept a Symbol -- but a second raises
+      # TypeError.
+      def extract_capture(version, requirements)
+        return requirements if version.blank?
 
-        return capture if requirements.blank?
-
-        requirements.merge(capture)
+        requirements.merge(version: Regexp.union(Array.wrap(version).map(&:to_s)))
       end
 
       def build_path_from_pattern(pattern, anchor)
-        if pattern.end_with?('*path')
-          pattern.dup.insert(pattern.rindex('/') + 1, '?')
-        elsif anchor
-          pattern
-        elsif pattern.end_with?('/')
-          "#{pattern}?*path"
-        else
-          "#{pattern}/?*path"
-        end
-      end
+        return pattern.dup.insert(pattern.rindex('/') + 1, '?') if pattern.end_with?('*path')
+        return pattern if anchor
+        return "#{pattern}?*path" if pattern.end_with?('/')
 
-      def map_str(value)
-        Array.wrap(value).map(&:to_s)
+        "#{pattern}/?*path"
       end
 
       class PatternCache < Grape::Util::Cache

data/lib/grape/router/route.rb

@@ -8,23 +8,22 @@ module Grape
       FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
       NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
 
-      attr_reader :app, :request_method
+      attr_reader :app, :request_method, :index
 
-      def_delegators :pattern, :path, :origin
+      def_delegators :@app, :call
 
-      def initialize(method, origin, path, options)
+      def initialize(endpoint, method, pattern, options, forward_match:, params: {}, **route_attributes)
+        super(pattern, options, **route_attributes)
+        @app = endpoint
         @request_method = upcase_method(method)
-        @pattern = Grape::Router::Pattern.new(origin, path, options)
-        @match_function = options[:forward_match] ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
-        super(options)
+        @match_function = forward_match ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
+        @declared_params = params
       end
 
-      def convert_to_head_request!
-        @request_method = Rack::HEAD
-      end
-
-      def exec(env)
-        @app.call(env)
+      def to_head
+        head = dup
+        head.convert_to_head_request!
+        head
       end
 
       def apply(app)
@@ -38,19 +37,68 @@ module Grape
         @match_function.call(input, pattern)
       end
 
-      def params(input = nil)
-        return params_without_input if input.blank?
+      # The route's declared params keyed by name — path captures plus any
+      # declared body/query params, as their definitions. Used for documentation
+      # (e.g. grape-swagger), not for extracting request values.
+      def params
+        @params ||= pattern.captures_default.merge(@declared_params)
+      end
+
+      # Extract param values from a matched request path. Used by the router.
+      #
+      # A pattern with no named captures has nothing to extract, so it skips the
+      # match entirely and answers nil — the same way {GreedyRoute#params_for}
+      # does, and what the router already coerces into the Hash it builds
+      # routing args in.
+      def params_for(input)
+        return unless pattern.captures?
 
         parsed = pattern.params(input)
-        return {} unless parsed
+        return unless parsed
 
-        parsed.compact.symbolize_keys
+        params = {}
+        parsed.each { |name, value| params[name.to_sym] = tag_utf8!(value) unless value.nil? }
+        params
+      end
+
+      protected
+
+      def convert_to_head_request!
+        @request_method = Rack::HEAD
       end
 
       private
 
-      def params_without_input
-        @params_without_input ||= pattern.captures_default.merge(attributes.params)
+      # Mustermann decodes path captures out of +PATH_INFO+, which Rack hands us
+      # tagged ASCII-8BIT, so path params came back binary while Rack tags query
+      # and body params UTF-8. That split makes an API's own declarations
+      # disagree with themselves: `values: ['café']` matched `?id=café` but not
+      # `/café`, since a binary string never equals the UTF-8 literal it was
+      # written as.
+      #
+      # Re-tag as UTF-8. Nothing obliges a client to send UTF-8: the request
+      # target is octets to HTTP, and Rack's SPEC has CGI keys carry non-ASCII
+      # as ASCII-8BIT. But UTF-8 is what browsers percent-encode with, what an
+      # IRI maps to, and what Rails settles on — ActionDispatch::Journey::Router
+      # force_encodes every path capture to UTF-8 after unescaping it.
+      #
+      # Only the encoding changes; the bytes are untouched. Octets that are not
+      # UTF-8 therefore stay invalid and are caught downstream rather than being
+      # silently scrubbed into something the client never sent.
+      #
+      # The re-tag is in place, hence the bang. Mustermann's +Pattern#params+
+      # builds a fresh Hash of fresh, unfrozen strings on every call and skips
+      # its own Match cache, so the mutation cannot escape this request — which
+      # is also what lets the Array branch re-tag its elements with +each+.
+      def tag_utf8!(value)
+        case value
+        when String
+          value.force_encoding(Encoding::UTF_8)
+        when Array
+          value.each { |v| tag_utf8!(v) }
+        else
+          value
+        end
       end
 
       def upcase_method(method)

data/lib/grape/router.rb

@@ -2,71 +2,53 @@
 
 module Grape
   class Router
-    attr_reader :map, :compiled
-
-    # Taken from Rails
-    #     normalize_path("/foo")  # => "/foo"
-    #     normalize_path("/foo/") # => "/foo"
-    #     normalize_path("foo")   # => "/foo"
-    #     normalize_path("")      # => "/"
-    #     normalize_path("/%ab")  # => "/%AB"
-    # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
-    def self.normalize_path(path)
-      return +'/' unless path
-
-      # Fast path for the overwhelming majority of paths that don't need to be normalized
-      return path.dup if path == '/' || (path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//})))
-
-      # Slow path
-      encoding = path.encoding
-      path = +"/#{path}"
-      path.squeeze!('/')
-
-      unless path == '/'
-        path.delete_suffix!('/')
-        path.gsub!(/(%[a-f0-9]{2})/) { ::Regexp.last_match(1).upcase }
-      end
-
-      path.force_encoding(encoding)
-    end
-
     def initialize
       @neutral_map = []
       @neutral_regexes = []
-      @map = Hash.new { |hash, key| hash[key] = [] }
-      @optimized_map = Hash.new { |hash, key| hash[key] = // }
+      # Plain hashes with no auto-vivifying default: a lookup for an HTTP method
+      # that has no routes must not insert a key. `compile!` freezes both maps,
+      # so request-time reads never mutate shared state (see #match? / #rotation).
+      @map = {}
+      @optimized_map = {}
     end
 
     def compile!
-      return if compiled
+      return if @compiled
 
-      @union = Regexp.union(@neutral_regexes)
+      @union = resolve_capture_groups(Regexp.union(@neutral_regexes), @neutral_map)
       @neutral_regexes = nil
-      (Grape::HTTP_SUPPORTED_METHODS + ['*']).each do |method|
-        next unless map.key?(method)
-
-        routes = map[method]
+      # Compiled from the routes actually registered rather than from
+      # Grape::HTTP_SUPPORTED_METHODS. A route declared with any other verb
+      # (`route :purge, '/cache'`) is accepted at definition time and is
+      # already collected into the resource's Allow header, so skipping it here
+      # left it in @map but out of @optimized_map — the only map #match? reads.
+      # The resource then advertised a method that could never be matched and
+      # answered every request for it with 405.
+      @map.each do |method, routes|
         optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
-        @optimized_map[method] = Regexp.union(optimized_map)
+        @optimized_map[method] = resolve_capture_groups(Regexp.union(optimized_map), routes)
       end
+      @map.freeze
+      @optimized_map.freeze
       @compiled = true
     end
 
     def append(route)
-      map[route.request_method] << route
+      (@map[route.request_method] ||= []) << route
     end
 
-    def associate_routes(pattern, options)
-      Grape::Router::GreedyRoute.new(pattern, options).then do |greedy_route|
-        @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
-        @neutral_map << greedy_route
-      end
+    def associate_routes(greedy_route)
+      @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+      @neutral_map << greedy_route
     end
 
     def call(env)
       with_optimization do
-        response, route = identity(env)
-        response || rotation(env, route)
+        # Published on the env so the middleware the matched route runs -- the
+        # path versioner above all -- reads the path this routed on instead of
+        # normalizing PATH_INFO a second time.
+        input = env[Grape::Env::GRAPE_NORMALIZED_PATH] = Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
+        transaction(input, env[Rack::REQUEST_METHOD], env)
       end
     end
 
@@ -77,114 +59,143 @@ module Grape
       any.endpoint
     end
 
+    DEFAULT_RESPONSE_HEADERS = Grape::Util::Header.new.merge('X-Cascade' => 'pass').freeze
+    DEFAULT_RESPONSE_BODY = ['404 Not Found'].freeze
+
     private
 
-    def identity(env)
-      route = nil
-      response = transaction(env) do |input, method|
-        route = match?(input, method)
-        process_route(route, env) if route
+    # Resolve +input+ against the compiled routes, in priority order:
+    #
+    # 1. the routes registered for +method+ — the compiled-union match first,
+    #    then, when that route cascades, its siblings (see #rotation);
+    # 2. the ANY (+'*'+) routes;
+    # 3. the greedy neighbour, which answers auto-OPTIONS and 405.
+    #
+    # Returns nil when nothing answered, leaving the caller to 404. A response
+    # that cascades is never final: it is returned only once every later
+    # candidate has declined too, so the caller (or a mounting app upstream)
+    # can keep looking.
+    def transaction(input, method, env)
+      exact_route = match?(input, method)
+      response = process_route(exact_route, input, env) if exact_route
+      return response if halt?(response)
+
+      # A cascading route has only declined this request. Its siblings — the
+      # routes sharing this path but differing in, say, version — must be
+      # tried before falling back to the ANY routes and the greedy neighbour.
+      # Skipped when nothing matched: the compiled union is the disjunction of
+      # the same patterns #rotation walks, so a miss there is a miss here.
+      cascaded = !response.nil?
+      if cascaded
+        response = rotation(input, method, env, exact_route)
+        return response if response && !cascade?(response)
       end
-      [response, route]
-    end
 
-    def rotation(env, exact_route = nil)
-      response = nil
-      input, method = *extract_input_and_method(env)
-      map[method].each do |route|
-        next if exact_route == route
-        next unless route.match?(input)
+      last_neighbor_route = greedy_match?(input)
 
-        response = process_route(route, env)
-        break unless cascade?(response)
-      end
-      response
-    end
+      # If last_neighbor_route exists and request method is OPTIONS,
+      # return response by using #include_allow_header.
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !cascaded && method == Rack::OPTIONS && last_neighbor_route
 
-    def transaction(env)
-      input, method = *extract_input_and_method(env)
+      star_route = match?(input, '*')
 
-      # using a Proc is important since `return` will exit the enclosing function
-      cascade_or_return_response = proc do |response|
-        if response
-          cascade?(response).tap do |cascade|
-            return response unless cascade
+      if star_route
+        close_body(response) if response # superseded by the ANY route
+        response = process_route(star_route, input, env)
+        return response if halt?(response)
 
-            # we need to close the body if possible before dismissing
-            response[2].try(:close)
-          end
-        end
+        cascaded ||= !response.nil?
       end
 
-      last_response_cascade = cascade_or_return_response.call(yield(input, method))
-      last_neighbor_route = greedy_match?(input)
+      return process_route(last_neighbor_route, input, env, include_allow_header: true) if !cascaded && last_neighbor_route
 
-      # If last_neighbor_route exists and request method is OPTIONS,
-      # return response by using #call_with_allow_headers.
-      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Rack::OPTIONS && !last_response_cascade
-
-      route = match?(input, '*')
+      response
+    end
 
-      return last_neighbor_route.options[:endpoint].call(env) if last_neighbor_route && last_response_cascade && route
+    # The routes registered for +method+ other than +exact_route+, tried in
+    # registration order until one answers without cascading. Returns the last
+    # response processed — a cascading one when every sibling declined, so the
+    # caller can hand it back — or nil when no sibling matched.
+    def rotation(input, method, env, exact_route)
+      response = nil
+      @map[method]&.each do |route|
+        next if exact_route == route
+        next unless route.match?(input)
 
-      last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
+        close_body(response) if response # the previous sibling cascaded
+        response = process_route(route, input, env)
+        break unless cascade?(response)
+      end
+      response
+    end
 
-      return call_with_allow_headers(env, last_neighbor_route) if !last_response_cascade && last_neighbor_route
+    # Returns true if `response` should be returned as-is from the enclosing
+    # transaction. Closes the body as a side effect when the response is
+    # cascading so callers can safely try the next match.
+    def halt?(response)
+      return false unless response
 
-      nil
+      cascade = cascade?(response)
+      close_body(response) if cascade
+      !cascade
     end
 
-    def process_route(route, env)
-      prepare_env_from_route(env, route)
-      route.exec(env)
+    # Releases a response the router has decided not to return. Rack requires
+    # every body it hands out to be closed, and a cascading candidate is
+    # discarded as soon as a later one answers.
+    def close_body(response)
+      body = response[2]
+      body.close if body.respond_to?(:close)
     end
 
-    def make_routing_args(default_args, route, input)
-      args = default_args || { route_info: route }
-      args.merge(route.params(input))
+    # Routing args are rebuilt for every attempt: when a route cascades
+    # (X-Cascade pass), the next candidate must not observe the previous
+    # attempt's +route_info+ or path captures.
+    def process_route(route, input, env, include_allow_header: false)
+      # The path captures are the hash: +route_info+ is written into them
+      # rather than merged in from a second one.
+      routing_args = route.params_for(input) || {}
+      routing_args[:route_info] = route
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = routing_args
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.allow_header if include_allow_header
+      route.call(env)
     end
 
-    def extract_input_and_method(env)
-      input = string_for(env[Rack::PATH_INFO])
-      method = env[Rack::REQUEST_METHOD]
-      [input, method]
+    # Tells each route the number of the group it ended up as in +union+. The
+    # numbering is a property of the union rather than of the route's own
+    # pattern -- every route ahead of it contributes however many groups its
+    # pattern declares -- so it can only be resolved once the union is built.
+    # Returns the union, so a caller can assign it in one expression.
+    def resolve_capture_groups(union, routes)
+      named_captures = union.named_captures
+      routes.each { |route| route.resolve_capture_group!(named_captures) }
+      union
     end
 
     def with_optimization
-      compile! unless compiled
+      compile!
       yield || default_response
     end
 
     def default_response
-      headers = Grape::Util::Header.new.merge('X-Cascade' => 'pass')
-      [404, headers, ['404 Not Found']]
+      [404, DEFAULT_RESPONSE_HEADERS.dup, DEFAULT_RESPONSE_BODY.dup]
     end
 
+    # Which alternative of the union matched is answered by scanning one group
+    # per registered route, so on an API with many of them that scan is what a
+    # request costs. The groups are indexed by number rather than by name: a
+    # name sends MatchData through the pattern's name table on every lookup,
+    # a number indexes the match region directly.
     def match?(input, method)
-      @optimized_map[method].match(input) { |m| @map[method].detect { |route| m[route.regexp_capture_index] } }
+      @optimized_map[method]&.match(input) { |m| @map[method].detect { |route| m[route.regexp_capture_group] } }
     end
 
     def greedy_match?(input)
-      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_index] } }
-    end
-
-    def call_with_allow_headers(env, route)
-      prepare_env_from_route(env, route)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.options[:allow_header]
-      route.options[:endpoint].call(env)
-    end
-
-    def prepare_env_from_route(env, route)
-      input, = *extract_input_and_method(env)
-      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
+      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_group] } }
     end
 
     def cascade?(response)
       response && response[1]['X-Cascade'] == 'pass'
     end
-
-    def string_for(input)
-      self.class.normalize_path(input)
-    end
   end
 end

data/lib/grape/serve_stream/file_body.rb

@@ -31,6 +31,13 @@ module Grape
       def ==(other)
         path == other.path
       end
+      alias eql? ==
+
+      # Mirrors #==, which keys on the path alone and does not check the
+      # class, so the class must stay out of the hash too.
+      def hash
+        path.hash
+      end
     end
   end
 end

data/lib/grape/serve_stream/sendfile_response.rb

@@ -6,11 +6,9 @@ module Grape
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response
       def respond_to?(method_name, include_all = false)
-        if method_name == :to_path
-          @body.respond_to?(:to_path, include_all)
-        else
-          super
-        end
+        return @body.respond_to?(:to_path, include_all) if method_name == :to_path
+
+        super
       end
 
       def to_path