grape 2.4.0 → 4.0.1

data/lib/grape/middleware/formatter.rb

@@ -3,9 +3,40 @@
 module Grape
   module Middleware
     class Formatter < Base
-      DEFAULT_OPTIONS = {
-        default_format: :txt
-      }.freeze
+      include PrecomputedContentTypes
+
+      Options = Data.define(:content_types, :default_format, :format, :formatters, :parsers) do
+        def initialize(content_types: nil, default_format: :txt, format: nil, formatters: nil, parsers: nil)
+          super
+        end
+      end
+
+      ALL_MEDIA_TYPES = '*/*'
+
+      # The request methods that can carry a body worth parsing. See
+      # {#read_body_input?}, which tests the env against this before anything
+      # asks for a Rack::Request. QUERY is here because its content *is* the
+      # query (RFC 10008, Section 2), not an optional payload.
+      BODY_CARRYING_METHODS = [Rack::POST, Rack::PUT, Rack::PATCH, Rack::DELETE, Grape::QUERY].freeze
+
+      # Read off ivars rather than delegated into +config+ on every request:
+      # +negotiate_content_type+ asks for +format+ and +default_format+ per
+      # request and +fetch_formatter+ for +formatters+, and each delegator cost
+      # a Forwardable frame plus a Data reader for a value that was frozen when
+      # the middleware was built.
+      attr_reader :default_format, :format, :formatters, :parsers
+
+      # The formatter is the only middleware that maps an incoming media type
+      # back to a format, so it warms +mime_types+ itself rather than making
+      # every content-type-aware middleware build a table none of them read.
+      def initialize(app, **options)
+        super
+        @default_format = config.default_format
+        @format = config.format
+        @formatters = config.formatters
+        @parsers = config.parsers
+        mime_types
+      end
 
       def before
         negotiate_content_type
@@ -15,19 +46,17 @@ module Grape
       def after
         return unless @app_response
 
-        status, headers, bodies = *@app_response
+        status, headers, bodies = @app_response
 
-        if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
-          [status, headers, []]
-        else
-          build_formatted_response(status, headers, bodies)
-        end
+        return [status, headers, []] if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+
+        build_formatted_response(status, headers, bodies)
       end
 
       private
 
       def build_formatted_response(status, headers, bodies)
-        headers = ensure_content_type(headers)
+        ensure_content_type!(headers)
 
         if bodies.is_a?(Grape::ServeStream::StreamResponse)
           Grape::ServeStream::SendfileResponse.new([], status, headers) do |resp|
@@ -35,44 +64,64 @@ module Grape
           end
         else
           # Allow content-type to be explicitly overwritten
-          formatter = fetch_formatter(headers, options)
-          bodymap = ActiveSupport::Notifications.instrument('format_response.grape', formatter: formatter, env: env) do
-            bodies.collect { |body| formatter.call(body, env) }
+          formatter = fetch_formatter(headers)
+          bodymap = instrument_format_response(formatter) do
+            bodies.map { |body| formatter.call(body, env) }
           end
-          Rack::Response.new(bodymap, status, headers)
+          # A bare Rack tuple rather than a Rack::Response: +headers+ is already
+          # a Grape::Util::Header (a Rack::Headers on Rack 3), so wrapping only
+          # re-normalizes the same keys into a second Headers hash that
+          # +Middleware::Base#call+ unwraps again with +to_a+ on the way out.
+          # The 204/304 bodies Rack::Response#finish would blank are returned
+          # above, before this point.
+          [status, headers, bodymap]
         end
       rescue Grape::Exceptions::InvalidFormatter => e
-        throw :error, status: 500, message: e.message, backtrace: e.backtrace, original_exception: e
+        throw :error, Grape::Exceptions::ErrorResponse.new(status: 500, message: e.message, backtrace: e.backtrace, original_exception: e)
       end
 
-      def fetch_formatter(headers, options)
+      # Guards on +listening?+ so that with no subscriber the payload Hash and
+      # notification machinery are skipped and the block runs directly (no added
+      # allocations); the block is forwarded anonymously.
+      def instrument_format_response(formatter, &)
+        return yield unless ActiveSupport::Notifications.notifier.listening?('format_response.grape')
+
+        ActiveSupport::Notifications.instrument('format_response.grape', formatter:, env:, &)
+      end
+
+      def fetch_formatter(headers)
         api_format = env.fetch(Grape::Env::API_FORMAT) { mime_types[headers[Rack::CONTENT_TYPE]] }
-        Grape::Formatter.formatter_for(api_format, options[:formatters])
+        Grape::Formatter.formatter_for(api_format, formatters)
       end
 
       # Set the content type header for the API format if it is not already present.
       #
-      # @param headers [Hash]
-      # @return [Hash]
-      def ensure_content_type(headers)
-        if headers[Rack::CONTENT_TYPE]
-          headers
-        else
-          headers.merge(Rack::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
-        end
+      # Written into +headers+ rather than returned as a copy, hence the +!+:
+      # this runs on every response, and copying the hash costs an allocation
+      # per request for a header the caller is about to send anyway.
+      #
+      # @param headers [Hash] the response headers, mutated in place
+      # @return [void]
+      def ensure_content_type!(headers)
+        return if headers[Rack::CONTENT_TYPE]
+
+        headers[Rack::CONTENT_TYPE] = content_type_for(env[Grape::Env::API_FORMAT])
       end
 
       def read_body_input
+        return unless read_body_input?
+
         input = rack_request.body # reads RACK_INPUT
         return if input.nil?
-        return unless read_body_input?
 
-        input.try(:rewind)
+        rewind = input.respond_to?(:rewind)
+
+        input.rewind if rewind
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
           read_rack_input(body)
         ensure
-          input.try(:rewind)
+          input.rewind if rewind
         end
       end
 
@@ -80,28 +129,33 @@ module Grape
         return if body.empty?
 
         media_type = rack_request.media_type
-        fmt = media_type ? mime_types[media_type] : options[:default_format]
-
-        throw :error, status: 415, message: "The provided content-type '#{media_type}' is not supported." unless content_type_for(fmt)
-        parser = Grape::Parser.parser_for fmt, options[:parsers]
-        if parser
-          begin
-            body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
-            if body.is_a?(Hash)
-              env[Rack::RACK_REQUEST_FORM_HASH] = if env.key?(Rack::RACK_REQUEST_FORM_HASH)
-                                                    env[Rack::RACK_REQUEST_FORM_HASH].merge(body)
-                                                  else
-                                                    body
-                                                  end
-              env[Rack::RACK_REQUEST_FORM_INPUT] = env[Rack::RACK_INPUT]
+
+        # RFC 10008, Sections 2 and 2.1: a QUERY carries its query in the
+        # content, so a request that never says what that content is cannot be
+        # interpreted and must fail rather than be read as the default format.
+        # Every other method keeps that fallback.
+        throw :error, Grape::Exceptions::ErrorResponse.new(status: 400, message: 'The QUERY method requires a content-type.') if media_type.nil? && env[Rack::REQUEST_METHOD] == Grape::QUERY
+
+        fmt = media_type ? mime_types[media_type] : default_format
+
+        throw :error, Grape::Exceptions::ErrorResponse.new(status: 415, message: "The provided content-type '#{media_type}' is not supported.") unless content_type_for(fmt)
+        parser = Grape::Parser.parser_for fmt, parsers
+        return env[Grape::Env::API_REQUEST_BODY] = body unless parser
+
+        begin
+          parsed = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
+          if parsed.is_a?(Hash)
+            if (form_hash = env[Rack::RACK_REQUEST_FORM_HASH])
+              form_hash.merge!(parsed)
+            else
+              env[Rack::RACK_REQUEST_FORM_HASH] = parsed
             end
-          rescue Grape::Exceptions::Base => e
-            raise e
-          rescue StandardError => e
-            throw :error, status: 400, message: e.message, backtrace: e.backtrace, original_exception: e
+            env[Rack::RACK_REQUEST_FORM_INPUT] = env[Rack::RACK_INPUT]
           end
-        else
-          env[Grape::Env::API_REQUEST_BODY] = body
+        rescue Grape::Exceptions::Base => e
+          raise e
+        rescue StandardError => e
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 400, message: e.message, backtrace: e.backtrace, original_exception: e)
         end
       end
 
@@ -112,35 +166,70 @@ module Grape
       # - multipart/related
       # - multipart/mixed
       def read_body_input?
-        (rack_request.post? || rack_request.put? || rack_request.patch? || rack_request.delete?) &&
-          !(rack_request.form_data? && rack_request.content_type) &&
-          !rack_request.parseable_data? &&
-          (rack_request.content_length.to_i.positive? || rack_request.env['HTTP_TRANSFER_ENCODING'] == 'chunked')
+        # Read off the env rather than through Rack::Request's predicates: this
+        # is what decides the question for every request, and on the GET, HEAD
+        # and OPTIONS majority it is the only thing the formatter would have
+        # built a Rack::Request for.
+        return false unless BODY_CARRYING_METHODS.include?(env[Rack::REQUEST_METHOD])
+        return false if rack_request.form_data? && rack_request.content_type
+        return false if rack_request.parseable_data?
+
+        rack_request.content_length.to_i.positive? || env['HTTP_TRANSFER_ENCODING'] == 'chunked'
       end
 
       def negotiate_content_type
-        fmt = format_from_extension || query_params['format'] || options[:format] || format_from_header || options[:default_format]
-        if content_type_for(fmt)
-          env[Grape::Env::API_FORMAT] = fmt.to_sym
-        else
-          throw :error, status: 406, message: "The requested format '#{fmt}' is not supported."
-        end
+        fmt = format_from_extension || format_from_query || format || format_from_header || default_format
+        return env[Grape::Env::API_FORMAT] = fmt.to_sym if content_type_for(fmt)
+
+        throw :error, Grape::Exceptions::ErrorResponse.new(status: 406, message: "The requested format '#{fmt}' is not supported.")
       end
 
+      # Only the extension is scrubbed, and only once the path turns out to have
+      # one: +String#rindex+ takes a byte offset and never raises on an invalid
+      # sequence, and a +.+ byte cannot be part of a multi-byte one, so the dot
+      # sits at the same place before and after scrubbing. The overwhelming
+      # majority of paths carry no extension and now skip the scrub entirely.
       def format_from_extension
-        request_path = rack_request.path.try(:scrub)
+        request_path = path_for_extension
         dot_pos = request_path.rindex('.')
         return unless dot_pos
 
-        extension = request_path[dot_pos + 1..]
+        extension = try_scrub(request_path[(dot_pos + 1)..])
         extension if content_type_for(extension)
       end
 
+      # The extension is the tail of the request path, so PATH_INFO answers it
+      # on its own whenever there is one: a dot in SCRIPT_NAME is followed by
+      # the slash that opens PATH_INFO, and no registered extension holds a
+      # slash. Only an empty PATH_INFO needs +Rack::Request#path+ — and with it
+      # the String its concatenation allocates. Tested with +empty?+ rather
+      # than +blank?+: the path is not scrubbed yet, and a regexp match on an
+      # invalid byte sequence raises.
+      def path_for_extension
+        path_info = env[Rack::PATH_INFO]
+        return rack_request.path if path_info.nil? || path_info.empty?
+
+        path_info
+      end
+
+      # +?format=+ can only be there when there is a query string at all, so
+      # the common query-less request skips parsing one.
+      def format_from_query
+        query_string = env[Rack::QUERY_STRING]
+        return if query_string.nil? || query_string.empty?
+
+        query_params['format']
+      end
+
+      # Media types are case-insensitive (RFC 9110 §8.3.1) but the registered
+      # ones are spelled in lower case and Rack matches them literally, so an
+      # `Accept: TEXT/PLAIN` found nothing and fell through to the default
+      # format — the client quietly got something other than what it asked for.
       def format_from_header
-        accept_header = env['HTTP_ACCEPT'].try(:scrub)
-        return if accept_header.blank?
+        accept_header = try_scrub(env['HTTP_ACCEPT'])
+        return if accept_header.blank? || accept_header == ALL_MEDIA_TYPES
 
-        media_type = Rack::Utils.best_q_match(accept_header, mime_types.keys)
+        media_type = Rack::Utils.best_q_match(accept_header.downcase, mime_types.keys)
         mime_types[media_type] if media_type
       end
     end

data/lib/grape/middleware/precomputed_content_types.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    # Include in a middleware subclass that needs content-type negotiation.
+    # Provides +content_types+ / +mime_types+ / +content_type_for+ /
+    # +content_type+ resolved from +config.content_types+ and
+    # +config.format+ — so the consuming middleware's +Options+ Data class
+    # must declare both fields. Warms those caches on the parent instance
+    # at initialization so per-request +dup+s inherit them rather than
+    # rebuilding them.
+    #
+    # +mime_types+ is not warmed here: Formatter is the only middleware that
+    # reads it, and it warms it itself. The tables behind +mime_types+ and
+    # +content_type_for+ are shared process-wide per content-type registry
+    # (see Grape::ContentTypes), so the ivars below memoize a lookup, not a
+    # copy.
+    #
+    # Opt-in: plain +Grape::Middleware::Base+ subclasses that don't need
+    # content-type-aware helpers don't pay for them.
+    module PrecomputedContentTypes
+      def initialize(app, **options)
+        super
+        content_types
+        content_types_lookup
+      end
+
+      def content_types
+        @content_types ||= Grape::ContentTypes.content_types_for(config.content_types)
+      end
+
+      def mime_types
+        @mime_types ||= Grape::ContentTypes.mime_types_for(content_types)
+      end
+
+      def content_type_for(format)
+        content_types_lookup[format]
+      end
+
+      def content_type
+        content_type_for(env[Grape::Env::API_FORMAT] || config.format) || 'text/html'
+      end
+
+      private
+
+      def content_types_lookup
+        @content_types_lookup ||= Grape::ContentTypes.lookup_for(content_types)
+      end
+    end
+  end
+end

data/lib/grape/middleware/stack.rb

@@ -6,6 +6,7 @@ module Grape
     # It allows to insert and insert after
     class Stack
       extend Forwardable
+
       class Middleware
         attr_reader :args, :block, :klass
 
@@ -27,6 +28,16 @@ module Grape
             klass == other || (name.nil? && klass.superclass == other)
           end
         end
+        alias eql? ==
+
+        # Keyed on the wrapped class, so two Middleware wrapping the same
+        # class hash alike — and so does the class itself, which #== also
+        # accepts. The superclass fallback above can't be honoured here (a
+        # class and its superclass hash differently); it only ever serves
+        # #index / #include?, which compare with #== rather than by hash.
+        def hash
+          klass.hash
+        end
 
         def inspect
           klass.to_s
@@ -53,15 +64,15 @@ module Grape
       end
 
       def insert(index, klass, *args, &block)
-        index = assert_index(index, :before)
-        middlewares.insert(index, self.class::Middleware.new(klass, args, block))
+        at = assert_index(index, :before)
+        middlewares.insert(at, self.class::Middleware.new(klass, args, block))
       end
 
       alias insert_before insert
 
-      def insert_after(index, *args, &block)
-        index = assert_index(index, :after)
-        insert(index + 1, *args, &block)
+      def insert_after(index, ...)
+        at = assert_index(index, :after)
+        insert(at + 1, ...)
       end
 
       def use(klass, *args, &block)
@@ -82,12 +93,10 @@ module Grape
 
       # @return [Rack::Builder] the builder object with our middlewares applied
       def build
-        Rack::Builder.new.tap do |builder|
-          others.shift(others.size).each { |m| merge_with(m) }
-          middlewares.each do |m|
-            m.build(builder)
-          end
-        end
+        builder = Rack::Builder.new
+        others.shift(others.size).each { |m| merge_with(m) }
+        middlewares.each { |m| m.build(builder) }
+        builder
       end
 
       # @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later

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

@@ -18,8 +18,8 @@ module Grape
       # route.
       class AcceptVersionHeader < Base
         def before
-          potential_version = env['HTTP_ACCEPT_VERSION'].try(:scrub)
-          not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?
+          potential_version = try_scrub(env['HTTP_ACCEPT_VERSION'])
+          not_acceptable!('Accept-Version header must be set.') if strict && potential_version.blank?
 
           return if potential_version.blank?
 
@@ -30,7 +30,7 @@ module Grape
         private
 
         def not_acceptable!(message)
-          throw :error, status: 406, headers: error_headers, message: message
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 406, headers: error_headers, message:)
         end
       end
     end

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

@@ -4,69 +4,61 @@ module Grape
   module Middleware
     module Versioner
       class Base < Grape::Middleware::Base
-        DEFAULT_OPTIONS = {
-          pattern: /.*/i.freeze,
-          version_options: {
-            strict: false,
-            cascade: true,
-            parameter: 'apiver'
-          }.freeze
-        }.freeze
+        extend Forwardable
+        include Grape::Middleware::PrecomputedContentTypes
 
-        def self.inherited(klass)
-          super
-          Versioner.register(klass)
+        Options = Data.define(
+          :content_types, :format, :mount_path, :prefix, :version_options, :versions
+        ) do
+          def initialize(
+            content_types: nil, format: nil, mount_path: nil, prefix: nil,
+            version_options: Grape::DSL::VersionOptions.new, versions: nil
+          )
+            super
+          end
         end
 
-        def versions
-          options[:versions]
-        end
-
-        def prefix
-          options[:prefix]
-        end
+        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
 
-        def mount_path
-          options[:mount_path]
-        end
-
-        def pattern
-          options[:pattern]
-        end
-
-        def version_options
-          options[:version_options]
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
         end
 
-        def strict?
-          version_options[:strict]
-        end
+        attr_reader :available_media_types, :error_headers, :versions
 
-        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-        # of routes (see Grape::Router) for more information). To prevent
-        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
-        def cascade?
-          version_options[:cascade]
-        end
+        def_delegators :config, :mount_path, :prefix, :version_options
+        def_delegators :version_options, :cascade, :parameter, :strict, :vendor
 
-        def parameter_key
-          version_options[:parameter]
+        def initialize(app, **options)
+          super
+          @versions = config.versions&.map(&:to_s) # making sure versions are strings to ease potential match
+          @error_headers = cascade ? CASCADE_PASS_HEADER : {}
+          @available_media_types = build_available_media_types
         end
 
-        def vendor
-          version_options[:vendor]
+        def potential_version_match?(potential_version)
+          versions.blank? || versions.include?(potential_version)
         end
 
-        def error_headers
-          cascade? ? { 'X-Cascade' => 'pass' } : {}
+        def version_not_found!
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER)
         end
 
-        def potential_version_match?(potential_version)
-          versions.blank? || versions.any? { |v| v.to_s == potential_version }
-        end
+        private
 
-        def version_not_found!
-          throw :error, status: 404, message: '404 API Version Not Found', headers: { 'X-Cascade' => 'pass' }
+        def build_available_media_types
+          media_types = []
+          base_media_type = "application/vnd.#{vendor}"
+          versions&.reverse_each do |version|
+            versioned_base = "#{base_media_type}-#{version}"
+            content_types.each_key { |extension| media_types << "#{versioned_base}+#{extension}" }
+            media_types << versioned_base
+          end
+          content_types.each_key { |extension| media_types << "#{base_media_type}+#{extension}" }
+          media_types << base_media_type
+          media_types.concat(content_types.values.flatten)
+          media_types
         end
       end
     end

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

@@ -41,11 +41,9 @@ module Grape
 
           strict_header_checks!
           media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types)
-          if media_type
-            yield media_type
-          else
-            fail!
-          end
+          return yield media_type if media_type
+
+          fail!
         end
 
         def accept_header
@@ -53,7 +51,7 @@ module Grape
         end
 
         def strict_header_checks!
-          return unless strict?
+          return unless strict
 
           accept_header_check!
           version_and_vendor_check!
@@ -101,26 +99,10 @@ module Grape
         end
 
         def version_not_found!(media_types)
-          return unless media_types.all? { |media_type| media_type&.version && versions&.exclude?(media_type.version) }
+          return unless media_types.all? { |media_type| media_type&.version && versions && !versions.include?(media_type.version) }
 
           invalid_version_header!('API version not found.')
         end
-
-        def available_media_types
-          [].tap do |available_media_types|
-            base_media_type = "application/vnd.#{vendor}"
-            content_types.each_key do |extension|
-              versions&.reverse_each do |version|
-                available_media_types << "#{base_media_type}-#{version}+#{extension}"
-                available_media_types << "#{base_media_type}-#{version}"
-              end
-              available_media_types << "#{base_media_type}+#{extension}"
-            end
-
-            available_media_types << base_media_type
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
       end
     end
   end

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

@@ -20,11 +20,11 @@ module Grape
       #   env['api.version'] => 'v1'
       class Param < Base
         def before
-          potential_version = query_params[parameter_key]
+          potential_version = query_params[parameter]
           return if potential_version.blank?
 
           version_not_found! unless potential_version_match?(potential_version)
-          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter_key)
+          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter)
         end
       end
     end