grape 2.4.0 → 3.2.1

data/lib/grape/dsl/validations.rb

@@ -3,54 +3,48 @@
 module Grape
   module DSL
     module Validations
-      extend ActiveSupport::Concern
-
-      include Grape::DSL::Configuration
+      # Opens a root-level ParamsScope, defining parameter coercions and
+      # validations for the endpoint.
+      # @yield instance context of the new scope
+      def params(&)
+        Grape::Validations::ParamsScope.new(api: self, type: Hash, &)
+      end
 
-      module ClassMethods
-        # Clears all defined parameters and validations. The main purpose of it is to clean up
-        # settings, so next endpoint won't interfere with previous one.
-        #
-        #    params do
-        #      # params for the endpoint below this block
-        #    end
-        #    post '/current' do
-        #      # whatever
-        #    end
-        #
-        #    # somewhere between them the reset_validations! method gets called
-        #
-        #    params do
-        #      # params for the endpoint below this block
-        #    end
-        #    post '/next' do
-        #      # whatever
-        #    end
-        def reset_validations!
-          unset_namespace_stackable :declared_params
-          unset_namespace_stackable :validations
-          unset_namespace_stackable :params
-        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)
 
-        # Opens a root-level ParamsScope, defining parameter coercions and
-        # validations for the endpoint.
-        # @yield instance context of the new scope
-        def params(&block)
-          Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
-        end
+        Grape::Validations::ContractScope.new(self, contract, &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)
+      private
 
-          Grape::Validations::ContractScope.new(self, contract, &block)
-        end
+      # Clears all defined parameters and validations. The main purpose of it is to clean up
+      # settings, so next endpoint won't interfere with previous one.
+      #
+      #    params do
+      #      # params for the endpoint below this block
+      #    end
+      #    post '/current' do
+      #      # whatever
+      #    end
+      #
+      #    # somewhere between them the reset_validations! method gets called
+      #
+      #    params do
+      #      # params for the endpoint below this block
+      #    end
+      #    post '/next' do
+      #      # whatever
+      #    end
+      def reset_validations!
+        inheritable_setting.namespace_stackable.delete(:declared_params, :params, :validations)
       end
     end
   end

data/lib/grape/endpoint.rb

@@ -8,60 +8,40 @@ module Grape
   class Endpoint
     extend Forwardable
     include Grape::DSL::Settings
+    include Grape::DSL::Headers
     include Grape::DSL::InsideRoute
 
-    attr_accessor :block, :source, :options
-    attr_reader :env, :request
+    attr_reader :env, :request, :source, :options, :endpoints
 
     def_delegators :request, :params, :headers, :cookies
     def_delegator :cookies, :response_cookies
 
     class << self
-      def new(...)
-        self == Endpoint ? Class.new(Endpoint).new(...) : super
-      end
-
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
           return @before_each unless block
 
           @before_each << block
-        else
+        elsif new_setup
           @before_each = [new_setup]
+        else
+          @before_each.clear
         end
       end
 
       def run_before_each(endpoint)
         superclass.run_before_each(endpoint) unless self == Endpoint
-        before_each.each { |blk| blk.try(:call, endpoint) }
+        before_each.each { |blk| blk.call(endpoint) }
       end
 
-      # @api private
-      #
-      # Create an UnboundMethod that is appropriate for executing an endpoint
-      # route.
-      #
-      # The unbound method allows explicit calls to +return+ without raising a
-      # +LocalJumpError+. The method will be removed, but a +Proc+ reference to
-      # it will be returned. The returned +Proc+ expects a single argument: the
-      # instance of +Endpoint+ to bind to the method during the call.
-      #
-      # @param [String, Symbol] method_name
-      # @return [Proc]
-      # @raise [NameError] an instance method with the same name already exists
-      def generate_api_method(method_name, &block)
-        raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name") if method_defined?(method_name)
-
-        define_method(method_name, &block)
-        method = instance_method(method_name)
-        remove_method(method_name)
-
-        proc do |endpoint_instance|
-          ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: endpoint_instance) do
-            method.bind_call(endpoint_instance)
-          end
-        end
+      def block_to_unbound_method(block)
+        return unless block
+
+        define_method :temp_unbound_method, block
+        method = instance_method(:temp_unbound_method)
+        remove_method :temp_unbound_method
+        method
       end
     end
 
@@ -77,42 +57,30 @@ module Grape
     # @note This happens at the time of API definition, so in this context the
     # endpoint does not know if it will be mounted under a different endpoint.
     # @yield a block defining what your API should do when this endpoint is hit
-    def initialize(new_settings, options = {}, &block)
-      require_option(options, :path)
-      require_option(options, :method)
-
+    def initialize(new_settings, **options, &block)
       self.inheritable_setting = new_settings.point_in_time_copy
 
       # now +namespace_stackable(:declared_params)+ contains all params defined for
       # this endpoint and its parents, but later it will be cleaned up,
       # see +reset_validations!+ in lib/grape/dsl/validations.rb
-      route_setting(:declared_params, namespace_stackable(:declared_params).flatten)
-      route_setting(:saved_validations, namespace_stackable(:validations))
+      inheritable_setting.route[:declared_params] = inheritable_setting.namespace_stackable[:declared_params].flatten
+      inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations]
 
-      namespace_stackable(:representations, []) unless namespace_stackable(:representations)
-      namespace_inheritable(:default_error_status, 500) unless namespace_inheritable(:default_error_status)
+      inheritable_setting.namespace_stackable[:representations] ||= []
+      inheritable_setting.namespace_inheritable[:default_error_status] ||= 500
 
       @options = options
 
-      @options[:path] = Array(options[:path])
-      @options[:path] << '/' if options[:path].empty?
-
-      @options[:method] = Array(options[:method])
-      @options[:route_options] ||= {}
-
-      @lazy_initialize_lock = Mutex.new
-      @lazy_initialized = nil
-      @block = nil
+      @options[:path] = Array(@options[:path])
+      @options[:path] << '/' if @options[:path].empty?
+      @options[:method] = Array(@options[:method])
 
       @status = nil
       @stream = nil
       @body = nil
-      @proc = nil
-
-      return unless block
-
-      @source = block
-      @block = self.class.generate_api_method(method_name, &block)
+      @source = self.class.block_to_unbound_method(block)
+      @before_filter_passed = false
+      @endpoints = @options[:app].endpoints if @options[:app].respond_to?(:endpoints)
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -126,20 +94,8 @@ module Grape
       endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
     end
 
-    def require_option(options, key)
-      raise Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
-    end
-
-    def method_name
-      [options[:method],
-       Namespace.joined_space(namespace_stackable(:namespace)),
-       (namespace_stackable(:mount_path) || []).join('/'),
-       options[:path].join('/')]
-        .join(' ')
-    end
-
     def routes
-      @routes ||= endpoints&.collect(&:routes)&.flatten || to_routes
+      @routes ||= endpoints&.flat_map(&:routes) || to_routes
     end
 
     def reset_routes!
@@ -149,12 +105,16 @@ module Grape
     end
 
     def mount_in(router)
-      return endpoints.each { |e| e.mount_in(router) } if endpoints
+      if endpoints
+        compile!
+        return endpoints.each { |e| e.mount_in(router) }
+      end
 
       reset_routes!
+      compile!
       routes.each do |route|
         router.append(route.apply(self))
-        next unless !namespace_inheritable(:do_not_route_head) && route.request_method == Rack::GET
+        next if inheritable_setting.namespace_inheritable[:do_not_route_head] || route.request_method != Rack::GET
 
         route.dup.then do |head_route|
           head_route.convert_to_head_request!
@@ -163,77 +123,28 @@ module Grape
       end
     end
 
-    def to_routes
-      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
-
-    def prepare_routes_requirements
-      {}.merge!(*namespace_stackable(:namespace).map(&:requirements)).tap do |requirements|
-        endpoint_requirements = options.dig(:route_options, :requirements)
-        requirements.merge!(endpoint_requirements) if endpoint_requirements
-      end
-    end
-
-    def prepare_default_route_attributes
-      {
-        namespace: namespace,
-        version: prepare_version,
-        requirements: prepare_routes_requirements,
-        prefix: namespace_inheritable(:root_prefix),
-        anchor: options[:route_options].fetch(:anchor, true),
-        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
-        forward_match: options[:forward_match]
-      }
-    end
-
-    def prepare_version
-      version = namespace_inheritable(:version)
-      return if version.blank?
-
-      version.length == 1 ? version.first : version
-    end
-
-    def map_routes
-      options[:method].map { |method| options[:path].map { |path| yield method, path } }
-    end
-
-    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
-      @namespace ||= Namespace.joined_space_path(namespace_stackable(:namespace))
+      @namespace ||= Namespace.joined_space_path(inheritable_setting.namespace_stackable[:namespace])
     end
 
     def call(env)
-      lazy_initialize!
       dup.call!(env)
     end
 
     def call!(env)
       env[Grape::Env::API_ENDPOINT] = self
       @env = env
+      # this adds the helpers only to the instance
+      singleton_class.include(@helpers) if @helpers
       @app.call(env)
     end
 
-    # Return the collection of endpoints within this endpoint.
-    # This is the case when an Grape::API mounts another Grape::API.
-    def endpoints
-      @endpoints ||= options[:app].try(:endpoints)
-    end
-
-    def equals?(endpoint)
-      (options == endpoint.options) && (inheritable_setting.to_hash == endpoint.inheritable_setting.to_hash)
+    def ==(other)
+      other.is_a?(self.class) &&
+        options == other.options &&
+        inheritable_setting.to_hash == other.inheritable_setting.to_hash
     end
+    alias eql? ==
 
     # The purpose of this override is solely for stripping internals when an error occurs while calling
     # an endpoint through an api. See https://github.com/ruby-grape/grape/issues/2398
@@ -247,11 +158,12 @@ module Grape
     protected
 
     def run
-      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
+      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env:) do
+        @request = Grape::Request.new(env, build_params_with: inheritable_setting.namespace_inheritable[:build_params_with])
         begin
           self.class.run_before_each(self)
           run_filters befores, :before
+          @before_filter_passed = true
 
           if env.key?(Grape::Env::GRAPE_ALLOWED_METHODS)
             header['Allow'] = env[Grape::Env::GRAPE_ALLOWED_METHODS].join(', ')
@@ -262,7 +174,7 @@ module Grape
             status 204
           else
             run_filters before_validations, :before_validation
-            run_validators validations, request
+            run_validators(request:)
             run_filters after_validations, :after_validation
             response_object = execute
           end
@@ -284,63 +196,47 @@ module Grape
     end
 
     def execute
-      @block&.call(self)
-    end
-
-    def helpers
-      lazy_initialize! && @helpers
-    end
-
-    def lazy_initialize!
-      return true if @lazy_initialized
-
-      @lazy_initialize_lock.synchronize do
-        return true if @lazy_initialized
-
-        @helpers = build_helpers&.tap { |mod| self.class.include mod }
-        @app = options[:app] || build_stack(@helpers)
+      return unless source
 
-        @lazy_initialized = true
+      ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self) do
+        source.bind_call(self)
       end
     end
 
-    def run_validators(validators, request)
+    def run_validators(request:)
+      validators = inheritable_setting.route[:saved_validations]
+      return if validators.empty?
+
       validation_errors = []
 
-      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
-        validators.each do |validator|
-          validator.validate(request)
-        rescue Grape::Exceptions::Validation => e
-          validation_errors << e
-          break if validator.fail_fast?
-        rescue Grape::Exceptions::ValidationArrayErrors => e
-          validation_errors.concat e.errors
-          break if validator.fail_fast?
+      Grape::Validations::ParamScopeTracker.track do
+        ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators:, request:) do
+          validators.each do |validator|
+            validator.validate(request)
+          rescue Grape::Exceptions::Validation => e
+            validation_errors << e
+            break if validator.fail_fast?
+          rescue Grape::Exceptions::ValidationArrayErrors => e
+            validation_errors.concat e.errors
+            break if validator.fail_fast?
+          end
         end
       end
 
-      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header))
+      raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header)) if validation_errors.any?
     end
 
     def run_filters(filters, type = :other)
-      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
-        filters&.each { |filter| instance_eval(&filter) }
+      return unless filters
+
+      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters:, type:) do
+        filters.each { |filter| instance_eval(&filter) }
       end
-      post_extension = DSL::InsideRoute.post_filter_methods(type)
-      extend post_extension if post_extension
     end
 
     %i[befores before_validations after_validations afters finallies].each do |method|
       define_method method do
-        namespace_stackable(method)
-      end
-    end
-
-    def validations
-      return enum_for(:validations) unless block_given?
-
-      route_setting(:saved_validations)&.each do |saved_validation|
-        yield Grape::Validations::ValidatorFactory.create_validator(saved_validation)
+        inheritable_setting.namespace_stackable[method]
       end
     end
 
@@ -351,45 +247,104 @@ module Grape
 
     private
 
-    def build_stack(helpers)
+    attr_reader :before_filter_passed
+
+    def compile!
+      @app = options[:app] || build_stack
+      @helpers = build_helpers
+    end
+
+    def to_routes
+      route_options = options[:route_options]
+      default_route_options = prepare_default_route_attributes(route_options)
+      complete_route_options = route_options.merge(default_route_options)
+      path_settings = prepare_default_path_settings
+
+      options[:method].flat_map do |method|
+        options[:path].map do |path|
+          prepared_path = Path.new(path, default_route_options[:namespace], path_settings)
+          pattern = Grape::Router::Pattern.new(
+            origin: prepared_path.origin,
+            suffix: prepared_path.suffix,
+            anchor: default_route_options[:anchor],
+            params: route_options[:params],
+            format: options[:format],
+            version: default_route_options[:version],
+            requirements: default_route_options[:requirements]
+          )
+          Grape::Router::Route.new(self, method, pattern, complete_route_options)
+        end
+      end
+    end
+
+    def prepare_default_route_attributes(route_options)
+      {
+        namespace:,
+        version: prepare_version(inheritable_setting.namespace_inheritable[:version]),
+        requirements: prepare_routes_requirements(route_options[:requirements]),
+        prefix: inheritable_setting.namespace_inheritable[:root_prefix],
+        anchor: route_options.fetch(:anchor, true),
+        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
+        forward_match: options[:forward_match]
+      }
+    end
+
+    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 prepare_routes_requirements(route_options_requirements)
+      namespace_requirements = inheritable_setting.namespace_stackable[:namespace].filter_map(&:requirements)
+      namespace_requirements << route_options_requirements if route_options_requirements.present?
+      namespace_requirements.reduce({}, :merge)
+    end
+
+    def prepare_version(namespace_inheritable_version)
+      return if namespace_inheritable_version.blank?
+
+      namespace_inheritable_version.length == 1 ? namespace_inheritable_version.first : namespace_inheritable_version
+    end
+
+    def build_stack
       stack = Grape::Middleware::Stack.new
 
-      content_types = namespace_stackable_with_hash(:content_types)
-      format = namespace_inheritable(:format)
+      content_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
+      format = inheritable_setting.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
+      stack.use Grape::Middleware::Error,
+                format:,
+                content_types:,
+                default_status: inheritable_setting.namespace_inheritable[:default_error_status],
+                rescue_all: inheritable_setting.namespace_inheritable[:rescue_all],
+                rescue_grape_exceptions: inheritable_setting.namespace_inheritable[:rescue_grape_exceptions],
+                default_error_formatter: inheritable_setting.namespace_inheritable[:default_error_formatter],
+                error_formatters: inheritable_setting.namespace_stackable_with_hash(:error_formatters),
+                rescue_options: inheritable_setting.namespace_stackable_with_hash(:rescue_options),
+                rescue_handlers:,
+                base_only_rescue_handlers: inheritable_setting.namespace_stackable_with_hash(:base_only_rescue_handlers),
+                all_rescue_handler: inheritable_setting.namespace_inheritable[:all_rescue_handler],
+                grape_exceptions_rescue_handler: inheritable_setting.namespace_inheritable[:grape_exceptions_rescue_handler]
+
+      stack.concat inheritable_setting.namespace_stackable[:middleware]
+
+      if inheritable_setting.namespace_inheritable[:version].present?
+        stack.use Grape::Middleware::Versioner.using(inheritable_setting.namespace_inheritable[:version_options][:using]),
+                  versions: inheritable_setting.namespace_inheritable[:version].flatten,
+                  version_options: inheritable_setting.namespace_inheritable[:version_options],
+                  prefix: inheritable_setting.namespace_inheritable[:root_prefix],
+                  mount_path: inheritable_setting.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)
+                format:,
+                default_format: inheritable_setting.namespace_inheritable[:default_format] || :txt,
+                content_types:,
+                formatters: inheritable_setting.namespace_stackable_with_hash(:formatters),
+                parsers: inheritable_setting.namespace_stackable_with_hash(:parsers)
 
       builder = stack.build
       builder.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
@@ -397,7 +352,7 @@ module Grape
     end
 
     def build_helpers
-      helpers = namespace_stackable(:helpers)
+      helpers = inheritable_setting.namespace_stackable[:helpers]
       return if helpers.empty?
 
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
@@ -405,13 +360,22 @@ module Grape
 
     def build_response_cookies
       response_cookies do |name, value|
-        cookie_value = value.is_a?(Hash) ? value : { value: value }
+        cookie_value = value.is_a?(Hash) ? value : { value: }
         Rack::Utils.set_cookie_header! header, name, cookie_value
       end
     end
 
     def lint?
-      namespace_inheritable(:lint) || Grape.config.lint
+      inheritable_setting.namespace_inheritable[:lint] || Grape.config.lint
+    end
+
+    def rescue_handlers
+      rescue_handlers = inheritable_setting.namespace_reverse_stackable[:rescue_handlers]
+      return if rescue_handlers.blank?
+
+      rescue_handlers.each_with_object({}) do |rescue_handler, result|
+        result.merge!(rescue_handler) { |_k, s1, _s2| s1 }
+      end
     end
   end
 end

data/lib/grape/error_formatter/base.rb

@@ -40,7 +40,7 @@ module Grape
           end
 
           if presenter
-            embeds = { env: env }
+            embeds = { env: }
             embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
             presented_message = presenter.represent(presented_message, embeds).serializable_hash
           end
@@ -51,13 +51,15 @@ module Grape
         def wrap_message(message)
           return message if message.is_a?(Hash)
 
-          { message: message }
+          { message: }
         end
 
         def format_structured_message(_structured_message)
           raise NotImplementedError
         end
 
+        private
+
         def inherited(klass)
           super
           ErrorFormatter.register(klass)