grape 2.0.0 → 2.4.0

data/lib/grape/endpoint.rb

@@ -6,15 +6,19 @@ module Grape
   # on the instance level of this class may be called
   # from inside a `get`, `post`, etc.
   class Endpoint
+    extend Forwardable
     include Grape::DSL::Settings
     include Grape::DSL::InsideRoute
 
     attr_accessor :block, :source, :options
-    attr_reader :env, :request, :headers, :params
+    attr_reader :env, :request
+
+    def_delegators :request, :params, :headers, :cookies
+    def_delegator :cookies, :response_cookies
 
     class << self
-      def new(*args, &block)
-        self == Endpoint ? Class.new(Endpoint).new(*args, &block) : super
+      def new(...)
+        self == Endpoint ? Class.new(Endpoint).new(...) : super
       end
 
       def before_each(new_setup = false, &block)
@@ -30,7 +34,7 @@ module Grape
 
       def run_before_each(endpoint)
         superclass.run_before_each(endpoint) unless self == Endpoint
-        before_each.each { |blk| blk.call(endpoint) if blk.respond_to?(:call) }
+        before_each.each { |blk| blk.try(:call, endpoint) }
       end
 
       # @api private
@@ -55,7 +59,7 @@ module Grape
 
         proc do |endpoint_instance|
           ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
-            method.bind(endpoint_instance).call
+            method.bind_call(endpoint_instance)
           end
         end
       end
@@ -114,10 +118,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
@@ -135,7 +139,7 @@ module Grape
     end
 
     def routes
-      @routes ||= endpoints ? endpoints.collect(&:routes).flatten : to_routes
+      @routes ||= endpoints&.collect(&:routes)&.flatten || to_routes
     end
 
     def reset_routes!
@@ -145,27 +149,27 @@ 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 << Grape::Http::Headers::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::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
+
+      map_routes do |method, raw_path|
+        prepared_path = Path.new(raw_path, namespace, prepare_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
@@ -190,23 +194,20 @@ module Grape
     end
 
     def prepare_version
-      version = namespace_inheritable(:version) || []
-      return if version.empty?
+      version = namespace_inheritable(:version)
+      return if version.blank?
 
-      version.length == 1 ? version.first.to_s : version
-    end
-
-    def merge_route_options(**default)
-      options[:route_options].clone.merge!(**default)
+      version.length == 1 ? version.first : version
     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.prepare(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
@@ -227,30 +228,36 @@ module Grape
     # Return the collection of endpoints within this endpoint.
     # This is the case when an Grape::API mounts another Grape::API.
     def endpoints
-      options[:app].endpoints if options[:app].respond_to?(:endpoints)
+      @endpoints ||= options[:app].try(:endpoints)
+    end
+
+    def equals?(endpoint)
+      (options == endpoint.options) && (inheritable_setting.to_hash == endpoint.inheritable_setting.to_hash)
     end
 
-    def equals?(e)
-      (options == e.options) && (inheritable_setting.to_hash == e.inheritable_setting.to_hash)
+    # 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
       ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @header = {}
         @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
-        @params = @request.params
-        @headers = @request.headers
         begin
-          cookies.read(@request)
           self.class.run_before_each(self)
           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?
+          if env.key?(Grape::Env::GRAPE_ALLOWED_METHODS)
+            header['Allow'] = env[Grape::Env::GRAPE_ALLOWED_METHODS].join(', ')
+            raise Grape::Exceptions::MethodNotAllowed.new(header) unless options?
 
-            header Grape::Http::Headers::ALLOW, allowed_methods
+            header 'Allow', header['Allow']
             response_object = ''
             status 204
           else
@@ -261,7 +268,7 @@ module Grape
           end
 
           run_filters afters, :after
-          cookies.write(header)
+          build_response_cookies
 
           # status verifies body presence when DELETE
           @body ||= response_object
@@ -276,54 +283,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
@@ -338,7 +297,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
@@ -371,45 +330,88 @@ module Grape
       extend post_extension if post_extension
     end
 
-    def befores
-      namespace_stackable(:befores)
+    %i[befores before_validations after_validations afters finallies].each do |method|
+      define_method method do
+        namespace_stackable(method)
+      end
     end
 
-    def before_validations
-      namespace_stackable(:before_validations)
-    end
+    def validations
+      return enum_for(:validations) unless block_given?
 
-    def after_validations
-      namespace_stackable(:after_validations)
+      route_setting(:saved_validations)&.each do |saved_validation|
+        yield Grape::Validations::ValidatorFactory.create_validator(saved_validation)
+      end
     end
 
-    def afters
-      namespace_stackable(:afters)
+    def options?
+      options[:options_route_enabled] &&
+        env[Rack::REQUEST_METHOD] == Rack::OPTIONS
     end
 
-    def finallies
-      namespace_stackable(:finallies)
-    end
+    private
 
-    def validations
-      return enum_for(:validations) unless block_given?
+    def build_stack(helpers)
+      stack = Grape::Middleware::Stack.new
 
-      route_setting(:saved_validations)&.each do |saved_validation|
-        yield Grape::Validations::ValidatorFactory.create_validator(**saved_validation)
+      content_types = namespace_stackable_with_hash(:content_types)
+      format = namespace_inheritable(:format)
+
+      stack.use Rack::Head
+      stack.use Rack::Lint if lint?
+      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 options?
-      options[:options_route_enabled] &&
-        env[Grape::Http::Headers::REQUEST_METHOD] == Grape::Http::Headers::OPTIONS
+    def build_helpers
+      helpers = namespace_stackable(:helpers)
+      return if helpers.empty?
+
+      Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
-    def method_missing(name, *_args)
-      raise NoMethodError.new("undefined method `#{name}' for #{self.class} in `#{route.origin}' endpoint")
+    def build_response_cookies
+      response_cookies do |name, value|
+        cookie_value = value.is_a?(Hash) ? value : { value: value }
+        Rack::Utils.set_cookie_header! header, name, cookie_value
+      end
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      super
+    def lint?
+      namespace_inheritable(:lint) || Grape.config.lint
     end
   end
 end

data/lib/grape/{util/env.rb → env.rb}

@@ -11,11 +11,6 @@ module Grape
     API_VENDOR = 'api.vendor'
     API_FORMAT = 'api.format'
 
-    RACK_INPUT = 'rack.input'
-    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'
-    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'
-    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'
-
     GRAPE_REQUEST = 'grape.request'
     GRAPE_REQUEST_HEADERS = 'grape.request.headers'
     GRAPE_REQUEST_PARAMS = 'grape.request.params'

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/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,25 +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
-          rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result += "\r\n backtrace:"
-            result += backtrace.join("\r\n ")
+    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 rescue_options[:original_exception] && original_exception
-            result += "\r\n original exception:"
-            result += "\r\n #{original_exception.inspect}"
+          if structured_message.key?(:original_exception)
+            final_message << 'original exception:'
+            final_message << structured_message[:original_exception]
           end
-          result
-        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