grape 1.5.3 → 1.7.1

data/lib/grape/dsl/settings.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     # Keeps track of settings (implemented as key-value pairs, grouped by
@@ -103,12 +101,14 @@ module Grape
       def namespace_stackable_with_hash(key)
         settings = get_or_set :namespace_stackable, key, nil
         return if settings.blank?
+
         settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
       end
 
       def namespace_reverse_stackable_with_hash(key)
         settings = get_or_set :namespace_reverse_stackable, key, nil
         return if settings.blank?
+
         result = {}
         settings.each do |setting|
           setting.each do |field, value|
@@ -154,10 +154,10 @@ module Grape
 
       # Execute the block within a context where our inheritable settings are forked
       # to a new copy (see #namespace_start).
-      def within_namespace(&_block)
+      def within_namespace(&block)
         namespace_start
 
-        result = yield if block_given?
+        result = yield if block
 
         namespace_end
         reset_validations!
@@ -175,9 +175,7 @@ module Grape
           # +inheritable_setting+, however, it doesn't contain any user-defined settings.
           # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
           # in the chain for every endpoint.
-          if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
-            setting.inherit_from superclass.inheritable_setting
-          end
+          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
         end
       end
     end

data/lib/grape/dsl/validations.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-
 module Grape
   module DSL
     module Validations
@@ -32,7 +30,6 @@ module Grape
           unset_namespace_stackable :declared_params
           unset_namespace_stackable :validations
           unset_namespace_stackable :params
-          unset_description_field :params
         end
 
         # Opens a root-level ParamsScope, defining parameter coercions and
@@ -41,18 +38,6 @@ module Grape
         def params(&block)
           Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
         end
-
-        def document_attribute(names, opts)
-          setting = description_field(:params)
-          setting ||= description_field(:params, {})
-          Array(names).each do |name|
-            full_name = name[:full_name].to_s
-            setting[full_name] ||= {}
-            setting[full_name].merge!(opts)
-
-            namespace_stackable(:params, full_name => opts)
-          end
-        end
       end
     end
   end

data/lib/grape/endpoint.rb

@@ -20,7 +20,8 @@ module Grape
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
-          return @before_each unless block_given?
+          return @before_each unless block
+
           @before_each << block
         else
           @before_each = [new_setup]
@@ -46,9 +47,7 @@ module Grape
       # @return [Proc]
       # @raise [NameError] an instance method with the same name already exists
       def generate_api_method(method_name, &block)
-        if method_defined?(method_name)
-          raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
-        end
+        raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name") if method_defined?(method_name)
 
         define_method(method_name, &block)
         method = instance_method(method_name)
@@ -106,7 +105,7 @@ module Grape
       @body = nil
       @proc = nil
 
-      return unless block_given?
+      return unless block
 
       @source = block
       @block = self.class.generate_api_method(method_name, &block)
@@ -118,11 +117,9 @@ module Grape
       inheritable_setting.route[:saved_validations] += namespace_stackable[:validations]
       parent_declared_params = namespace_stackable[:declared_params]
 
-      if parent_declared_params
-        inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten)
-      end
+      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params
 
-      endpoints && endpoints.each { |e| e.inherit_settings(namespace_stackable) }
+      endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
     end
 
     def require_option(options, key)
@@ -142,7 +139,7 @@ module Grape
     end
 
     def reset_routes!
-      endpoints.each(&:reset_routes!) if endpoints
+      endpoints&.each(&:reset_routes!)
       @namespace = nil
       @routes = nil
     end
@@ -154,13 +151,9 @@ module Grape
         reset_routes!
         routes.each do |route|
           methods = [route.request_method]
-          if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
-            methods << Grape::Http::Headers::HEAD
-          end
+          methods << Grape::Http::Headers::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
           methods.each do |method|
-            unless route.request_method == method
-              route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h)
-            end
+            route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h) unless route.request_method == method
             router.append(route.apply(self))
           end
         end
@@ -200,6 +193,7 @@ module Grape
     def prepare_version
       version = namespace_inheritable(:version) || []
       return if version.empty?
+
       version.length == 1 ? version.first.to_s : version
     end
 
@@ -234,7 +228,7 @@ module Grape
     # Return the collection of endpoints within this endpoint.
     # This is the case when an Grape::API mounts another Grape::API.
     def endpoints
-      options[:app].endpoints if options[:app] && options[:app].respond_to?(:endpoints)
+      options[:app].endpoints if options[:app].respond_to?(:endpoints)
     end
 
     def equals?(e)
@@ -256,13 +250,13 @@ module Grape
 
           if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
             raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allowed_methods)) unless options?
+
             header 'Allow', allowed_methods
             response_object = ''
             status 204
           else
             run_filters before_validations, :before_validation
             run_validators validations, request
-            remove_renamed_params
             run_filters after_validations, :after_validation
             response_object = execute
           end
@@ -305,7 +299,7 @@ module Grape
 
       if namespace_inheritable(:version)
         stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-                  versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil,
+                  versions: namespace_inheritable(:version)&.flatten,
                   version_options: namespace_inheritable(:version_options),
                   prefix: namespace_inheritable(:root_prefix),
                   mount_path: namespace_stackable(:mount_path).first
@@ -328,17 +322,10 @@ module Grape
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
-    def remove_renamed_params
-      return unless route_setting(:renamed_params)
-      route_setting(:renamed_params).flat_map(&:keys).each do |renamed_param|
-        @params.delete(renamed_param)
-      end
-    end
-
-    private :build_stack, :build_helpers, :remove_renamed_params
+    private :build_stack, :build_helpers
 
     def execute
-      @block ? @block.call(self) : nil
+      @block&.call(self)
     end
 
     def helpers
@@ -365,15 +352,13 @@ module Grape
 
       ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
         validators.each do |validator|
-          begin
-            validator.validate(request)
-          rescue Grape::Exceptions::Validation => e
-            validation_errors << e
-            break if validator.fail_fast?
-          rescue Grape::Exceptions::ValidationArrayErrors => e
-            validation_errors.concat e.errors
-            break if validator.fail_fast?
-          end
+          validator.validate(request)
+        rescue Grape::Exceptions::Validation => e
+          validation_errors << e
+          break if validator.fail_fast?
+        rescue Grape::Exceptions::ValidationArrayErrors => e
+          validation_errors.concat e.errors
+          break if validator.fail_fast?
         end
       end
 

data/lib/grape/error_formatter/json.rb

@@ -10,12 +10,8 @@ module Grape
           result = wrap_message(present(message, env))
 
           rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result = result.merge(backtrace: backtrace)
-          end
-          if rescue_options[:original_exception] && original_exception
-            result = result.merge(original_exception: original_exception.inspect)
-          end
+          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
+          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
           ::Grape::Json.dump(result)
         end
 
@@ -25,9 +21,15 @@ module Grape
           if message.is_a?(Exceptions::ValidationErrors) || message.is_a?(Hash)
             message
           else
-            { error: message }
+            { error: ensure_utf8(message) }
           end
         end
+
+        def ensure_utf8(message)
+          return message unless message.respond_to? :encode
+
+          message.encode('UTF-8', invalid: :replace, undef: :replace)
+        end
       end
     end
   end

data/lib/grape/error_formatter/xml.rb

@@ -11,12 +11,8 @@ module Grape
 
           result = message.is_a?(Hash) ? message : { message: message }
           rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result = result.merge(backtrace: backtrace)
-          end
-          if rescue_options[:original_exception] && original_exception
-            result = result.merge(original_exception: original_exception.inspect)
-          end
+          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
+          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
           result.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s
         end
       end

data/lib/grape/exceptions/base.rb

@@ -7,11 +7,12 @@ module Grape
       BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'
       FALLBACK_LOCALE = :en
 
-      attr_reader :status, :message, :headers
+      attr_reader :status, :headers
 
       def initialize(status: nil, message: nil, headers: nil, **_options)
+        super(message)
+
         @status  = status
-        @message = message
         @headers = headers
       end
 

data/lib/grape/exceptions/missing_group_type.rb

@@ -2,10 +2,17 @@
 
 module Grape
   module Exceptions
-    class MissingGroupTypeError < Base
+    class MissingGroupType < Base
       def initialize
         super(message: compose_message(:missing_group_type))
       end
     end
   end
 end
+
+Grape::Exceptions::MissingGroupTypeError = Class.new(Grape::Exceptions::MissingGroupType) do
+  def initialize(*)
+    super
+    warn '[DEPRECATION] `Grape::Exceptions::MissingGroupTypeError` is deprecated. Use `Grape::Exceptions::MissingGroupType` instead.'
+  end
+end

data/lib/grape/exceptions/too_many_multipart_files.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class TooManyMultipartFiles < Base
+      def initialize(limit)
+        super(message: compose_message(:too_many_multipart_files, limit: limit), status: 413)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unsupported_group_type.rb

@@ -2,10 +2,17 @@
 
 module Grape
   module Exceptions
-    class UnsupportedGroupTypeError < Base
+    class UnsupportedGroupType < Base
       def initialize
         super(message: compose_message(:unsupported_group_type))
       end
     end
   end
 end
+
+Grape::Exceptions::UnsupportedGroupTypeError = Class.new(Grape::Exceptions::UnsupportedGroupType) do
+  def initialize(*)
+    super
+    warn '[DEPRECATION] `Grape::Exceptions::UnsupportedGroupTypeError` is deprecated. Use `Grape::Exceptions::UnsupportedGroupType` instead.'
+  end
+end

data/lib/grape/exceptions/validation.rb

@@ -5,8 +5,7 @@ require 'grape/exceptions/base'
 module Grape
   module Exceptions
     class Validation < Grape::Exceptions::Base
-      attr_accessor :params
-      attr_accessor :message_key
+      attr_accessor :params, :message_key
 
       def initialize(params:, message: nil, **args)
         @params = params
@@ -22,10 +21,6 @@ module Grape
       def as_json(*_args)
         to_s
       end
-
-      def to_s
-        message
-      end
     end
   end
 end

data/lib/grape/formatter/json.rb

@@ -6,6 +6,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_json if object.respond_to?(:to_json)
+
           ::Grape::Json.dump(object)
         end
       end

data/lib/grape/formatter/serializable_hash.rb

@@ -8,13 +8,14 @@ module Grape
           return object if object.is_a?(String)
           return ::Grape::Json.dump(serialize(object)) if serializable?(object)
           return object.to_json if object.respond_to?(:to_json)
+
           ::Grape::Json.dump(object)
         end
 
         private
 
         def serializable?(object)
-          object.respond_to?(:serializable_hash) || object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash } || object.is_a?(Hash)
+          object.respond_to?(:serializable_hash) || (object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash }) || object.is_a?(Hash)
         end
 
         def serialize(object)

data/lib/grape/formatter/xml.rb

@@ -6,6 +6,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_xml if object.respond_to?(:to_xml)
+
           raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
         end
       end

data/lib/grape/locale/en.yml

@@ -11,8 +11,8 @@ en:
         except_values: 'has a value not allowed'
         same_as: 'is not the same as %{parameter}'
         missing_vendor_option:
-          problem: 'missing :vendor option.'
-          summary: 'when version using header, you must specify :vendor option. '
+          problem: 'missing :vendor option'
+          summary: 'when version using header, you must specify :vendor option'
           resolution: "eg: version 'v1', using: :header, vendor: 'twitter'"
         missing_mime_type:
           problem: 'missing mime type for %{new_format}'
@@ -21,12 +21,12 @@ en:
             or add your own with content_type :%{new_format}, 'application/%{new_format}'
             "
         invalid_with_option_for_represent:
-          problem: 'You must specify an entity class in the :with option.'
+          problem: 'you must specify an entity class in the :with option'
           resolution: 'eg: represent User, :with => Entity::User'
-        missing_option: 'You must specify :%{option} options.'
+        missing_option: 'you must specify :%{option} options'
         invalid_formatter: 'cannot convert %{klass} to %{to_format}'
         invalid_versioner_option:
-          problem: 'Unknown :using for versioner: %{strategy}'
+          problem: 'unknown :using for versioner: %{strategy}'
           resolution: 'available strategy for :using is :path, :header, :accept_version_header, :param'
         unknown_validator: 'unknown validator: %{validator_type}'
         unknown_options: 'unknown options: %{options}'
@@ -44,11 +44,12 @@ en:
             "when specifying %{body_format} as content-type, you must pass valid
             %{body_format} in the request's 'body'
             "
-        empty_message_body: 'Empty message body supplied with %{body_format} content-type'
+        empty_message_body: 'empty message body supplied with %{body_format} content-type'
+        too_many_multipart_files: "the number of uploaded files exceeded the system's configured limit (%{limit})"
         invalid_accept_header:
-          problem: 'Invalid accept header'
+          problem: 'invalid accept header'
           resolution: '%{message}'
         invalid_version_header:
-          problem: 'Invalid version header'
+          problem: 'invalid version header'
           resolution: '%{message}'
         invalid_response: 'Invalid response'

data/lib/grape/middleware/auth/dsl.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rack/auth/basic'
-require 'active_support/concern'
 
 module Grape
   module Middleware
@@ -32,7 +31,13 @@ module Grape
 
           def http_digest(options = {}, &block)
             options[:realm] ||= 'API Authorization'
-            options[:opaque] ||= 'secret'
+
+            if options[:realm].respond_to?(:values_at)
+              options[:realm][:opaque] ||= 'secret'
+            else
+              options[:opaque] ||= 'secret'
+            end
+
             auth :http_digest, options, &block
           end
         end

data/lib/grape/middleware/base.rb

@@ -59,7 +59,8 @@ module Grape
 
       def response
         return @app_response if @app_response.is_a?(Rack::Response)
-        Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
+
+        @app_response = Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
       def content_type_for(format)
@@ -84,6 +85,7 @@ module Grape
 
       def merge_headers(response)
         return unless headers.is_a?(Hash)
+
         case response
         when Rack::Response then response.headers.merge!(headers)
         when Array          then response[1].merge!(headers)

data/lib/grape/middleware/error.rb

@@ -72,7 +72,7 @@ module Grape
 
       def rack_response(message, status = options[:default_status], headers = { Grape::Http::Headers::CONTENT_TYPE => content_type })
         message = ERB::Util.html_escape(message) if headers[Grape::Http::Headers::CONTENT_TYPE] == TEXT_HTML
-        Rack::Response.new([message], status, headers)
+        Rack::Response.new([message], Rack::Utils.status_code(status), headers)
       end
 
       def format_message(message, backtrace, original_exception = nil)
@@ -121,7 +121,7 @@ module Grape
 
       def run_rescue_handler(handler, error)
         if handler.instance_of?(Symbol)
-          raise NoMethodError, "undefined method `#{handler}'" unless respond_to?(handler)
+          raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
 
           handler = public_method(handler)
         end

data/lib/grape/middleware/formatter.rb

@@ -22,6 +22,7 @@ module Grape
 
       def after
         return unless @app_response
+
         status, headers, bodies = *@app_response
 
         if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
@@ -79,7 +80,7 @@ module Grape
           (request.post? || request.put? || request.patch? || request.delete?) &&
           (!request.form_data? || !request.media_type) &&
           !request.parseable_data? &&
-          (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
+          (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
 
         return unless (input = env[Grape::Env::RACK_INPUT])
 
@@ -96,9 +97,7 @@ module Grape
       def read_rack_input(body)
         fmt = request.media_type ? mime_types[request.media_type] : options[:default_format]
 
-        unless content_type_for(fmt)
-          throw :error, status: 415, message: "The provided content-type '#{request.media_type}' is not supported."
-        end
+        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
@@ -145,6 +144,7 @@ module Grape
         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)
+
         fmt
       end
 

data/lib/grape/middleware/stack.rb

@@ -45,8 +45,8 @@ module Grape
         @others = []
       end
 
-      def each
-        @middlewares.each { |x| yield x }
+      def each(&block)
+        @middlewares.each(&block)
       end
 
       def size
@@ -95,7 +95,7 @@ module Grape
 
       # @return [Rack::Builder] the builder object with our middlewares applied
       def build(builder = Rack::Builder.new)
-        others.shift(others.size).each(&method(:merge_with))
+        others.shift(others.size).each { |m| merge_with(m) }
         middlewares.each do |m|
           m.use_in(builder)
         end

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

@@ -22,11 +22,9 @@ module Grape
         def before
           potential_version = (env[Grape::Http::Headers::HTTP_ACCEPT_VERSION] || '').strip
 
-          if strict?
+          if strict? && potential_version.empty?
             # If no Accept-Version header:
-            if potential_version.empty?
-              throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
-            end
+            throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
           end
 
           return if potential_version.empty?
@@ -51,7 +49,7 @@ module Grape
         # 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] && options[:version_options].key?(:cascade)
+          if options[:version_options]&.key?(:cascade)
             options[:version_options][:cascade]
           else
             true

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

@@ -26,10 +26,10 @@ module Grape
       # route.
       class Header < Base
         VENDOR_VERSION_HEADER_REGEX =
-          /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
+          /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
 
-        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#\$&\^]+/.freeze
-        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))+/.freeze
+        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#{Regexp.last_match(0)}\^]+/.freeze
+        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))+/.freeze
 
         def before
           strict_header_checks if strict?
@@ -52,12 +52,14 @@ module Grape
 
         def strict_accept_header_presence_check
           return unless header.qvalues.empty?
+
           fail_with_invalid_accept_header!('Accept header must be set.')
         end
 
         def strict_version_vendor_accept_header_presence_check
           return unless versions.present?
           return if an_accept_header_with_version_and_vendor_is_present?
+
           fail_with_invalid_accept_header!('API vendor or version not found.')
         end
 
@@ -160,7 +162,7 @@ module Grape
         # information). To prevent # this behavior, and not add the `X-Cascade`
         # header, one can set the `:cascade` option to `false`.
         def cascade?
-          if version_options && version_options.key?(:cascade)
+          if version_options&.key?(:cascade)
             version_options[:cascade]
           else
             true

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

@@ -32,6 +32,7 @@ module Grape
         def before
           potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
           return if potential_version.nil?
+
           throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
           env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require 'English'
 module Rack
   module Accept
     module Header
-      ALLOWED_CHARACTERS = %r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$}.freeze
+      ALLOWED_CHARACTERS = %r{^([a-z*]+)/([a-z0-9*&\^\-_#{$ERROR_INFO}.+]+)(?:;([a-z0-9=;]+))?$}.freeze
       class << self
         # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44
         def parse_media_type(media_type)

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

@@ -37,6 +37,7 @@ module Grape
           pieces = path.split('/')
           potential_version = pieces[1]
           return unless potential_version&.match?(options[:pattern])
+
           throw :error, status: 404, message: '404 API Version Not Found' if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
         end
@@ -45,6 +46,7 @@ module Grape
 
         def mounted_path?(path)
           return false unless mount_path && path.start_with?(mount_path)
+
           rest = path.slice(mount_path.length..-1)
           rest.start_with?('/') || rest.empty?
         end