grape 1.8.0 → 4.0.1

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-require 'grape/middleware/versioner/parse_media_type_patch'
-
 module Grape
   module Middleware
     module Versioner
@@ -25,168 +22,86 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        VENDOR_VERSION_HEADER_REGEX =
-          /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.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?
-
-          if media_type || env[Grape::Env::GRAPE_ALLOWED_METHODS]
-            media_type_header_handler
-          elsif headers_contain_wrong_vendor?
-            fail_with_invalid_accept_header!('API vendor not found.')
-          elsif headers_contain_wrong_version?
-            fail_with_invalid_version_header!('API version not found.')
+          match_best_quality_media_type! do |media_type|
+            env.update(
+              Grape::Env::API_TYPE => media_type.type,
+              Grape::Env::API_SUBTYPE => media_type.subtype,
+              Grape::Env::API_VENDOR => media_type.vendor,
+              Grape::Env::API_VERSION => media_type.version,
+              Grape::Env::API_FORMAT => media_type.format
+            )
           end
         end
 
         private
 
-        def strict_header_checks
-          strict_accept_header_presence_check
-          strict_version_vendor_accept_header_presence_check
-        end
-
-        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 if versions.blank? || an_accept_header_with_version_and_vendor_is_present?
-
-          fail_with_invalid_accept_header!('API vendor or version not found.')
-        end
-
-        def an_accept_header_with_version_and_vendor_is_present?
-          header.qvalues.keys.any? do |h|
-            VENDOR_VERSION_HEADER_REGEX.match?(h.sub('application/', ''))
-          end
-        end
+        def match_best_quality_media_type!
+          return unless vendor
 
-        def header
-          @header ||= rack_accept_header
-        end
+          strict_header_checks!
+          media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types)
+          return yield media_type if media_type
 
-        def media_type
-          @media_type ||= header.best_of(available_media_types)
+          fail!
         end
 
-        def media_type_header_handler
-          type, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          env[Grape::Env::API_TYPE] = type
-          env[Grape::Env::API_SUBTYPE] = subtype
-
-          return unless VENDOR_VERSION_HEADER_REGEX =~ subtype
-
-          env[Grape::Env::API_VENDOR] = Regexp.last_match[1]
-          env[Grape::Env::API_VERSION] = Regexp.last_match[2]
-          # weird that Grape::Middleware::Formatter also does this
-          env[Grape::Env::API_FORMAT] = Regexp.last_match[3]
+        def accept_header
+          env['HTTP_ACCEPT']
         end
 
-        def fail_with_invalid_accept_header!(message)
-          raise Grape::Exceptions::InvalidAcceptHeader
-            .new(message, error_headers)
-        end
+        def strict_header_checks!
+          return unless strict
 
-        def fail_with_invalid_version_header!(message)
-          raise Grape::Exceptions::InvalidVersionHeader
-            .new(message, error_headers)
+          accept_header_check!
+          version_and_vendor_check!
         end
 
-        def available_media_types
-          [].tap do |available_media_types|
-            content_types.each_key do |extension|
-              versions.reverse_each do |version|
-                available_media_types << "application/vnd.#{vendor}-#{version}+#{extension}"
-                available_media_types << "application/vnd.#{vendor}-#{version}"
-              end
-              available_media_types << "application/vnd.#{vendor}+#{extension}"
-            end
-
-            available_media_types << "application/vnd.#{vendor}"
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
+        def accept_header_check!
+          return if accept_header.present?
 
-        def headers_contain_wrong_vendor?
-          header.values.all? do |header_value|
-            vendor?(header_value) && request_vendor(header_value) != vendor
-          end
+          invalid_accept_header!('Accept header must be set.')
         end
 
-        def headers_contain_wrong_version?
-          header.values.all? do |header_value|
-            version?(header_value) && versions.exclude?(request_version(header_value))
-          end
-        end
+        def version_and_vendor_check!
+          return if versions.blank? || version_and_vendor?
 
-        def rack_accept_header
-          Rack::Accept::MediaType.new env[Grape::Http::Headers::HTTP_ACCEPT]
-        rescue RuntimeError => e
-          fail_with_invalid_accept_header!(e.message)
+          invalid_accept_header!('API vendor or version not found.')
         end
 
-        def versions
-          options[:versions] || []
+        def q_values_mime_types
+          @q_values_mime_types ||= Rack::Utils.q_values(accept_header).map(&:first)
         end
 
-        def vendor
-          version_options && version_options[:vendor]
+        def version_and_vendor?
+          q_values_mime_types.any? { |mime_type| Grape::Util::MediaType.match?(mime_type) }
         end
 
-        def strict?
-          version_options && version_options[:strict]
+        def invalid_accept_header!(message)
+          raise Grape::Exceptions::InvalidAcceptHeader.new(message, error_headers)
         end
 
-        def version_options
-          options[:version_options]
+        def invalid_version_header!(message)
+          raise Grape::Exceptions::InvalidVersionHeader.new(message, error_headers)
         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 version_options&.key?(:cascade)
-            version_options[:cascade]
-          else
-            true
-          end
-        end
+        def fail!
+          return if env[Grape::Env::GRAPE_ALLOWED_METHODS].present?
 
-        def error_headers
-          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+          media_types = q_values_mime_types.map { |mime_type| Grape::Util::MediaType.parse(mime_type) }
+          vendor_not_found!(media_types) || version_not_found!(media_types)
         end
 
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets a vendor
-        def vendor?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VENDOR_REGEX]
-        end
+        def vendor_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.vendor && media_type.vendor != vendor }
 
-        def request_vendor(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[1]
+          invalid_accept_header!('API vendor not found.')
         end
 
-        def request_version(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.match(VENDOR_VERSION_HEADER_REGEX)[2]
-        end
+        def version_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.version && versions && !versions.include?(media_type.version) }
 
-        # @param [String] media_type a content type
-        # @return [Boolean] whether the content type sets an API version
-        def version?(media_type)
-          _, subtype = Rack::Accept::Header.parse_media_type(media_type)
-          subtype.present? && subtype[HAS_VERSION_REGEX]
+          invalid_version_header!('API version not found.')
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -21,31 +19,12 @@ module Grape
       #
       #   env['api.version'] => 'v1'
       class Param < Base
-        def default_options
-          {
-            version_options: {
-              parameter: 'apiver'
-            }
-          }
-        end
-
         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
-        end
-
-        private
-
-        def paramkey
-          version_options[:parameter] || default_options[:version_options][:parameter]
-        end
+          potential_version = query_params[parameter]
+          return if potential_version.blank?
 
-        def version_options
-          options[:version_options]
+          version_not_found! unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter)
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/middleware/base'
-
 module Grape
   module Middleware
     module Versioner
@@ -19,44 +17,69 @@ module Grape
       #   env['api.version'] => 'v1'
       #
       class Path < Base
-        def default_options
-          {
-            pattern: /.*/i
-          }
+        def initialize(app, **options)
+          super
+          @prefixes = [mount_path, Grape::Util::PathNormalizer.call(prefix)].select { |p| p.present? && p != '/' }.freeze
         end
 
         def before
-          path = env[Grape::Http::Headers::PATH_INFO].dup
-          path.sub!(mount_path, '') if mounted_path?(path)
+          routed = routed_version
+          return env[Grape::Env::API_VERSION] = routed if routed
 
-          if prefix && path.index(prefix) == 0 # rubocop:disable all
-            path.sub!(prefix, '')
-            path = Grape::Router.normalize_path(path)
-          end
+          path_info = env[Grape::Env::GRAPE_NORMALIZED_PATH] || Grape::Util::PathNormalizer.call(env[Rack::PATH_INFO])
+          return if path_info == '/'
 
-          pieces = path.split('/')
-          potential_version = pieces[1]
-          return unless potential_version&.match?(options[:pattern])
+          # `each` rather than `reduce`: Array does not override Enumerable's,
+          # so the generic accumulator path costs more than the work it drives
+          # on a list that holds at most a mount path and a prefix — and most
+          # often nothing at all.
+          @prefixes.each { |prefix| path_info = path_info.delete_prefix(prefix) if path_info.start_with?(prefix) }
 
-          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
+          slash_position = path_info.index('/', 1) # omit the first one
+          return version_from_first_segment(path_info, slash_position) if slash_position
+
+          version_from_only_segment(path_info)
         end
 
         private
 
-        def mounted_path?(path)
-          return false unless mount_path && path.start_with?(mount_path)
+        # Under path versioning every route pattern carries the version as a
+        # named capture (Pattern::Path#build_parts inserts it), constrained to
+        # the declared versions -- so the router has already sliced the segment
+        # out and validated it, and re-deriving it from PATH_INFO would repeat
+        # the normalize, prefix-strip and slice below for the same answer.
+        #
+        # Nil, and the path parsed as before, when there are no routing args at
+        # all (the middleware used outside a Grape router) and for the greedy
+        # routes behind auto-OPTIONS and 405, which capture nothing. An Array
+        # means the route declared a +:version+ segment of its own on top of the
+        # versioning one: Mustermann then reports the capture as every position
+        # it matched rather than the single segment recorded here, so that too
+        # is left to the path parse.
+        def routed_version
+          version = env[Grape::Env::GRAPE_ROUTING_ARGS]&.[](:version)
+          version if version.is_a?(String)
+        end
 
-          rest = path.slice(mount_path.length..-1)
-          rest.start_with?('/') || rest.empty?
+        def version_from_first_segment(path_info, slash_position)
+          potential_version = path_info[1..(slash_position - 1)]
+          version_not_found! unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = potential_version
         end
 
-        def mount_path
-          @mount_path ||= options[:mount_path] && options[:mount_path] != '/' ? options[:mount_path] : ''
+        # The path is a single segment (e.g. `GET /v1` — the root route of a
+        # path-versioned API). Nothing follows to disambiguate a version from a
+        # plain path or from a `.format` suffix (`/v1.json`), so the version is
+        # only recorded on an exact match against the declared versions, and an
+        # unmatched segment is left for the router to resolve — never a 404.
+        def version_from_only_segment(path_info)
+          candidate = path_info[1..]
+          candidate = candidate[0...candidate.rindex('.')] while candidate.include?('.') && !declared_version?(candidate)
+          env[Grape::Env::API_VERSION] = candidate if declared_version?(candidate)
         end
 
-        def prefix
-          Grape::Router.normalize_path(options[:prefix].to_s) if options[:prefix]
+        def declared_version?(candidate)
+          versions.present? && versions.include?(candidate)
         end
       end
     end

data/lib/grape/middleware/versioner.rb

@@ -4,30 +4,23 @@
 # on the requests. The current methods for determining version are:
 #
 #   :header - version from HTTP Accept header.
+#   :accept_version_header - version from HTTP Accept-Version header
 #   :path   - version from uri. e.g. /v1/resource
 #   :param  - version from uri query string, e.g. /v1/resource?apiver=v1
-#
 # See individual classes for details.
 module Grape
   module Middleware
     module Versioner
+      extend Grape::Util::Registry
+
       module_function
 
-      # @param strategy [Symbol] :path, :header or :param
+      # @param strategy [Symbol] :path, :header, :accept_version_header or :param
       # @return a middleware class based on strategy
       def using(strategy)
-        case strategy
-        when :path
-          Path
-        when :header
-          Header
-        when :param
-          Param
-        when :accept_version_header
-          AcceptVersionHeader
-        else
-          raise Grape::Exceptions::InvalidVersionerOption.new(strategy)
-        end
+        raise Grape::Exceptions::InvalidVersionerOption, strategy unless registry.key?(strategy)
+
+        registry[strategy]
       end
     end
   end

data/lib/grape/mountable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grape
+  # Marker module for a mountable Grape application. Both {Grape::API} (the
+  # remountable user-facing class) and {Grape::API::Instance} (the compiled
+  # engine) extend it, so a mounted Grape app can be told apart from a bare
+  # Rack app with `is_a?(Grape::Mountable)` — a single, explicit predicate
+  # rather than duck-typing on an incidental internal method such as
+  # `inheritable_setting`.
+  #
+  # `Grape::API` and `Grape::API::Instance` are not related by inheritance and
+  # do not even respond to the same methods (the former to `mount_instance`,
+  # the latter to `inheritable_setting`/`endpoints`), so there is no common
+  # ancestor to key an `is_a?` check on without this marker.
+  #
+  # It answers identity only ("is this a Grape app?"). Capability checks that
+  # go on to call a stage-specific method — e.g. `respond_to?(:endpoints)`
+  # before reading `endpoints` — must stay as they are, since a `Mountable`
+  # does not necessarily respond to every such method.
+  module Mountable
+  end
+end

data/lib/grape/namespace.rb

@@ -1,45 +1,52 @@
 # frozen_string_literal: true
 
-require 'grape/util/cache'
-
 module Grape
   # A container for endpoints or other namespaces, which allows for both
   # logical grouping of endpoints as well as sharing common configuration.
   # May also be referred to as group, segment, or resource.
   class Namespace
-    attr_reader :space, :options
+    attr_reader :space, :requirements, :options
 
     # @param space [String] the name of this namespace
     # @param options [Hash] options hash
     # @option options :requirements [Hash] param-regex pairs, all of which must
     #   be met by a request's params for all endpoints in this namespace, or
     #   validation will fail and return a 422.
-    def initialize(space, **options)
+    def initialize(space, requirements: nil, **options)
       @space = space.to_s
+      @requirements = requirements
       @options = options
     end
 
-    # Retrieves the requirements from the options hash, if given.
-    # @return [Hash]
-    def requirements
-      options[:requirements] || {}
-    end
-
     # (see ::joined_space_path)
     def self.joined_space(settings)
       settings&.map(&:space)
     end
 
-    # Join the namespaces from a list of settings to create a path prefix.
-    # @param settings [Array] list of Grape::Util::InheritableSettings.
+    def ==(other)
+      other.class == self.class &&
+        other.space == space &&
+        other.requirements == requirements &&
+        other.options == options
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, space, requirements, options].hash
+    end
+
+    # Join the namespaces from a list of Namespace objects to create a path
+    # prefix.
+    # @param settings [Array] list of Grape::Namespace objects.
     def self.joined_space_path(settings)
-      Grape::Router.normalize_path(JoinedSpaceCache[joined_space(settings)])
+      JoinedSpaceCache[joined_space(settings)]
     end
 
     class JoinedSpaceCache < Grape::Util::Cache
       def initialize
+        super
         @cache = Hash.new do |h, joined_space|
-          h[joined_space] = -joined_space.join('/')
+          h[joined_space] = Grape::Util::PathNormalizer.call(joined_space.join('/'))
         end
       end
     end

data/lib/grape/params_builder/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Base
+      class << self
+        def call(_params)
+          raise NotImplementedError
+        end
+
+        private
+
+        def inherited(klass)
+          super
+          ParamsBuilder.register(klass)
+        end
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Hash < Base
+      def self.call(params)
+        params.deep_symbolize_keys
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash_with_indifferent_access.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashWithIndifferentAccess < Base
+      def self.call(params)
+        ActiveSupport::HashWithIndifferentAccess.new(params)
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hashie_mash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashieMash < Base
+      def self.call(params)
+        ::Hashie::Mash.new(params)
+      end
+    end
+  end
+end

data/lib/grape/params_builder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    extend Grape::Util::Registry
+
+    module_function
+
+    def params_builder_for(short_name)
+      raise Grape::Exceptions::UnknownParamsBuilder, short_name unless registry.key?(short_name)
+
+      registry[short_name]
+    end
+  end
+end

data/lib/grape/parser/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Parser.register(klass)
+      end
+    end
+  end
+end

data/lib/grape/parser/json.rb

@@ -2,14 +2,12 @@
 
 module Grape
   module Parser
-    module Json
-      class << self
-        def call(object, _env)
-          ::Grape::Json.load(object)
-        rescue ::Grape::Json::ParseError
-          # handle JSON parsing errors via the rescue handlers or provide error message
-          raise Grape::Exceptions::InvalidMessageBody.new('application/json')
-        end
+    class Json < Base
+      def self.call(object, _env)
+        ::Grape::Json.parse(object)
+      rescue ::Grape::Json::ParseError
+        # handle JSON parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/json')
       end
     end
   end

data/lib/grape/parser/xml.rb

@@ -2,14 +2,12 @@
 
 module Grape
   module Parser
-    module Xml
-      class << self
-        def call(object, _env)
-          ::Grape::Xml.parse(object)
-        rescue ::Grape::Xml::ParseError
-          # handle XML parsing errors via the rescue handlers or provide error message
-          raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
-        end
+    class Xml < Base
+      def self.call(object, _env)
+        ::Grape::Xml.parse(object)
+      rescue ::Grape::Xml::ParseError
+        # handle XML parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
       end
     end
   end