grape 2.4.0 → 3.0.1

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

@@ -8,19 +8,15 @@ 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
 
     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
@@ -36,33 +32,6 @@ module Grape
         superclass.run_before_each(endpoint) unless self == Endpoint
         before_each.each { |blk| blk.try(: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
-      end
     end
 
     # Create a new endpoint.
@@ -86,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
 
@@ -102,17 +71,10 @@ 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)
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -130,14 +92,6 @@ 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&.collect(&:routes)&.flatten || to_routes
     end
@@ -154,7 +108,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!
@@ -175,7 +129,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
@@ -186,7 +140,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]
@@ -194,7 +148,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
@@ -211,7 +165,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)
@@ -222,6 +176,8 @@ 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
 
@@ -248,7 +204,7 @@ module Grape
 
     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))
+        @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
@@ -284,11 +240,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!
@@ -297,9 +256,8 @@ 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
+        @helpers = build_helpers
         @lazy_initialized = true
       end
     end
@@ -332,14 +290,16 @@ module Grape
 
     %i[befores before_validations after_validations afters finallies].each do |method|
       define_method method do
-        namespace_stackable(method)
+        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
@@ -351,45 +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 Rack::Lint if lint?
-      stack.use Class.new(Grape::Middleware::Error),
-                helpers: helpers,
+      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 }
@@ -397,7 +356,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 } }
@@ -411,7 +370,16 @@ module Grape
     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

@@ -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/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/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/middleware/auth/dsl.rb

@@ -5,12 +5,11 @@ module Grape
     module Auth
       module DSL
         def auth(type = nil, options = {}, &block)
-          if type
-            namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block))
-            use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
-          else
-            namespace_inheritable(:auth)
-          end
+          namespace_inheritable = inheritable_setting.namespace_inheritable
+          return namespace_inheritable[:auth] unless type
+
+          namespace_inheritable[:auth] = options.reverse_merge(type: type.to_sym, proc: block)
+          use Grape::Middleware::Auth::Base, namespace_inheritable[:auth]
         end
 
         # Add HTTP Basic authorization to the API.

data/lib/grape/middleware/error.rb

@@ -16,11 +16,6 @@ module Grape
         }.freeze
       }.freeze
 
-      def initialize(app, **options)
-        super
-        self.class.include(options[:helpers]) if options[:helpers]
-      end
-
       def call!(env)
         @env = env
         error_response(catch(:error) { return @app.call(@env) })
@@ -103,12 +98,7 @@ module Grape
       end
 
       def run_rescue_handler(handler, error, endpoint)
-        if handler.instance_of?(Symbol)
-          raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
-
-          handler = public_method(handler)
-        end
-
+        handler = endpoint.public_method(handler) if handler.instance_of?(Symbol)
         response = catch(:error) do
           handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
         end

data/lib/grape/middleware/formatter.rb

@@ -7,6 +7,8 @@ module Grape
         default_format: :txt
       }.freeze
 
+      ALL_MEDIA_TYPES = '*/*'
+
       def before
         negotiate_content_type
         read_body_input
@@ -132,13 +134,13 @@ module Grape
         dot_pos = request_path.rindex('.')
         return unless dot_pos
 
-        extension = request_path[dot_pos + 1..]
+        extension = request_path[(dot_pos + 1)..]
         extension if content_type_for(extension)
       end
 
       def format_from_header
         accept_header = env['HTTP_ACCEPT'].try(:scrub)
-        return if accept_header.blank?
+        return if accept_header.blank? || accept_header == ALL_MEDIA_TYPES
 
         media_type = Rack::Utils.best_q_match(accept_header, mime_types.keys)
         mime_types[media_type] if media_type

data/lib/grape/middleware/stack.rb

@@ -6,6 +6,7 @@ module Grape
     # It allows to insert and insert after
     class Stack
       extend Forwardable
+
       class Middleware
         attr_reader :args, :block, :klass
 
@@ -59,9 +60,9 @@ module Grape
 
       alias insert_before insert
 
-      def insert_after(index, *args, &block)
+      def insert_after(index, ...)
         index = assert_index(index, :after)
-        insert(index + 1, *args, &block)
+        insert(index + 1, ...)
       end
 
       def use(klass, *args, &block)

data/lib/grape/middleware/versioner/accept_version_header.rb

@@ -19,7 +19,7 @@ module Grape
       class AcceptVersionHeader < Base
         def before
           potential_version = env['HTTP_ACCEPT_VERSION'].try(:scrub)
-          not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?
+          not_acceptable!('Accept-Version header must be set.') if strict && potential_version.blank?
 
           return if potential_version.blank?
 

data/lib/grape/middleware/versioner/base.rb

@@ -5,68 +5,50 @@ module Grape
     module Versioner
       class Base < Grape::Middleware::Base
         DEFAULT_OPTIONS = {
-          pattern: /.*/i.freeze,
+          pattern: /.*/i,
+          prefix: nil,
+          mount_path: nil,
           version_options: {
             strict: false,
             cascade: true,
-            parameter: 'apiver'
+            parameter: 'apiver',
+            vendor: nil
           }.freeze
         }.freeze
 
-        def self.inherited(klass)
-          super
-          Versioner.register(klass)
-        end
-
-        def versions
-          options[:versions]
-        end
-
-        def prefix
-          options[:prefix]
-        end
-
-        def mount_path
-          options[:mount_path]
-        end
+        CASCADE_PASS_HEADER = { 'X-Cascade' => 'pass' }.freeze
 
-        def pattern
-          options[:pattern]
+        DEFAULT_OPTIONS.each_key do |key|
+          define_method key do
+            options[key]
+          end
         end
 
-        def version_options
-          options[:version_options]
+        DEFAULT_OPTIONS[:version_options].each_key do |key|
+          define_method key do
+            options[:version_options][key]
+          end
         end
 
-        def strict?
-          version_options[:strict]
-        end
-
-        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-        # of routes (see Grape::Router) for more information). To prevent
-        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
-        def cascade?
-          version_options[:cascade]
-        end
-
-        def parameter_key
-          version_options[:parameter]
+        def self.inherited(klass)
+          super
+          Versioner.register(klass)
         end
 
-        def vendor
-          version_options[:vendor]
-        end
+        attr_reader :error_headers, :versions
 
-        def error_headers
-          cascade? ? { 'X-Cascade' => 'pass' } : {}
+        def initialize(app, **options)
+          super
+          @error_headers = cascade ? CASCADE_PASS_HEADER : {}
+          @versions = options[:versions]&.map(&:to_s) # making sure versions are strings to ease potential match
         end
 
         def potential_version_match?(potential_version)
-          versions.blank? || versions.any? { |v| v.to_s == potential_version }
+          versions.blank? || versions.include?(potential_version)
         end
 
         def version_not_found!
-          throw :error, status: 404, message: '404 API Version Not Found', headers: { 'X-Cascade' => 'pass' }
+          throw :error, status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER
         end
       end
     end

data/lib/grape/middleware/versioner/header.rb

@@ -53,7 +53,7 @@ module Grape
         end
 
         def strict_header_checks!
-          return unless strict?
+          return unless strict
 
           accept_header_check!
           version_and_vendor_check!

data/lib/grape/middleware/versioner/param.rb

@@ -20,11 +20,11 @@ module Grape
       #   env['api.version'] => 'v1'
       class Param < Base
         def before
-          potential_version = query_params[parameter_key]
+          potential_version = query_params[parameter]
           return if potential_version.blank?
 
           version_not_found! unless potential_version_match?(potential_version)
-          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter_key)
+          env[Grape::Env::API_VERSION] = env[Rack::RACK_REQUEST_QUERY_HASH].delete(parameter)
         end
       end
     end