grape 3.0.1 → 3.1.0

data/lib/grape/dsl/parameters.rb

@@ -160,33 +160,15 @@ module Grape
       # Define common settings for one or more parameters
       # @param (see #requires)
       # @option (see #requires)
-      def with(*attrs, &block)
+      def with(*attrs, &)
         new_group_attrs = [@group, attrs.clone.first].compact.reduce(&:deep_merge)
-        new_group_scope([new_group_attrs], &block)
+        new_group_scope([new_group_attrs], &)
       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) })
-      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: message })
+        end
       end
 
       # Define a block of validations which should be applied if and only if
@@ -196,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

data/lib/grape/dsl/routing.rb

@@ -5,6 +5,22 @@ module Grape
     module Routing
       attr_reader :endpoints
 
+      def given(conditional_option, &)
+        return unless conditional_option
+
+        mounted(&)
+      end
+
+      def mounted(&block)
+        evaluate_as_instance_with_configuration(block, lazy: true)
+      end
+
+      def cascade(value = nil)
+        return inheritable_setting.namespace_inheritable.key?(:cascade) ? !inheritable_setting.namespace_inheritable[:cascade].nil? : true if value.nil?
+
+        inheritable_setting.namespace_inheritable[:cascade] = value
+      end
+
       # Specify an API version.
       #
       # @example API with legacy support.
@@ -141,7 +157,7 @@ module Grape
       #       {hello: 'world'}
       #     end
       #   end
-      def route(methods, paths = ['/'], route_options = {}, &block)
+      def route(methods, paths = ['/'], route_options = {}, &)
         method = methods == :any ? '*' : methods
         endpoint_params = inheritable_setting.namespace_stackable_with_hash(:params) || {}
         endpoint_description = inheritable_setting.route[:description]
@@ -149,14 +165,14 @@ module Grape
         all_route_options.deep_merge!(endpoint_description) if endpoint_description
         all_route_options.deep_merge!(route_options) if route_options&.any?
 
-        endpoint_options = {
+        new_endpoint = Grape::Endpoint.new(
+          inheritable_setting,
           method: method,
           path: paths,
           for: self,
-          route_options: all_route_options
-        }
-
-        new_endpoint = Grape::Endpoint.new(inheritable_setting, endpoint_options, &block)
+          route_options: all_route_options,
+          &
+        )
         endpoints << new_endpoint unless endpoints.any? { |e| e.equals?(new_endpoint) }
 
         inheritable_setting.route_end
@@ -182,12 +198,12 @@ module Grape
       #         # defines the endpoint: GET /foo/bar
       #       end
       #     end
-      def namespace(space = nil, options = {}, &block)
+      def namespace(space = nil, requirements: nil, **options, &block)
         return Namespace.joined_space_path(inheritable_setting.namespace_stackable[:namespace]) unless space || block
 
         within_namespace do
           nest(block) do
-            inheritable_setting.namespace_stackable[:namespace] = Grape::Namespace.new(space, options) if space
+            inheritable_setting.namespace_stackable[:namespace] = Grape::Namespace.new(space, requirements: requirements, **options) if space
           end
         end
       end
@@ -202,33 +218,19 @@ module Grape
         @routes ||= endpoints.map(&:routes).flatten
       end
 
-      # Remove all defined routes.
-      def reset_routes!
-        endpoints.each(&:reset_routes!)
-        @routes = nil
-      end
-
-      def reset_endpoints!
-        @endpoints = []
-      end
-
       # This method allows you to quickly define a parameter route segment
       # in your API.
       #
       # @param param [Symbol] The name of the parameter you wish to declare.
       # @option options [Regexp] You may supply a regular expression that the declared parameter must meet.
-      def route_param(param, options = {}, &block)
-        options = options.dup
-
-        options[:requirements] = {
-          param.to_sym => options[:requirements]
-        } if options[:requirements].is_a?(Regexp)
+      def route_param(param, requirements: nil, type: nil, **options, &)
+        requirements = { param.to_sym => requirements } if requirements.is_a?(Regexp)
 
         Grape::Validations::ParamsScope.new(api: self) do
-          requires param, type: options[:type]
-        end if options.key?(:type)
+          requires param, type: type
+        end if type
 
-        namespace(":#{param}", options, &block)
+        namespace(":#{param}", requirements: requirements, **options, &)
       end
 
       # @return array of defined versions
@@ -238,6 +240,16 @@ module Grape
 
       private
 
+      # Remove all defined routes.
+      def reset_routes!
+        endpoints.each(&:reset_routes!)
+        @routes = nil
+      end
+
+      def reset_endpoints!
+        @endpoints = []
+      end
+
       def refresh_mounted_api(mounts, *opts)
         opts << { refresh_already_mounted: true }
         mount(mounts, *opts)
@@ -260,12 +272,12 @@ module Grape
       def evaluate_as_instance_with_configuration(block, lazy: false)
         lazy_block = Grape::Util::Lazy::Block.new do |configuration|
           value_for_configuration = configuration
-          self.configuration = value_for_configuration.evaluate if value_for_configuration.try(:lazy?)
+          self.configuration = value_for_configuration.evaluate if value_for_configuration.respond_to?(:lazy?) && value_for_configuration.lazy?
           response = instance_eval(&block)
           self.configuration = value_for_configuration
           response
         end
-        if base && base_instance? && lazy
+        if @base && base_instance? && lazy
           lazy_block
         else
           lazy_block.evaluate_from(configuration)

data/lib/grape/dsl/settings.rb

@@ -7,7 +7,7 @@ module Grape
     # matter where they're defined, and inheritable settings which apply only
     # in the current scope and scopes nested under it.
     module Settings
-      attr_writer :inheritable_setting, :top_level_setting
+      attr_writer :inheritable_setting
 
       # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting

data/lib/grape/dsl/validations.rb

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

data/lib/grape/endpoint.rb

@@ -30,7 +30,16 @@ module Grape
 
       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
+
+      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
 
@@ -46,10 +55,7 @@ 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
@@ -65,16 +71,13 @@ module Grape
 
       @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
       @status = nil
       @stream = nil
       @body = nil
-      @source = block
+      @source = self.class.block_to_unbound_method(block)
+      @before_filter_passed = false
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -88,10 +91,6 @@ 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 routes
       @routes ||= endpoints&.collect(&:routes)&.flatten || to_routes
     end
@@ -103,9 +102,13 @@ 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 !inheritable_setting.namespace_inheritable[:do_not_route_head] && route.request_method == Rack::GET
@@ -117,59 +120,11 @@ 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!(*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
-    end
-
-    def prepare_default_route_attributes
-      {
-        namespace: namespace,
-        version: prepare_version,
-        requirements: prepare_routes_requirements,
-        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]
-      }
-    end
-
-    def prepare_version
-      version = inheritable_setting.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(inheritable_setting.namespace_stackable[:namespace])
     end
 
     def call(env)
-      lazy_initialize!
       dup.call!(env)
     end
 
@@ -184,7 +139,7 @@ module Grape
     # 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)
+      @endpoints ||= options[:app].respond_to?(:endpoints) ? options[:app].endpoints : nil
     end
 
     def equals?(endpoint)
@@ -208,6 +163,7 @@ module Grape
         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(', ')
@@ -243,22 +199,7 @@ module Grape
       return unless @source
 
       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!
-      return true if @lazy_initialized
-
-      @lazy_initialize_lock.synchronize do
-        return true if @lazy_initialized
-
-        @app = options[:app] || build_stack
-        @helpers = build_helpers
-        @lazy_initialized = true
+        @source.bind_call(self)
       end
     end
 
@@ -281,11 +222,11 @@ module Grape
     end
 
     def run_filters(filters, type = :other)
+      return unless filters
+
       ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
-        filters&.each { |filter| instance_eval(&filter) }
+        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|
@@ -311,6 +252,66 @@ module Grape
 
     private
 
+    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: 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
 

data/lib/grape/exceptions/base.rb

@@ -65,7 +65,7 @@ module Grape
       end
 
       def fallback_message(key, options)
-        if ::I18n.enforce_available_locales && ::I18n.available_locales.exclude?(FALLBACK_LOCALE)
+        if ::I18n.enforce_available_locales && !::I18n.available_locales.include?(FALLBACK_LOCALE)
           key
         else
           ::I18n.translate(key, locale: FALLBACK_LOCALE, **options)

data/lib/grape/middleware/auth/dsl.rb

@@ -16,12 +16,12 @@ module Grape
         #
         # @param [Hash] options A hash of options.
         # @option options [String] :realm "API Authorization" The HTTP Basic realm.
-        def http_basic(options = {}, &block)
+        def http_basic(options = {}, &)
           options[:realm] ||= 'API Authorization'
-          auth :http_basic, options, &block
+          auth(:http_basic, options, &)
         end
 
-        def http_digest(options = {}, &block)
+        def http_digest(options = {}, &)
           options[:realm] ||= 'API Authorization'
 
           if options[:realm].respond_to?(:values_at)
@@ -30,7 +30,7 @@ module Grape
             options[:opaque] ||= 'secret'
           end
 
-          auth :http_digest, options, &block
+          auth(:http_digest, options, &)
         end
       end
     end

data/lib/grape/middleware/base.rb

@@ -109,6 +109,10 @@ module Grape
           options
         end
       end
+
+      def try_scrub(obj)
+        obj.respond_to?(:valid_encoding?) && !obj.valid_encoding? ? obj.scrub : obj
+      end
     end
   end
 end

data/lib/grape/middleware/error.rb

@@ -58,7 +58,7 @@ module Grape
           h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
         end
         backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
-        original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
+        original_exception = error.is_a?(Exception) ? error : error[:original_exception]
         rack_response(status, headers, format_message(message, backtrace, original_exception))
       end
 

data/lib/grape/middleware/formatter.rb

@@ -69,12 +69,14 @@ module Grape
         return if input.nil?
         return unless read_body_input?
 
-        input.try(:rewind)
+        rewind = input.respond_to?(:rewind)
+
+        input.rewind if rewind
         body = env[Grape::Env::API_REQUEST_INPUT] = input.read
         begin
           read_rack_input(body)
         ensure
-          input.try(:rewind)
+          input.rewind if rewind
         end
       end
 
@@ -130,7 +132,7 @@ module Grape
       end
 
       def format_from_extension
-        request_path = rack_request.path.try(:scrub)
+        request_path = try_scrub(rack_request.path)
         dot_pos = request_path.rindex('.')
         return unless dot_pos
 
@@ -139,7 +141,7 @@ module Grape
       end
 
       def format_from_header
-        accept_header = env['HTTP_ACCEPT'].try(:scrub)
+        accept_header = try_scrub(env['HTTP_ACCEPT'])
         return if accept_header.blank? || accept_header == ALL_MEDIA_TYPES
 
         media_type = Rack::Utils.best_q_match(accept_header, mime_types.keys)

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

@@ -18,7 +18,7 @@ module Grape
       # route.
       class AcceptVersionHeader < Base
         def before
-          potential_version = env['HTTP_ACCEPT_VERSION'].try(:scrub)
+          potential_version = try_scrub(env['HTTP_ACCEPT_VERSION'])
           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

@@ -50,6 +50,26 @@ module Grape
         def version_not_found!
           throw :error, status: 404, message: '404 API Version Not Found', headers: CASCADE_PASS_HEADER
         end
+
+        private
+
+        def available_media_types
+          @available_media_types ||= begin
+            media_types = []
+            base_media_type = "application/vnd.#{vendor}"
+            content_types.each_key do |extension|
+              versions&.reverse_each do |version|
+                media_types << "#{base_media_type}-#{version}+#{extension}"
+                media_types << "#{base_media_type}-#{version}"
+              end
+              media_types << "#{base_media_type}+#{extension}"
+            end
+
+            media_types << base_media_type
+            media_types.concat(content_types.values.flatten)
+            media_types
+          end
+        end
       end
     end
   end

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

@@ -101,26 +101,10 @@ module Grape
         end
 
         def version_not_found!(media_types)
-          return unless media_types.all? { |media_type| media_type&.version && versions&.exclude?(media_type.version) }
+          return unless media_types.all? { |media_type| media_type&.version && versions && !versions.include?(media_type.version) }
 
           invalid_version_header!('API version not found.')
         end
-
-        def available_media_types
-          [].tap do |available_media_types|
-            base_media_type = "application/vnd.#{vendor}"
-            content_types.each_key do |extension|
-              versions&.reverse_each do |version|
-                available_media_types << "#{base_media_type}-#{version}+#{extension}"
-                available_media_types << "#{base_media_type}-#{version}"
-              end
-              available_media_types << "#{base_media_type}+#{extension}"
-            end
-
-            available_media_types << base_media_type
-            available_media_types.concat(content_types.values.flatten)
-          end
-        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module Grape
           return if path_info == '/'
 
           [mount_path, Grape::Router.normalize_path(prefix)].each do |path|
-            path_info.delete_prefix!(path) if path.present? && path != '/' && path_info.start_with?(path)
+            path_info = path_info.delete_prefix(path) if path.present? && path != '/' && path_info.start_with?(path)
           end
 
           slash_position = path_info.index('/', 1) # omit the first one