grape 2.0.0 → 2.4.0

data/lib/grape/dsl/inside_route.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/dsl/headers'
-
 module Grape
   module DSL
     module InsideRoute
@@ -28,14 +26,20 @@ module Grape
       # has completed
       module PostBeforeFilter
         def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
-          options = options.reverse_merge(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
-          declared_params ||= optioned_declared_params(**options)
+          options.reverse_merge!(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
+          declared_params ||= optioned_declared_params(options[:include_parent_namespaces])
 
-          if passed_params.is_a?(Array)
-            declared_array(passed_params, options, declared_params, params_nested_path)
-          else
-            declared_hash(passed_params, options, declared_params, params_nested_path)
+          res = if passed_params.is_a?(Array)
+                  declared_array(passed_params, options, declared_params, params_nested_path)
+                else
+                  declared_hash(passed_params, options, declared_params, params_nested_path)
+                end
+
+          if (key_maps = namespace_stackable(:contract_key_map))
+            key_maps.each { |key_map| key_map.write(passed_params, res) }
           end
+
+          res
         end
 
         private
@@ -75,7 +79,7 @@ module Grape
           else
             # If it is not a Hash then it does not have children.
             # Find its value or set it to nil.
-            return unless options[:include_missing] || passed_params.key?(declared_param)
+            return unless options[:include_missing] || passed_params.try(:key?, declared_param)
 
             rename_path = params_nested_path + [declared_param.to_s]
             renamed_param_name = renamed_params[rename_path]
@@ -99,11 +103,11 @@ module Grape
 
           route_options_params = options[:route_options][:params] || {}
           type = route_options_params.dig(key, :type)
-          has_children = route_options_params.keys.any? { |k| k != key && k.start_with?(key) }
+          has_children = route_options_params.keys.any? { |k| k != key && k.start_with?("#{key}[") }
 
           if type == 'Hash' && !has_children
             {}
-          elsif type == 'Array' || (type&.start_with?('[') && type&.exclude?(','))
+          elsif type == 'Array' || (type&.start_with?('[') && type.exclude?(','))
             []
           elsif type == 'Set' || type&.start_with?('#<Set')
             Set.new
@@ -116,8 +120,8 @@ module Grape
           options[:stringify] ? declared_param.to_s : declared_param.to_sym
         end
 
-        def optioned_declared_params(**options)
-          declared_params = if options[:include_parent_namespaces]
+        def optioned_declared_params(include_parent_namespaces)
+          declared_params = if include_parent_namespaces
                               # Declared params including parent namespaces
                               route_setting(:declared_params)
                             else
@@ -159,33 +163,57 @@ 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)
-        self.status(status || namespace_inheritable(:default_error_status))
+      # @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: self.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.
+      # The content type in the headers is set to the default content type unless provided.
+      # The message is HTML-escaped if the content type is 'text/html'.
+      #
+      # @param message [String] The content of the response.
+      # @param status [Integer] The HTTP status code.
+      # @params headers [Hash] (optional) Headers for the response
+      #                      (default: {Rack::CONTENT_TYPE => content_type}).
+      #
+      # Returns:
+      # A Rack::Response object containing the specified message, status, and headers.
+      #
+      def rack_response(message, status = 200, headers = { Rack::CONTENT_TYPE => content_type })
+        Grape.deprecator.warn('The rack_response method has been deprecated, use error! instead.')
+        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == 'text/html'
+        Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), headers)
       end
 
       # Redirect to a new url.
       #
       # @param url [String] The url to be redirect.
-      # @param options [Hash] The options used when redirect.
-      #                       :permanent, default false.
-      #                       :body, default a short message including the URL.
-      def redirect(url, permanent: false, body: nil, **_options)
+      # @param permanent [Boolean] default false.
+      # @param body default a short message including the URL.
+      def redirect(url, permanent: false, body: nil)
         body_message = body
         if permanent
           status 301
           body_message ||= "This resource has been moved permanently to #{url}."
-        elsif env[Grape::Http::Headers::HTTP_VERSION] == 'HTTP/1.1' && request.request_method.to_s.upcase != Grape::Http::Headers::GET
+        elsif http_version == 'HTTP/1.1' && !request.get?
           status 303
           body_message ||= "An alternate resource is located at #{url}."
         else
           status 302
           body_message ||= "This resource has been moved temporarily to #{url}."
         end
-        header Grape::Http::Headers::LOCATION, url
+        header 'Location', url
         content_type 'text/plain'
         body body_message
       end
@@ -204,10 +232,9 @@ module Grape
         when nil
           return @status if instance_variable_defined?(:@status) && @status
 
-          case request.request_method.to_s.upcase
-          when Grape::Http::Headers::POST
+          if request.post?
             201
-          when Grape::Http::Headers::DELETE
+          elsif request.delete?
             if instance_variable_defined?(:@body) && @body.present?
               200
             else
@@ -230,18 +257,6 @@ module Grape
         end
       end
 
-      # Set or get a cookie
-      #
-      # @example
-      #   cookies[:mycookie] = 'mycookie val'
-      #   cookies['mycookie-string'] = 'mycookie string val'
-      #   cookies[:more] = { value: '123', expires: Time.at(0) }
-      #   cookies.delete :more
-      #
-      def cookies
-        @cookies ||= Cookies.new
-      end
-
       # Allows you to define the response body as something other than the
       # return value.
       #
@@ -277,20 +292,6 @@ module Grape
         body false
       end
 
-      # Deprecated method to send files to the client. Use `sendfile` or `stream`
-      def file(value = nil)
-        if value.is_a?(String)
-          Grape.deprecator.warn('Use sendfile or stream to send files.')
-          sendfile(value)
-        elsif !value.is_a?(NilClass)
-          Grape.deprecator.warn('Use stream to use a Stream object.')
-          stream(value)
-        else
-          Grape.deprecator.warn('Use sendfile or stream to send files.')
-          sendfile
-        end
-      end
-
       # Allows you to send a file to the client via sendfile.
       #
       # @example
@@ -329,7 +330,7 @@ module Grape
         return if value.nil? && @stream.nil?
 
         header Rack::CONTENT_LENGTH, nil
-        header Grape::Http::Headers::TRANSFER_ENCODING, nil
+        header 'Transfer-Encoding', nil
         header Rack::CACHE_CONTROL, 'no-cache' # Skips ETag generation (reading the response up front)
         if value.is_a?(String)
           file_body = Grape::ServeStream::FileBody.new(value)
@@ -434,7 +435,19 @@ module Grape
       def entity_representation_for(entity_class, object, options)
         embeds = { env: env }
         embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
-        entity_class.represent(object, **embeds.merge(options))
+        entity_class.represent(object, **embeds, **options)
+      end
+
+      def http_version
+        env.fetch('HTTP_VERSION') { env[Rack::SERVER_PROTOCOL] }
+      end
+
+      def api_format(format)
+        env[Grape::Env::API_FORMAT] = format
+      end
+
+      def context
+        self
       end
     end
   end

data/lib/grape/dsl/parameters.rb

@@ -23,14 +23,14 @@ module Grape
       #     class API < Grape::API
       #       desc "Get collection"
       #       params do
-      #         build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+      #         build_with :hashie_mash
       #         requires :user_id, type: Integer
       #       end
       #       get do
       #         params['user_id']
       #       end
       #     end
-      def build_with(build_with = nil)
+      def build_with(build_with)
         @api.namespace_inheritable(:build_params_with, build_with)
       end
 
@@ -130,13 +130,13 @@ module Grape
 
         opts = attrs.extract_options!.clone
         opts[:presence] = { value: true, message: opts[:message] }
-        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
+        opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
 
         if opts[:using]
           require_required_and_optional_fields(attrs.first, opts)
         else
           validate_attributes(attrs, opts, &block)
-          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, **opts.slice(:as))
+          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, opts.slice(:as))
         end
       end
 
@@ -149,7 +149,7 @@ module Grape
 
         opts = attrs.extract_options!.clone
         type = opts[:type]
-        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
+        opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
 
         # check type for optional parameter group
         if attrs && block
@@ -162,7 +162,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, **opts.slice(:as))
+          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, opts.slice(:as))
         end
       end
 
@@ -170,7 +170,8 @@ module Grape
       # @param (see #requires)
       # @option (see #requires)
       def with(*attrs, &block)
-        new_group_scope(attrs.clone, &block)
+        new_group_attrs = [@group, attrs.clone.first].compact.reduce(&:deep_merge)
+        new_group_scope([new_group_attrs], &block)
       end
 
       # Disallow the given parameters to be present in the same request.
@@ -230,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)
@@ -250,7 +251,7 @@ module Grape
       # @return hash of parameters relevant for the current scope
       # @api private
       def params(params)
-        params = @parent.params(params) if instance_variable_defined?(:@parent) && @parent
+        params = @parent.params_meeting_dependency.presence || @parent.params(params) if instance_variable_defined?(:@parent) && @parent
         params = map_params(params, @element) if instance_variable_defined?(:@element) && @element
         params
       end

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/dsl/routing.rb

@@ -30,7 +30,7 @@ module Grape
           if args.any?
             options = args.extract_options!
             options = options.reverse_merge(using: :path)
-            requested_versions = args.flatten
+            requested_versions = args.flatten.map(&:to_s)
 
             raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
@@ -54,7 +54,7 @@ module Grape
 
         # Define a root URL prefix for your entire API.
         def prefix(prefix = nil)
-          namespace_inheritable(:root_prefix, prefix)
+          namespace_inheritable(:root_prefix, prefix&.to_s)
         end
 
         # Create a scope without affecting the URL.
@@ -67,6 +67,10 @@ module Grape
           end
         end
 
+        def build_with(build_with)
+          namespace_inheritable(:build_params_with, build_with)
+        end
+
         # Do not route HEAD requests to GET requests automatically.
         def do_not_route_head!
           namespace_inheritable(:do_not_route_head, true)
@@ -77,6 +81,10 @@ module Grape
           namespace_inheritable(:do_not_route_options, true)
         end
 
+        def lint!
+          namespace_inheritable(:lint, true)
+        end
+
         def do_not_document!
           namespace_inheritable(:do_not_document, true)
         end
@@ -85,8 +93,8 @@ module Grape
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
             if app.respond_to?(:mount_instance)
-              opts_with = opts.any? ? opts.shift[:with] : {}
-              mount({ app.mount_instance(configuration: opts_with) => path })
+              opts_with = opts.any? ? opts.first[:with] : {}
+              mount({ app.mount_instance(configuration: opts_with) => path }, *opts)
               next
             end
             in_setting = inheritable_setting
@@ -103,6 +111,15 @@ module Grape
               change!
             end
 
+            # When trying to mount multiple times the same endpoint, remove the previous ones
+            # from the list of endpoints if refresh_already_mounted parameter is true
+            refresh_already_mounted = opts.any? ? opts.first[:refresh_already_mounted] : false
+            if refresh_already_mounted && !endpoints.empty?
+              endpoints.delete_if do |endpoint|
+                endpoint.options[:app].to_s == app.to_s
+              end
+            end
+
             endpoints << Grape::Endpoint.new(
               in_setting,
               method: :any,
@@ -145,7 +162,7 @@ module Grape
           reset_validations!
         end
 
-        Grape::Http::Headers::SUPPORTED_METHODS.each do |supported_method|
+        Grape::HTTP_SUPPORTED_METHODS.each do |supported_method|
           define_method supported_method.downcase do |*args, &block|
             options = args.extract_options!
             paths = args.first || ['/']
@@ -166,19 +183,12 @@ module Grape
         #       end
         #     end
         def namespace(space = nil, options = {}, &block)
-          @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description
-
-          if space || block
-            within_namespace do
-              previous_namespace_description = @namespace_description
-              @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
-              nest(block) do
-                namespace_stackable(:namespace, Namespace.new(space, **options)) if space
-              end
-              @namespace_description = previous_namespace_description
+          return Namespace.joined_space_path(namespace_stackable(:namespace)) unless space || block
+
+          within_namespace do
+            nest(block) do
+              namespace_stackable(:namespace, Namespace.new(space, options)) if space
             end
-          else
-            Namespace.joined_space_path(namespace_stackable(:namespace))
           end
         end
 
@@ -225,6 +235,13 @@ module Grape
         def versions
           @versions ||= []
         end
+
+        private
+
+        def refresh_mounted_api(mounts, *opts)
+          opts << { refresh_already_mounted: true }
+          mount(mounts, *opts)
+        end
       end
     end
   end

data/lib/grape/dsl/validations.rb

@@ -38,6 +38,19 @@ module Grape
         def params(&block)
           Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
         end
+
+        # Declare the contract to be used for the endpoint's parameters.
+        # @param contract [Class<Dry::Validation::Contract> | Dry::Schema::Processor]
+        #   The contract or schema to be used for validation. Optional.
+        # @yield a block yielding a new instance of Dry::Schema::Params
+        #   subclass, allowing to define the schema inline. When the
+        #   +contract+ parameter is a schema, it will be used as a parent. Optional.
+        def contract(contract = nil, &block)
+          raise ArgumentError, 'Either contract or block must be provided' unless contract || block
+          raise ArgumentError, 'Cannot inherit from contract, only schema' if block && contract.respond_to?(:schema)
+
+          Grape::Validations::ContractScope.new(self, contract, &block)
+        end
       end
     end
   end