grape 4.0.0 → 4.1.0

data/lib/grape/middleware/versioner/header.rb

@@ -22,32 +22,87 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        def before
-          match_best_quality_media_type! do |media_type|
-            env.update(
-              Grape::Env::API_TYPE => media_type.type,
-              Grape::Env::API_SUBTYPE => media_type.subtype,
-              Grape::Env::API_VENDOR => media_type.vendor,
-              Grape::Env::API_VERSION => media_type.version,
-              Grape::Env::API_FORMAT => media_type.format
-            )
+        # Accept headers answered up front besides the declared media types:
+        # +*/*+, what curl, Net::HTTP and most HTTP libraries send unless told
+        # otherwise, and no Accept header at all.
+        COMMON_ACCEPT_HEADERS = ['*/*', nil].freeze
+
+        # +MediaType.best_quality+ answers from the header and
+        # +available_media_types+ alone, and the latter is fixed once the
+        # middleware is built. Most requests send one of a handful of headers --
+        # a declared media type spelled as declared (+application/vnd.acme-v1+json+)
+        # or one of COMMON_ACCEPT_HEADERS -- so their answers are worked out
+        # once instead of re-running Rack's q-value match and a parse on every
+        # request. Any other header (a q-value list, another casing) is not a
+        # key and takes the full path, so a client cannot grow a table.
+        #
+        # Shared per vendor and list: every endpoint builds its own versioner,
+        # and all of an API's declare the same media types. The list in the
+        # key is a frozen copy, as the middleware's own list stays reachable
+        # through +available_media_types+.
+        class MediaTypeForAcceptCache < Grape::Util::Cache
+          def initialize
+            super
+            @cache = Hash.new do |h, (vendor, available_media_types)|
+              declared = available_media_types.map(&:-@).freeze
+              h[[vendor, declared].freeze] = [*declared, *COMMON_ACCEPT_HEADERS].to_h do |accept|
+                [accept, Grape::Util::MediaType.best_quality(accept, declared, vendor:)]
+              end.compact.freeze
+            end
           end
         end
 
+        def initialize(app, **options)
+          super
+          @media_type_for_accept = MediaTypeForAcceptCache[[vendor, available_media_types]]
+        end
+
+        # Base#call copies the middleware per request so #before can keep the
+        # env and the Accept header it scrubs in ivars. A request whose Accept
+        # header the table answers (see MediaTypeForAcceptCache) needs neither
+        # unless the API is strict, whose checks read the header itself: its
+        # media type is recorded and the app called from the one instance the
+        # stack built. Any other request goes through #before.
+        def call(env)
+          media_type = @media_type_for_accept[env['HTTP_ACCEPT']] if vendor && !strict
+          return super unless media_type
+
+          record_media_type(env, media_type)
+          app.call(env).to_a
+        end
+
+        def before
+          match_best_quality_media_type! { |media_type| record_media_type(env, media_type) }
+        end
+
         private
 
+        def record_media_type(env, media_type)
+          env.update(
+            Grape::Env::API_TYPE => media_type.type,
+            Grape::Env::API_SUBTYPE => media_type.subtype,
+            Grape::Env::API_VENDOR => media_type.vendor,
+            Grape::Env::API_VERSION => media_type.version,
+            Grape::Env::API_FORMAT => media_type.format
+          )
+        end
+
         def match_best_quality_media_type!
           return unless vendor
 
           strict_header_checks!
-          media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types)
+          # The table's keys are valid Strings, which scrubbing leaves alone, so
+          # it is read with the header as it came.
+          media_type = @media_type_for_accept[env['HTTP_ACCEPT']] || Grape::Util::MediaType.best_quality(accept_header, available_media_types, vendor:)
           return yield media_type if media_type
 
           fail!
         end
 
+        # Scrubbed of any bytes its encoding does not allow: +blank?+,
+        # +downcase+ and Rack's q-value parsing all raise on one.
         def accept_header
-          env['HTTP_ACCEPT']
+          @accept_header ||= try_scrub(env['HTTP_ACCEPT'])
         end
 
         def strict_header_checks!
@@ -64,7 +119,7 @@ module Grape
         end
 
         def version_and_vendor_check!
-          return if versions.blank? || version_and_vendor?
+          return if versions.nil? || versions.empty? || version_and_vendor?
 
           invalid_accept_header!('API vendor or version not found.')
         end
@@ -86,9 +141,9 @@ module Grape
         end
 
         def fail!
-          return if env[Grape::Env::GRAPE_ALLOWED_METHODS].present?
+          return if env[Grape::Env::GRAPE_ALLOWED_METHODS]
 
-          media_types = q_values_mime_types.map { |mime_type| Grape::Util::MediaType.parse(mime_type) }
+          media_types = q_values_mime_types.map { |mime_type| Grape::Util::MediaType.parse(mime_type, vendor:) }
           vendor_not_found!(media_types) || version_not_found!(media_types)
         end
 
@@ -99,7 +154,7 @@ module Grape
         end
 
         def version_not_found!(media_types)
-          return unless media_types.all? { |media_type| media_type&.version && versions && !versions.include?(media_type.version) }
+          return unless media_types.all? { |media_type| media_type&.version && versions&.none? { |version| version.casecmp?(media_type.version) } }
 
           invalid_version_header!('API version not found.')
         end

data/lib/grape/middleware/versioner/param.rb

@@ -8,19 +8,17 @@ module Grape
       # request parameters for subsequent middleware and API.
       # If the version substring does not match any potential initialized
       # versions, a 404 error is thrown.
-      # If the version substring is not passed the version (highest mounted)
-      # version will be used.
+      # If no version is passed, none is set and the first matching route answers.
       #
       # Example: For a uri path
       #   /resource?apiver=v1
       #
-      # The following rack env variables are set and path is rewritten to
-      # '/resource':
+      # The following rack env variable is set:
       #
       #   env['api.version'] => 'v1'
       class Param < Base
         def before
-          potential_version = query_params[parameter]
+          potential_version = try_scrub(query_params[parameter])
           return if potential_version.blank?
 
           version_not_found! unless potential_version_match?(potential_version)

data/lib/grape/middleware/versioner/path.rb

@@ -4,28 +4,37 @@ module Grape
   module Middleware
     module Versioner
       # This middleware sets various version related rack environment variables
-      # based on the uri path and removes the version substring from the uri
-      # path. If the version substring does not match any potential initialized
-      # versions, a 404 error is thrown.
+      # based on the uri path, which it leaves unchanged. If the version
+      # substring does not match any potential initialized versions, a 404
+      # error is thrown.
       #
       # Example: For a uri path
       #   /v1/resource
       #
-      # The following rack env variables are set and path is rewritten to
-      # '/resource':
+      # The following rack env variable is set:
       #
       #   env['api.version'] => 'v1'
       #
       class Path < Base
         def initialize(app, **options)
           super
-          @prefixes = [mount_path, Grape::Util::PathNormalizer.call(prefix)].select { |p| p.present? && p != '/' }.freeze
+          @prefixes = [mount_path, Grape::Util::PathNormalizer.call(prefix)].select { |p| p && p != '/' }.freeze
         end
 
-        def before
-          routed = routed_version
-          return env[Grape::Env::API_VERSION] = routed if routed
+        # A request the router matched carries its version already (see
+        # #routed_version), so all there is to do is record it -- without the
+        # per-request copy of this middleware that Base#call makes to run
+        # #before and #after, neither of which has anything left to do.
+        def call(env)
+          routed = routed_version(env)
+          return super unless routed
+
+          env[Grape::Env::API_VERSION] = routed
+          app.call(env).to_a
+        end
 
+        # Reached only when #call found no routed version.
+        def before
           path_info = env[Grape::Env::GRAPE_NORMALIZED_PATH] || Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
           return if path_info == '/'
 
@@ -56,7 +65,7 @@ module Grape
         # versioning one: Mustermann then reports the capture as every position
         # it matched rather than the single segment recorded here, so that too
         # is left to the path parse.
-        def routed_version
+        def routed_version(env)
           version = env[Grape::Env::GRAPE_ROUTING_ARGS]&.[](:version)
           version if version.is_a?(String)
         end
@@ -79,7 +88,7 @@ module Grape
         end
 
         def declared_version?(candidate)
-          versions.present? && versions.include?(candidate)
+          !versions.nil? && versions.include?(candidate)
         end
       end
     end

data/lib/grape/middleware/versioner.rb

@@ -6,7 +6,7 @@
 #   :header - version from HTTP Accept header.
 #   :accept_version_header - version from HTTP Accept-Version header
 #   :path   - version from uri. e.g. /v1/resource
-#   :param  - version from uri query string, e.g. /v1/resource?apiver=v1
+#   :param  - version from uri query string, e.g. /resource?apiver=v1
 # See individual classes for details.
 module Grape
   module Middleware

data/lib/grape/mountable.rb

@@ -8,10 +8,8 @@ module Grape
   # rather than duck-typing on an incidental internal method such as
   # `inheritable_setting`.
   #
-  # `Grape::API` and `Grape::API::Instance` are not related by inheritance and
-  # do not even respond to the same methods (the former to `mount_instance`,
-  # the latter to `inheritable_setting`/`endpoints`), so there is no common
-  # ancestor to key an `is_a?` check on without this marker.
+  # `Grape::API` and `Grape::API::Instance` are not related by inheritance, so
+  # there is no common ancestor to key an `is_a?` check on without this marker.
   #
   # It answers identity only ("is this a Grape app?"). Capability checks that
   # go on to call a stage-specific method — e.g. `respond_to?(:endpoints)`

data/lib/grape/namespace.rb

@@ -8,10 +8,9 @@ module Grape
     attr_reader :space, :requirements, :options
 
     # @param space [String] the name of this namespace
+    # @param requirements [Hash] param-regex pairs a request's path must meet
+    #   for this namespace's endpoints to match
     # @param options [Hash] options hash
-    # @option options :requirements [Hash] param-regex pairs, all of which must
-    #   be met by a request's params for all endpoints in this namespace, or
-    #   validation will fail and return a 422.
     def initialize(space, requirements: nil, **options)
       @space = space.to_s
       @requirements = requirements

data/lib/grape/parser/jsonl.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    # Parses a JSON Lines body into an Array of its values. Like a JSON body
+    # that is an Array, it is left in +env['api.request.body']+ rather than
+    # merged into +params+, which only takes a Hash.
+    #
+    # Blank lines are skipped, so a body may end with a newline or not, and
+    # its lines may end in CRLF.
+    class Jsonl < Base
+      def self.call(object, _env)
+        object.each_line.reject { |line| line.strip.empty? }.map { |line| ::Grape::Json.parse(line) }
+      rescue ::Grape::Json::ParseError
+        raise Grape::Exceptions::InvalidMessageBody.new('application/jsonl')
+      end
+    end
+  end
+end

data/lib/grape/request.rb

@@ -136,6 +136,10 @@ module Grape
       ["HTTP_#{header.upcase.tr('-', '_')}", header]
     end.freeze
 
+    # Routing-args keys that are Grape's own, not request params.
+    GRAPE_OWNED_ROUTING_ARGS = %i[version route_info].freeze
+    ROUTE_INFO_ONLY = %i[route_info].freeze
+
     alias rack_params params
     alias rack_cookies cookies
 
@@ -174,12 +178,38 @@ module Grape
       @params_builder ||= Grape::ParamsBuilder.params_builder_for(@build_params_with || Grape.config[:param_builder])
     end
 
-    def make_params
-      params = params_builder.call(rack_params)
-      filtered = routing_args_as_params(env[Grape::Env::GRAPE_ROUTING_ARGS])
-      return params if filtered.blank?
+    # Whether the request can have form params at all. Rack::Request#params is
+    # the query params merged with the form params, and a request that carries
+    # no body has none to merge -- but finding that out costs Rack a
+    # CONTENT_TYPE parse and an empty Hash written back into the env, on every
+    # request that reads params without sending a body. The env answers it
+    # first: form params already read, by Rack or by the formatter's parsers,
+    # are memoized under Rack's own key, and without them only a body could
+    # hold any. The method is deliberately not part of the test -- Rack reads
+    # a form body whatever the method says.
+    def form_params?
+      return true if env.key?(Rack::RACK_REQUEST_FORM_HASH)
+
+      env['CONTENT_LENGTH'].to_i.positive? || env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+    end
+
+    # +self.GET+ is the query hash Rack memoized in the env, not the copy the
+    # merge in Rack::Request#params used to hand over. Every builder Grape
+    # ships constructs a new object, so there is nothing to copy; one that
+    # returns its argument would otherwise let the writes that follow --
+    # routing args, coercions, defaults -- reach the env.
+    def build_params
+      return params_builder.call(rack_params) if form_params?
 
-      params.deep_merge!(filtered)
+      query_hash = self.GET
+      built = params_builder.call(query_hash)
+      built.equal?(query_hash) ? built.dup : built
+    end
+
+    def make_params
+      params = build_params
+      merge_routing_args!(params, env[Grape::Env::GRAPE_ROUTING_ARGS])
+      params
     rescue *Grape::RACK_ERRORS
       raise Grape::Exceptions::RequestError
     end
@@ -193,11 +223,19 @@ module Grape
     # (`route_param :version`, `get '/:version'`), and that capture belongs to
     # the application. Dropping it unconditionally left `params[:version]` nil
     # on a route that had matched, losing the segment silently.
-    def routing_args_as_params(routing_args)
+    #
+    # The rest are written into +params+ one by one rather than deep-merged
+    # from an +except+ copy, which was a Hash built per request only to be
+    # merged away. A capture is a String or an Array of them, never a Hash,
+    # so +deep_merge!+ had nothing to merge into: it replaced the value, as
+    # assigning it does.
+    def merge_routing_args!(params, routing_args)
       return if routing_args.nil?
-      return routing_args.except(:version, :route_info) if grape_owns_version?(routing_args)
 
-      routing_args.except(:route_info)
+      grape_owned = grape_owns_version?(routing_args) ? GRAPE_OWNED_ROUTING_ARGS : ROUTE_INFO_ONLY
+      routing_args.each do |key, value|
+        params[key] = value unless grape_owned.include?(key)
+      end
     end
 
     # A route reports a +version+ only when the API declared one, which is the

data/lib/grape/router/base_route.rb

@@ -66,10 +66,30 @@ module Grape
         Regexp.new("(?<#{regexp_capture_index}>#{pattern_regexp})")
       end
 
+      # This route's named captures mapped to their group numbers in the router's
+      # union, or nil when a union match would not reproduce what Mustermann
+      # returns (see Route#params_for). Assigned in {#resolve_capture_group!},
+      # never at request time -- instances are shared across threads.
+      attr_reader :union_captures
+
+      # {#union_captures} renumbered for a union in which this route's own
+      # group is +group+ -- one of a bucket's, say. Every capture sits at a
+      # fixed offset from the route's own group, so the whole map shifts by
+      # the same number. Nil when the route has no reusable captures.
+      def union_captures_at(group)
+        return if @union_captures.nil?
+
+        shift = group - @regexp_capture_group
+        return @union_captures if shift.zero?
+
+        @union_captures.transform_values { |capture| capture + shift }.freeze
+      end
+
       # @api private
       # @see #regexp_capture_group
       def resolve_capture_group!(union_named_captures)
         @regexp_capture_group = union_named_captures.fetch(regexp_capture_index).first
+        @union_captures = resolve_union_captures
       end
 
       class CaptureIndexCache < Grape::Util::Cache
@@ -80,6 +100,27 @@ module Grape
           end
         end
       end
+
+      private
+
+      # +to_regexp+'s wrapper is the group just before the pattern's own, and
+      # +Regexp.union+ shifts numbering only by the groups preceding a branch --
+      # what +regexp_capture_group+ counts. So the capture at position +n+ of the
+      # route's regexp is group +regexp_capture_group + n+ of the union.
+      def resolve_union_captures
+        own = @pattern.to_regexp.named_captures
+        return if own.empty?
+
+        # Mustermann returns an Array for a name matched at several positions.
+        return unless own.each_value.all? { |positions| positions.size == 1 }
+
+        # Rejects param converters and the always-Array +splat+/+captures+ names.
+        # Empty strings probe only what holds for every request; unescaping, the
+        # one thing that does not, is gated on the path in Route#params_for.
+        return unless @pattern.pattern.identity_params?(own.transform_values { '' })
+
+        own.to_h { |name, positions| [name.to_sym, @regexp_capture_group + positions.first] }
+      end
     end
   end
 end

data/lib/grape/router/greedy_route.rb

@@ -22,7 +22,7 @@ module Grape
         nil
       end
 
-      def params_for(_input)
+      def params_for(_input, _match = nil, _captures = nil)
         nil
       end
     end

data/lib/grape/router/mustermann_pattern.rb

@@ -20,7 +20,7 @@ module Grape
         param_name = scan(/\w+/)
         # Integer params (declared via Grape's `params` option) match digits only;
         # any other capture matches a single path segment (anything but / ? # .).
-        param_type = pattern&.options&.dig(:params, param_name, :type)
+        param_type = pattern.options.dig(:params, param_name, :type)
         constraint = param_type == 'Integer' ? /\d/ : '[^/?#.]'
         node(:capture, param_name, constraint:) { scan(/\w+/) }
       end

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

@@ -57,7 +57,7 @@ module Grape
         end
 
         def uses_path_versioning?(settings)
-          settings.version && settings.version_options&.using == :path
+          settings.version && settings.version_options.using == :path
         end
 
         def valid_part?(part)

data/lib/grape/router/pattern.rb

@@ -13,8 +13,8 @@ module Grape
       def_delegators :to_regexp, :===
       alias match? ===
 
-      # Build a Pattern from a raw path, namespace and the API's inheritable
-      # settings. {Path} owns the settings-aware assembly of +origin+/+suffix+;
+      # Build a Pattern from a raw path, namespace and a PathSettings snapshot.
+      # {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)
@@ -27,9 +27,15 @@ module Grape
         @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))
+        # +cache: false+: Mustermann memoizes what it matched in two
+        # ObjectSpace::WeakKeyMaps per pattern, one for +match+ and one for
+        # +peek_match+. Grape calls neither -- it matches through the compiled
+        # +to_regexp+, and the one method it does reach Mustermann for,
+        # +params+, reads the captures straight off that regexp without
+        # touching either map. Both were allocated per route and never read.
+        @pattern = MustermannPattern.new(@path, uri_decode: true, params:, capture: extract_capture(version, requirements), cache: false)
         @to_regexp = @pattern.to_regexp
-        @captures = @to_regexp.names.any?
+        @captures = !@to_regexp.names.empty?
       end
 
       # True when the compiled pattern has named captures to extract from a
@@ -83,7 +89,7 @@ module Grape
       # +Regexp.escape+, which does accept a Symbol -- but a second raises
       # TypeError.
       def extract_capture(version, requirements)
-        return requirements if version.blank?
+        return requirements if version.nil? || version.empty?
 
         requirements.merge(version: Regexp.union(Array.wrap(version).map(&:to_s)))
       end

data/lib/grape/router/route.rb

@@ -3,15 +3,11 @@
 module Grape
   class Router
     class Route < BaseRoute
-      extend Forwardable
-
       FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
       NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
 
       attr_reader :app, :request_method, :index
 
-      def_delegators :@app, :call
-
       def initialize(endpoint, method, pattern, options, forward_match:, params: {}, **route_attributes)
         super(pattern, options, **route_attributes)
         @app = endpoint
@@ -31,8 +27,17 @@ module Grape
         self
       end
 
+      # Written out rather than delegated: the router calls it on every
+      # request, and a Forwardable delegator checks its target with +defined?+
+      # and forwards through +...+ each time.
+      def call(env)
+        @app.call(env)
+      end
+
+      # The router hands over a normalized path, which always opens with a
+      # slash, so there is no whitespace-only one to treat as blank.
       def match?(input)
-        return false if input.blank?
+        return false if input.nil? || input.empty?
 
         @match_function.call(input, pattern)
       end
@@ -50,15 +55,21 @@ module Grape
       # 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)
+      #
+      # +match+, when given, is the union MatchData the router matched this route
+      # with; its groups already hold the substrings a second match would produce
+      # (see {BaseRoute#union_captures}). +captures+ names those groups, since a
+      # route sits at one number in the router's union and at another in each
+      # bucket that holds it (see {BaseRoute#union_captures_at}); nil there means
+      # the match cannot stand in for Mustermann. Mustermann percent-decodes a
+      # captured value containing '%', and none can unless the path does -- so a
+      # '%'-free path reads the groups, anything else the full match below.
+      def params_for(input, match = nil, captures = union_captures)
         return unless pattern.captures?
 
-        parsed = pattern.params(input)
-        return unless parsed
+        return params_from_union(captures, match) if match && captures && !input.include?('%')
 
-        params = {}
-        parsed.each { |name, value| params[name.to_sym] = tag_utf8!(value) unless value.nil? }
-        params
+        params_from_pattern(input)
       end
 
       protected
@@ -69,6 +80,26 @@ module Grape
 
       private
 
+      # MatchData yields fresh, unfrozen Strings, as Mustermann's Hash does, so
+      # +tag_utf8!+ stays safe in place.
+      def params_from_union(captures, match)
+        params = {}
+        captures.each do |name, group|
+          value = match[group]
+          params[name] = tag_utf8!(value) unless value.nil?
+        end
+        params
+      end
+
+      def params_from_pattern(input)
+        parsed = pattern.params(input)
+        return unless parsed
+
+        params = {}
+        parsed.each { |name, value| params[name.to_sym] = tag_utf8!(value) unless value.nil? }
+        params
+      end
+
       # 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