grape 2.4.0 → 3.2.1

data/lib/grape/dsl/inside_route.rb

@@ -3,152 +3,10 @@
 module Grape
   module DSL
     module InsideRoute
-      extend ActiveSupport::Concern
-      include Grape::DSL::Settings
-      include Grape::DSL::Headers
+      include Declared
 
-      # Denotes a situation where a DSL method has been invoked in a
-      # filter which it should not yet be available in
-      class MethodNotYetAvailable < StandardError; end
-
-      # @param type [Symbol] The type of filter for which evaluation has been
-      #   completed
-      # @return [Module] A module containing method overrides suitable for the
-      #   position in the filter evaluation sequence denoted by +type+.  This
-      #   defaults to an empty module if no overrides are defined for the given
-      #   filter +type+.
-      def self.post_filter_methods(type)
-        @post_filter_modules ||= { before: PostBeforeFilter }
-        @post_filter_modules[type]
-      end
-
-      # Methods which should not be available in filters until the before filter
-      # has completed
-      module PostBeforeFilter
-        def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
-          options.reverse_merge!(include_missing: true, include_parent_namespaces: true, evaluate_given: false)
-          declared_params ||= optioned_declared_params(options[:include_parent_namespaces])
-
-          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
-
-        def declared_array(passed_params, options, declared_params, params_nested_path)
-          passed_params.map do |passed_param|
-            declared(passed_param || {}, options, declared_params, params_nested_path)
-          end
-        end
-
-        def declared_hash(passed_params, options, declared_params, params_nested_path)
-          declared_params.each_with_object(passed_params.class.new) do |declared_param_attr, memo|
-            next if options[:evaluate_given] && !declared_param_attr.scope.attr_meets_dependency?(passed_params)
-
-            declared_hash_attr(passed_params, options, declared_param_attr.key, params_nested_path, memo)
-          end
-        end
-
-        def declared_hash_attr(passed_params, options, declared_param, params_nested_path, memo)
-          renamed_params = route_setting(:renamed_params) || {}
-          if declared_param.is_a?(Hash)
-            declared_param.each_pair do |declared_parent_param, declared_children_params|
-              params_nested_path_dup = params_nested_path.dup
-              params_nested_path_dup << declared_parent_param.to_s
-              next unless options[:include_missing] || passed_params.key?(declared_parent_param)
-
-              rename_path = params_nested_path + [declared_parent_param.to_s]
-              renamed_param_name = renamed_params[rename_path]
-
-              memo_key = optioned_param_key(renamed_param_name || declared_parent_param, options)
-              passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
-
-              memo[memo_key] = handle_passed_param(params_nested_path_dup, passed_children_params.any?) do
-                declared(passed_children_params, options, declared_children_params, params_nested_path_dup)
-              end
-            end
-          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.try(:key?, declared_param)
-
-            rename_path = params_nested_path + [declared_param.to_s]
-            renamed_param_name = renamed_params[rename_path]
-
-            memo_key = optioned_param_key(renamed_param_name || declared_param, options)
-            passed_param = passed_params[declared_param]
-
-            params_nested_path_dup = params_nested_path.dup
-            params_nested_path_dup << declared_param.to_s
-            memo[memo_key] = passed_param || handle_passed_param(params_nested_path_dup) do
-              passed_param
-            end
-          end
-        end
-
-        def handle_passed_param(params_nested_path, has_passed_children = false, &_block)
-          return yield if has_passed_children
-
-          key = params_nested_path[0]
-          key += "[#{params_nested_path[1..].join('][')}]" if params_nested_path.size > 1
-
-          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}[") }
-
-          if type == 'Hash' && !has_children
-            {}
-          elsif type == 'Array' || (type&.start_with?('[') && type.exclude?(','))
-            []
-          elsif type == 'Set' || type&.start_with?('#<Set')
-            Set.new
-          else
-            yield
-          end
-        end
-
-        def optioned_param_key(declared_param, options)
-          options[:stringify] ? declared_param.to_s : declared_param.to_sym
-        end
-
-        def optioned_declared_params(include_parent_namespaces)
-          declared_params = if include_parent_namespaces
-                              # Declared params including parent namespaces
-                              route_setting(:declared_params)
-                            else
-                              # Declared params at current namespace
-                              namespace_stackable(:declared_params).last || []
-                            end
-
-          raise ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
-
-          declared_params
-        end
-      end
-
-      # A filtering method that will return a hash
-      # consisting only of keys that have been declared by a
-      # `params` statement against the current/target endpoint or parent
-      # namespaces.
-      #
-      # @see +PostBeforeFilter#declared+
-      #
-      # @param params [Hash] The initial hash to filter. Usually this will just be `params`
-      # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces`
-      # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
-      # you want only to return params declared against the current/target endpoint.
-      def declared(*)
-        raise MethodNotYetAvailable, '#declared is not available prior to parameter validation.'
-      end
+      # Backward compatibility: alias exception class to previous location
+      MethodNotYetAvailable = Declared::MethodNotYetAvailable
 
       # The API version as specified in the URL.
       def version
@@ -168,32 +26,14 @@ module Grape
       # @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))
+        status = self.status(status || inheritable_setting.namespace_inheritable[:default_error_status])
         headers = additional_headers.present? ? header.merge(additional_headers) : header
         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)
+              message:,
+              status:,
+              headers:,
+              backtrace:,
+              original_exception:
       end
 
       # Redirect to a new url.
@@ -230,12 +70,12 @@ module Grape
         when Integer
           @status = status
         when nil
-          return @status if instance_variable_defined?(:@status) && @status
+          return @status if @status
 
           if request.post?
             201
           elsif request.delete?
-            if instance_variable_defined?(:@body) && @body.present?
+            if @body.present?
               200
             else
               204
@@ -274,7 +114,7 @@ module Grape
           @body = ''
           status 204
         else
-          instance_variable_defined?(:@body) ? @body : nil
+          @body
         end
       end
 
@@ -359,8 +199,7 @@ module Grape
       #       with: API::Entities::User,
       #       admin: current_user.admin?
       #   end
-      def present(*args)
-        options = args.count > 1 ? args.extract_options! : {}
+      def present(*args, **options)
         key, object = if args.count == 2 && args.first.is_a?(Symbol)
                         args
                       else
@@ -411,29 +250,29 @@ module Grape
       # @return [Class] the located Entity class, or nil if none is found
       def entity_class_for_obj(object, options)
         entity_class = options.delete(:with)
-
-        if entity_class.nil?
-          # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
-          object_class = if object.respond_to?(:klass)
-                           object.klass
-                         else
-                           object.respond_to?(:first) ? object.first.class : object.class
-                         end
-
-          object_class.ancestors.each do |potential|
-            entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential]
-          end
-
-          entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
+        return entity_class if entity_class
+
+        # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection
+        object_class = if object.respond_to?(:klass)
+                         object.klass
+                       else
+                         object.respond_to?(:first) ? object.first.class : object.class
+                       end
+
+        representations = inheritable_setting.namespace_stackable_with_hash(:representations)
+        if representations
+          potential = object_class.ancestors.detect { |potential| representations.key?(potential) }
+          entity_class = representations[potential] if potential
         end
 
+        entity_class = object_class.const_get(:Entity) if !entity_class && object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)
         entity_class
       end
 
       # @return the representation of the given object as done through
       #   the given entity_class.
       def entity_representation_for(entity_class, object, options)
-        embeds = { env: env }
+        embeds = { env: }
         embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
         entity_class.represent(object, **embeds, **options)
       end

data/lib/grape/dsl/logger.rb

@@ -3,18 +3,15 @@
 module Grape
   module DSL
     module Logger
-      include Grape::DSL::Settings
-
-      attr_writer :logger
-
       # Set or retrive the configured logger. If none was configured, this
       # method will create a new one, logging to stdout.
       # @param logger [Object] the new logger to use
       def logger(logger = nil)
+        global_settings = inheritable_setting.global
         if logger
-          global_setting(:logger, logger)
+          global_settings[:logger] = logger
         else
-          global_setting(:logger) || global_setting(:logger, ::Logger.new($stdout))
+          global_settings[:logger] || global_settings[:logger] = ::Logger.new($stdout)
         end
       end
     end

data/lib/grape/dsl/middleware.rb

@@ -3,51 +3,33 @@
 module Grape
   module DSL
     module Middleware
-      extend ActiveSupport::Concern
-
-      include Grape::DSL::Configuration
-
-      module ClassMethods
-        # Apply a custom middleware to the API. Applies
-        # to the current namespace and any children, but
-        # not parents.
-        #
-        # @param middleware_class [Class] The class of the middleware you'd like
-        #   to inject.
-        def use(middleware_class, *args, &block)
-          arr = [:use, middleware_class, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
-
-        def insert(*args, &block)
-          arr = [:insert, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
-
-        def insert_before(*args, &block)
-          arr = [:insert_before, *args]
-          arr << block if block
-
-          namespace_stackable(:middleware, arr)
-        end
+      # Apply a custom middleware to the API. Applies
+      # to the current namespace and any children, but
+      # not parents.
+      #
+      # @param middleware_class [Class] The class of the middleware you'd like
+      #   to inject.
+      def use(middleware_class, *args, &block)
+        arr = [:use, middleware_class, *args]
+        arr << block if block
+
+        inheritable_setting.namespace_stackable[:middleware] = arr
+      end
 
-        def insert_after(*args, &block)
-          arr = [:insert_after, *args]
+      %i[insert insert_before insert_after].each do |method_name|
+        define_method method_name do |*args, &block|
+          arr = [method_name, *args]
           arr << block if block
 
-          namespace_stackable(:middleware, arr)
+          inheritable_setting.namespace_stackable[:middleware] = arr
         end
+      end
 
-        # Retrieve an array of the middleware classes
-        # and arguments that are currently applied to the
-        # application.
-        def middleware
-          namespace_stackable(:middleware) || []
-        end
+      # Retrieve an array of the middleware classes
+      # and arguments that are currently applied to the
+      # application.
+      def middleware
+        inheritable_setting.namespace_stackable[:middleware] || []
       end
     end
   end

data/lib/grape/dsl/parameters.rb

@@ -6,8 +6,6 @@ module Grape
     # and describe the parameters accepted by an endpoint, or all endpoints
     # within a namespace.
     module Parameters
-      extend ActiveSupport::Concern
-
       # Set the module used to build the request.params.
       #
       # @param build_with the ParamBuilder module to use when building request.params
@@ -31,7 +29,7 @@ module Grape
       #       end
       #     end
       def build_with(build_with)
-        @api.namespace_inheritable(:build_params_with, build_with)
+        @api.inheritable_setting.namespace_inheritable[:build_params_with] = build_with
       end
 
       # Include reusable params rules among current.
@@ -55,9 +53,8 @@ module Grape
       #         Collection.page(params[:page]).per(params[:per_page])
       #       end
       #     end
-      def use(*names)
-        named_params = @api.namespace_stackable_with_hash(:named_params) || {}
-        options = names.extract_options!
+      def use(*names, **options)
+        named_params = @api.inheritable_setting.namespace_stackable_with_hash(:named_params) || {}
         names.each do |name|
           params_block = named_params.fetch(name) do
             raise "Params :#{name} not found!"
@@ -125,18 +122,15 @@ module Grape
       #         requires :name, type: String
       #       end
       #     end
-      def requires(*attrs, &block)
-        orig_attrs = attrs.clone
-
-        opts = attrs.extract_options!.clone
+      def requires(*attrs, **opts, &block)
         opts[:presence] = { value: true, message: opts[:message] }
-        opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
+        opts = @group.deep_merge(opts) if @group
 
         if opts[:using]
-          require_required_and_optional_fields(attrs.first, opts)
+          require_required_and_optional_fields(attrs.first, using: opts[:using], except: opts[:except])
         else
-          validate_attributes(attrs, opts, &block)
-          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, opts.slice(:as))
+          validate_attributes(attrs, **opts, &block)
+          block ? new_scope(attrs.first, type: opts[:type], as: opts[:as], &block) : push_declared_params(attrs, as: opts[:as])
         end
       end
 
@@ -144,12 +138,9 @@ module Grape
       #   endpoint.
       # @param (see #requires)
       # @option (see #requires)
-      def optional(*attrs, &block)
-        orig_attrs = attrs.clone
-
-        opts = attrs.extract_options!.clone
+      def optional(*attrs, **opts, &block)
         type = opts[:type]
-        opts = @group.deep_merge(opts) if instance_variable_defined?(:@group) && @group
+        opts = @group.deep_merge(opts) if @group
 
         # check type for optional parameter group
         if attrs && block
@@ -158,44 +149,26 @@ module Grape
         end
 
         if opts[:using]
-          require_optional_fields(attrs.first, opts)
+          require_optional_fields(attrs.first, using: opts[:using], except: opts[:except])
         else
-          validate_attributes(attrs, opts, &block)
+          validate_attributes(attrs, **opts, &block)
 
-          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, opts.slice(:as))
+          block ? new_scope(attrs.first, type: opts[:type], as: opts[:as], optional: true, &block) : push_declared_params(attrs, as: opts[:as])
         end
       end
 
       # Define common settings for one or more parameters
       # @param (see #requires)
       # @option (see #requires)
-      def with(*attrs, &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.
-      # @param attrs [*Symbol] parameters to validate
-      def mutually_exclusive(*attrs)
-        validates(attrs, mutual_exclusion: { value: true, message: extract_message_option(attrs) })
+      def with(**opts, &)
+        new_group_attrs = @group&.deep_merge(opts) || opts
+        new_group_scope(new_group_attrs, &)
       end
 
-      # Require exactly one of the given parameters to be present.
-      # @param (see #mutually_exclusive)
-      def exactly_one_of(*attrs)
-        validates(attrs, exactly_one_of: { value: true, message: extract_message_option(attrs) })
-      end
-
-      # Require at least one of the given parameters to be present.
-      # @param (see #mutually_exclusive)
-      def at_least_one_of(*attrs)
-        validates(attrs, at_least_one_of: { value: true, message: extract_message_option(attrs) })
-      end
-
-      # Require that either all given params are present, or none are.
-      # @param (see #mutually_exclusive)
-      def all_or_none_of(*attrs)
-        validates(attrs, all_or_none_of: { value: true, message: extract_message_option(attrs) })
+      %i[mutually_exclusive exactly_one_of at_least_one_of all_or_none_of].each do |validator|
+        define_method validator do |*attrs, message: nil|
+          validates(attrs, validator => { value: true, message: })
+        end
       end
 
       # Define a block of validations which should be applied if and only if
@@ -205,12 +178,12 @@ module Grape
       # @raise Grape::Exceptions::UnknownParameter if `attr` has not been
       #   defined in this scope yet
       # @yield a parameter definition DSL
-      def given(*attrs, &block)
+      def given(*attrs, &)
         attrs.each do |attr|
           proxy_attr = first_hash_key_or_param(attr)
           raise Grape::Exceptions::UnknownParameter.new(proxy_attr) unless declared_param?(proxy_attr)
         end
-        new_lateral_scope(dependent_on: attrs, &block)
+        new_lateral_scope(dependent_on: attrs, &)
       end
 
       # Test for whether a certain parameter has been defined in this params
@@ -251,8 +224,8 @@ module Grape
       # @return hash of parameters relevant for the current scope
       # @api private
       def params(params)
-        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 = @parent.qualifying_params.presence || @parent.params(params) if @parent
+        params = map_params(params, @element) if @element
         params
       end