grape 2.1.2 → 2.2.0

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/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/validations/params_scope.rb

@@ -190,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

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

@@ -7,20 +7,25 @@ module Grape
         def initialize(attrs, options, required, scope, **opts)
           @min = options[:min]
           @max = options[:max]
+          @is = options[:is]
 
           super
 
           raise ArgumentError, 'min must be an integer greater than or equal to zero' if !@min.nil? && (!@min.is_a?(Integer) || @min.negative?)
           raise ArgumentError, 'max must be an integer greater than or equal to zero' if !@max.nil? && (!@max.is_a?(Integer) || @max.negative?)
           raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if !@min.nil? && !@max.nil? && @min > @max
+
+          return if @is.nil?
+          raise ArgumentError, 'is must be an integer greater than zero' if !@is.is_a?(Integer) || !@is.positive?
+          raise ArgumentError, 'is cannot be combined with min or max' if !@min.nil? || !@max.nil?
         end
 
         def validate_param!(attr_name, params)
           param = params[attr_name]
 
-          raise ArgumentError, "parameter #{param} does not support #length" unless param.respond_to?(:length)
+          return unless param.respond_to?(:length)
 
-          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max)
+          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max) || (!@is.nil? && param.length != @is)
 
           raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: build_message)
         end
@@ -32,8 +37,10 @@ module Grape
             format I18n.t(:length, scope: 'grape.errors.messages'), min: @min, max: @max
           elsif @min
             format I18n.t(:length_min, scope: 'grape.errors.messages'), min: @min
-          else
+          elsif @max
             format I18n.t(:length_max, scope: 'grape.errors.messages'), max: @max
+          else
+            format I18n.t(:length_is, scope: 'grape.errors.messages'), is: @is
           end
         end
       end

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '2.1.2'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Michael Bleigh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-28 00:00:00.000000000 Z
+date: 2024-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -172,6 +172,7 @@ files:
 - lib/grape/middleware/versioner/header.rb
 - lib/grape/middleware/versioner/param.rb
 - lib/grape/middleware/versioner/path.rb
+- lib/grape/middleware/versioner_helpers.rb
 - lib/grape/namespace.rb
 - lib/grape/parser.rb
 - lib/grape/parser/json.rb
@@ -189,7 +190,6 @@ files:
 - lib/grape/serve_stream/sendfile_response.rb
 - lib/grape/serve_stream/stream_response.rb
 - lib/grape/types/invalid_value.rb
-- lib/grape/util/accept_header_handler.rb
 - lib/grape/util/base_inheritable.rb
 - lib/grape/util/cache.rb
 - lib/grape/util/endpoint_configuration.rb
@@ -203,7 +203,6 @@ files:
 - lib/grape/util/lazy/value_enumerable.rb
 - lib/grape/util/lazy/value_hash.rb
 - lib/grape/util/media_type.rb
-- lib/grape/util/registrable.rb
 - lib/grape/util/reverse_stackable_values.rb
 - lib/grape/util/stackable_values.rb
 - lib/grape/util/strict_hash_configuration.rb
@@ -251,9 +250,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/ruby-grape/grape/issues
-  changelog_uri: https://github.com/ruby-grape/grape/blob/v2.1.2/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/grape/2.1.2
-  source_code_uri: https://github.com/ruby-grape/grape/tree/v2.1.2
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v2.2.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/2.2.0
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v2.2.0
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/grape/util/accept_header_handler.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    class AcceptHeaderHandler
-      attr_reader :accept_header, :versions, :vendor, :strict, :cascade
-
-      def initialize(accept_header:, versions:, **options)
-        @accept_header = accept_header
-        @versions = versions
-        @vendor = options.fetch(:vendor, nil)
-        @strict = options.fetch(:strict, false)
-        @cascade = options.fetch(:cascade, true)
-      end
-
-      def match_best_quality_media_type!(content_types: Grape::ContentTypes::CONTENT_TYPES, allowed_methods: nil)
-        return unless vendor
-
-        strict_header_checks!
-        media_type = Grape::Util::MediaType.best_quality(accept_header, available_media_types(content_types))
-        if media_type
-          yield media_type
-        else
-          fail!(allowed_methods)
-        end
-      end
-
-      private
-
-      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 error_headers
-        cascade ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
-      end
-
-      def available_media_types(content_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/util/registrable.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    module Registrable
-      def default_elements
-        @default_elements ||= {}
-      end
-
-      def register(format, element)
-        default_elements[format] = element unless default_elements[format]
-      end
-    end
-  end
-end