grape 3.2.1 → 3.3.0

data/lib/grape/middleware/error.rb

@@ -3,18 +3,50 @@
 module Grape
   module Middleware
     class Error < Base
-      DEFAULT_OPTIONS = {
-        default_status: 500,
-        default_message: '',
-        format: :txt,
-        rescue_all: false,
-        rescue_grape_exceptions: false,
-        rescue_subclasses: true,
-        rescue_options: {
-          backtrace: false,
-          original_exception: false
-        }.freeze
-      }.freeze
+      extend Forwardable
+      include PrecomputedContentTypes
+
+      Options = Data.define(
+        :all_rescue_handler, :base_only_rescue_handlers, :content_types,
+        :default_error_formatter, :default_message, :default_status,
+        :error_formatters, :format,
+        :grape_exceptions_rescue_handler, :internal_grape_exceptions_rescue_handler,
+        :rescue_all, :rescue_grape_exceptions, :rescue_handlers, :rescue_options
+      ) do
+        include Grape::Middleware::DeprecatedOptionsHashAccess
+
+        def initialize(
+          all_rescue_handler: nil, base_only_rescue_handlers: nil, content_types: nil,
+          default_error_formatter: nil, default_message: '', default_status: 500,
+          error_formatters: nil, format: :txt,
+          grape_exceptions_rescue_handler: nil, internal_grape_exceptions_rescue_handler: nil,
+          rescue_all: false, rescue_grape_exceptions: false, rescue_handlers: nil,
+          rescue_options: nil
+        )
+          # `rescue_options:` arrives nil from `Endpoint#error_middleware_options`
+          # when no `rescue_from` has been called — fall back to the documented
+          # defaults rather than letting nil propagate to `def_delegator
+          # :rescue_options, :backtrace`.
+          rescue_options ||= Grape::DSL::RescueOptions.new
+          super
+        end
+      end
+
+      # @deprecated Kept as a frozen Hash representation of the {Options}
+      #   defaults for back-compat. Will be removed in a future release.
+      DEFAULT_OPTIONS = Options.new.to_h.freeze
+
+      def_delegators :config,
+                     :all_rescue_handler, :base_only_rescue_handlers, :default_error_formatter,
+                     :default_message, :default_status, :error_formatters, :format,
+                     :grape_exceptions_rescue_handler, :internal_grape_exceptions_rescue_handler,
+                     :rescue_all, :rescue_grape_exceptions, :rescue_handlers, :rescue_options
+
+      # +:backtrace+ / +:original_exception+ on the rescue options become
+      # +#include_backtrace+ / +#include_original_exception+ on the middleware,
+      # which is what the formatter call site reads.
+      def_delegator :rescue_options, :backtrace, :include_backtrace
+      def_delegator :rescue_options, :original_exception, :include_original_exception
 
       def call!(env)
         @env = env
@@ -30,52 +62,57 @@ module Grape
         Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), Grape::Util::Header.new.merge(headers))
       end
 
-      def format_message(message, backtrace, original_exception = nil)
-        format = env[Grape::Env::API_FORMAT] || options[:format]
-        formatter = Grape::ErrorFormatter.formatter_for(format, options[:error_formatters], options[:default_error_formatter])
-        return formatter.call(message, backtrace, options, env, original_exception) if formatter
+      def format_message(error)
+        current_format = env[Grape::Env::API_FORMAT] || format
+        formatter = Grape::ErrorFormatter.formatter_for(current_format, error_formatters, default_error_formatter)
+        return formatter.call(error:, env:, include_backtrace:, include_original_exception:) if formatter
 
-        throw :error,
-              status: 406,
-              message: "The requested format '#{format}' is not supported.",
-              backtrace:,
-              original_exception:
+        throw :error, Grape::Exceptions::ErrorResponse.new(
+          status: 406,
+          message: "The requested format '#{current_format}' is not supported.",
+          backtrace: error.backtrace,
+          original_exception: error.original_exception
+        )
       end
 
       def find_handler(klass)
-        rescue_handler_for_base_only_class(klass) ||
-          rescue_handler_for_class_or_its_ancestor(klass) ||
+        registered_rescue_handler(klass) ||
           rescue_handler_for_grape_exception(klass) ||
           rescue_handler_for_any_class(klass) ||
           raise
       end
 
-      def error_response(error = {})
-        status = error[:status] || options[:default_status]
-        env[Grape::Env::API_ENDPOINT].status(status) # error! may not have been called
-        message = error[:message] || options[:default_message]
-        headers = { Rack::CONTENT_TYPE => content_type }.tap do |h|
-          h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
-        end
-        backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
-        original_exception = error.is_a?(Exception) ? error : error[:original_exception]
-        rack_response(status, headers, format_message(message, backtrace, original_exception))
+      def error_response(error = nil)
+        raw = Grape::Exceptions::ErrorResponse.coerce(error)
+        headers = { Rack::CONTENT_TYPE => content_type }
+        headers.merge!(raw.headers) if raw.headers.is_a?(Hash)
+        payload = raw.with(
+          status: raw.status || default_status,
+          message: raw.message || default_message,
+          headers:,
+          backtrace: raw.backtrace || raw.original_exception&.backtrace || []
+        )
+        env[Grape::Env::API_ENDPOINT].status(payload.status) # error! may not have been called
+        rack_response(payload.status, payload.headers, format_message(payload))
       end
 
       def default_rescue_handler(exception)
-        error_response(message: exception.message, backtrace: exception.backtrace, original_exception: exception)
+        error_response(
+          Grape::Exceptions::ErrorResponse.new(
+            message: exception.message,
+            backtrace: exception.backtrace,
+            original_exception: exception
+          )
+        )
       end
 
-      def rescue_handler_for_base_only_class(klass)
-        error, handler = options[:base_only_rescue_handlers]&.find { |err, _handler| klass == err }
-
-        return unless error
-
-        handler || method(:default_rescue_handler)
+      def registered_rescue_handler(klass)
+        rescue_handler_from(base_only_rescue_handlers) { |err| klass == err } ||
+          rescue_handler_from(rescue_handlers) { |err| klass <= err }
       end
 
-      def rescue_handler_for_class_or_its_ancestor(klass)
-        error, handler = options[:rescue_handlers]&.find { |err, _handler| klass <= err }
+      def rescue_handler_from(handlers)
+        error, handler = handlers&.find { |err, _handler| yield(err) }
 
         return unless error
 
@@ -85,45 +122,98 @@ module Grape
       def rescue_handler_for_grape_exception(klass)
         return unless klass <= Grape::Exceptions::Base
         return method(:error_response) if klass == Grape::Exceptions::InvalidVersionHeader
-        return unless options[:rescue_grape_exceptions] || !options[:rescue_all]
+        return unless rescue_grape_exceptions || !rescue_all
 
-        options[:grape_exceptions_rescue_handler] || method(:error_response)
+        grape_exceptions_rescue_handler || method(:error_response)
       end
 
       def rescue_handler_for_any_class(klass)
         return unless klass <= StandardError
-        return unless options[:rescue_all] || options[:rescue_grape_exceptions]
+        return unless rescue_all || rescue_grape_exceptions
 
-        options[:all_rescue_handler] || method(:default_rescue_handler)
+        all_rescue_handler || method(:default_rescue_handler)
       end
 
-      def run_rescue_handler(handler, error, endpoint)
-        handler = endpoint.public_method(handler) if handler.instance_of?(Symbol)
+      def run_rescue_handler(handler, error, endpoint, redispatched: false)
+        handler = endpoint.public_method(handler) if handler.is_a?(Symbol)
         response = catch(:error) do
           handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
+        rescue StandardError => e
+          return redispatch(e, endpoint, redispatched)
         end
 
-        if error?(response)
-          error_response(response)
-        elsif response.is_a?(Rack::Response)
-          response
-        else
-          run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
-        end
+        return error_response(response) if error?(response)
+        return response if response.is_a?(Rack::Response)
+
+        run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
       end
 
-      def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
+      # Route an exception raised inside a +rescue_from+ block.
+      #
+      # * If we have already redispatched once (the redispatched handler
+      #   itself raised), go straight to {#framework_default} — bounds the
+      #   chain at one redispatch.
+      # * Else if the exception has a registered +rescue_from+ handler,
+      #   run it.
+      # * Else if it's a +Grape::Exceptions::Base+ subclass, render it
+      #   through +error_response+ with its own +status+ and +message+.
+      # * Else fall through to {#safe_default}, which lets the user opt
+      #   in via +rescue_from :internal_grape_exceptions+ or, failing
+      #   that, applies the framework default.
+      def redispatch(error, endpoint, already_redispatched)
+        return framework_default(endpoint) if already_redispatched
+
+        registered = registered_rescue_handler(error.class)
+
+        return run_rescue_handler(registered, error, endpoint, redispatched: true) if registered
+        return run_rescue_handler(method(:error_response), error, endpoint, redispatched: true) if error.is_a?(Grape::Exceptions::Base)
+
+        safe_default(error, endpoint)
+      end
+
+      # The unrecognised-error path. Exposes the original exception on
+      # the rack env so upstream Rack middleware (loggers, error
+      # trackers) can observe it. If the user registered a
+      # +rescue_from :internal_grape_exceptions+ handler, that handler
+      # runs and owns the response. Otherwise the framework renders the
+      # generic +InternalServerError+ — never the original exception's
+      # message. The framework deliberately does no logging of its own
+      # here; that's the application's call.
+      def safe_default(error, endpoint)
+        env[Grape::Env::GRAPE_EXCEPTION] = error
+        return run_rescue_handler(internal_grape_exceptions_rescue_handler, error, endpoint, redispatched: true) if internal_grape_exceptions_rescue_handler
+
+        framework_default(endpoint)
+      end
+
+      def framework_default(endpoint)
+        run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InternalServerError.new, endpoint)
+      end
+
+      def error!(message, status = default_status, headers = {}, backtrace = [], original_exception = nil)
         env[Grape::Env::API_ENDPOINT].status(status) # not error! inside route
-        rack_response(
-          status, headers.reverse_merge(Rack::CONTENT_TYPE => content_type),
-          format_message(message, backtrace, original_exception)
+        merged_headers = { Rack::CONTENT_TYPE => content_type }.merge!(headers)
+        error = Grape::Exceptions::ErrorResponse.new(
+          status:, message:, headers: merged_headers, backtrace:, original_exception:
         )
+        rack_response(status, merged_headers, format_message(error))
       end
 
       def error?(response)
-        return false unless response.is_a?(Hash)
-
-        response.key?(:message) && response.key?(:status) && response.key?(:headers)
+        case response
+        when Grape::Exceptions::ErrorResponse
+          true
+        when Hash
+          return false unless response.key?(:message) && response.key?(:status) && response.key?(:headers)
+
+          Grape.deprecator.warn(
+            'Returning or throwing a Hash from a rescue handler is deprecated. ' \
+            'Use `error!(...)` or a `Grape::Exceptions::ErrorResponse` instead.'
+          )
+          true
+        else
+          false
+        end
       end
     end
   end

data/lib/grape/middleware/formatter.rb

@@ -3,12 +3,25 @@
 module Grape
   module Middleware
     class Formatter < Base
-      DEFAULT_OPTIONS = {
-        default_format: :txt
-      }.freeze
+      extend Forwardable
+      include PrecomputedContentTypes
+
+      Options = Data.define(:content_types, :default_format, :format, :formatters, :parsers) do
+        include Grape::Middleware::DeprecatedOptionsHashAccess
+
+        def initialize(content_types: nil, default_format: :txt, format: nil, formatters: nil, parsers: nil)
+          super
+        end
+      end
+
+      # @deprecated Kept as a frozen Hash representation of the {Options}
+      #   defaults for back-compat. Will be removed in a future release.
+      DEFAULT_OPTIONS = Options.new.to_h.freeze
 
       ALL_MEDIA_TYPES = '*/*'
 
+      def_delegators :config, :default_format, :format, :formatters, :parsers
+
       def before
         negotiate_content_type
         read_body_input
@@ -17,13 +30,11 @@ 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
@@ -37,19 +48,28 @@ module Grape
           end
         else
           # Allow content-type to be explicitly overwritten
-          formatter = fetch_formatter(headers, options)
-          bodymap = ActiveSupport::Notifications.instrument('format_response.grape', formatter:, 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)
         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
+
+      # 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, options)
+      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.
@@ -57,11 +77,10 @@ module Grape
       # @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
+        return headers if headers[Rack::CONTENT_TYPE]
+
+        headers[Rack::CONTENT_TYPE] = content_type_for(env[Grape::Env::API_FORMAT])
+        headers
       end
 
       def read_body_input
@@ -84,28 +103,26 @@ 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]
+        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
+          body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
+          if body.is_a?(Hash)
+            if (form_hash = env[Rack::RACK_REQUEST_FORM_HASH])
+              form_hash.merge!(body)
+            else
+              env[Rack::RACK_REQUEST_FORM_HASH] = body
             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
 
@@ -116,19 +133,18 @@ 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')
+        return false unless rack_request.post? || rack_request.put? || rack_request.patch? || rack_request.delete?
+        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? || rack_request.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 || query_params['format'] || 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
 
       def format_from_extension

data/lib/grape/middleware/precomputed_content_types.rb

@@ -0,0 +1,46 @@
+# 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 (avoiding
+    # ~1 µs/request of +with_indifferent_access+ recomputation).
+    #
+    # 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
+        mime_types
+        content_types_indifferent_access
+      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_indifferent_access[format]
+      end
+
+      def content_type
+        content_type_for(env[Grape::Env::API_FORMAT] || config.format) || 'text/html'
+      end
+
+      private
+
+      def content_types_indifferent_access
+        @content_types_indifferent_access ||= ActiveSupport::HashWithIndifferentAccess.new(content_types)
+      end
+    end
+  end
+end

data/lib/grape/middleware/stack.rb

@@ -28,6 +28,7 @@ module Grape
             klass == other || (name.nil? && klass.superclass == other)
           end
         end
+        alias eql? ==
 
         def inspect
           klass.to_s
@@ -83,12 +84,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

@@ -30,7 +30,7 @@ module Grape
         private
 
         def not_acceptable!(message)
-          throw :error, status: 406, headers: error_headers, message:
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 406, headers: error_headers, message:)
         end
       end
     end

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

@@ -4,43 +4,43 @@ module Grape
   module Middleware
     module Versioner
       class Base < Grape::Middleware::Base
-        DEFAULT_OPTIONS = {
-          pattern: /.*/i,
-          prefix: nil,
-          mount_path: nil,
-          version_options: {
-            strict: false,
-            cascade: true,
-            parameter: 'apiver',
-            vendor: nil
-          }.freeze
-        }.freeze
+        extend Forwardable
+        include Grape::Middleware::PrecomputedContentTypes
 
-        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
+        Options = Data.define(
+          :content_types, :format, :mount_path, :pattern, :prefix, :version_options, :versions
+        ) do
+          include Grape::Middleware::DeprecatedOptionsHashAccess
 
-        DEFAULT_OPTIONS.each_key do |key|
-          define_method key do
-            options[key]
+          def initialize(
+            content_types: nil, format: nil, mount_path: nil, pattern: /.*/i, prefix: nil,
+            version_options: Grape::DSL::VersionOptions.new, versions: nil
+          )
+            super
           end
         end
 
-        DEFAULT_OPTIONS[:version_options].each_key do |key|
-          define_method key do
-            options[:version_options][key]
-          end
-        end
+        # @deprecated Kept as a frozen Hash representation of the {Options}
+        #   defaults for back-compat. Will be removed in a future release.
+        DEFAULT_OPTIONS = Options.new.to_h.freeze
+
+        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
 
         def self.inherited(klass)
           super
           Versioner.register(klass)
         end
 
-        attr_reader :error_headers, :versions
+        attr_reader :available_media_types, :error_headers, :versions
+
+        def_delegators :config, :mount_path, :pattern, :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 : {}
-          @versions = options[:versions]&.map(&:to_s) # making sure versions are strings to ease potential match
+          @available_media_types = build_available_media_types
         end
 
         def potential_version_match?(potential_version)
@@ -48,27 +48,23 @@ module Grape
         end
 
         def version_not_found!
-          throw :error, status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER
+          throw :error, Grape::Exceptions::ErrorResponse.new(status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER)
         end
 
         private
 
-        def available_media_types
-          @available_media_types ||= begin
-            media_types = []
-            base_media_type = "application/vnd.#{vendor}"
-            content_types.each_key do |extension|
-              versions&.reverse_each do |version|
-                media_types << "#{base_media_type}-#{version}+#{extension}"
-                media_types << "#{base_media_type}-#{version}"
-              end
-              media_types << "#{base_media_type}+#{extension}"
-            end
-
-            media_types << base_media_type
-            media_types.concat(content_types.values.flatten)
-            media_types
+        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