grape 1.7.1 → 2.0.0

data/lib/grape/formatter/serializable_hash.rb

@@ -15,24 +15,24 @@ module Grape
         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) || array_serializable?(object) || object.is_a?(Hash)
         end
 
         def serialize(object)
           if object.respond_to? :serializable_hash
             object.serializable_hash
-          elsif object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash }
+          elsif array_serializable?(object)
             object.map(&:serializable_hash)
           elsif object.is_a?(Hash)
-            h = {}
-            object.each_pair do |k, v|
-              h[k] = serialize(v)
-            end
-            h
+            object.transform_values { |v| serialize(v) }
           else
             object
           end
         end
+
+        def array_serializable?(object)
+          object.is_a?(Array) && object.all? { |o| o.respond_to? :serializable_hash }
+        end
       end
     end
   end

data/lib/grape/http/headers.rb

@@ -10,7 +10,18 @@ module Grape
       PATH_INFO       = 'PATH_INFO'
       REQUEST_METHOD  = 'REQUEST_METHOD'
       QUERY_STRING    = 'QUERY_STRING'
-      CONTENT_TYPE    = 'Content-Type'
+
+      if Grape.lowercase_headers?
+        ALLOW             = 'allow'
+        LOCATION          = 'location'
+        TRANSFER_ENCODING = 'transfer-encoding'
+        X_CASCADE         = 'x-cascade'
+      else
+        ALLOW             = 'Allow'
+        LOCATION          = 'Location'
+        TRANSFER_ENCODING = 'Transfer-Encoding'
+        X_CASCADE         = 'X-Cascade'
+      end
 
       GET     = 'GET'
       POST    = 'POST'
@@ -24,7 +35,6 @@ module Grape
       SUPPORTED_METHODS_WITHOUT_OPTIONS = Grape::Util::LazyObject.new { [GET, POST, PUT, PATCH, DELETE, HEAD].freeze }
 
       HTTP_ACCEPT_VERSION    = 'HTTP_ACCEPT_VERSION'
-      X_CASCADE              = 'X-Cascade'
       HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
       HTTP_ACCEPT            = 'HTTP_ACCEPT'
 

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

@@ -28,7 +28,7 @@ module Grape
 
             strategy_info = Grape::Middleware::Auth::Strategies[options[:type]]
 
-            throw(:error, status: 401, message: 'API Authorization Failed.') unless strategy_info.present?
+            throw(:error, status: 401, message: 'API Authorization Failed.') if strategy_info.blank?
 
             strategy = strategy_info.create(@app, options) do |*args|
               auth_proc_context.instance_exec(*args, &auth_proc)

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

@@ -12,8 +12,7 @@ module Grape
 
         def auth_strategies
           @auth_strategies ||= {
-            http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) { [settings[:realm]] }),
-            http_digest: StrategyInfo.new(Rack::Auth::Digest::MD5, ->(settings) { [settings[:realm], settings[:opaque]] })
+            http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) { [settings[:realm]] })
           }
         end
 

data/lib/grape/middleware/error.rb

@@ -51,7 +51,7 @@ module Grape
       end
 
       def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
-        headers = headers.reverse_merge(Grape::Http::Headers::CONTENT_TYPE => content_type)
+        headers = headers.reverse_merge(Rack::CONTENT_TYPE => content_type)
         rack_response(format_message(message, backtrace, original_exception), status, headers)
       end
 
@@ -63,15 +63,15 @@ module Grape
       def error_response(error = {})
         status = error[:status] || options[:default_status]
         message = error[:message] || options[:default_message]
-        headers = { Grape::Http::Headers::CONTENT_TYPE => content_type }
+        headers = { Rack::CONTENT_TYPE => content_type }
         headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
         backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
         original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
         rack_response(format_message(message, backtrace, original_exception), status, headers)
       end
 
-      def rack_response(message, status = options[:default_status], headers = { Grape::Http::Headers::CONTENT_TYPE => content_type })
-        message = ERB::Util.html_escape(message) if headers[Grape::Http::Headers::CONTENT_TYPE] == TEXT_HTML
+      def rack_response(message, status = options[:default_status], headers = { Rack::CONTENT_TYPE => content_type })
+        message = ERB::Util.html_escape(message) if headers[Rack::CONTENT_TYPE] == TEXT_HTML
         Rack::Response.new([message], Rack::Utils.status_code(status), headers)
       end
 
@@ -109,7 +109,7 @@ module Grape
         return :error_response if klass == Grape::Exceptions::InvalidVersionHeader
         return unless options[:rescue_grape_exceptions] || !options[:rescue_all]
 
-        :error_response
+        options[:grape_exceptions_rescue_handler] || :error_response
       end
 
       def rescue_handler_for_any_class(klass)

data/lib/grape/middleware/formatter.rb

@@ -54,7 +54,7 @@ module Grape
       end
 
       def fetch_formatter(headers, options)
-        api_format = mime_types[headers[Grape::Http::Headers::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
+        api_format = mime_types[headers[Rack::CONTENT_TYPE]] || env[Grape::Env::API_FORMAT]
         Grape::Formatter.formatter_for(api_format, **options)
       end
 
@@ -63,10 +63,10 @@ module Grape
       # @param headers [Hash]
       # @return [Hash]
       def ensure_content_type(headers)
-        if headers[Grape::Http::Headers::CONTENT_TYPE]
+        if headers[Rack::CONTENT_TYPE]
           headers
         else
-          headers.merge(Grape::Http::Headers::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
+          headers.merge(Rack::CONTENT_TYPE => content_type_for(env[Grape::Env::API_FORMAT]))
         end
       end
 
@@ -103,7 +103,7 @@ module Grape
           begin
             body = (env[Grape::Env::API_REQUEST_BODY] = parser.call(body, env))
             if body.is_a?(Hash)
-              env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env[Grape::Env::RACK_REQUEST_FORM_HASH]
+              env[Grape::Env::RACK_REQUEST_FORM_HASH] = if env.key?(Grape::Env::RACK_REQUEST_FORM_HASH)
                                                           env[Grape::Env::RACK_REQUEST_FORM_HASH].merge(body)
                                                         else
                                                           body
@@ -164,14 +164,14 @@ module Grape
             \w+/[\w+.-]+)     # eg application/vnd.example.myformat+xml
           (?:
            (?:;[^,]*?)?       # optionally multiple formats in a row
-           ;\s*q=([\d.]+)     # optional "quality" preference (eg q=0.5)
+           ;\s*q=([\w.]+)     # optional "quality" preference (eg q=0.5)
           )?
         }x
 
         vendor_prefix_pattern = /vnd\.[^+]+\+/
 
         accept.scan(accept_into_mime_and_quality)
-              .sort_by { |_, quality_preference| -quality_preference.to_f }
+              .sort_by { |_, quality_preference| -(quality_preference ? quality_preference.to_f : 1.0) }
               .flat_map { |mime, _| [mime, mime.sub(vendor_prefix_pattern, '')] }
       end
     end

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

@@ -57,8 +57,7 @@ module Grape
         end
 
         def strict_version_vendor_accept_header_presence_check
-          return unless versions.present?
-          return if an_accept_header_with_version_and_vendor_is_present?
+          return if versions.blank? || an_accept_header_with_version_and_vendor_is_present?
 
           fail_with_invalid_accept_header!('API vendor or version not found.')
         end
@@ -101,25 +100,18 @@ module Grape
         end
 
         def available_media_types
-          available_media_types = []
-
-          content_types.each_key do |extension|
-            versions.reverse_each do |version|
-              available_media_types += [
-                "application/vnd.#{vendor}-#{version}+#{extension}",
-                "application/vnd.#{vendor}-#{version}"
-              ]
+          [].tap do |available_media_types|
+            content_types.each_key do |extension|
+              versions.reverse_each do |version|
+                available_media_types << "application/vnd.#{vendor}-#{version}+#{extension}"
+                available_media_types << "application/vnd.#{vendor}-#{version}"
+              end
+              available_media_types << "application/vnd.#{vendor}+#{extension}"
             end
-            available_media_types << "application/vnd.#{vendor}+#{extension}"
-          end
-
-          available_media_types << "application/vnd.#{vendor}"
 
-          content_types.each_value do |media_type|
-            available_media_types << media_type
+            available_media_types << "application/vnd.#{vendor}"
+            available_media_types.concat(content_types.values.flatten)
           end
-
-          available_media_types.flatten
         end
 
         def headers_contain_wrong_vendor?
@@ -130,7 +122,7 @@ module Grape
 
         def headers_contain_wrong_version?
           header.values.all? do |header_value|
-            version?(header_value) && !versions.include?(request_version(header_value))
+            version?(header_value) && versions.exclude?(request_version(header_value))
           end
         end
 

data/lib/grape/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Grape
+  class Railtie < ::Rails::Railtie
+    initializer 'grape.deprecator' do |app|
+      app.deprecators[:grape] = Grape.deprecator
+    end
+  end
+end

data/lib/grape/request.rb

@@ -46,8 +46,14 @@ module Grape
       end
     end
 
-    def transform_header(header)
-      -header[5..].split('_').each(&:capitalize!).join('-')
+    if Grape.lowercase_headers?
+      def transform_header(header)
+        -header[5..].tr('_', '-').downcase
+      end
+    else
+      def transform_header(header)
+        -header[5..].split('_').map(&:capitalize).join('-')
+      end
     end
   end
 end

data/lib/grape/router/route.rb

@@ -84,9 +84,7 @@ 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}.
-        WARNING
+        Grape.deprecator.warn("#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.")
       end
     end
   end

data/lib/grape/util/lazy_value.rb

@@ -70,29 +70,21 @@ module Grape
       end
 
       def evaluate
-        evaluated = []
-        @value_hash.each_with_index do |value, index|
-          evaluated[index] = value.evaluate
-        end
-        evaluated
+        @value_hash.map(&:evaluate)
       end
     end
 
     class LazyValueHash < LazyValueEnumerable
       def initialize(hash)
         super
-        @value_hash = {}.with_indifferent_access
+        @value_hash = ActiveSupport::HashWithIndifferentAccess.new
         hash.each do |key, value|
           self[key] = value
         end
       end
 
       def evaluate
-        evaluated = {}.with_indifferent_access
-        @value_hash.each do |key, value|
-          evaluated[key] =  value.evaluate
-        end
-        evaluated
+        @value_hash.transform_values(&:evaluate)
       end
     end
   end

data/lib/grape/util/strict_hash_configuration.rb

@@ -66,11 +66,10 @@ module Grape
           end
 
           define_method :to_hash do
-            merge_hash = {}
-            setting_name.each_key { |k| merge_hash[k] = send("#{k}_context").to_hash }
-
             @settings.to_hash.merge(
-              merge_hash
+              setting_name.each_key.with_object({}) do |k, merge_hash|
+                merge_hash[k] = send("#{k}_context").to_hash
+              end
             )
           end
         end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -6,7 +6,7 @@ module Grape
       private
 
       def yield_attributes(resource_params, _attrs)
-        yield resource_params, skip?(resource_params)
+        yield resource_params unless skip?(resource_params)
       end
     end
   end

data/lib/grape/validations/params_scope.rb

@@ -10,6 +10,11 @@ module Grape
 
       include Grape::DSL::Parameters
 
+      # There are a number of documentation options on entities that don't have
+      # corresponding validators. Since there is nowhere that enumerates them all,
+      # we maintain a list of them here and skip looking up validators for them.
+      RESERVED_DOCUMENTATION_KEYWORDS = %i[as required param_type is_array format example].freeze
+
       class Attr
         attr_accessor :key, :scope
 
@@ -359,7 +364,8 @@ module Grape
         coerce_type validations, attrs, doc, opts
 
         validations.each do |type, options|
-          next if type == :as
+          # Don't try to look up validators for documentation params that don't have one.
+          next if RESERVED_DOCUMENTATION_KEYWORDS.include?(type)
 
           validate(type, options, attrs, doc, opts)
         end
@@ -414,7 +420,7 @@ module Grape
 
         # but not special JSON types, which
         # already imply coercion method
-        return unless [JSON, Array[JSON]].include? validations[:coerce]
+        return if [JSON, Array[JSON]].exclude? validations[:coerce]
 
         raise ArgumentError, 'coerce_with disallowed for type: JSON'
       end

data/lib/grape/validations/single_attribute_iterator.rb

@@ -6,8 +6,10 @@ module Grape
       private
 
       def yield_attributes(val, attrs)
+        return if skip?(val)
+
         attrs.each do |attr_name|
-          yield val, attr_name, empty?(val), skip?(val)
+          yield val, attr_name, empty?(val)
         end
       end
 

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -141,7 +141,7 @@ module Grape
             lambda do |val|
               method.call(val).tap do |new_val|
                 new_val.map do |item|
-                  item.is_a?(Hash) ? symbolize_keys(item) : item
+                  item.is_a?(Hash) ? item.deep_symbolize_keys : item
                 end
               end
             end
@@ -149,7 +149,7 @@ module Grape
           # Hash objects are processed directly
           elsif type == Hash
             lambda do |val|
-              symbolize_keys method.call(val)
+              method.call(val).deep_symbolize_keys
             end
 
           # Simple types are not processed.
@@ -158,20 +158,6 @@ module Grape
             method
           end
         end
-
-        def symbolize_keys!(hash)
-          hash.each_key do |key|
-            hash[key.to_sym] = hash.delete(key) if key.respond_to?(:to_sym)
-          end
-          hash
-        end
-
-        def symbolize_keys(hash)
-          hash.inject({}) do |new_hash, (key, value)|
-            new_key = key.respond_to?(:to_sym) ? key.to_sym : key
-            new_hash.merge!(new_key => value)
-          end
-        end
       end
     end
   end

data/lib/grape/validations/validators/base.rb

@@ -46,34 +46,23 @@ module Grape
           # there may be more than one error per field
           array_errors = []
 
-          attributes.each do |val, attr_name, empty_val, skip_value|
-            next if skip_value
+          attributes.each do |val, attr_name, empty_val|
             next if !@scope.required? && empty_val
             next unless @scope.meets_dependency?(val, params)
 
-            begin
-              validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
-            rescue Grape::Exceptions::Validation => e
-              array_errors << e
-            end
+            validate_param!(attr_name, val) if @required || (val.respond_to?(:key?) && val.key?(attr_name))
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
           end
 
           raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        def self.convert_to_short_name(klass)
-          ret = klass.name.gsub(/::/, '/')
-          ret.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          ret.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-          ret.tr!('-', '_')
-          ret.downcase!
-          File.basename(ret, '_validator')
-        end
-
         def self.inherited(klass)
-          return unless klass.name.present?
+          return if klass.name.blank?
 
-          Validations.register_validator(convert_to_short_name(klass), klass)
+          short_validator_name = klass.name.demodulize.underscore.delete_suffix('_validator')
+          Validations.register_validator(short_validator_name, klass)
         end
 
         def message(default_key = nil)
@@ -95,8 +84,8 @@ module Grape
 end
 
 Grape::Validations::Base = Class.new(Grape::Validations::Validators::Base) do
-  def initialize(*)
+  def self.inherited(*)
+    Grape.deprecator.warn 'Grape::Validations::Base is deprecated! Use Grape::Validations::Validators::Base instead.'
     super
-    warn '[DEPRECATION] `Grape::Validations::Base` is deprecated. Use `Grape::Validations::Validators::Base` instead.'
   end
 end

data/lib/grape/validations/validators/default_validator.rb

@@ -12,10 +12,10 @@ module Grape
         def validate_param!(attr_name, params)
           params[attr_name] = if @default.is_a? Proc
                                 @default.call
-                              elsif @default.frozen? || !duplicatable?(@default)
+                              elsif @default.frozen? || !@default.duplicable?
                                 @default
                               else
-                                duplicate(@default)
+                                @default.dup
                               end
         end
 
@@ -27,24 +27,6 @@ module Grape
             validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
           end
         end
-
-        private
-
-        # return true if we might be able to dup this object
-        def duplicatable?(obj)
-          !obj.nil? &&
-            obj != true &&
-            obj != false &&
-            !obj.is_a?(Symbol) &&
-            !obj.is_a?(Numeric)
-        end
-
-        # make a best effort to dup the object
-        def duplicate(obj)
-          obj.dup
-        rescue TypeError
-          obj
-        end
       end
     end
   end

data/lib/grape/validations/validators/multiple_params_base.rb

@@ -8,14 +8,10 @@ module Grape
           attributes = MultipleAttributesIterator.new(self, @scope, params)
           array_errors = []
 
-          attributes.each do |resource_params, skip_value|
-            next if skip_value
-
-            begin
-              validate_params!(resource_params)
-            rescue Grape::Exceptions::Validation => e
-              array_errors << e
-            end
+          attributes.each do |resource_params|
+            validate_params!(resource_params)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
           end
 
           raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?

data/lib/grape/validations/validators/values_validator.rb

@@ -10,13 +10,11 @@ module Grape
             @values = options[:value]
             @proc = options[:proc]
 
-            warn '[DEPRECATION] The values validator except option is deprecated. ' \
-                 'Use the except validator instead.' if @excepts
+            Grape.deprecator.warn('The values validator except option is deprecated. Use the except validator instead.') if @excepts
 
             raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
 
-            warn '[DEPRECATION] The values validator proc option is deprecated. ' \
-                 'The lambda expression can now be assigned directly to values.' if @proc
+            Grape.deprecator.warn('The values validator proc option is deprecated. The lambda expression can now be assigned directly to values.') if @proc
           else
             @excepts = nil
             @values = nil
@@ -45,7 +43,7 @@ module Grape
           unless check_values(param_array, attr_name)
 
           raise validation_exception(attr_name, message(:values)) \
-          if @proc && !param_array.all? { |param| @proc.call(param) }
+            if @proc && !validate_proc(@proc, param_array)
         end
 
         private
@@ -70,6 +68,17 @@ module Grape
           param_array.none? { |param| excepts.include?(param) }
         end
 
+        def validate_proc(proc, param_array)
+          case proc.arity
+          when 0
+            param_array.all? { |_param| proc.call }
+          when 1
+            param_array.all? { |param| proc.call(param) }
+          else
+            raise ArgumentError, 'proc arity must be 0 or 1'
+          end
+        end
+
         def except_message
           options = instance_variable_get(:@option)
           options_key?(:except_message) ? options[:except_message] : message(:except_values)

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.7.1'
+  VERSION = '2.0.0'
 end

data/lib/grape.rb

@@ -5,33 +5,49 @@ require 'rack'
 require 'rack/builder'
 require 'rack/accept'
 require 'rack/auth/basic'
-require 'rack/auth/digest/md5'
 require 'set'
 require 'bigdecimal'
 require 'date'
 require 'active_support'
 require 'active_support/concern'
+require 'active_support/configurable'
 require 'active_support/version'
 require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR > 6
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/string/exclude'
 require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
+require 'active_support/inflector'
 require 'active_support/notifications'
 require 'i18n'
 
 I18n.load_path << File.expand_path('grape/locale/en.yml', __dir__)
 
 module Grape
+  include ActiveSupport::Configurable
   extend ::ActiveSupport::Autoload
 
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Grape')
+  end
+
+  def self.lowercase_headers?
+    Rack::CONTENT_TYPE == 'content-type'
+  end
+
   eager_autoload do
     autoload :API
     autoload :Endpoint
@@ -92,8 +108,6 @@ module Grape
   module Extensions
     extend ::ActiveSupport::Autoload
     eager_autoload do
-      autoload :DeepMergeableHash
-      autoload :DeepSymbolizeHash
       autoload :Hash
     end
     module ActiveSupport
@@ -285,13 +299,20 @@ module Grape
       autoload :InvalidValue
     end
   end
+
+  configure do |config|
+    config.param_builder = Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+    config.compile_methods!
+  end
 end
 
-require 'grape/config'
 require 'grape/content_types'
 
 require 'grape/util/lazy_value'
 require 'grape/util/lazy_block'
 require 'grape/util/endpoint_configuration'
-
 require 'grape/version'
+
+# https://api.rubyonrails.org/classes/ActiveSupport/Deprecation.html
+# adding Grape.deprecator to Rails App if any
+require 'grape/railtie' if defined?(Rails::Railtie) && ActiveSupport.gem_version >= Gem::Version.new('7.1')