grape 2.1.0 → 2.2.0

data/lib/grape/middleware/base.rb

@@ -4,18 +4,17 @@ module Grape
   module Middleware
     class Base
       include Helpers
+      include Grape::DSL::Headers
 
       attr_reader :app, :env, :options
 
       TEXT_HTML = 'text/html'
 
-      include Grape::DSL::Headers
-
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
       def initialize(app, *options)
         @app = app
-        @options = options.any? ? default_options.merge(options.shift) : default_options
+        @options = options.any? ? default_options.deep_merge(options.shift) : default_options
         @app_response = nil
       end
 
@@ -61,22 +60,20 @@ module Grape
         @app_response = Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
-      def content_type_for(format)
-        HashWithIndifferentAccess.new(content_types)[format]
+      def content_types
+        @content_types ||= Grape::ContentTypes.content_types_for(options[:content_types])
       end
 
-      def content_types
-        ContentTypes.content_types_for(options[:content_types])
+      def mime_types
+        @mime_types ||= Grape::ContentTypes.mime_types_for(content_types)
       end
 
-      def content_type
-        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || TEXT_HTML
+      def content_type_for(format)
+        content_types_indifferent_access[format]
       end
 
-      def mime_types
-        @mime_type ||= content_types.each_pair.with_object({}) do |(k, v), types_without_params|
-          types_without_params[v.split(';').first] = k
-        end
+      def content_type
+        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || TEXT_HTML
       end
 
       private
@@ -89,6 +86,10 @@ module Grape
         when Array          then response[1].merge!(headers)
         end
       end
+
+      def content_types_indifferent_access
+        @content_types_indifferent_access ||= content_types.with_indifferent_access
+      end
     end
   end
 end

data/lib/grape/middleware/error.rb

@@ -26,7 +26,7 @@ module Grape
 
       def initialize(app, *options)
         super
-        self.class.send(:include, @options[:helpers]) if @options[:helpers]
+        self.class.include(@options[:helpers]) if @options[:helpers]
       end
 
       def call!(env)
@@ -45,7 +45,7 @@ module Grape
 
       def format_message(message, backtrace, original_exception = nil)
         format = env[Grape::Env::API_FORMAT] || options[:format]
-        formatter = Grape::ErrorFormatter.formatter_for(format, **options)
+        formatter = Grape::ErrorFormatter.formatter_for(format, options[:error_formatters], options[:default_error_formatter])
         return formatter.call(message, backtrace, options, env, original_exception) if formatter
 
         throw :error,
@@ -74,12 +74,12 @@ module Grape
         rack_response(status, headers, format_message(message, backtrace, original_exception))
       end
 
-      def default_rescue_handler(e)
-        error_response(message: e.message, backtrace: e.backtrace, original_exception: e)
+      def default_rescue_handler(exception)
+        error_response(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 }
+        error, handler = options[:base_only_rescue_handlers]&.find { |err, _handler| klass == err }
 
         return unless error
 
@@ -87,7 +87,7 @@ module Grape
       end
 
       def rescue_handler_for_class_or_its_ancestor(klass)
-        error, handler = options[:rescue_handlers].find { |err, _handler| klass <= err }
+        error, handler = options[:rescue_handlers]&.find { |err, _handler| klass <= err }
 
         return unless error
 
@@ -120,12 +120,12 @@ module Grape
           handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
         end
 
-        response = error!(response[:message], response[:status], response[:headers]) if error?(response)
-
-        if response.is_a?(Rack::Response)
+        if error?(response)
+          error_response(response)
+        elsif response.is_a?(Rack::Response)
           response
         else
-          run_rescue_handler(:default_rescue_handler, Grape::Exceptions::InvalidResponse.new, endpoint)
+          run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
         end
       end
 
@@ -137,7 +137,9 @@ module Grape
       end
 
       def error?(response)
-        response.is_a?(Hash) && response[:message] && response[:status] && response[:headers]
+        return false unless response.is_a?(Hash)
+
+        response.key?(:message) && response.key?(:status) && response.key?(:headers)
       end
     end
   end

data/lib/grape/middleware/formatter.rb

@@ -54,7 +54,7 @@ module Grape
 
       def fetch_formatter(headers, options)
         api_format = mime_types[headers[Rack::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
-        Grape::Formatter.formatter_for(api_format, **options)
+        Grape::Formatter.formatter_for(api_format, options[:formatters])
       end
 
       # Set the content type header for the API format if it is not already present.
@@ -97,7 +97,7 @@ module Grape
         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
+        parser = Grape::Parser.parser_for fmt, options[:parsers]
         if parser
           begin
             body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))

data/lib/grape/middleware/stack.rb

@@ -57,8 +57,8 @@ module Grape
         middlewares.last
       end
 
-      def [](i)
-        middlewares[i]
+      def [](index)
+        middlewares[index]
       end
 
       def insert(index, *args, &block)

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

@@ -17,45 +17,22 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # 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
+        include VersionerHelpers
 
-          return if potential_version.empty?
+        def before
+          potential_version = env[Grape::Http::Headers::HTTP_ACCEPT_VERSION]&.strip
+          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, status: 406, headers: error_headers, message: message
         end
       end
     end

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

@@ -22,17 +22,10 @@ module Grape
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
+        include VersionerHelpers
+
         def before
-          handler = Grape::Util::AcceptHeaderHandler.new(
-            accept_header: env[Grape::Http::Headers::HTTP_ACCEPT],
-            versions: options[:versions],
-            **options.fetch(:version_options) { {} }
-          )
-
-          handler.match_best_quality_media_type!(
-            content_types: content_types,
-            allowed_methods: env[Grape::Env::GRAPE_ALLOWED_METHODS]
-          ) do |media_type|
+          match_best_quality_media_type! do |media_type|
             env.update(
               Grape::Env::API_TYPE => media_type.type,
               Grape::Env::API_SUBTYPE => media_type.subtype,
@@ -42,6 +35,98 @@ module Grape
             )
           end
         end
+
+        private
+
+        def match_best_quality_media_type!
+          return unless vendor
+
+          strict_header_checks!
+          media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types)
+          if media_type
+            yield media_type
+          else
+            fail!(allowed_methods)
+          end
+        end
+
+        def allowed_methods
+          env[Grape::Env::GRAPE_ALLOWED_METHODS]
+        end
+
+        def accept_header
+          env[Grape::Http::Headers::HTTP_ACCEPT]
+        end
+
+        def strict_header_checks!
+          return unless strict?
+
+          accept_header_check!
+          version_and_vendor_check!
+        end
+
+        def accept_header_check!
+          return if accept_header.present?
+
+          invalid_accept_header!('Accept header must be set.')
+        end
+
+        def version_and_vendor_check!
+          return if versions.blank? || version_and_vendor?
+
+          invalid_accept_header!('API vendor or version not found.')
+        end
+
+        def q_values_mime_types
+          @q_values_mime_types ||= Rack::Utils.q_values(accept_header).map(&:first)
+        end
+
+        def version_and_vendor?
+          q_values_mime_types.any? { |mime_type| Grape::Util::MediaType.match?(mime_type) }
+        end
+
+        def invalid_accept_header!(message)
+          raise Grape::Exceptions::InvalidAcceptHeader.new(message, error_headers)
+        end
+
+        def invalid_version_header!(message)
+          raise Grape::Exceptions::InvalidVersionHeader.new(message, error_headers)
+        end
+
+        def fail!(grape_allowed_methods)
+          return grape_allowed_methods if grape_allowed_methods.present?
+
+          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
+
+        def vendor_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.vendor && media_type.vendor != vendor }
+
+          invalid_accept_header!('API vendor not found.')
+        end
+
+        def version_not_found!(media_types)
+          return unless media_types.all? { |media_type| media_type&.version && versions&.exclude?(media_type.version) }
+
+          invalid_version_header!('API version not found.')
+        end
+
+        def available_media_types
+          [].tap do |available_media_types|
+            base_media_type = "application/vnd.#{vendor}"
+            content_types.each_key do |extension|
+              versions&.reverse_each do |version|
+                available_media_types << "#{base_media_type}-#{version}+#{extension}"
+                available_media_types << "#{base_media_type}-#{version}"
+              end
+              available_media_types << "#{base_media_type}+#{extension}"
+            end
+
+            available_media_types << base_media_type
+            available_media_types.concat(content_types.values.flatten)
+          end
+        end
       end
     end
   end

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

@@ -19,31 +19,15 @@ module Grape
       #
       #   env['api.version'] => 'v1'
       class Param < Base
-        def default_options
-          {
-            version_options: {
-              parameter: 'apiver'
-            }
-          }
-        end
+        include VersionerHelpers
 
         def before
-          potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[paramkey]
-          return if potential_version.nil?
+          potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[parameter_key]
+          return if potential_version.blank?
 
-          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 }
+          version_not_found! unless potential_version_match?(potential_version)
           env[Grape::Env::API_VERSION] = potential_version
-          env[Rack::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Rack::RACK_REQUEST_QUERY_HASH
-        end
-
-        private
-
-        def paramkey
-          version_options[:parameter] || default_options[:version_options][:parameter]
-        end
-
-        def version_options
-          options[:version_options]
+          env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter_key) if env.key? Rack::RACK_REQUEST_QUERY_HASH
         end
       end
     end

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

@@ -17,44 +17,24 @@ module Grape
       #   env['api.version'] => 'v1'
       #
       class Path < Base
-        def default_options
-          {
-            pattern: /.*/i
-          }
-        end
+        include VersionerHelpers
 
         def before
-          path = env[Rack::PATH_INFO].dup
-          path.sub!(mount_path, '') if mounted_path?(path)
+          path_info = Grape::Router.normalize_path(env[Rack::PATH_INFO])
+          return if path_info == '/'
 
-          if prefix && path.index(prefix) == 0 # rubocop:disable all
-            path.sub!(prefix, '')
-            path = Grape::Router.normalize_path(path)
+          [mount_path, Grape::Router.normalize_path(prefix)].each do |path|
+            path_info.delete_prefix!(path) if path.present? && path != '/' && path_info.start_with?(path)
           end
 
-          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
-
-        private
+          slash_position = path_info.index('/', 1) # omit the first one
+          return unless slash_position
 
-        def mounted_path?(path)
-          return false unless mount_path && path.start_with?(mount_path)
+          potential_version = path_info[1..slash_position - 1]
+          return unless potential_version.match?(pattern)
 
-          rest = path.slice(mount_path.length..-1)
-          rest.start_with?('/') || rest.empty?
-        end
-
-        def mount_path
-          @mount_path ||= options[:mount_path] && options[:mount_path] != '/' ? options[:mount_path] : ''
-        end
-
-        def prefix
-          Grape::Router.normalize_path(options[:prefix].to_s) if options[:prefix]
+          version_not_found! unless potential_version_match?(potential_version)
+          env[Grape::Env::API_VERSION] = potential_version
         end
       end
     end

data/lib/grape/middleware/versioner.rb

@@ -4,30 +4,21 @@
 # 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
       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
+        Grape::Middleware::Versioner.const_get(:"#{strategy.to_s.camelize}")
+      rescue NameError
+        raise Grape::Exceptions::InvalidVersionerOption, strategy
       end
     end
   end

data/lib/grape/middleware/versioner_helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module VersionerHelpers
+      DEFAULT_PATTERN = /.*/i.freeze
+      DEFAULT_PARAMETER = 'apiver'
+
+      def default_options
+        {
+          versions: nil,
+          prefix: nil,
+          mount_path: nil,
+          pattern: DEFAULT_PATTERN,
+          version_options: {
+            strict: false,
+            cascade: true,
+            parameter: DEFAULT_PARAMETER
+          }
+        }
+      end
+
+      def versions
+        options[:versions]
+      end
+
+      def prefix
+        options[:prefix]
+      end
+
+      def mount_path
+        options[:mount_path]
+      end
+
+      def pattern
+        options[:pattern]
+      end
+
+      def version_options
+        options[:version_options]
+      end
+
+      def strict?
+        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?
+        version_options[:cascade]
+      end
+
+      def parameter_key
+        version_options[:parameter]
+      end
+
+      def vendor
+        version_options[:vendor]
+      end
+
+      def error_headers
+        cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+      end
+
+      def potential_version_match?(potential_version)
+        versions.blank? || versions.any? { |v| v.to_s == potential_version }
+      end
+
+      def version_not_found!
+        throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
+      end
+    end
+  end
+end

data/lib/grape/parser.rb

@@ -2,32 +2,16 @@
 
 module Grape
   module Parser
-    extend Util::Registrable
+    module_function
 
-    class << self
-      def builtin_parsers
-        @builtin_parsers ||= {
-          json: Grape::Parser::Json,
-          jsonapi: Grape::Parser::Json,
-          xml: Grape::Parser::Xml
-        }
-      end
+    DEFAULTS = {
+      json: Grape::Parser::Json,
+      jsonapi: Grape::Parser::Json,
+      xml: Grape::Parser::Xml
+    }.freeze
 
-      def parsers(**options)
-        builtin_parsers.merge(default_elements).merge!(options[:parsers] || {})
-      end
-
-      def parser_for(api_format, **options)
-        spec = parsers(**options)[api_format]
-        case spec
-        when nil
-          nil
-        when Symbol
-          method(spec)
-        else
-          spec
-        end
-      end
+    def parser_for(format, parsers = nil)
+      parsers&.key?(format) ? parsers[format] : DEFAULTS[format]
     end
   end
 end

data/lib/grape/router.rb

@@ -138,7 +138,8 @@ module Grape
     end
 
     def default_response
-      [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']]
+      headers = Grape::Util::Header.new.merge(Grape::Http::Headers::X_CASCADE => 'pass')
+      [404, headers, ['404 Not Found']]
     end
 
     def match?(input, method)

data/lib/grape/validations/attributes_iterator.rb

@@ -21,6 +21,7 @@ module Grape
       private
 
       def do_each(params_to_process, parent_indicies = [], &block)
+        @scope.reset_index # gets updated depending on the size of params_to_process
         params_to_process.each_with_index do |resource_params, index|
           # when we get arrays of arrays it means that target element located inside array
           # we need this because we want to know parent arrays indicies

data/lib/grape/validations/params_scope.rb

@@ -93,9 +93,7 @@ module Grape
 
       def meets_dependency?(params, request_params)
         return true unless @dependent_on
-
         return false if @parent.present? && !@parent.meets_dependency?(@parent.params(request_params), request_params)
-
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
 
         meets_hash_dependency?(params)
@@ -103,7 +101,6 @@ module Grape
 
       def attr_meets_dependency?(params)
         return true unless @dependent_on
-
         return false if @parent.present? && !@parent.attr_meets_dependency?(params)
 
         meets_hash_dependency?(params)
@@ -169,6 +166,10 @@ module Grape
         !@optional
       end
 
+      def reset_index
+        @index = nil
+      end
+
       protected
 
       # Adds a parameter declaration to our list of validations.
@@ -189,7 +190,13 @@ module Grape
       #
       # @return [Array<Symbol>] the nesting/path of the current parameter scope
       def full_path
-        nested? ? @parent.full_path + [@element] : []
+        if nested?
+          (@parent.full_path + [@element])
+        elsif lateral?
+          @parent.full_path
+        else
+          []
+        end
       end
 
       private
@@ -297,12 +304,7 @@ module Grape
       #   `optional` invocation that opened this scope.
       # @yield parameter scope
       def new_group_scope(attrs, &block)
-        self.class.new(
-          api: @api,
-          parent: self,
-          group: attrs.first,
-          &block
-        )
+        self.class.new(api: @api, parent: self, group: attrs.first, &block)
       end
 
       # Pushes declared params to parent or settings

data/lib/grape/validations/validators/exactly_one_of_validator.rb

@@ -7,7 +7,7 @@ module Grape
         def validate_params!(params)
           keys = keys_in_common(params)
           return if keys.length == 1
-          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.empty?
 
           raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
         end