grape 1.5.3 → 1.6.0

data/lib/grape/dsl/settings.rb

@@ -103,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|
@@ -154,10 +156,10 @@ 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!
@@ -175,9 +177,7 @@ module Grape
           # +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.
-          if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
-            setting.inherit_from superclass.inheritable_setting
-          end
+          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
         end
       end
     end

data/lib/grape/endpoint.rb

@@ -20,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]
@@ -46,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 method_defined?(method_name)
-          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)
@@ -106,7 +105,7 @@ module Grape
       @body = nil
       @proc = nil
 
-      return unless block_given?
+      return unless block
 
       @source = block
       @block = self.class.generate_api_method(method_name, &block)
@@ -118,11 +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].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)
@@ -142,7 +139,7 @@ module Grape
     end
 
     def reset_routes!
-      endpoints.each(&:reset_routes!) if endpoints
+      endpoints&.each(&:reset_routes!)
       @namespace = nil
       @routes = nil
     end
@@ -154,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 == 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
@@ -200,6 +193,7 @@ module Grape
     def prepare_version
       version = namespace_inheritable(:version) || []
       return if version.empty?
+
       version.length == 1 ? version.first.to_s : version
     end
 
@@ -234,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)
@@ -256,13 +250,13 @@ module Grape
 
           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
-            remove_renamed_params
             run_filters after_validations, :after_validation
             response_object = execute
           end
@@ -328,14 +322,7 @@ module Grape
       Module.new { helpers.each { |mod_to_include| include mod_to_include } }
     end
 
-    def remove_renamed_params
-      return unless route_setting(:renamed_params)
-      route_setting(:renamed_params).flat_map(&:keys).each do |renamed_param|
-        @params.delete(renamed_param)
-      end
-    end
-
-    private :build_stack, :build_helpers, :remove_renamed_params
+    private :build_stack, :build_helpers
 
     def execute
       @block ? @block.call(self) : nil
@@ -365,15 +352,13 @@ module Grape
 
       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.concat 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
 

data/lib/grape/error_formatter/json.rb

@@ -10,12 +10,8 @@ module Grape
           result = wrap_message(present(message, env))
 
           rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result = result.merge(backtrace: backtrace)
-          end
-          if rescue_options[:original_exception] && original_exception
-            result = result.merge(original_exception: original_exception.inspect)
-          end
+          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
+          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
           ::Grape::Json.dump(result)
         end
 

data/lib/grape/error_formatter/xml.rb

@@ -11,12 +11,8 @@ module Grape
 
           result = message.is_a?(Hash) ? message : { message: message }
           rescue_options = options[:rescue_options] || {}
-          if rescue_options[:backtrace] && backtrace && !backtrace.empty?
-            result = result.merge(backtrace: backtrace)
-          end
-          if rescue_options[:original_exception] && original_exception
-            result = result.merge(original_exception: original_exception.inspect)
-          end
+          result = result.merge(backtrace: backtrace) if rescue_options[:backtrace] && backtrace && !backtrace.empty?
+          result = result.merge(original_exception: original_exception.inspect) if rescue_options[:original_exception] && original_exception
           result.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s
         end
       end

data/lib/grape/exceptions/validation.rb

@@ -5,8 +5,7 @@ require 'grape/exceptions/base'
 module Grape
   module Exceptions
     class Validation < Grape::Exceptions::Base
-      attr_accessor :params
-      attr_accessor :message_key
+      attr_accessor :params, :message_key
 
       def initialize(params:, message: nil, **args)
         @params = params

data/lib/grape/formatter/json.rb

@@ -6,6 +6,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_json if object.respond_to?(:to_json)
+
           ::Grape::Json.dump(object)
         end
       end

data/lib/grape/formatter/serializable_hash.rb

@@ -8,13 +8,14 @@ module Grape
           return object if object.is_a?(String)
           return ::Grape::Json.dump(serialize(object)) if serializable?(object)
           return object.to_json if object.respond_to?(:to_json)
+
           ::Grape::Json.dump(object)
         end
 
         private
 
         def serializable?(object)
-          object.respond_to?(:serializable_hash) || object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash } || object.is_a?(Hash)
+          object.respond_to?(:serializable_hash) || (object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash }) || object.is_a?(Hash)
         end
 
         def serialize(object)

data/lib/grape/formatter/xml.rb

@@ -6,6 +6,7 @@ module Grape
       class << self
         def call(object, _env)
           return object.to_xml if object.respond_to?(:to_xml)
+
           raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
         end
       end

data/lib/grape/middleware/base.rb

@@ -59,6 +59,7 @@ module Grape
 
       def response
         return @app_response if @app_response.is_a?(Rack::Response)
+
         Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
       end
 
@@ -84,6 +85,7 @@ module Grape
 
       def merge_headers(response)
         return unless headers.is_a?(Hash)
+
         case response
         when Rack::Response then response.headers.merge!(headers)
         when Array          then response[1].merge!(headers)

data/lib/grape/middleware/formatter.rb

@@ -22,6 +22,7 @@ module Grape
 
       def after
         return unless @app_response
+
         status, headers, bodies = *@app_response
 
         if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
@@ -79,7 +80,7 @@ module Grape
           (request.post? || request.put? || request.patch? || request.delete?) &&
           (!request.form_data? || !request.media_type) &&
           !request.parseable_data? &&
-          (request.content_length.to_i > 0 || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
+          (request.content_length.to_i.positive? || request.env[Grape::Http::Headers::HTTP_TRANSFER_ENCODING] == CHUNKED)
 
         return unless (input = env[Grape::Env::RACK_INPUT])
 
@@ -96,9 +97,7 @@ module Grape
       def read_rack_input(body)
         fmt = request.media_type ? mime_types[request.media_type] : options[:default_format]
 
-        unless content_type_for(fmt)
-          throw :error, status: 415, message: "The provided content-type '#{request.media_type}' is not supported."
-        end
+        throw :error, status: 415, message: "The provided content-type '#{request.media_type}' is not supported." unless content_type_for(fmt)
         parser = Grape::Parser.parser_for fmt, **options
         if parser
           begin
@@ -145,6 +144,7 @@ module Grape
         fmt = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[Grape::Http::Headers::FORMAT]
         # avoid symbol memory leak on an unknown format
         return fmt.to_sym if content_type_for(fmt)
+
         fmt
       end
 

data/lib/grape/middleware/stack.rb

@@ -45,8 +45,8 @@ module Grape
         @others = []
       end
 
-      def each
-        @middlewares.each { |x| yield x }
+      def each(&block)
+        @middlewares.each(&block)
       end
 
       def size

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

@@ -22,11 +22,9 @@ module Grape
         def before
           potential_version = (env[Grape::Http::Headers::HTTP_ACCEPT_VERSION] || '').strip
 
-          if strict?
+          if strict? && potential_version.empty?
             # If no Accept-Version header:
-            if potential_version.empty?
-              throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
-            end
+            throw :error, status: 406, headers: error_headers, message: 'Accept-Version header must be set.'
           end
 
           return if potential_version.empty?
@@ -51,7 +49,7 @@ module Grape
         # 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?
-          if options[:version_options] && options[:version_options].key?(:cascade)
+          if options[:version_options]&.key?(:cascade)
             options[:version_options][:cascade]
           else
             true

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

@@ -26,10 +26,10 @@ module Grape
       # route.
       class Header < Base
         VENDOR_VERSION_HEADER_REGEX =
-          /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
+          /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))?(?:\+([a-z0-9*\-.]+))?\z/.freeze
 
-        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#\$&\^]+/.freeze
-        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#\$&\^]+?)(?:-([a-z0-9*.]+))+/.freeze
+        HAS_VENDOR_REGEX = /\Avnd\.[a-z0-9.\-_!#{Regexp.last_match(0)}\^]+/.freeze
+        HAS_VERSION_REGEX = /\Avnd\.([a-z0-9.\-_!#{Regexp.last_match(0)}\^]+?)(?:-([a-z0-9*.]+))+/.freeze
 
         def before
           strict_header_checks if strict?
@@ -52,12 +52,14 @@ module Grape
 
         def strict_accept_header_presence_check
           return unless header.qvalues.empty?
+
           fail_with_invalid_accept_header!('Accept header must be set.')
         end
 
         def strict_version_vendor_accept_header_presence_check
           return unless versions.present?
           return if an_accept_header_with_version_and_vendor_is_present?
+
           fail_with_invalid_accept_header!('API vendor or version not found.')
         end
 
@@ -160,7 +162,7 @@ module Grape
         # information). To prevent # this behavior, and not add the `X-Cascade`
         # header, one can set the `:cascade` option to `false`.
         def cascade?
-          if version_options && version_options.key?(:cascade)
+          if version_options&.key?(:cascade)
             version_options[:cascade]
           else
             true

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

@@ -32,6 +32,7 @@ module Grape
         def before
           potential_version = Rack::Utils.parse_nested_query(env[Grape::Http::Headers::QUERY_STRING])[paramkey]
           return if potential_version.nil?
+
           throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' } if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
           env[Grape::Env::RACK_REQUEST_QUERY_HASH].delete(paramkey) if env.key? Grape::Env::RACK_REQUEST_QUERY_HASH

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require 'English'
 module Rack
   module Accept
     module Header
-      ALLOWED_CHARACTERS = %r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$}.freeze
+      ALLOWED_CHARACTERS = %r{^([a-z*]+)/([a-z0-9*&\^\-_#{$ERROR_INFO}.+]+)(?:;([a-z0-9=;]+))?$}.freeze
       class << self
         # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44
         def parse_media_type(media_type)

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

@@ -37,6 +37,7 @@ module Grape
           pieces = path.split('/')
           potential_version = pieces[1]
           return unless potential_version&.match?(options[:pattern])
+
           throw :error, status: 404, message: '404 API Version Not Found' if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
           env[Grape::Env::API_VERSION] = potential_version
         end
@@ -45,6 +46,7 @@ module Grape
 
         def mounted_path?(path)
           return false unless mount_path && path.start_with?(mount_path)
+
           rest = path.slice(mount_path.length..-1)
           rest.start_with?('/') || rest.empty?
         end

data/lib/grape/path.rb

@@ -91,6 +91,7 @@ module Grape
 
     def split_setting(key)
       return if settings[key].nil?
+
       settings[key].to_s.split('/')
     end
   end

data/lib/grape/request.rb

@@ -37,6 +37,7 @@ module Grape
       Grape::Util::LazyObject.new do
         env.each_pair.with_object({}) do |(k, v), headers|
           next unless k.to_s.start_with? HTTP_PREFIX
+
           transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
           headers[transformed_header] = v
         end

data/lib/grape/router/pattern.rb

@@ -41,7 +41,7 @@ module Grape
         end
 
         pattern = -pattern.split('/').tap do |parts|
-          parts[parts.length - 1] = '?' + parts.last
+          parts[parts.length - 1] = "?#{parts.last}"
         end.join('/') if pattern.end_with?('*path')
 
         PatternCache[[pattern, suffix]]

data/lib/grape/router/route.rb

@@ -84,8 +84,8 @@ module Grape
         path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
         path = File.realpath(path) if Pathname.new(path).relative?
         expected ||= name
-        warn <<-WARNING
-#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
+        warn <<~WARNING
+          #{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
         WARNING
       end
     end

data/lib/grape/router.rb

@@ -28,6 +28,7 @@ module Grape
 
     def compile!
       return if compiled
+
       @union = Regexp.union(@neutral_regexes)
       @neutral_regexes = nil
       self.class.supported_methods.each do |method|
@@ -60,6 +61,7 @@ module Grape
     def recognize_path(input)
       any = with_optimization { greedy_match?(input) }
       return if any == default_response
+
       any.endpoint
     end
 
@@ -80,6 +82,7 @@ module Grape
       map[method].each do |route|
         next if exact_route == route
         next unless route.match?(input)
+
         response = process_route(route, env)
         break unless cascade?(response)
       end
@@ -91,6 +94,7 @@ module Grape
       response = yield(input, method)
 
       return response if response && !(cascade = cascade?(response))
+
       last_neighbor_route = greedy_match?(input)
 
       # If last_neighbor_route exists and request method is OPTIONS,
@@ -139,12 +143,14 @@ module Grape
     def match?(input, method)
       current_regexp = @optimized_map[method]
       return unless current_regexp.match(input)
+
       last_match = Regexp.last_match
       @map[method].detect { |route| last_match["_#{route.index}"] }
     end
 
     def greedy_match?(input)
       return unless @union.match(input)
+
       last_match = Regexp.last_match
       @neutral_map.detect { |route| last_match["_#{route.index}"] }
     end

data/lib/grape/util/inheritable_setting.rb

@@ -5,9 +5,7 @@ module Grape
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace
-      attr_accessor :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable
-      attr_accessor :parent, :point_in_time_copies
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
 
       # Retrieve global settings.
       def self.global

data/lib/grape/util/lazy_value.rb

@@ -49,9 +49,10 @@ module Grape
       end
 
       def []=(key, value)
-        @value_hash[key] = if value.is_a?(Hash)
+        @value_hash[key] = case value
+                           when Hash
                              LazyValueHash.new(value)
-                           elsif value.is_a?(Array)
+                           when Array
                              LazyValueArray.new(value)
                            else
                              LazyValue.new(value)