grape 2.1.3 → 2.3.0

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
@@ -145,27 +145,28 @@ module Grape
     end
 
     def mount_in(router)
-      if endpoints
-        endpoints.each { |e| e.mount_in(router) }
-      else
-        reset_routes!
-        routes.each do |route|
-          methods = [route.request_method]
-          methods << Rack::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Rack::GET
-          methods.each do |method|
-            route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h) unless route.request_method == method
-            router.append(route.apply(self))
-          end
+      return endpoints.each { |e| e.mount_in(router) } if endpoints
+
+      reset_routes!
+      routes.each do |route|
+        router.append(route.apply(self))
+        next unless !namespace_inheritable(:do_not_route_head) && route.request_method == Rack::GET
+
+        route.dup.then do |head_route|
+          head_route.convert_to_head_request!
+          router.append(head_route.apply(self))
         end
       end
     end
 
     def to_routes
-      route_options = prepare_default_route_attributes
-      map_routes do |method, path|
-        path = prepare_path(path)
-        params = merge_route_options(**route_options.merge(suffix: path.suffix))
-        route = Router::Route.new(method, path.path, **params)
+      default_route_options = prepare_default_route_attributes
+      default_path_settings = prepare_default_path_settings
+
+      map_routes do |method, raw_path|
+        prepared_path = Path.new(raw_path, namespace, default_path_settings)
+        params = options[:route_options].present? ? options[:route_options].merge(default_route_options) : default_route_options
+        route = Grape::Router::Route.new(method, prepared_path.origin, prepared_path.suffix, params)
         route.apply(self)
       end.flatten
     end
@@ -191,23 +192,19 @@ 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
 
-    def merge_route_options(**default)
-      options[:route_options].clone.merge!(**default)
-    end
-
     def map_routes
       options[:method].map { |method| options[:path].map { |path| yield method, path } }
     end
 
-    def prepare_path(path)
-      path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable])
-      Path.new(path, namespace, path_settings)
+    def prepare_default_path_settings
+      namespace_stackable_hash = inheritable_setting.namespace_stackable.to_hash
+      namespace_inheritable_hash = inheritable_setting.namespace_inheritable.to_hash
+      namespace_stackable_hash.merge!(namespace_inheritable_hash)
     end
 
     def namespace
@@ -235,6 +232,15 @@ module Grape
       (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
 
     def run
@@ -249,9 +255,10 @@ module Grape
           run_filters befores, :before
 
           if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
-            raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allowed_methods)) unless options?
+            allow_header_value = allowed_methods.join(', ')
+            raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allow_header_value)) unless options?
 
-            header Grape::Http::Headers::ALLOW, allowed_methods
+            header Grape::Http::Headers::ALLOW, allow_header_value
             response_object = ''
             status 204
           else
@@ -277,54 +284,6 @@ module Grape
       end
     end
 
-    def build_stack(helpers)
-      stack = Grape::Middleware::Stack.new
-
-      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),
-                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) || {},
-                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)
-        stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
-                  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),
-                default_format: namespace_inheritable(:default_format) || :txt,
-                content_types: namespace_stackable_with_hash(:content_types),
-                formatters: namespace_stackable_with_hash(:formatters),
-                parsers: namespace_stackable_with_hash(:parsers)
-
-      builder = stack.build
-      builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
-      builder.to_app
-    end
-
-    def build_helpers
-      helpers = namespace_stackable(:helpers)
-      Module.new { helpers&.each { |mod_to_include| include mod_to_include } }
-    end
-
-    private :build_stack, :build_helpers
-
     def execute
       @block&.call(self)
     end
@@ -339,7 +298,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
@@ -396,7 +355,7 @@ module Grape
       return enum_for(:validations) unless block_given?
 
       route_setting(:saved_validations)&.each do |saved_validation|
-        yield Grape::Validations::ValidatorFactory.create_validator(**saved_validation)
+        yield Grape::Validations::ValidatorFactory.create_validator(saved_validation)
       end
     end
 
@@ -405,8 +364,57 @@ module Grape
         env[Rack::REQUEST_METHOD] == Rack::OPTIONS
     end
 
-    def inspect
-      "#{self.class} in `#{route.origin}' endpoint"
+    private
+
+    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: 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),
+                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).present?
+        stack.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
+                  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: format,
+                default_format: namespace_inheritable(:default_format) || :txt,
+                content_types: content_types,
+                formatters: namespace_stackable_with_hash(:formatters),
+                parsers: namespace_stackable_with_hash(:parsers)
+
+      builder = stack.build
+      builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
+      builder.to_app
+    end
+
+    def build_helpers
+      helpers = namespace_stackable(:helpers)
+      return if helpers.empty?
+
+      Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
   end
 end

data/lib/grape/error_formatter/base.rb

@@ -2,36 +2,66 @@
 
 module Grape
   module ErrorFormatter
-    module Base
-      def present(message, env)
-        present_options = {}
-        presented_message = message
-        if presented_message.is_a?(Hash)
-          presented_message = presented_message.dup
-          present_options[:with] = presented_message.delete(:with)
+    class Base
+      class << self
+        def call(message, backtrace, options = {}, env = nil, original_exception = nil)
+          merge_backtrace = backtrace.present? && options.dig(:rescue_options, :backtrace)
+          merge_original_exception = original_exception && options.dig(:rescue_options, :original_exception)
+
+          wrapped_message = wrap_message(present(message, env))
+          if wrapped_message.is_a?(Hash)
+            wrapped_message[:backtrace] = backtrace if merge_backtrace
+            wrapped_message[:original_exception] = original_exception.inspect if merge_original_exception
+          end
+
+          format_structured_message(wrapped_message)
         end
 
-        presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(presented_message, present_options)
+        def present(message, env)
+          present_options = {}
+          presented_message = message
+          if presented_message.is_a?(Hash)
+            presented_message = presented_message.dup
+            present_options[:with] = presented_message.delete(:with)
+          end
+
+          presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(presented_message, present_options)
+
+          unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil?
+            # env['api.endpoint'].route does not work when the error occurs within a middleware
+            # the Endpoint does not have a valid env at this moment
+            http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || []
+
+            found_code = http_codes.find do |http_code|
+              (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
+            end if env[Grape::Env::API_ENDPOINT].request
 
-        unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil?
-          # env['api.endpoint'].route does not work when the error occurs within a middleware
-          # the Endpoint does not have a valid env at this moment
-          http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || []
+            presenter = found_code[2] if found_code
+          end
 
-          found_code = http_codes.find do |http_code|
-            (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
-          end if env[Grape::Env::API_ENDPOINT].request
+          if presenter
+            embeds = { env: 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
 
-          presenter = found_code[2] if found_code
+          presented_message
         end
 
-        if presenter
-          embeds = { env: env }
-          embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
-          presented_message = presenter.represent(presented_message, embeds).serializable_hash
+        def wrap_message(message)
+          return message if message.is_a?(Hash)
+
+          { message: message }
+        end
+
+        def format_structured_message(_structured_message)
+          raise NotImplementedError
         end
 
-        presented_message
+        def inherited(klass)
+          super
+          ErrorFormatter.register(klass)
+        end
       end
     end
   end

data/lib/grape/error_formatter/json.rb

@@ -2,27 +2,19 @@
 
 module Grape
   module ErrorFormatter
-    module Json
-      extend Base
-
+    class Json < Base
       class << self
-        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
-          ::Grape::Json.dump(result)
+        def format_structured_message(structured_message)
+          ::Grape::Json.dump(structured_message)
         end
 
         private
 
         def wrap_message(message)
-          if message.is_a?(Exceptions::ValidationErrors) || message.is_a?(Hash)
-            message
-          else
-            { error: ensure_utf8(message) }
-          end
+          return message if message.is_a?(Hash)
+          return message.as_json if message.is_a?(Exceptions::ValidationErrors)
+
+          { error: ensure_utf8(message) }
         end
 
         def ensure_utf8(message)

data/lib/grape/error_formatter/jsonapi.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Grape
+  module ErrorFormatter
+    class Jsonapi < Json; end
+  end
+end

data/lib/grape/error_formatter/serializable_hash.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Grape
+  module ErrorFormatter
+    class SerializableHash < Json; end
+  end
+end

data/lib/grape/error_formatter/txt.rb

@@ -2,26 +2,19 @@
 
 module Grape
   module ErrorFormatter
-    module Txt
-      extend Base
-
-      class << self
-        def call(message, backtrace, options = {}, env = nil, original_exception = nil)
-          message = present(message, env)
-
-          result = message.is_a?(Hash) ? ::Grape::Json.dump(message) : message
-          Array.wrap(result).tap do |final_result|
-            rescue_options = options[:rescue_options] || {}
-            if rescue_options[:backtrace] && backtrace.present?
-              final_result << 'backtrace:'
-              final_result.concat(backtrace)
-            end
-            if rescue_options[:original_exception] && original_exception
-              final_result << 'original exception:'
-              final_result << original_exception.inspect
-            end
-          end.join("\r\n ")
-        end
+    class Txt < Base
+      def self.format_structured_message(structured_message)
+        message = structured_message[:message] || Grape::Json.dump(structured_message)
+        Array.wrap(message).tap do |final_message|
+          if structured_message.key?(:backtrace)
+            final_message << 'backtrace:'
+            final_message.concat(structured_message[:backtrace])
+          end
+          if structured_message.key?(:original_exception)
+            final_message << 'original exception:'
+            final_message << structured_message[:original_exception]
+          end
+        end.join("\r\n ")
       end
     end
   end

data/lib/grape/error_formatter/xml.rb

@@ -2,19 +2,9 @@
 
 module Grape
   module ErrorFormatter
-    module Xml
-      extend Base
-
-      class << self
-        def call(message, backtrace, options = {}, env = nil, original_exception = nil)
-          message = present(message, env)
-
-          result = message.is_a?(Hash) ? message : { message: message }
-          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.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s
-        end
+    class Xml < Base
+      def self.format_structured_message(structured_message)
+        structured_message.respond_to?(:to_xml) ? structured_message.to_xml(root: :error) : structured_message.to_s
       end
     end
   end

data/lib/grape/error_formatter.rb

@@ -2,34 +2,14 @@
 
 module Grape
   module ErrorFormatter
-    extend Util::Registrable
+    extend Grape::Util::Registry
 
-    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
+    module_function
 
-      def formatters(**options)
-        builtin_formatters.merge(default_elements).merge!(options[:error_formatters] || {})
-      end
+    def formatter_for(format, error_formatters = nil, default_error_formatter = nil)
+      return error_formatters[format] if error_formatters&.key?(format)
 
-      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
+      registry[format] || default_error_formatter || Grape::ErrorFormatter::Txt
     end
   end
 end

data/lib/grape/exceptions/base.rb

@@ -9,7 +9,7 @@ module Grape
 
       attr_reader :status, :headers
 
-      def initialize(status: nil, message: nil, headers: nil, **_options)
+      def initialize(status: nil, message: nil, headers: nil)
         super(message)
 
         @status  = status
@@ -26,42 +26,32 @@ module Grape
       # 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)
-        if short_message.is_a? Hash
-          @problem = problem(key, **attributes)
-          @summary = summary(key, **attributes)
-          @resolution = resolution(key, **attributes)
-          [['Problem', @problem], ['Summary', @summary], ['Resolution', @resolution]].each_with_object(+'') do |detail_array, message|
-            message << "\n#{detail_array[0]}:\n  #{detail_array[1]}" unless detail_array[1].blank?
-            message
-          end
-        else
-          short_message
-        end
-      end
+        short_message = translate_message(key, attributes)
+        return short_message unless short_message.is_a?(Hash)
 
-      def problem(key, **attributes)
-        translate_message(:"#{key}.problem", **attributes)
+        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 summary(key, **attributes)
-        translate_message(:"#{key}.summary", **attributes)
-      end
+      def each_steps(key, attributes)
+        return enum_for(:each_steps, key, attributes) unless block_given?
 
-      def resolution(key, **attributes)
-        translate_message(:"#{key}.resolution", **attributes)
+        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)
+      def translate_attributes(keys, options = {})
         keys.map do |key|
-          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", default: key, **options)
+          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", options.merge(default: key.to_s))
         end.join(', ')
       end
 
-      def translate_message(key, **options)
+      def translate_message(key, options = {})
         case key
         when Symbol
-          translate("#{BASE_MESSAGES_KEY}.#{key}", default: '', **options)
+          translate("#{BASE_MESSAGES_KEY}.#{key}", options.merge(default: ''))
         when Proc
           key.call
         else
@@ -69,14 +59,12 @@ module Grape
         end
       end
 
-      def translate(key, **options)
-        options = options.dup
-        options[:default] &&= options[:default].to_s
+      def translate(key, options)
         message = ::I18n.translate(key, **options)
-        message.presence || fallback_message(key, **options)
+        message.presence || fallback_message(key, options)
       end
 
-      def fallback_message(key, **options)
+      def fallback_message(key, options)
         if ::I18n.enforce_available_locales && ::I18n.available_locales.exclude?(FALLBACK_LOCALE)
           key
         else

data/lib/grape/exceptions/validation.rb

@@ -2,16 +2,17 @@
 
 module Grape
   module Exceptions
-    class Validation < Grape::Exceptions::Base
+    class Validation < Base
       attr_accessor :params, :message_key
 
-      def initialize(params:, message: nil, **args)
+      def initialize(params:, message: nil, status: nil, headers: nil)
         @params = params
         if message
           @message_key = message if message.is_a?(Symbol)
-          args[:message] = translate_message(message)
+          message = translate_message(message)
         end
-        super(**args)
+
+        super(status: status, message: message, headers: headers)
       end
 
       # Remove all the unnecessary stuff from Grape::Exceptions::Base like status

data/lib/grape/exceptions/validation_errors.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Exceptions
-    class ValidationErrors < Grape::Exceptions::Base
+    class ValidationErrors < Base
       ERRORS_FORMAT_KEY = 'grape.errors.format'
       DEFAULT_ERRORS_FORMAT = '%<attributes>s %<message>s'
 
@@ -10,7 +10,7 @@ module Grape
 
       attr_reader :errors
 
-      def initialize(errors: [], headers: {}, **_options)
+      def initialize(errors: [], headers: {})
         @errors = errors.group_by(&:params)
         super(message: full_messages.join(', '), status: 400, headers: headers)
       end

data/lib/grape/formatter/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Formatter
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Formatter.register(klass)
+      end
+    end
+  end
+end

data/lib/grape/formatter/json.rb

@@ -2,13 +2,11 @@
 
 module Grape
   module Formatter
-    module Json
-      class << self
-        def call(object, _env)
-          return object.to_json if object.respond_to?(:to_json)
+    class Json < Base
+      def self.call(object, _env)
+        return object.to_json if object.respond_to?(:to_json)
 
-          ::Grape::Json.dump(object)
-        end
+        ::Grape::Json.dump(object)
       end
     end
   end

data/lib/grape/formatter/serializable_hash.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Formatter
-    module SerializableHash
+    class SerializableHash < Base
       class << self
         def call(object, _env)
           return object if object.is_a?(String)