grape 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ea97a4725e49023d0d321920359d449d1a97ac1ea796bf8393f680d512799c7
-  data.tar.gz: 2f36ea240c2f987ec11479522a6a4f3113f3fb296903baa749305ba60e07ad44
+  metadata.gz: dc04f424b8181e92cc304d02d2923952f07e2532ef0291233596813726a2cb68
+  data.tar.gz: 46729a20982fc16129540a81061bea229fd3ba5dd81426c1830119b52fe6ccd2
 SHA512:
-  metadata.gz: 9b09628eb40cf9fe5f08e01b3391d3a7abca14b24c8bdda9fb6b52d326c97c2edc7ceb05ba8a27826d6f6d902867d5cad1e031884a466b59677e893df81b52e1
-  data.tar.gz: e1c916b0be5480c0f6cff795eefde716f6056a3f6cc28eb97235cb3c79b503e0028b69286447fb47d3850936a411863166bb8f09dc1de4f21a56b48b439b2572
+  metadata.gz: 45e47b5059a37bbf75331c41bb1fdda2487610e3713baf5b8181dcbbae1727c47995503f5dc8a12375fd0765908140540100579afe834dfe96dc4c07cd771b2f
+  data.tar.gz: 9692f64fc61714c33035ef59c0d68a9c34fb3725a5842e0fe16cbd4d7025265bef50ea5086a3f61d5ed1f0fd8740435619ff616eed55e45fd3cc48e090a02b7d

data/CHANGELOG.md

@@ -1,3 +1,49 @@
+### 2.2.0 (2024-09-14)
+
+#### Features
+
+* [#2475](https://github.com/ruby-grape/grape/pull/2475): Remove Grape::Util::Registrable - [@ericproulx](https://github.com/ericproulx).
+* [#2484](https://github.com/ruby-grape/grape/pull/2484): Refactor versioner middlewares - [@ericproulx](https://github.com/ericproulx).
+* [#2489](https://github.com/ruby-grape/grape/pull/2489): Add Rails 7.2 in CI workflow - [@ericproulx](https://github.com/ericproulx).
+* [#2493](https://github.com/ruby-grape/grape/pull/2493): MFA required when releasing - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2471](https://github.com/ruby-grape/grape/pull/2471): Fix absence of original_exception and/or backtrace even if passed in error! - [@numbata](https://github.com/numbata).
+* [#2478](https://github.com/ruby-grape/grape/pull/2478): Fix rescue_from with invalid response - [@ericproulx](https://github.com/ericproulx).
+* [#2480](https://github.com/ruby-grape/grape/pull/2480): Fix rescue_from ValidationErrors exception - [@numbata](https://github.com/numbata).
+* [#2464](https://github.com/ruby-grape/grape/pull/2464): The `length` validator only takes effect for parameters with types that support `#length` method - [@OuYangJinTing](https://github.com/OuYangJinTing).
+* [#2485](https://github.com/ruby-grape/grape/pull/2485): Add `is:` param to length validator - [@dakad](https://github.com/dakad).
+* [#2492](https://github.com/ruby-grape/grape/pull/2492): Fix `Grape::Endpoint#inspect` method - [@ericproulx](https://github.com/ericproulx).
+* [#2496](https://github.com/ruby-grape/grape/pull/2496): Reduce object allocation when compiling - [@ericproulx](https://github.com/ericproulx).
+
+### 2.1.3 (2024-07-13)
+
+#### Fixes
+
+* [#2467](https://github.com/ruby-grape/grape/pull/2467): Fix repo coverage - [@ericproulx](https://github.com/ericproulx).
+* [#2468](https://github.com/ruby-grape/grape/pull/2468): Align `error!` method signatures across different places - [@numbata](https://github.com/numbata).
+* [#2469](https://github.com/ruby-grape/grape/pull/2469): Fix full path building for lateral scopes - [@numbata](https://github.com/numbata).
+
+### 2.1.2 (2024-06-28)
+
+#### Fixes
+
+* [#2459](https://github.com/ruby-grape/grape/pull/2459): Autocorrect cops - [@ericproulx](https://github.com/ericproulx).
+* [#3458](https://github.com/ruby-grape/grape/pull/2458): Remove unused Grape::Util::Accept::Header - [@ericproulx](https://github.com/ericproulx).
+* [#2463](https://github.com/ruby-grape/grape/pull/2463): Fix error message indices - [@ericproulx](https://github.com/ericproulx).
+
+### 2.1.1 (2024-06-22)
+
+#### Features
+
+* [#2450](https://github.com/ruby-grape/grape/pull/2450): Update RuboCop to 1.64.1 - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2453](https://github.com/ruby-grape/grape/pull/2453): Fix context in rescue_from - [@ericproulx](https://github.com/ericproulx).
+* [#2455](https://github.com/ruby-grape/grape/pull/2455): Fix default response headers to work with Rack 3 - [@ericproulx](https://github.com/ericproulx).
+
 ### 2.1.0 (2024/06/15)
 
 #### Features

data/README.md

@@ -157,8 +157,7 @@ Grape is a REST-like API framework for Ruby. It's designed to run on Rack or com
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, **2.1.0**.
-Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
+You're reading the documentation for the stable release of Grape, 2.2.0. Please read UPGRADING when upgrading from a previous version.
 
 ## Project Resources
 
@@ -1713,10 +1712,11 @@ end
 
 Parameters with types that support `#length` method can be restricted to have a specific length with the `:length` option.
 
-The validator accepts `:min` or `:max` or both options to validate that the value of the parameter is within the given limits.
+The validator accepts `:min` or `:max` or both options or only `:is` to validate that the value of the parameter is within the given limits.
 
 ```ruby
 params do
+  requires :code, type: String, length: { is: 2 }
   requires :str, type: String, length: { min: 3 }
   requires :list, type: [Integer], length: { min: 3, max: 5 }
   requires :hash, type: Hash, length: { max: 5 }
@@ -2044,6 +2044,7 @@ end
 
 ```ruby
 params do
+  requires :code, type: String, length: { is: 2, message: 'code is expected to be exactly 2 characters long' }
   requires :str, type: String, length: { min: 5, message: 'str is expected to be atleast 5 characters long' }
   requires :list, type: [Integer], length: { min: 2, max: 3, message: 'list is expected to have between 2 and 3 elements' }
 end

data/UPGRADING.md

@@ -1,6 +1,14 @@
 Upgrading Grape
 ===============
 
+### Upgrading to >= 2.2.0
+
+### `Length` validator
+
+After Grape 2.2.0, `length` validator will only take effect for parameters with types that support `#length` method, will not throw `ArgumentError` exception.
+
+See [#2464](https://github.com/ruby-grape/grape/pull/2464) for more information.
+
 ### Upgrading to >= 2.1.0
 
 #### Optional Builder

data/grape.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
     'bug_tracker_uri' => 'https://github.com/ruby-grape/grape/issues',
     'changelog_uri' => "https://github.com/ruby-grape/grape/blob/v#{s.version}/CHANGELOG.md",
     'documentation_uri' => "https://www.rubydoc.info/gems/grape/#{s.version}",
-    'source_code_uri' => "https://github.com/ruby-grape/grape/tree/v#{s.version}"
+    'source_code_uri' => "https://github.com/ruby-grape/grape/tree/v#{s.version}",
+    'rubygems_mfa_required' => 'true'
   }
 
   s.add_runtime_dependency 'activesupport', '>= 6'

data/lib/grape/api/instance.rb

@@ -46,7 +46,7 @@ module Grape
         # Parses the API's definition and compiles it into an instance of
         # Grape::API.
         def compile
-          @instance ||= new
+          @instance ||= new # rubocop:disable Naming/MemoizedInstanceVariableName
         end
 
         # Wipe the compiled API so we can recompile after changes were made.

data/lib/grape/api.rb

@@ -32,7 +32,7 @@ module Grape
       def inherited(api)
         super
 
-        api.initial_setup(Grape::API == self ? Grape::API::Instance : @base_instance)
+        api.initial_setup(self == Grape::API ? Grape::API::Instance : @base_instance)
         api.override_all_methods!
       end
 
@@ -108,7 +108,7 @@ module Grape
       end
 
       def respond_to?(method, include_private = false)
-        super(method, include_private) || base_instance.respond_to?(method, include_private)
+        super || base_instance.respond_to?(method, include_private)
       end
 
       def respond_to_missing?(method, include_private = false)

data/lib/grape/content_types.rb

@@ -2,10 +2,10 @@
 
 module Grape
   module ContentTypes
-    extend Util::Registrable
+    module_function
 
     # Content types are listed in order of preference.
-    CONTENT_TYPES = {
+    DEFAULTS = {
       xml: 'application/xml',
       serializable_hash: 'application/json',
       json: 'application/json',
@@ -13,13 +13,18 @@ module Grape
       txt: 'text/plain'
     }.freeze
 
-    class << self
-      def content_types_for_settings(settings)
-        settings&.inject(:merge!)
-      end
+    MIME_TYPES = Grape::ContentTypes::DEFAULTS.except(:serializable_hash).invert.freeze
+
+    def content_types_for(from_settings)
+      from_settings.presence || DEFAULTS
+    end
+
+    def mime_types_for(from_settings)
+      return MIME_TYPES if from_settings == Grape::ContentTypes::DEFAULTS
 
-      def content_types_for(from_settings)
-        from_settings.presence || Grape::ContentTypes::CONTENT_TYPES.merge(default_elements)
+      from_settings.each_with_object({}) do |(k, v), types_without_params|
+        # remove optional parameter
+        types_without_params[v.split(';', 2).first] = k
       end
     end
   end

data/lib/grape/dsl/helpers.rb

@@ -33,18 +33,22 @@ module Grape
         #     end
         #
         def helpers(*new_modules, &block)
-          include_new_modules(new_modules) if new_modules.any?
-          include_block(block) if block
+          include_new_modules(new_modules)
+          include_block(block)
           include_all_in_scope if !block && new_modules.empty?
         end
 
         protected
 
         def include_new_modules(modules)
+          return if modules.empty?
+
           modules.each { |mod| make_inclusion(mod) }
         end
 
         def include_block(block)
+          return unless block
+
           Module.new.tap do |mod|
             make_inclusion(mod) { mod.class_eval(&block) }
           end
@@ -58,7 +62,7 @@ module Grape
 
         def include_all_in_scope
           Module.new.tap do |mod|
-            namespace_stackable(:helpers).each { |mod_to_include| mod.send :include, mod_to_include }
+            namespace_stackable(:helpers).each { |mod_to_include| mod.include mod_to_include }
             change!
           end
         end

data/lib/grape/dsl/inside_route.rb

@@ -163,12 +163,19 @@ module Grape
       # end user with the specified message.
       #
       # @param message [String] The message to display.
-      # @param status [Integer] the HTTP Status Code. Defaults to default_error_status, 500 if not set.
+      # @param status [Integer] The HTTP Status Code. Defaults to default_error_status, 500 if not set.
       # @param additional_headers [Hash] Addtional headers for the response.
-      def error!(message, status = nil, additional_headers = nil)
+      # @param backtrace [Array<String>] The backtrace of the exception that caused the error.
+      # @param original_exception [Exception] The original exception that caused the error.
+      def error!(message, status = nil, additional_headers = nil, backtrace = nil, original_exception = nil)
         status = self.status(status || namespace_inheritable(:default_error_status))
         headers = additional_headers.present? ? header.merge(additional_headers) : header
-        throw :error, message: message, status: status, headers: headers
+        throw :error,
+              message: message,
+              status: status,
+              headers: headers,
+              backtrace: backtrace,
+              original_exception: original_exception
       end
 
       # Creates a Rack response based on the provided message, status, and headers.
@@ -461,6 +468,10 @@ module Grape
       def http_version
         env['HTTP_VERSION'] || env[Rack::SERVER_PROTOCOL]
       end
+
+      def context
+        self
+      end
     end
   end
 end

data/lib/grape/dsl/parameters.rb

@@ -231,7 +231,7 @@ module Grape
 
       alias group requires
 
-      class EmptyOptionalValue; end
+      class EmptyOptionalValue; end # rubocop:disable Lint/EmptyClass
 
       def map_params(params, element, is_array = false)
         if params.is_a?(Array)

data/lib/grape/dsl/request_response.rb

@@ -17,18 +17,16 @@ module Grape
         # Specify the format for the API's serializers.
         # May be `:json`, `:xml`, `:txt`, etc.
         def format(new_format = nil)
-          if new_format
-            namespace_inheritable(:format, new_format.to_sym)
-            # define the default error formatters
-            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, **{}))
-            # define a single mime type
-            mime_type = content_types[new_format.to_sym]
-            raise Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
-
-            namespace_stackable(:content_types, new_format.to_sym => mime_type)
-          else
-            namespace_inheritable(:format)
-          end
+          return namespace_inheritable(:format) unless new_format
+
+          symbolic_new_format = new_format.to_sym
+          namespace_inheritable(:format, symbolic_new_format)
+          namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(symbolic_new_format))
+
+          content_type = content_types[symbolic_new_format]
+          raise Grape::Exceptions::MissingMimeType.new(new_format) unless content_type
+
+          namespace_stackable(:content_types, symbolic_new_format => content_type)
         end
 
         # Specify a custom formatter for a content-type.
@@ -43,12 +41,10 @@ module Grape
 
         # Specify a default error formatter.
         def default_error_formatter(new_formatter_name = nil)
-          if new_formatter_name
-            new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name, **{})
-            namespace_inheritable(:default_error_formatter, new_formatter)
-          else
-            namespace_inheritable(:default_error_formatter)
-          end
+          return namespace_inheritable(:default_error_formatter) unless new_formatter_name
+
+          new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name)
+          namespace_inheritable(:default_error_formatter, new_formatter)
         end
 
         def error_formatter(format, options)

data/lib/grape/endpoint.rb

@@ -114,10 +114,10 @@ module Grape
     # Update our settings from a given set of stackable parameters. Used when
     # the endpoint's API is mounted under another one.
     def inherit_settings(namespace_stackable)
-      inheritable_setting.route[:saved_validations] += namespace_stackable[:validations]
+      parent_validations = namespace_stackable[:validations]
+      inheritable_setting.route[:saved_validations].concat(parent_validations) if parent_validations.any?
       parent_declared_params = namespace_stackable[:declared_params]
-
-      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params
+      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params.any?
 
       endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
     end
@@ -191,8 +191,7 @@ module Grape
 
     def prepare_version
       version = namespace_inheritable(:version)
-      return unless version
-      return if version.empty?
+      return if version.blank?
 
       version.length == 1 ? version.first : version
     end
@@ -206,7 +205,9 @@ module Grape
     end
 
     def prepare_path(path)
-      path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable])
+      namespace_stackable_hash = inheritable_setting.namespace_stackable.to_hash
+      namespace_inheritable_hash = inheritable_setting.namespace_inheritable.to_hash
+      path_settings = namespace_stackable_hash.merge!(namespace_inheritable_hash)
       Path.new(path, namespace, path_settings)
     end
 
@@ -231,8 +232,17 @@ module Grape
       options[:app].endpoints if options[:app].respond_to?(:endpoints)
     end
 
-    def equals?(e)
-      (options == e.options) && (inheritable_setting.to_hash == e.inheritable_setting.to_hash)
+    def equals?(endpoint)
+      (options == endpoint.options) && (inheritable_setting.to_hash == endpoint.inheritable_setting.to_hash)
+    end
+
+    # The purpose of this override is solely for stripping internals when an error occurs while calling
+    # an endpoint through an api. See https://github.com/ruby-grape/grape/issues/2398
+    # Otherwise, it calls super.
+    def inspect
+      return super unless env
+
+      "#{self.class} in '#{route.origin}' endpoint"
     end
 
     protected
@@ -280,36 +290,39 @@ module Grape
     def build_stack(helpers)
       stack = Grape::Middleware::Stack.new
 
+      content_types = namespace_stackable_with_hash(:content_types)
+      format = namespace_inheritable(:format)
+
       stack.use Rack::Head
       stack.use Class.new(Grape::Middleware::Error),
                 helpers: helpers,
-                format: namespace_inheritable(:format),
-                content_types: namespace_stackable_with_hash(:content_types),
+                format: format,
+                content_types: content_types,
                 default_status: namespace_inheritable(:default_error_status),
                 rescue_all: namespace_inheritable(:rescue_all),
                 rescue_grape_exceptions: namespace_inheritable(:rescue_grape_exceptions),
                 default_error_formatter: namespace_inheritable(:default_error_formatter),
                 error_formatters: namespace_stackable_with_hash(:error_formatters),
-                rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
-                rescue_handlers: namespace_reverse_stackable_with_hash(:rescue_handlers) || {},
-                base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
+                rescue_options: namespace_stackable_with_hash(:rescue_options),
+                rescue_handlers: namespace_reverse_stackable_with_hash(:rescue_handlers),
+                base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers),
                 all_rescue_handler: namespace_inheritable(:all_rescue_handler),
                 grape_exceptions_rescue_handler: namespace_inheritable(:grape_exceptions_rescue_handler)
 
       stack.concat namespace_stackable(:middleware)
 
-      if namespace_inheritable(:version)
+      if namespace_inheritable(:version).present?
         stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-                  versions: namespace_inheritable(:version)&.flatten,
+                  versions: namespace_inheritable(:version).flatten,
                   version_options: namespace_inheritable(:version_options),
                   prefix: namespace_inheritable(:root_prefix),
                   mount_path: namespace_stackable(:mount_path).first
       end
 
       stack.use Grape::Middleware::Formatter,
-                format: namespace_inheritable(:format),
+                format: format,
                 default_format: namespace_inheritable(:default_format) || :txt,
-                content_types: namespace_stackable_with_hash(:content_types),
+                content_types: content_types,
                 formatters: namespace_stackable_with_hash(:formatters),
                 parsers: namespace_stackable_with_hash(:parsers)
 
@@ -320,7 +333,9 @@ module Grape
 
     def build_helpers
       helpers = namespace_stackable(:helpers)
-      Module.new { helpers&.each { |mod_to_include| include mod_to_include } }
+      return if helpers.empty?
+
+      Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
     private :build_stack, :build_helpers
@@ -339,7 +354,7 @@ module Grape
       @lazy_initialize_lock.synchronize do
         return true if @lazy_initialized
 
-        @helpers = build_helpers.tap { |mod| self.class.send(:include, mod) }
+        @helpers = build_helpers&.tap { |mod| self.class.include mod }
         @app = options[:app] || build_stack(@helpers)
 
         @lazy_initialized = true
@@ -404,9 +419,5 @@ module Grape
       options[:options_route_enabled] &&
         env[Rack::REQUEST_METHOD] == Rack::OPTIONS
     end
-
-    def inspect
-      "#{self.class} in `#{route.origin}' endpoint"
-    end
   end
 end

data/lib/grape/error_formatter/json.rb

@@ -9,17 +9,18 @@ module Grape
         def call(message, backtrace, options = {}, env = nil, original_exception = nil)
           result = wrap_message(present(message, env))
 
-          rescue_options = options[:rescue_options] || {}
-          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
+          result = merge_rescue_options(result, backtrace, options, original_exception) if result.is_a?(Hash)
+
           ::Grape::Json.dump(result)
         end
 
         private
 
         def wrap_message(message)
-          if message.is_a?(Exceptions::ValidationErrors) || message.is_a?(Hash)
+          if message.is_a?(Hash)
             message
+          elsif message.is_a?(Exceptions::ValidationErrors)
+            message.as_json
           else
             { error: ensure_utf8(message) }
           end
@@ -30,6 +31,14 @@ module Grape
 
           message.encode('UTF-8', invalid: :replace, undef: :replace)
         end
+
+        def merge_rescue_options(result, backtrace, options, original_exception)
+          rescue_options = options[:rescue_options] || {}
+          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
+          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
+
+          result
+        end
       end
     end
   end

data/lib/grape/error_formatter.rb

@@ -2,34 +2,22 @@
 
 module Grape
   module ErrorFormatter
-    extend Util::Registrable
+    module_function
 
-    class << self
-      def builtin_formatters
-        @builtin_formatters ||= {
-          serializable_hash: Grape::ErrorFormatter::Json,
-          json: Grape::ErrorFormatter::Json,
-          jsonapi: Grape::ErrorFormatter::Json,
-          txt: Grape::ErrorFormatter::Txt,
-          xml: Grape::ErrorFormatter::Xml
-        }
-      end
+    DEFAULTS = {
+      serializable_hash: Grape::ErrorFormatter::Json,
+      json: Grape::ErrorFormatter::Json,
+      jsonapi: Grape::ErrorFormatter::Json,
+      txt: Grape::ErrorFormatter::Txt,
+      xml: Grape::ErrorFormatter::Xml
+    }.freeze
 
-      def formatters(**options)
-        builtin_formatters.merge(default_elements).merge!(options[:error_formatters] || {})
-      end
+    def formatter_for(format, error_formatters = nil, default_error_formatter = nil)
+      select_formatter(error_formatters, format) || default_error_formatter || DEFAULTS[:txt]
+    end
 
-      def formatter_for(api_format, **options)
-        spec = formatters(**options)[api_format]
-        case spec
-        when nil
-          options[:default_error_formatter] || Grape::ErrorFormatter::Txt
-        when Symbol
-          method(spec)
-        else
-          spec
-        end
-      end
+    def select_formatter(error_formatters, format)
+      error_formatters&.key?(format) ? error_formatters[format] : DEFAULTS[format]
     end
   end
 end

data/lib/grape/exceptions/validation_errors.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class ValidationErrors < Grape::Exceptions::Base
       ERRORS_FORMAT_KEY = 'grape.errors.format'
-      DEFAULT_ERRORS_FORMAT = '%{attributes} %{message}'
+      DEFAULT_ERRORS_FORMAT = '%<attributes>s %<message>s'
 
       include Enumerable
 

data/lib/grape/formatter.rb

@@ -2,34 +2,24 @@
 
 module Grape
   module Formatter
-    extend Util::Registrable
+    module_function
 
-    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
+    DEFAULTS = {
+      json: Grape::Formatter::Json,
+      jsonapi: Grape::Formatter::Json,
+      serializable_hash: Grape::Formatter::SerializableHash,
+      txt: Grape::Formatter::Txt,
+      xml: Grape::Formatter::Xml
+    }.freeze
 
-      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)
+      select_formatter(formatters, api_format) || DEFAULT_LAMBDA_FORMATTER
+    end
+
+    def select_formatter(formatters, api_format)
+      formatters&.key?(api_format) ? formatters[api_format] : DEFAULTS[api_format]
     end
   end
 end

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: