grape 3.1.1 → 3.2.0

data/lib/grape/dsl/routing.rb

@@ -60,7 +60,7 @@ module Grape
           end
         end
 
-        @versions.last if instance_variable_defined?(:@versions) && @versions
+        @versions&.last
       end
 
       # Define a root URL prefix for your entire API.
@@ -136,8 +136,8 @@ module Grape
           endpoints << Grape::Endpoint.new(
             in_setting,
             method: :any,
-            path: path,
-            app: app,
+            path:,
+            app:,
             route_options: { anchor: false },
             forward_match: !app.respond_to?(:inheritable_setting),
             for: self
@@ -167,13 +167,13 @@ module Grape
 
         new_endpoint = Grape::Endpoint.new(
           inheritable_setting,
-          method: method,
+          method:,
           path: paths,
           for: self,
           route_options: all_route_options,
           &
         )
-        endpoints << new_endpoint unless endpoints.any? { |e| e.equals?(new_endpoint) }
+        endpoints << new_endpoint unless endpoints.include?(new_endpoint)
 
         inheritable_setting.route_end
         reset_validations!
@@ -203,7 +203,7 @@ module Grape
 
         within_namespace do
           nest(block) do
-            inheritable_setting.namespace_stackable[:namespace] = Grape::Namespace.new(space, requirements: requirements, **options) if space
+            inheritable_setting.namespace_stackable[:namespace] = Grape::Namespace.new(space, requirements:, **options) if space
           end
         end
       end
@@ -223,14 +223,14 @@ module Grape
       #
       # @param param [Symbol] The name of the parameter you wish to declare.
       # @option options [Regexp] You may supply a regular expression that the declared parameter must meet.
-      def route_param(param, requirements: nil, type: nil, **options, &)
+      def route_param(param, requirements: nil, type: nil, **, &)
         requirements = { param.to_sym => requirements } if requirements.is_a?(Regexp)
 
         Grape::Validations::ParamsScope.new(api: self) do
           requires param, type: type
         end if type
 
-        namespace(":#{param}", requirements: requirements, **options, &)
+        namespace(":#{param}", requirements:, **, &)
       end
 
       # @return array of defined versions

data/lib/grape/endpoint.rb

@@ -11,7 +11,7 @@ module Grape
     include Grape::DSL::Headers
     include Grape::DSL::InsideRoute
 
-    attr_reader :env, :request, :source, :options
+    attr_reader :env, :request, :source, :options, :endpoints
 
     def_delegators :request, :params, :headers, :cookies
     def_delegator :cookies, :response_cookies
@@ -66,20 +66,21 @@ module Grape
       inheritable_setting.route[:declared_params] = inheritable_setting.namespace_stackable[:declared_params].flatten
       inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations]
 
-      inheritable_setting.namespace_stackable[:representations] = [] unless inheritable_setting.namespace_stackable[:representations]
-      inheritable_setting.namespace_inheritable[:default_error_status] = 500 unless inheritable_setting.namespace_inheritable[:default_error_status]
+      inheritable_setting.namespace_stackable[:representations] ||= []
+      inheritable_setting.namespace_inheritable[:default_error_status] ||= 500
 
       @options = options
 
-      @options[:path] = Array(options[:path])
-      @options[:path] << '/' if options[:path].empty?
-      @options[:method] = Array(options[:method])
+      @options[:path] = Array(@options[:path])
+      @options[:path] << '/' if @options[:path].empty?
+      @options[:method] = Array(@options[:method])
 
       @status = nil
       @stream = nil
       @body = nil
       @source = self.class.block_to_unbound_method(block)
       @before_filter_passed = false
+      @endpoints = @options[:app].endpoints if @options[:app].respond_to?(:endpoints)
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -94,7 +95,7 @@ module Grape
     end
 
     def routes
-      @routes ||= endpoints&.collect(&:routes)&.flatten || to_routes
+      @routes ||= endpoints&.flat_map(&:routes) || to_routes
     end
 
     def reset_routes!
@@ -113,7 +114,7 @@ module Grape
       compile!
       routes.each do |route|
         router.append(route.apply(self))
-        next unless !inheritable_setting.namespace_inheritable[:do_not_route_head] && route.request_method == Rack::GET
+        next if inheritable_setting.namespace_inheritable[:do_not_route_head] || route.request_method != Rack::GET
 
         route.dup.then do |head_route|
           head_route.convert_to_head_request!
@@ -138,15 +139,12 @@ module Grape
       @app.call(env)
     end
 
-    # Return the collection of endpoints within this endpoint.
-    # This is the case when an Grape::API mounts another Grape::API.
-    def endpoints
-      @endpoints ||= options[:app].respond_to?(:endpoints) ? options[:app].endpoints : nil
-    end
-
-    def equals?(endpoint)
-      (options == endpoint.options) && (inheritable_setting.to_hash == endpoint.inheritable_setting.to_hash)
+    def ==(other)
+      other.is_a?(self.class) &&
+        options == other.options &&
+        inheritable_setting.to_hash == other.inheritable_setting.to_hash
     end
+    alias eql? ==
 
     # 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
@@ -160,7 +158,7 @@ module Grape
     protected
 
     def run
-      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
+      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env:) do
         @request = Grape::Request.new(env, build_params_with: inheritable_setting.namespace_inheritable[:build_params_with])
         begin
           self.class.run_before_each(self)
@@ -176,7 +174,7 @@ module Grape
             status 204
           else
             run_filters before_validations, :before_validation
-            run_validators validations, request
+            run_validators(request:)
             run_filters after_validations, :after_validation
             response_object = execute
           end
@@ -198,35 +196,40 @@ module Grape
     end
 
     def execute
-      return unless @source
+      return unless source
 
       ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self) do
-        @source.bind_call(self)
+        source.bind_call(self)
       end
     end
 
-    def run_validators(validators, request)
+    def run_validators(request:)
+      validators = inheritable_setting.route[:saved_validations]
+      return if validators.empty?
+
       validation_errors = []
 
-      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
-        validators.each do |validator|
-          validator.validate(request)
-        rescue Grape::Exceptions::Validation => e
-          validation_errors << e
-          break if validator.fail_fast?
-        rescue Grape::Exceptions::ValidationArrayErrors => e
-          validation_errors.concat e.errors
-          break if validator.fail_fast?
+      Grape::Validations::ParamScopeTracker.track do
+        ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators:, request:) do
+          validators.each do |validator|
+            validator.validate(request)
+          rescue Grape::Exceptions::Validation => e
+            validation_errors << e
+            break if validator.fail_fast?
+          rescue Grape::Exceptions::ValidationArrayErrors => e
+            validation_errors.concat e.errors
+            break if validator.fail_fast?
+          end
         end
       end
 
-      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header))
+      raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header)) if validation_errors.any?
     end
 
     def run_filters(filters, type = :other)
       return unless filters
 
-      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
+      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters:, type:) do
         filters.each { |filter| instance_eval(&filter) }
       end
     end
@@ -237,16 +240,6 @@ module Grape
       end
     end
 
-    def validations
-      saved_validations = inheritable_setting.route[:saved_validations]
-      return if saved_validations.nil?
-      return enum_for(:validations) unless block_given?
-
-      saved_validations.each do |saved_validation|
-        yield Grape::Validations::ValidatorFactory.create_validator(saved_validation)
-      end
-    end
-
     def options?
       options[:options_route_enabled] &&
         env[Rack::REQUEST_METHOD] == Rack::OPTIONS
@@ -286,7 +279,7 @@ module Grape
 
     def prepare_default_route_attributes(route_options)
       {
-        namespace: namespace,
+        namespace:,
         version: prepare_version(inheritable_setting.namespace_inheritable[:version]),
         requirements: prepare_routes_requirements(route_options[:requirements]),
         prefix: inheritable_setting.namespace_inheritable[:root_prefix],
@@ -323,15 +316,15 @@ module Grape
       stack.use Rack::Head
       stack.use Rack::Lint if lint?
       stack.use Grape::Middleware::Error,
-                format: format,
-                content_types: content_types,
+                format:,
+                content_types:,
                 default_status: inheritable_setting.namespace_inheritable[:default_error_status],
                 rescue_all: inheritable_setting.namespace_inheritable[:rescue_all],
                 rescue_grape_exceptions: inheritable_setting.namespace_inheritable[:rescue_grape_exceptions],
                 default_error_formatter: inheritable_setting.namespace_inheritable[:default_error_formatter],
                 error_formatters: inheritable_setting.namespace_stackable_with_hash(:error_formatters),
                 rescue_options: inheritable_setting.namespace_stackable_with_hash(:rescue_options),
-                rescue_handlers: rescue_handlers,
+                rescue_handlers:,
                 base_only_rescue_handlers: inheritable_setting.namespace_stackable_with_hash(:base_only_rescue_handlers),
                 all_rescue_handler: inheritable_setting.namespace_inheritable[:all_rescue_handler],
                 grape_exceptions_rescue_handler: inheritable_setting.namespace_inheritable[:grape_exceptions_rescue_handler]
@@ -347,9 +340,9 @@ module Grape
       end
 
       stack.use Grape::Middleware::Formatter,
-                format: format,
+                format:,
                 default_format: inheritable_setting.namespace_inheritable[:default_format] || :txt,
-                content_types: content_types,
+                content_types:,
                 formatters: inheritable_setting.namespace_stackable_with_hash(:formatters),
                 parsers: inheritable_setting.namespace_stackable_with_hash(:parsers)
 
@@ -367,7 +360,7 @@ module Grape
 
     def build_response_cookies
       response_cookies do |name, value|
-        cookie_value = value.is_a?(Hash) ? value : { value: value }
+        cookie_value = value.is_a?(Hash) ? value : { value: }
         Rack::Utils.set_cookie_header! header, name, cookie_value
       end
     end

data/lib/grape/error_formatter/base.rb

@@ -40,7 +40,7 @@ module Grape
           end
 
           if presenter
-            embeds = { env: env }
+            embeds = { env: }
             embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
             presented_message = presenter.represent(presented_message, embeds).serializable_hash
           end
@@ -51,7 +51,7 @@ module Grape
         def wrap_message(message)
           return message if message.is_a?(Hash)
 
-          { message: message }
+          { message: }
         end
 
         def format_structured_message(_structured_message)

data/lib/grape/exceptions/base.rb

@@ -3,9 +3,9 @@
 module Grape
   module Exceptions
     class Base < StandardError
-      BASE_MESSAGES_KEY = 'grape.errors.messages'
-      BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'
-      FALLBACK_LOCALE = :en
+      include Grape::Util::Translation
+
+      MESSAGE_STEPS = %w[problem summary resolution].to_h { |s| [s, s.capitalize] }.freeze
 
       attr_reader :status, :headers
 
@@ -20,55 +20,29 @@ module Grape
         __send__ index
       end
 
-      protected
+      private
 
-      # TODO: translate attribute first
-      # if BASE_ATTRIBUTES_KEY.key respond to a string message, then short_message is returned
-      # if BASE_ATTRIBUTES_KEY.key respond to a Hash, means it may have problem , summary and resolution
-      def compose_message(key, **attributes)
-        short_message = translate_message(key, attributes)
+      def compose_message(key, **)
+        short_message = translate_message(key, **)
         return short_message unless short_message.is_a?(Hash)
 
-        each_steps(key, attributes).with_object(+'') do |detail_array, message|
-          message << "\n#{detail_array[0]}:\n  #{detail_array[1]}" unless detail_array[1].blank?
-        end
-      end
-
-      def each_steps(key, attributes)
-        return enum_for(:each_steps, key, attributes) unless block_given?
-
-        yield 'Problem', translate_message(:"#{key}.problem", attributes)
-        yield 'Summary', translate_message(:"#{key}.summary", attributes)
-        yield 'Resolution', translate_message(:"#{key}.resolution", attributes)
-      end
-
-      def translate_attributes(keys, options = {})
-        keys.map do |key|
-          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.merge(default: key.to_s))
-        end.join(', ')
+        MESSAGE_STEPS.filter_map do |step, label|
+          detail = translate_message(:"#{key}.#{step}", **)
+          "\n#{label}:\n  #{detail}" if detail.present?
+        end.join
       end
 
-      def translate_message(key, options = {})
-        case key
+      def translate_message(translation_key, **)
+        case translation_key
         when Symbol
-          translate("#{BASE_MESSAGES_KEY}.#{key}", options.merge(default: ''))
+          translate(translation_key, **)
+        when Hash
+          translation_key => { key:, **opts }
+          translate(key, **opts)
         when Proc
-          key.call
-        else
-          key
-        end
-      end
-
-      def translate(key, options)
-        message = ::I18n.translate(key, **options)
-        message.presence || fallback_message(key, options)
-      end
-
-      def fallback_message(key, options)
-        if ::I18n.enforce_available_locales && !::I18n.available_locales.include?(FALLBACK_LOCALE)
-          key
+          translation_key.call
         else
-          ::I18n.translate(key, locale: FALLBACK_LOCALE, **options)
+          translation_key
         end
       end
     end

data/lib/grape/exceptions/incompatible_option_values.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class IncompatibleOptionValues < Base
       def initialize(option1, value1, option2, value2)
-        super(message: compose_message(:incompatible_option_values, option1: option1, value1: value1, option2: option2, value2: value2))
+        super(message: compose_message(:incompatible_option_values, option1:, value1:, option2:, value2:))
       end
     end
   end

data/lib/grape/exceptions/invalid_accept_header.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class InvalidAcceptHeader < Base
       def initialize(message, headers)
-        super(message: compose_message(:invalid_accept_header, message: message), status: 406, headers: headers)
+        super(message: compose_message(:invalid_accept_header, message:), status: 406, headers:)
       end
     end
   end

data/lib/grape/exceptions/invalid_formatter.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class InvalidFormatter < Base
       def initialize(klass, to_format)
-        super(message: compose_message(:invalid_formatter, klass: klass, to_format: to_format))
+        super(message: compose_message(:invalid_formatter, klass:, to_format:))
       end
     end
   end

data/lib/grape/exceptions/invalid_message_body.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class InvalidMessageBody < Base
       def initialize(body_format)
-        super(message: compose_message(:invalid_message_body, body_format: body_format), status: 400)
+        super(message: compose_message(:invalid_message_body, body_format:), status: 400)
       end
     end
   end

data/lib/grape/exceptions/invalid_version_header.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class InvalidVersionHeader < Base
       def initialize(message, headers)
-        super(message: compose_message(:invalid_version_header, message: message), status: 406, headers: headers)
+        super(message: compose_message(:invalid_version_header, message:), status: 406, headers:)
       end
     end
   end

data/lib/grape/exceptions/invalid_versioner_option.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class InvalidVersionerOption < Base
       def initialize(strategy)
-        super(message: compose_message(:invalid_versioner_option, strategy: strategy))
+        super(message: compose_message(:invalid_versioner_option, strategy:))
       end
     end
   end

data/lib/grape/exceptions/method_not_allowed.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class MethodNotAllowed < Base
       def initialize(headers)
-        super(message: '405 Not Allowed', status: 405, headers: headers)
+        super(message: '405 Not Allowed', status: 405, headers:)
       end
     end
   end

data/lib/grape/exceptions/missing_mime_type.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class MissingMimeType < Base
       def initialize(new_format)
-        super(message: compose_message(:missing_mime_type, new_format: new_format))
+        super(message: compose_message(:missing_mime_type, new_format:))
       end
     end
   end

data/lib/grape/exceptions/request_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class RequestError < Base
+      def initialize(status: 400)
+        super(message: $ERROR_INFO&.message, status:)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_auth_strategy.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class UnknownAuthStrategy < Base
       def initialize(strategy:)
-        super(message: compose_message(:unknown_auth_strategy, strategy: strategy))
+        super(message: compose_message(:unknown_auth_strategy, strategy:))
       end
     end
   end

data/lib/grape/exceptions/unknown_parameter.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class UnknownParameter < Base
       def initialize(param)
-        super(message: compose_message(:unknown_parameter, param: param))
+        super(message: compose_message(:unknown_parameter, param:))
       end
     end
   end

data/lib/grape/exceptions/unknown_params_builder.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class UnknownParamsBuilder < Base
       def initialize(params_builder_type)
-        super(message: compose_message(:unknown_params_builder, params_builder_type: params_builder_type))
+        super(message: compose_message(:unknown_params_builder, params_builder_type:))
       end
     end
   end

data/lib/grape/exceptions/unknown_validator.rb

@@ -4,7 +4,7 @@ module Grape
   module Exceptions
     class UnknownValidator < Base
       def initialize(validator_type)
-        super(message: compose_message(:unknown_validator, validator_type: validator_type))
+        super(message: compose_message(:unknown_validator, validator_type:))
       end
     end
   end

data/lib/grape/exceptions/validation.rb

@@ -3,16 +3,19 @@
 module Grape
   module Exceptions
     class Validation < Base
-      attr_accessor :params, :message_key
+      attr_reader :params, :message_key
 
       def initialize(params:, message: nil, status: nil, headers: nil)
-        @params = params
+        @params = Array(params)
         if message
-          @message_key = message if message.is_a?(Symbol)
+          @message_key = case message
+                         when Symbol then message
+                         when Hash then message[:key]
+                         end
           message = translate_message(message)
         end
 
-        super(status: status, message: message, headers: headers)
+        super(status:, message:, headers:)
       end
 
       # Remove all the unnecessary stuff from Grape::Exceptions::Base like status

data/lib/grape/exceptions/validation_errors.rb

@@ -3,16 +3,13 @@
 module Grape
   module Exceptions
     class ValidationErrors < Base
-      ERRORS_FORMAT_KEY = 'grape.errors.format'
-      DEFAULT_ERRORS_FORMAT = '%<attributes>s %<message>s'
-
       include Enumerable
 
       attr_reader :errors
 
       def initialize(errors: [], headers: {})
         @errors = errors.group_by(&:params)
-        super(message: full_messages.join(', '), status: 400, headers: headers)
+        super(message: full_messages.join(', '), status: 400, headers:)
       end
 
       def each
@@ -38,9 +35,10 @@ module Grape
 
       def full_messages
         messages = map do |attributes, error|
-          I18n.t(
-            ERRORS_FORMAT_KEY,
-            default: DEFAULT_ERRORS_FORMAT,
+          translate(
+            :format,
+            scope: 'grape.errors',
+            default: '%<attributes>s %<message>s',
             attributes: translate_attributes(attributes),
             message: error.message
           )
@@ -48,6 +46,14 @@ module Grape
         messages.uniq!
         messages
       end
+
+      private
+
+      def translate_attributes(keys)
+        keys.map do |key|
+          translate(key, scope: 'grape.errors.attributes', default: key.to_s)
+        end.join(', ')
+      end
     end
   end
 end

data/lib/grape/locale/en.yml

@@ -8,8 +8,6 @@ en:
         at_least_one: 'are missing, at least one parameter must be provided'
         blank: 'is empty'
         coerce: 'is invalid'
-        conflicting_types: 'query params contains conflicting types'
-        empty_message_body: 'empty message body supplied with %{body_format} content-type'
         exactly_one: 'are missing, exactly one parameter must be provided'
         except_values: 'has a value not allowed'
         incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
@@ -20,7 +18,6 @@ en:
         invalid_message_body:
           problem: 'message body does not match declared format'
           resolution: 'when specifying %{body_format} as content-type, you must pass valid %{body_format} in the request''s ''body'' '
-        invalid_parameters: 'query params contains invalid format or byte sequence'
         invalid_response: 'Invalid response'
         invalid_version_header:
           problem: 'invalid version header'
@@ -48,8 +45,6 @@ en:
         presence: 'is missing'
         regexp: 'is invalid'
         same_as: 'is not the same as %{parameter}'
-        too_deep_parameters: 'query params are recursively nested over the specified limit (%{limit})'
-        too_many_multipart_files: 'the number of uploaded files exceeded the system''s configured limit (%{limit})'
         unknown_auth_strategy: 'unknown auth strategy: %{strategy}'
         unknown_options: 'unknown options: %{options}'
         unknown_parameter: 'unknown parameter: %{param}'

data/lib/grape/middleware/auth/base.rb

@@ -6,6 +6,8 @@ module Grape
       class Base < Grape::Middleware::Base
         def initialize(app, **options)
           super
+          return unless options.key?(:type)
+
           @auth_strategy = Grape::Middleware::Auth::Strategies[options[:type]].tap do |auth_strategy|
             raise Grape::Exceptions::UnknownAuthStrategy.new(strategy: options[:type]) unless auth_strategy
           end

data/lib/grape/middleware/base.rb

@@ -79,10 +79,8 @@ module Grape
 
       def query_params
         rack_request.GET
-      rescue Rack::QueryParser::ParamsTooDeepError
-        raise Grape::Exceptions::TooDeepParameters.new(Rack::Utils.param_depth_limit)
-      rescue Rack::Utils::ParameterTypeError
-        raise Grape::Exceptions::ConflictingTypes
+      rescue *Grape::RACK_ERRORS
+        raise Grape::Exceptions::RequestError
       end
 
       private

data/lib/grape/middleware/error.rb

@@ -38,8 +38,8 @@ module Grape
         throw :error,
               status: 406,
               message: "The requested format '#{format}' is not supported.",
-              backtrace: backtrace,
-              original_exception: original_exception
+              backtrace:,
+              original_exception:
       end
 
       def find_handler(klass)

data/lib/grape/middleware/formatter.rb

@@ -38,7 +38,7 @@ module Grape
         else
           # Allow content-type to be explicitly overwritten
           formatter = fetch_formatter(headers, options)
-          bodymap = ActiveSupport::Notifications.instrument('format_response.grape', formatter: formatter, env: env) do
+          bodymap = ActiveSupport::Notifications.instrument('format_response.grape', formatter:, env:) do
             bodies.collect { |body| formatter.call(body, env) }
           end
           Rack::Response.new(bodymap, status, headers)