grape 1.8.0 → 4.0.1

data/lib/grape/middleware/formatter.rb

@@ -1,18 +1,41 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     class Formatter < Base
-      CHUNKED = 'chunked'
+      include PrecomputedContentTypes
 
-      def default_options
-        {
-          default_format: :txt,
-          formatters: {},
-          parsers: {}
-        }
+      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
@@ -23,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)
-          @app_response
-        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|
@@ -43,136 +64,173 @@ 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)
-        api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
-        Grape::Formatter.formatter_for(api_format, **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, 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[Grape::Http::Headers::CONTENT_TYPE]
-          headers
-        else
-          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
-        end
-      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]
 
-      def request
-        @request ||= Rack::Request.new(env)
+        headers[Rack::CONTENT_TYPE] = content_type_for(env[Grape::Env::API_FORMAT])
       end
 
-      # store read input in env['api.request.input']
       def read_body_input
-        return unless
-          (request.post? || request.put? || request.patch? || request.delete?) &&
-          (!request.form_data? || !request.media_type) &&
-          !request.parseable_data? &&
-          (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
+        return unless read_body_input?
+
+        input = rack_request.body # reads RACK_INPUT
+        return if input.nil?
 
-        return unless (input = env[Grape::Env::RACK_INPUT])
+        rewind = input.respond_to?(:rewind)
 
-        input.rewind
+        input.rewind if rewind
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
-          read_rack_input(body) if body && !body.empty?
+          read_rack_input(body)
         ensure
-          input.rewind
+          input.rewind if rewind
         end
       end
 
-      # store parsed input in env['api.request.body']
       def read_rack_input(body)
-        fmt = request.media_type ? mime_types[request.media_type] : options[:default_format]
-
-        throw :error, status: 415, message: "The provided content-type '#{request.media_type}' is not supported." unless content_type_for(fmt)
-        parser = Grape::Parser.parser_for fmt, **options
-        if parser
-          begin
-            body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
-            if body.is_a?(Hash)
-              env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env.key?(Grape::Env::RACK_REQUEST_FORM_HASH)
-                                                          env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
-                                                        else
-                                                          body
-                                                        end
-              env[Grape::Env::RACK_REQUEST_FORM_INPUT] = env[Grape::Env::RACK_INPUT]
+        return if body.empty?
+
+        media_type = rack_request.media_type
+
+        # 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
 
-      def negotiate_content_type
-        fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format]
-        if content_type_for(fmt)
-          env[Grape::Env::API_FORMAT] = fmt
-        else
-          throw :error, status: 406, message: "The requested format '#{fmt}' is not supported."
-        end
+      # this middleware will not try to format the following content-types since Rack already handles them
+      # when calling Rack's `params` function
+      # - application/x-www-form-urlencoded
+      # - multipart/form-data
+      # - multipart/related
+      # - multipart/mixed
+      def read_body_input?
+        # 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 format_from_extension
-        parts = request.path.split('.')
+      def negotiate_content_type
+        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)
 
-        if parts.size > 1
-          extension = parts.last
-          # avoid symbol memory leak on an unknown format
-          return extension.to_sym if content_type_for(extension)
-        end
-        nil
+        throw :error, Grape::Exceptions::ErrorResponse.new(status: 406, message: "The requested format '#{fmt}' is not supported.")
       end
 
-      def format_from_params
-        fmt = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[Grape::Http::Headers::FORMAT]
-        # avoid symbol memory leak on an unknown format
-        return fmt.to_sym if content_type_for(fmt)
+      # 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 = path_for_extension
+        dot_pos = request_path.rindex('.')
+        return unless dot_pos
 
-        fmt
+        extension = try_scrub(request_path[(dot_pos + 1)..])
+        extension if content_type_for(extension)
       end
 
-      def format_from_header
-        mime_array.each do |t|
-          return mime_types[t] if mime_types.key?(t)
-        end
-        nil
+      # 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
 
-      def mime_array
-        accept = env[Grape::Http::Headers::HTTP_ACCEPT]
-        return [] unless accept
+      # +?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?
 
-        accept_into_mime_and_quality = %r{
-          (
-            \w+/[\w+.-]+)     # eg application/vnd.example.myformat+xml
-          (?:
-           (?:;[^,]*?)?       # optionally multiple formats in a row
-           ;\s*q=([\d.]+)     # optional "quality" preference (eg q=0.5)
-          )?
-        }x
+        query_params['format']
+      end
 
-        vendor_prefix_pattern = /vnd\.[^+]+\+/
+      # 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 = try_scrub(env['HTTP_ACCEPT'])
+        return if accept_header.blank? || accept_header == ALL_MEDIA_TYPES
 
-        accept.scan(accept_into_mime_and_quality)
-              .sort_by { |_, quality_preference| -quality_preference.to_f }
-              .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
+        media_type = Rack::Utils.best_q_match(accept_header.downcase, mime_types.keys)
+        mime_types[media_type] if media_type
       end
     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

@@ -5,10 +5,12 @@ module Grape
     # Class to handle the stack of middlewares based on ActionDispatch::MiddlewareStack
     # It allows to insert and insert after
     class Stack
+      extend Forwardable
+
       class Middleware
         attr_reader :args, :block, :klass
 
-        def initialize(klass, *args, &block)
+        def initialize(klass, args, block)
           @klass = klass
           @args = args
           @block = block
@@ -26,13 +28,27 @@ 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
         end
 
-        def use_in(builder)
-          builder.use(@klass, *@args, &@block)
+        def build(builder)
+          # we need to force the ruby2_keywords_hash for middlewares that initialize contains keywords
+          # like ActionDispatch::RequestId since middleware arguments are serialized
+          # https://rubyapi.org/3.4/o/hash#method-c-ruby2_keywords_hash
+          args[-1] = Hash.ruby2_keywords_hash(args[-1]) if args.last.is_a?(Hash) && Hash.respond_to?(:ruby2_keywords_hash)
+          builder.use(klass, *args, &block)
         end
       end
 
@@ -40,73 +56,55 @@ module Grape
 
       attr_accessor :middlewares, :others
 
+      def_delegators :middlewares, :each, :size, :last, :[]
+
       def initialize
         @middlewares = []
         @others = []
       end
 
-      def each(&block)
-        @middlewares.each(&block)
-      end
-
-      def size
-        middlewares.size
-      end
-
-      def last
-        middlewares.last
-      end
-
-      def [](i)
-        middlewares[i]
+      def insert(index, klass, *args, &block)
+        at = assert_index(index, :before)
+        middlewares.insert(at, self.class::Middleware.new(klass, args, block))
       end
 
-      def insert(index, *args, &block)
-        index = assert_index(index, :before)
-        middleware = self.class::Middleware.new(*args, &block)
-        middlewares.insert(index, middleware)
-      end
-      ruby2_keywords :insert if respond_to?(:ruby2_keywords, true)
-
       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
-      ruby2_keywords :insert_after if respond_to?(:ruby2_keywords, true)
 
-      def use(*args, &block)
-        middleware = self.class::Middleware.new(*args, &block)
+      def use(klass, *args, &block)
+        middleware = self.class::Middleware.new(klass, args, block)
         middlewares.push(middleware)
       end
-      ruby2_keywords :use if respond_to?(:ruby2_keywords, true)
 
       def merge_with(middleware_specs)
-        middleware_specs.each do |operation, *args|
+        middleware_specs.each do |operation, klass, *args|
           if args.last.is_a?(Proc)
             last_proc = args.pop
-            public_send(operation, *args, &last_proc)
+            public_send(operation, klass, *args, &last_proc)
           else
-            public_send(operation, *args)
+            public_send(operation, klass, *args)
           end
         end
       end
 
       # @return [Rack::Builder] the builder object with our middlewares applied
-      def build(builder = Rack::Builder.new)
+      def build
+        builder = Rack::Builder.new
         others.shift(others.size).each { |m| merge_with(m) }
-        middlewares.each do |m|
-          m.use_in(builder)
-        end
+        middlewares.each { |m| m.build(builder) }
         builder
       end
 
       # @description Add middlewares with :use operation to the stack. Store others with :insert_* operation for later
       # @param [Array] other_specs An array of middleware specifications (e.g. [[:use, klass], [:insert_before, *args]])
       def concat(other_specs)
-        @others << Array(other_specs).reject { |o| o.first == :use }
-        merge_with(Array(other_specs).select { |o| o.first == :use })
+        use, not_use = other_specs.partition { |o| o.first == :use }
+        others << not_use
+        merge_with(use)
       end
 
       protected

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -20,44 +18,19 @@ module Grape
       # route.
       class AcceptVersionHeader < Base
         def before
-          potential_version = (env[Grape::Http::Headers::HTTP_ACCEPT_VERSION] || '').strip
-
-          if strict? && potential_version.empty?
-            # If no Accept-Version header:
-            throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
-          end
-
-          return if potential_version.empty?
+          potential_version = try_scrub(env['HTTP_ACCEPT_VERSION'])
+          not_acceptable!('Accept-Version header must be set.') if strict && potential_version.blank?
 
-          # If the requested version is not supported:
-          throw :error, status: 406, headers: error_headers, message: 'The requested version is not supported.' unless versions.any? { |v| v.to_s == potential_version }
+          return if potential_version.blank?
 
+          not_acceptable!('The requested version is not supported.') unless potential_version_match?(potential_version)
           env[Grape::Env::API_VERSION] = potential_version
         end
 
         private
 
-        def versions
-          options[:versions] || []
-        end
-
-        def strict?
-          options[:version_options] && options[:version_options][:strict]
-        end
-
-        # 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?
-          if options[:version_options]&.key?(:cascade)
-            options[:version_options][:cascade]
-          else
-            true
-          end
-        end
-
-        def error_headers
-          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+        def not_acceptable!(message)
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 406, headers: error_headers, message:)
         end
       end
     end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      class Base < Grape::Middleware::Base
+        extend Forwardable
+        include Grape::Middleware::PrecomputedContentTypes
+
+        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
+
+        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
+
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
+        end
+
+        attr_reader :available_media_types, :error_headers, :versions
+
+        def_delegators :config, :mount_path, :prefix, :version_options
+        def_delegators :version_options, :cascade, :parameter, :strict, :vendor
+
+        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 potential_version_match?(potential_version)
+          versions.blank? || versions.include?(potential_version)
+        end
+
+        def version_not_found!
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER)
+        end
+
+        private
+
+        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
+  end
+end