grape 2.3.0 → 3.0.0

data/lib/grape/dsl/validations.rb

@@ -3,54 +3,46 @@
 module Grape
   module DSL
     module Validations
-      extend ActiveSupport::Concern
-
-      include Grape::DSL::Configuration
-
-      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
+      # 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
 
-        # 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
+      # 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
 
-        # 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)
+      # 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
+        Grape::Validations::ContractScope.new(self, contract, &block)
       end
     end
   end

data/lib/grape/endpoint.rb

@@ -6,17 +6,17 @@ 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::Headers
     include Grape::DSL::InsideRoute
 
-    attr_accessor :block, :source, :options
-    attr_reader :env, :request, :headers, :params
+    attr_reader :env, :request, :source, :options
 
-    class << self
-      def new(...)
-        self == Endpoint ? Class.new(Endpoint).new(...) : super
-      end
+    def_delegators :request, :params, :headers, :cookies
+    def_delegator :cookies, :response_cookies
 
+    class << self
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
@@ -30,34 +30,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) }
-      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
+        before_each.each { |blk| blk.try(:call, endpoint) }
       end
     end
 
@@ -82,11 +55,11 @@ module Grape
       # 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] = [] unless inheritable_setting.namespace_stackable[:representations]
+      inheritable_setting.namespace_inheritable[:default_error_status] = 500 unless inheritable_setting.namespace_inheritable[:default_error_status]
 
       @options = options
 
@@ -98,17 +71,11 @@ module Grape
 
       @lazy_initialize_lock = Mutex.new
       @lazy_initialized = nil
-      @block = nil
-
       @status = nil
       @stream = nil
       @body = nil
-      @proc = nil
-
-      return unless block
-
       @source = block
-      @block = self.class.generate_api_method(method_name, &block)
+      @helpers = build_helpers
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -126,16 +93,8 @@ module Grape
       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 ? endpoints.collect(&:routes).flatten : to_routes
+      @routes ||= endpoints&.collect(&:routes)&.flatten || to_routes
     end
 
     def reset_routes!
@@ -150,7 +109,7 @@ module Grape
       reset_routes!
       routes.each do |route|
         router.append(route.apply(self))
-        next unless !namespace_inheritable(:do_not_route_head) && route.request_method == Rack::GET
+        next unless !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!
@@ -161,10 +120,9 @@ module Grape
 
     def to_routes
       default_route_options = prepare_default_route_attributes
-      default_path_settings = prepare_default_path_settings
 
       map_routes do |method, raw_path|
-        prepared_path = Path.new(raw_path, namespace, default_path_settings)
+        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)
@@ -172,7 +130,7 @@ module Grape
     end
 
     def prepare_routes_requirements
-      {}.merge!(*namespace_stackable(:namespace).map(&:requirements)).tap do |requirements|
+      {}.merge!(*inheritable_setting.namespace_stackable[:namespace].map(&:requirements)).tap do |requirements|
         endpoint_requirements = options.dig(:route_options, :requirements)
         requirements.merge!(endpoint_requirements) if endpoint_requirements
       end
@@ -183,7 +141,7 @@ module Grape
         namespace: namespace,
         version: prepare_version,
         requirements: prepare_routes_requirements,
-        prefix: namespace_inheritable(:root_prefix),
+        prefix: inheritable_setting.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]
@@ -191,7 +149,7 @@ module Grape
     end
 
     def prepare_version
-      version = namespace_inheritable(:version)
+      version = inheritable_setting.namespace_inheritable[:version]
       return if version.blank?
 
       version.length == 1 ? version.first : version
@@ -208,7 +166,7 @@ module Grape
     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)
@@ -219,13 +177,15 @@ module Grape
     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
-      options[:app].endpoints if options[:app].respond_to?(:endpoints)
+      @endpoints ||= options[:app].try(:endpoints)
     end
 
     def equals?(endpoint)
@@ -245,20 +205,16 @@ module Grape
 
     def run
       ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env: env) do
-        @header = Grape::Util::Header.new
-        @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
-        @params = @request.params
-        @headers = @request.headers
+        @request = Grape::Request.new(env, build_params_with: inheritable_setting.namespace_inheritable[:build_params_with])
         begin
-          cookies.read(@request)
           self.class.run_before_each(self)
           run_filters befores, :before
 
-          if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
-            allow_header_value = allowed_methods.join(', ')
-            raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allow_header_value)) 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, allow_header_value
+            header 'Allow', header['Allow']
             response_object = ''
             status 204
           else
@@ -269,7 +225,7 @@ module Grape
           end
 
           run_filters afters, :after
-          cookies.write(header)
+          build_response_cookies
 
           # status verifies body presence when DELETE
           @body ||= response_object
@@ -285,11 +241,14 @@ module Grape
     end
 
     def execute
-      @block&.call(self)
-    end
+      return unless @source
 
-    def helpers
-      lazy_initialize! && @helpers
+      ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self) do
+        instance_exec(&@source)
+      rescue LocalJumpError => e
+        Grape.deprecator.warn 'Using `return` in an endpoint has been deprecated. Use `next` instead.'
+        return e.exit_value
+      end
     end
 
     def lazy_initialize!
@@ -298,9 +257,7 @@ module Grape
       @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)
-
+        @app = options[:app] || build_stack
         @lazy_initialized = true
       end
     end
@@ -331,30 +288,18 @@ module Grape
       extend post_extension if post_extension
     end
 
-    def befores
-      namespace_stackable(:befores)
-    end
-
-    def before_validations
-      namespace_stackable(:before_validations)
-    end
-
-    def after_validations
-      namespace_stackable(:after_validations)
-    end
-
-    def afters
-      namespace_stackable(:afters)
-    end
-
-    def finallies
-      namespace_stackable(:finallies)
+    %i[befores before_validations after_validations afters finallies].each do |method|
+      define_method method do
+        inheritable_setting.namespace_stackable[method]
+      end
     end
 
     def validations
+      saved_validations = inheritable_setting.route[:saved_validations]
+      return if saved_validations.nil?
       return enum_for(:validations) unless block_given?
 
-      route_setting(:saved_validations)&.each do |saved_validation|
+      saved_validations.each do |saved_validation|
         yield Grape::Validations::ValidatorFactory.create_validator(saved_validation)
       end
     end
@@ -366,44 +311,44 @@ module Grape
 
     private
 
-    def build_stack(helpers)
+    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 Class.new(Grape::Middleware::Error),
-                helpers: helpers,
+      stack.use Rack::Lint if lint?
+      stack.use Grape::Middleware::Error,
                 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
+                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: 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,
+                default_format: inheritable_setting.namespace_inheritable[:default_format] || :txt,
                 content_types: content_types,
-                formatters: namespace_stackable_with_hash(:formatters),
-                parsers: namespace_stackable_with_hash(:parsers)
+                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 }
@@ -411,10 +356,30 @@ 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 } }
     end
+
+    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 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

@@ -58,6 +58,8 @@ module Grape
           raise NotImplementedError
         end
 
+        private
+
         def inherited(klass)
           super
           ErrorFormatter.register(klass)

data/lib/grape/exceptions/base.rb

@@ -17,7 +17,7 @@ module Grape
       end
 
       def [](index)
-        send index
+        __send__ index
       end
 
       protected

data/lib/grape/exceptions/conflicting_types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class ConflictingTypes < Base
+      def initialize
+        super(message: compose_message(:conflicting_types), status: 400)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/invalid_parameters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class InvalidParameters < Base
+      def initialize
+        super(message: compose_message(:invalid_parameters), status: 400)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/missing_group_type.rb

@@ -9,5 +9,3 @@ module Grape
     end
   end
 end
-
-Grape::Exceptions::MissingGroupTypeError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Grape::Exceptions::MissingGroupTypeError', 'Grape::Exceptions::MissingGroupType', Grape.deprecator)

data/lib/grape/exceptions/too_deep_parameters.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class TooDeepParameters < Base
+      def initialize(limit)
+        super(message: compose_message(:too_deep_parameters, limit: limit), status: 400)
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_auth_strategy.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class UnknownAuthStrategy < Base
+      def initialize(strategy:)
+        super(message: compose_message(:unknown_auth_strategy, strategy: strategy))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_params_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class UnknownParamsBuilder < Base
+      def initialize(params_builder_type)
+        super(message: compose_message(:unknown_params_builder, params_builder_type: params_builder_type))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unsupported_group_type.rb

@@ -9,5 +9,3 @@ module Grape
     end
   end
 end
-
-Grape::Exceptions::UnsupportedGroupTypeError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Grape::Exceptions::UnsupportedGroupTypeError', 'Grape::Exceptions::UnsupportedGroupType', Grape.deprecator)

data/lib/grape/extensions/active_support/hash_with_indifferent_access.rb

@@ -8,11 +8,8 @@ module Grape
           extend ::ActiveSupport::Concern
 
           included do
-            namespace_inheritable(:build_params_with, Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder)
-          end
-
-          def params_builder
-            Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+            Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+            namespace_inheritable(:build_params_with, :hash_with_indifferent_access)
           end
 
           def build_params

data/lib/grape/extensions/hash.rb

@@ -7,7 +7,8 @@ module Grape
         extend ::ActiveSupport::Concern
 
         included do
-          namespace_inheritable(:build_params_with, Grape::Extensions::Hash::ParamBuilder)
+          Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+          namespace_inheritable(:build_params_with, :hash)
         end
 
         def build_params

data/lib/grape/extensions/hashie/mash.rb

@@ -6,12 +6,10 @@ module Grape
       module Mash
         module ParamBuilder
           extend ::ActiveSupport::Concern
-          included do
-            namespace_inheritable(:build_params_with, Grape::Extensions::Hashie::Mash::ParamBuilder)
-          end
 
-          def params_builder
-            Grape::Extensions::Hashie::Mash::ParamBuilder
+          included do
+            Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+            namespace_inheritable(:build_params_with, :hashie_mash)
           end
 
           def build_params