grape 2.1.3 → 2.3.0

data/lib/grape/formatter/txt.rb

@@ -2,11 +2,9 @@
 
 module Grape
   module Formatter
-    module Txt
-      class << self
-        def call(object, _env)
-          object.respond_to?(:to_txt) ? object.to_txt : object.to_s
-        end
+    class Txt < Base
+      def self.call(object, _env)
+        object.respond_to?(:to_txt) ? object.to_txt : object.to_s
       end
     end
   end

data/lib/grape/formatter/xml.rb

@@ -2,13 +2,11 @@
 
 module Grape
   module Formatter
-    module Xml
-      class << self
-        def call(object, _env)
-          return object.to_xml if object.respond_to?(:to_xml)
+    class Xml < Base
+      def self.call(object, _env)
+        return object.to_xml if object.respond_to?(:to_xml)
 
-          raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
-        end
+        raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
       end
     end
   end

data/lib/grape/formatter.rb

@@ -2,34 +2,16 @@
 
 module Grape
   module Formatter
-    extend Util::Registrable
+    extend Grape::Util::Registry
 
-    class << self
-      def builtin_formatters
-        @builtin_formatters ||= {
-          json: Grape::Formatter::Json,
-          jsonapi: Grape::Formatter::Json,
-          serializable_hash: Grape::Formatter::SerializableHash,
-          txt: Grape::Formatter::Txt,
-          xml: Grape::Formatter::Xml
-        }
-      end
+    module_function
 
-      def formatters(**options)
-        builtin_formatters.merge(default_elements).merge!(options[:formatters] || {})
-      end
+    DEFAULT_LAMBDA_FORMATTER = ->(obj, _env) { obj }
 
-      def formatter_for(api_format, **options)
-        spec = formatters(**options)[api_format]
-        case spec
-        when nil
-          ->(obj, _env) { obj }
-        when Symbol
-          method(spec)
-        else
-          spec
-        end
-      end
+    def formatter_for(api_format, formatters)
+      return formatters[api_format] if formatters&.key?(api_format)
+
+      registry[api_format] || DEFAULT_LAMBDA_FORMATTER
     end
   end
 end

data/lib/grape/http/headers.rb

@@ -6,6 +6,7 @@ module Grape
       HTTP_ACCEPT_VERSION = 'HTTP_ACCEPT_VERSION'
       HTTP_ACCEPT = 'HTTP_ACCEPT'
       HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
+      HTTP_VERSION = 'HTTP_VERSION'
 
       ALLOW = 'Allow'
       LOCATION = 'Location'

data/lib/grape/locale/en.yml

@@ -11,6 +11,7 @@ en:
         except_values: 'has a value not allowed'
         same_as: 'is not the same as %{parameter}'
         length: 'is expected to have length within %{min} and %{max}'
+        length_is: 'is expected to have length exactly equal to %{is}'
         length_min: 'is expected to have length greater than or equal to %{min}'
         length_max: 'is expected to have length less than or equal to %{max}'
         missing_vendor_option:

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_types ||= 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,
@@ -65,6 +65,7 @@ module Grape
 
       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)
@@ -79,7 +80,7 @@ module Grape
       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 +88,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,16 +121,17 @@ 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
 
       def error!(message, status = options[: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)
@@ -137,7 +139,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

@@ -53,8 +53,8 @@ module Grape
       end
 
       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)
+        api_format = env.fetch(Grape::Env::API_FORMAT) { mime_types[headers[Rack::CONTENT_TYPE]] }
+        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/versioner/accept_version_header.rb

@@ -18,44 +18,21 @@ module Grape
       # route.
       class AcceptVersionHeader < Base
         def before
-          potential_version = (env[Grape::Http::Headers::HTTP_ACCEPT_VERSION] || '').strip
+          potential_version = env[Grape::Http::Headers::HTTP_ACCEPT_VERSION]
+          potential_version = potential_version.scrub unless potential_version.nil?
 
-          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
+          not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?
 
-          return if potential_version.empty?
-
-          # 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/base.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      class Base < Grape::Middleware::Base
+        DEFAULT_PATTERN = /.*/i.freeze
+        DEFAULT_PARAMETER = 'apiver'
+
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
+        end
+
+        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
+end

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

@@ -23,16 +23,7 @@ module Grape
       # route.
       class Header < Base
         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 +33,94 @@ 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!
+          end
+        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!
+          return if env[Grape::Env::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,13 @@ 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[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,22 @@ module Grape
       #   env['api.version'] => 'v1'
       #
       class Path < Base
-        def default_options
-          {
-            pattern: /.*/i
-          }
-        end
-
         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,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/namespace.rb

@@ -12,7 +12,7 @@ module Grape
     # @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, options)
       @space = space.to_s
       @options = options
     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