grape 1.0.0 → 1.6.0

data/lib/grape/dsl/parameters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Grape
@@ -70,7 +72,7 @@ module Grape
 
       # Require one or more parameters for the current endpoint.
       #
-      # @param attrs list of parameter names, or, if :using is
+      # @param attrs list of parameters names, or, if :using is
       #   passed as an option, which keys to include (:all or :none) from
       #   the :using hash. The last key can be a hash, which specifies
       #   options for the parameters
@@ -125,14 +127,13 @@ module Grape
 
         opts = attrs.extract_options!.clone
         opts[:presence] = { value: true, message: opts[:message] }
-        opts = @group.merge(opts) if @group
+        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
 
         if opts[:using]
           require_required_and_optional_fields(attrs.first, opts)
         else
           validate_attributes(attrs, opts, &block)
-
-          block_given? ? new_scope(orig_attrs, &block) : push_declared_params(attrs)
+          block ? new_scope(orig_attrs, &block) : push_declared_params(attrs, **opts.slice(:as))
         end
       end
 
@@ -145,10 +146,10 @@ module Grape
 
         opts = attrs.extract_options!.clone
         type = opts[:type]
-        opts = @group.merge(opts) if @group
+        opts = @group.merge(opts) if instance_variable_defined?(:@group) && @group
 
         # check type for optional parameter group
-        if attrs && block_given?
+        if attrs && block
           raise Grape::Exceptions::MissingGroupTypeError.new if type.nil?
           raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
@@ -158,7 +159,7 @@ module Grape
         else
           validate_attributes(attrs, opts, &block)
 
-          block_given? ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs)
+          block ? new_scope(orig_attrs, true, &block) : push_declared_params(attrs, **opts.slice(:as))
         end
       end
 
@@ -202,7 +203,7 @@ module Grape
       # @yield a parameter definition DSL
       def given(*attrs, &block)
         attrs.each do |attr|
-          proxy_attr = attr.is_a?(Hash) ? attr.keys[0] : 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)
@@ -212,20 +213,31 @@ module Grape
       # block yet.
       # @return [Boolean] whether the parameter has been defined
       def declared_param?(param)
-        # @declared_params also includes hashes of options and such, but those
-        # won't be flattened out.
-        @declared_params.flatten.include?(param)
+        if lateral?
+          # Elements of @declared_params of lateral scope are pushed in @parent. So check them in @parent.
+          @parent.declared_param?(param)
+        else
+          # @declared_params also includes hashes of options and such, but those
+          # won't be flattened out.
+          @declared_params.flatten.any? do |declared_param|
+            first_hash_key_or_param(declared_param) == param
+          end
+        end
       end
 
       alias group requires
 
-      def map_params(params, element)
+      class EmptyOptionalValue; end
+
+      def map_params(params, element, is_array = false)
         if params.is_a?(Array)
           params.map do |el|
-            map_params(el, element)
+            map_params(el, element, true)
           end
         elsif params.is_a?(Hash)
-          params[element] || {}
+          params[element] || (@optional && is_array ? EmptyOptionalValue : {})
+        elsif params == EmptyOptionalValue
+          EmptyOptionalValue
         else
           {}
         end
@@ -235,10 +247,16 @@ module Grape
       # @return hash of parameters relevant for the current scope
       # @api private
       def params(params)
-        params = @parent.params(params) if @parent
-        params = map_params(params, @element) if @element
+        params = @parent.params(params) if instance_variable_defined?(:@parent) && @parent
+        params = map_params(params, @element) if instance_variable_defined?(:@element) && @element
         params
       end
+
+      private
+
+      def first_hash_key_or_param(parameter)
+        parameter.is_a?(Hash) ? parameter.keys.first : parameter
+      end
     end
   end
 end

data/lib/grape/dsl/request_response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Grape
@@ -20,10 +22,11 @@ module Grape
           if new_format
             namespace_inheritable(:format, new_format.to_sym)
             # define the default error formatters
-            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, {}))
+            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, **{}))
             # define a single mime type
             mime_type = content_types[new_format.to_sym]
             raise Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
+
             namespace_stackable(:content_types, new_format.to_sym => mime_type)
           else
             namespace_inheritable(:format)
@@ -43,7 +46,7 @@ module Grape
         # Specify a default error formatter.
         def default_error_formatter(new_formatter_name = nil)
           if new_formatter_name
-            new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name, {})
+            new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name, **{})
             namespace_inheritable(:default_error_formatter, new_formatter)
           else
             namespace_inheritable(:default_error_formatter)
@@ -100,14 +103,13 @@ module Grape
         def rescue_from(*args, &block)
           if args.last.is_a?(Proc)
             handler = args.pop
-          elsif block_given?
+          elsif block
             handler = block
           end
 
           options = args.extract_options!
-          if block_given? && options.key?(:with)
-            raise ArgumentError, 'both :with option and block cannot be passed'
-          end
+          raise ArgumentError, 'both :with option and block cannot be passed' if block && options.key?(:with)
+
           handler ||= extract_with(options)
 
           if args.include?(:all)
@@ -125,7 +127,7 @@ module Grape
                 :base_only_rescue_handlers
               end
 
-            namespace_reverse_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
+            namespace_reverse_stackable handler_type, args.map { |arg| [arg, handler] }.to_h
           end
 
           namespace_stackable(:rescue_options, options)
@@ -152,7 +154,8 @@ module Grape
         # @param model_class [Class] The model class that will be represented.
         # @option options [Class] :with The entity class that will represent the model.
         def represent(model_class, options)
-          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
+          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with].is_a?(Class)
+
           namespace_stackable(:representations, model_class => options[:with])
         end
 
@@ -160,9 +163,11 @@ module Grape
 
         def extract_with(options)
           return unless options.key?(:with)
+
           with_option = options.delete(:with)
           return with_option if with_option.instance_of?(Proc)
           return with_option.to_sym if with_option.instance_of?(Symbol) || with_option.instance_of?(String)
+
           raise ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc"
         end
       end

data/lib/grape/dsl/routing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Grape
@@ -36,7 +38,7 @@ module Grape
 
             @versions = versions | requested_versions
 
-            if block_given?
+            if block
               within_namespace do
                 namespace_inheritable(:version, requested_versions)
                 namespace_inheritable(:version_options, options)
@@ -49,7 +51,7 @@ module Grape
             end
           end
 
-          @versions.last unless @versions.nil?
+          @versions.last if instance_variable_defined?(:@versions) && @versions
         end
 
         # Define a root URL prefix for your entire API.
@@ -77,9 +79,14 @@ module Grape
           namespace_inheritable(:do_not_route_options, true)
         end
 
-        def mount(mounts)
+        def mount(mounts, *opts)
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
+            if app.respond_to?(:mount_instance)
+              opts_with = opts.any? ? opts.shift[:with] : {}
+              mount({ app.mount_instance(configuration: opts_with) => path })
+              next
+            end
             in_setting = inheritable_setting
 
             if app.respond_to?(:inheritable_setting, true)
@@ -136,16 +143,16 @@ module Grape
           reset_validations!
         end
 
-        %w(get post put head delete options patch).each do |meth|
-          define_method meth do |*args, &block|
+        Grape::Http::Headers::SUPPORTED_METHODS.each do |supported_method|
+          define_method supported_method.downcase do |*args, &block|
             options = args.extract_options!
             paths = args.first || ['/']
-            route(meth.upcase, paths, options, &block)
+            route(supported_method, paths, options, &block)
           end
         end
 
         # Declare a "namespace", which prefixes all subordinate routes with its
-        # name. Any endpoints within a namespace, or group, resource, segment,
+        # name. Any endpoints within a namespace, group, resource or segment,
         # etc., will share their parent context as well as any configuration
         # done in the namespace context.
         #
@@ -157,14 +164,14 @@ module Grape
         #       end
         #     end
         def namespace(space = nil, options = {}, &block)
-          if space || block_given?
+          @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description
+
+          if space || block
             within_namespace do
               previous_namespace_description = @namespace_description
               @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
               nest(block) do
-                if space
-                  namespace_stackable(:namespace, Namespace.new(space, options))
-                end
+                namespace_stackable(:namespace, Namespace.new(space, **options)) if space
               end
               @namespace_description = previous_namespace_description
             end
@@ -193,7 +200,7 @@ module Grape
           @endpoints = []
         end
 
-        # Thie method allows you to quickly define a parameter route segment
+        # 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.

data/lib/grape/dsl/settings.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Grape
   module DSL
-    # Keeps track of settings (impemented as key-value pairs, grouped by
+    # Keeps track of settings (implemented as key-value pairs, grouped by
     # types), in two contexts: top-level settings which apply globally no
     # matter where they're defined, and inheritable settings which apply only
     # in the current scope and scopes nested under it.
@@ -13,7 +15,7 @@ module Grape
 
       # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting
-        @top_level_setting ||= Grape::Util::InheritableSetting.new
+        @top_level_setting ||= build_top_level_setting
       end
 
       # Fetch our current inheritable settings, which are inherited by
@@ -101,12 +103,14 @@ module Grape
       def namespace_stackable_with_hash(key)
         settings = get_or_set :namespace_stackable, key, nil
         return if settings.blank?
+
         settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
       end
 
       def namespace_reverse_stackable_with_hash(key)
         settings = get_or_set :namespace_reverse_stackable, key, nil
         return if settings.blank?
+
         result = {}
         settings.each do |setting|
           setting.each do |field, value|
@@ -152,16 +156,30 @@ module Grape
 
       # Execute the block within a context where our inheritable settings are forked
       # to a new copy (see #namespace_start).
-      def within_namespace(&_block)
+      def within_namespace(&block)
         namespace_start
 
-        result = yield if block_given?
+        result = yield if block
 
         namespace_end
         reset_validations!
 
         result
       end
+
+      private
+
+      # Builds the current class :inheritable_setting. If available, it inherits from
+      # the superclass's :inheritable_setting.
+      def build_top_level_setting
+        Grape::Util::InheritableSetting.new.tap do |setting|
+          # Doesn't try to inherit settings from +Grape::API::Instance+ which also responds to
+          # +inheritable_setting+, however, it doesn't contain any user-defined settings.
+          # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
+          # in the chain for every endpoint.
+          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
+        end
+      end
     end
   end
 end

data/lib/grape/dsl/validations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module Grape
@@ -8,7 +10,24 @@ module Grape
       include Grape::DSL::Configuration
 
       module ClassMethods
-        # Clears all defined parameters and validations.
+        # 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
@@ -27,10 +46,11 @@ module Grape
           setting = description_field(:params)
           setting ||= description_field(:params, {})
           Array(names).each do |name|
-            setting[name[:full_name].to_s] ||= {}
-            setting[name[:full_name].to_s].merge!(opts)
+            full_name = name[:full_name].to_s
+            setting[full_name] ||= {}
+            setting[full_name].merge!(opts)
 
-            namespace_stackable(:params, name[:full_name].to_s => opts)
+            namespace_stackable(:params, full_name => opts)
           end
         end
       end

data/lib/grape/eager_load.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Grape.eager_load!
+Grape::Http.eager_load!
+Grape::Exceptions.eager_load!
+Grape::Extensions.eager_load!
+Grape::Extensions::ActiveSupport.eager_load!
+Grape::Extensions::Hashie.eager_load!
+Grape::Middleware.eager_load!
+Grape::Middleware::Auth.eager_load!
+Grape::Middleware::Versioner.eager_load!
+Grape::Util.eager_load!
+Grape::ErrorFormatter.eager_load!
+Grape::Formatter.eager_load!
+Grape::Parser.eager_load!
+Grape::DSL.eager_load!
+Grape::API.eager_load!
+Grape::Presenters.eager_load!
+Grape::ServeStream.eager_load!
+Rack::Head # AutoLoads the Rack::Head

data/lib/grape/endpoint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   # An Endpoint is the proxy scope in which all routing
   # blocks are executed. In other words, any methods
@@ -18,7 +20,8 @@ module Grape
       def before_each(new_setup = false, &block)
         @before_each ||= []
         if new_setup == false
-          return @before_each unless block_given?
+          return @before_each unless block
+
           @before_each << block
         else
           @before_each = [new_setup]
@@ -44,9 +47,7 @@ module Grape
       # @return [Proc]
       # @raise [NameError] an instance method with the same name already exists
       def generate_api_method(method_name, &block)
-        if instance_methods.include?(method_name.to_sym) || instance_methods.include?(method_name.to_s)
-          raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
-        end
+        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)
@@ -78,7 +79,10 @@ module Grape
 
       self.inheritable_setting = new_settings.point_in_time_copy
 
-      route_setting(:saved_declared_params, namespace_stackable(:declared_params))
+      # 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))
 
       namespace_stackable(:representations, []) unless namespace_stackable(:representations)
@@ -97,11 +101,11 @@ module Grape
       @block = nil
 
       @status = nil
-      @file = nil
+      @stream = nil
       @body = nil
       @proc = nil
 
-      return unless block_given?
+      return unless block
 
       @source = block
       @block = self.class.generate_api_method(method_name, &block)
@@ -113,12 +117,9 @@ module Grape
       inheritable_setting.route[:saved_validations] += namespace_stackable[:validations]
       parent_declared_params = namespace_stackable[:declared_params]
 
-      if parent_declared_params
-        inheritable_setting.route[:declared_params] ||= []
-        inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten)
-      end
+      inheritable_setting.route[:declared_params].concat(parent_declared_params.flatten) if parent_declared_params
 
-      endpoints && endpoints.each { |e| e.inherit_settings(namespace_stackable) }
+      endpoints&.each { |e| e.inherit_settings(namespace_stackable) }
     end
 
     def require_option(options, key)
@@ -138,7 +139,7 @@ module Grape
     end
 
     def reset_routes!
-      endpoints.each(&:reset_routes!) if endpoints
+      endpoints&.each(&:reset_routes!)
       @namespace = nil
       @routes = nil
     end
@@ -150,13 +151,9 @@ module Grape
         reset_routes!
         routes.each do |route|
           methods = [route.request_method]
-          if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
-            methods << Grape::Http::Headers::HEAD
-          end
+          methods << Grape::Http::Headers::HEAD if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
           methods.each do |method|
-            unless route.request_method.to_s.upcase == method
-              route = Grape::Router::Route.new(method, route.origin, route.attributes.to_h)
-            end
+            route = Grape::Router::Route.new(method, route.origin, **route.attributes.to_h) unless route.request_method == method
             router.append(route.apply(self))
           end
         end
@@ -167,8 +164,8 @@ module Grape
       route_options = prepare_default_route_attributes
       map_routes do |method, path|
         path = prepare_path(path)
-        params = merge_route_options(route_options.merge(suffix: path.suffix))
-        route = Router::Route.new(method, path.path, params)
+        params = merge_route_options(**route_options.merge(suffix: path.suffix))
+        route = Router::Route.new(method, path.path, **params)
         route.apply(self)
       end.flatten
     end
@@ -188,7 +185,7 @@ module Grape
         requirements: prepare_routes_requirements,
         prefix: namespace_inheritable(:root_prefix),
         anchor: options[:route_options].fetch(:anchor, true),
-        settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations),
+        settings: inheritable_setting.route.except(:declared_params, :saved_validations),
         forward_match: options[:forward_match]
       }
     end
@@ -196,11 +193,12 @@ module Grape
     def prepare_version
       version = namespace_inheritable(:version) || []
       return if version.empty?
+
       version.length == 1 ? version.first.to_s : version
     end
 
     def merge_route_options(**default)
-      options[:route_options].clone.reverse_merge(**default)
+      options[:route_options].clone.merge!(**default)
     end
 
     def map_routes
@@ -230,7 +228,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
-      options[:app].endpoints if options[:app] && options[:app].respond_to?(:endpoints)
+      options[:app].endpoints if options[:app].respond_to?(:endpoints)
     end
 
     def equals?(e)
@@ -245,32 +243,37 @@ module Grape
         @request = Grape::Request.new(env, build_params_with: namespace_inheritable(:build_params_with))
         @params = @request.params
         @headers = @request.headers
+        begin
+          cookies.read(@request)
+          self.class.run_before_each(self)
+          run_filters befores, :before
+
+          if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
+            raise Grape::Exceptions::MethodNotAllowed.new(header.merge('Allow' => allowed_methods)) unless options?
+
+            header 'Allow', allowed_methods
+            response_object = ''
+            status 204
+          else
+            run_filters before_validations, :before_validation
+            run_validators validations, request
+            run_filters after_validations, :after_validation
+            response_object = execute
+          end
 
-        cookies.read(@request)
-        self.class.run_before_each(self)
-        run_filters befores, :before
-
-        if (allowed_methods = env[Grape::Env::GRAPE_ALLOWED_METHODS])
-          raise Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => allowed_methods) unless options?
-          header 'Allow', allowed_methods
-          response_object = ''
-          status 204
-        else
-          run_filters before_validations, :before_validation
-          run_validators validations, request
-          run_filters after_validations, :after_validation
-          response_object = @block ? @block.call(self) : nil
-        end
+          run_filters afters, :after
+          cookies.write(header)
 
-        run_filters afters, :after
-        cookies.write(header)
+          # status verifies body presence when DELETE
+          @body ||= response_object
 
-        # status verifies body presence when DELETE
-        @body ||= response_object
+          # The body commonly is an Array of Strings, the application instance itself, or a Stream-like object
+          response_object = stream || [body]
 
-        # The Body commonly is an Array of Strings, the application instance itself, or a File-like object
-        response_object = file || [body]
-        [status, header, response_object]
+          [status, header, response_object]
+        ensure
+          run_filters finallies, :finally
+        end
       end
     end
 
@@ -321,6 +324,10 @@ module Grape
 
     private :build_stack, :build_helpers
 
+    def execute
+      @block ? @block.call(self) : nil
+    end
+
     def helpers
       lazy_initialize! && @helpers
     end
@@ -341,23 +348,21 @@ module Grape
     def run_validators(validator_factories, request)
       validation_errors = []
 
-      validators = validator_factories.map(&:create_validator)
+      validators = validator_factories.map { |options| Grape::Validations::ValidatorFactory.create_validator(**options) }
 
       ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators: validators, request: request) do
         validators.each do |validator|
-          begin
-            validator.validate(request)
-          rescue Grape::Exceptions::Validation => e
-            validation_errors << e
-            break if validator.fail_fast?
-          rescue Grape::Exceptions::ValidationArrayErrors => e
-            validation_errors += e.errors
-            break if validator.fail_fast?
-          end
+          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
 
-      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header)
+      validation_errors.any? && raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header))
     end
 
     def run_filters(filters, type = :other)
@@ -384,6 +389,10 @@ module Grape
       namespace_stackable(:afters) || []
     end
 
+    def finallies
+      namespace_stackable(:finallies) || []
+    end
+
     def validations
       route_setting(:saved_validations) || []
     end

data/lib/grape/error_formatter/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module ErrorFormatter
     module Base