grape 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1711dd2fb0f0c86757c7e73d780907efa87e3da54e0a999a4b45c276b5eec92c
-  data.tar.gz: f5ba49001d1816d92130f70fb1b63ae061d7d9250142605f706d75c207880ad9
+  metadata.gz: a1ba205b72fd823b11e700753891784fdfbd6791f591b790a99ac3433cb8fe23
+  data.tar.gz: '09e64a0d93415b28fdb179fbb5d7ef0d03e00dcb976fd885c0c655d6ac041345'
 SHA512:
-  metadata.gz: 8b2dcf4d4903e3923dd10086a3371258404756cf294cd42c6fb64f3d2520fe7243c0accfe1b68f2e02fbaa85f29396c161d830cde4c5fdedd660b31e8d223a7f
-  data.tar.gz: 88a4d5e9740495430cd28ed1e213d6aafd92895c1b7966bd6358dd6aeb5b2e1f16eac2e14834d63e7791a6d66e16475ef30cdef5e37d10bca0f38f1d1a22c1e4
+  metadata.gz: 06fcd2157bcfcc6e71876df09b34a318c600761b79fb99ad77739521d056950ee8391dfd050efd43618f7f99f11990623e276b32d15a27e92015ec3a56c6c08b
+  data.tar.gz: 5463bbd0347950765c9d92e859965e90dd69d7d1f781fd188386cf39597c196f5ba2dc697dbee4f896a70f6498c1e43034a33db8460ea9a719218a7d5df46d6f

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+### 1.3.2 (2020/04/12)
+
+#### Features
+* [#2020](https://github.com/ruby-grape/grape/pull/2020): Reduce array allocation - [@ericproulx](https://github.com/ericproulx).
+* [#2015](https://github.com/ruby-grape/grape/pull/2014): Reduce MatchData allocation - [@ericproulx](https://github.com/ericproulx).
+* [#2014](https://github.com/ruby-grape/grape/pull/2014): Reduce total allocated arrays - [@ericproulx](https://github.com/ericproulx).
+* [#2011](https://github.com/ruby-grape/grape/pull/2011): Reduce total retained regexes - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2033](https://github.com/ruby-grape/grape/pull/2033): Ensure `Float` params are correctly coerced to `BigDecimal` - [@tlconnor](https://github.com/tlconnor).
+* [#2031](https://github.com/ruby-grape/grape/pull/2031): Fix a regression with an array of a custom type - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2026](https://github.com/ruby-grape/grape/pull/2026): Fix a regression in `coerce_with` when coercion returns `nil` - [@misdoro](https://github.com/misdoro).
+* [#2025](https://github.com/ruby-grape/grape/pull/2025): Fix Decimal type category - [@kdoya](https://github.com/kdoya).
+* [#2019](https://github.com/ruby-grape/grape/pull/2019): Avoid coercing parameter with multiple types to an empty Array - [@stanhu](https://github.com/stanhu).
+
 ### 1.3.1 (2020/03/11)
 
 #### Features

data/README.md

@@ -154,7 +154,7 @@ content negotiation, versioning and much more.
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, **1.3.1**.
+You're reading the documentation for the stable release of Grape, 1.3.2.
 
 ## Project Resources
 
@@ -3187,14 +3187,13 @@ applies to the current namespace and any children, but not parents.
 ```ruby
 http_basic do |username, password|
   # verify user's password here
-  { 'test' => 'password1' }[username] == password
+  # IMPORTANT: make sure you use a comparison method which isn't prone to a timing attack
 end
 ```
 
 ```ruby
 http_digest({ realm: 'Test Api', opaque: 'app secret' }) do |username|
   # lookup the user's password here
-  { 'user1' => 'password1' }[username]
 end
 ```
 

data/UPGRADING.md

@@ -9,38 +9,83 @@ After adding dry-types, Ruby 2.4 or newer is required.
 
 #### Coercion
 
-[Virtus](https://github.com/solnic/virtus) has been replaced by [dry-types](https://dry-rb.org/gems/dry-types/1.2/) for parameter coercion. If your project depends on Virtus, explicitly add it to your `Gemfile`. Also, if Virtus is used for defining custom types
+[Virtus](https://github.com/solnic/virtus) has been replaced by
+[dry-types](https://dry-rb.org/gems/dry-types/1.2/) for parameter
+coercion. If your project depends on Virtus outside of Grape, explicitly
+add it to your `Gemfile`.
+
+Here's an example of how to migrate a custom type from Virtus to dry-types:
 
 ```ruby
-class User
-  include Virtus.model
+# Legacy Grape parser
+class SecureUriType < Virtus::Attribute
+  def coerce(input)
+    URI.parse value
+  end
 
-  attribute :id, Integer
-  attribute :name, String
+  def value_coerced?(input)
+    value.is_a? String
+  end
 end
 
-# somewhere in your API
 params do
-  requires :user, type: User
+  requires :secure_uri, type: SecureUri
 end
 ```
 
-Add a class-level `parse` method to the model:
+To use dry-types, we need to:
 
-```ruby
-class User
-  include Virtus.model
+1. Remove the inheritance of `Virtus::Attribute`
+1. Rename `coerce` to `self.parse`
+1. Rename `value_coerced?` to `self.parsed?`
 
-  attribute :id, Integer
-  attribute :name, String
+The custom type must have a class-level `parse` method to the model. A
+class-level `parsed?` is needed if the parsed type differs from the
+defined type. In the example below, since `SecureUri` is not the same
+as `URI::HTTPS`, `self.parsed?` is needed:
 
-  def self.parse(attrs)
-    new(attrs)
+```ruby
+# New dry-types parser
+class SecureUri
+  def self.parse(value)
+    URI.parse value
+  end
+
+  def self.parsed?(value)
+    value.is_a? URI::HTTPS
   end
 end
+
+params do
+  requires :secure_uri, type: SecureUri
+end
+```
+
+#### Ensure that Array types have explicit coercions
+
+Unlike Virtus, dry-types does not perform any implict coercions. If you
+have any uses of `Array[String]`, `Array[Integer]`, etc. be sure they
+use a `coerce_with` block. For example:
+
+```ruby
+requires :values, type: Array[String]
 ```
 
-Custom types which don't depend on Virtus don't require any changes.
+It's quite common to pass a comma-separated list, such as `tag1,tag2` as
+`values`. Previously Virtus would implicitly coerce this to
+`Array(values)` so that `["tag1,tag2"]` would pass the type checks, but
+with `dry-types` the values are no longer coerced for you. To fix this,
+you might do:
+
+```ruby
+requires :values, type: Array[String], coerce_with: ->(val) { val.split(',').map(&:strip) }
+```
+
+Likewise, for `Array[Integer]`, you might do:
+
+```ruby
+requires :values, type: Array[Integer], coerce_with: ->(val) { val.split(',').map(&:strip).map(&:to_i) }
+```
 
 For more information see [#1920](https://github.com/ruby-grape/grape/pull/1920).
 

data/lib/grape/api/instance.rb

@@ -243,9 +243,13 @@ module Grape
       # Generate a route that returns an HTTP 405 response for a user defined
       # path on methods not specified
       def generate_not_allowed_method(pattern, allowed_methods: [], **attributes)
-        not_allowed_methods = %w[GET PUT POST DELETE PATCH HEAD] - allowed_methods
-        not_allowed_methods << Grape::Http::Headers::OPTIONS if self.class.namespace_inheritable(:do_not_route_options)
-
+        supported_methods =
+          if self.class.namespace_inheritable(:do_not_route_options)
+            Grape::Http::Headers::SUPPORTED_METHODS
+          else
+            Grape::Http::Headers::SUPPORTED_METHODS_WITHOUT_OPTIONS
+          end
+        not_allowed_methods = supported_methods - allowed_methods
         return if not_allowed_methods.empty?
 
         @router.associate_routes(pattern, not_allowed_methods: not_allowed_methods, **attributes)

data/lib/grape/http/headers.rb

@@ -21,6 +21,7 @@ module Grape
       OPTIONS = 'OPTIONS'
 
       SUPPORTED_METHODS = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS].freeze
+      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'

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

@@ -63,7 +63,7 @@ module Grape
 
         def an_accept_header_with_version_and_vendor_is_present?
           header.qvalues.keys.any? do |h|
-            VENDOR_VERSION_HEADER_REGEX =~ h.sub('application/', '')
+            VENDOR_VERSION_HEADER_REGEX.match?(h.sub('application/', ''))
           end
         end
 

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

@@ -3,11 +3,12 @@
 module Rack
   module Accept
     module Header
+      ALLOWED_CHARACTERS = %r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([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)
           # see http://tools.ietf.org/html/rfc6838#section-4.2 for allowed characters in media type names
-          m = media_type.to_s.match(%r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$})
+          m = media_type&.match(ALLOWED_CHARACTERS)
           m ? [m[1], m[2], m[3] || ''] : []
         end
       end

data/lib/grape/path.rb

@@ -42,11 +42,11 @@ module Grape
     end
 
     def namespace?
-      namespace && namespace.to_s =~ /^\S/ && namespace != '/'
+      namespace&.match?(/^\S/) && namespace != '/'
     end
 
     def path?
-      raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
+      raw_path&.match?(/^\S/) && raw_path != '/'
     end
 
     def suffix

data/lib/grape/router.rb

@@ -8,10 +8,9 @@ module Grape
     attr_reader :map, :compiled
 
     class Any < AttributeTranslator
-      attr_reader :pattern, :regexp, :index
-      def initialize(pattern, regexp, index, **attributes)
+      attr_reader :pattern, :index
+      def initialize(pattern, index, **attributes)
         @pattern = pattern
-        @regexp = regexp
         @index = index
         super(attributes)
       end
@@ -39,18 +38,20 @@ module Grape
 
     def initialize
       @neutral_map = []
+      @neutral_regexes = []
       @map = Hash.new { |hash, key| hash[key] = [] }
       @optimized_map = Hash.new { |hash, key| hash[key] = // }
     end
 
     def compile!
       return if compiled
-      @union = Regexp.union(@neutral_map.map(&:regexp))
+      @union = Regexp.union(@neutral_regexes)
+      @neutral_regexes = nil
       self.class.supported_methods.each do |method|
         routes = map[method]
         @optimized_map[method] = routes.map.with_index do |route, index|
           route.index = index
-          route.regexp = Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
+          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
         end
         @optimized_map[method] = Regexp.union(@optimized_map[method])
       end
@@ -62,8 +63,8 @@ module Grape
     end
 
     def associate_routes(pattern, **options)
-      regexp = Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Any.new(pattern, regexp, @neutral_map.length, **options)
+      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
+      @neutral_map << Any.new(pattern, @neutral_map.length, **options)
     end
 
     def call(env)

data/lib/grape/router/route.rb

@@ -12,7 +12,7 @@ module Grape
       SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
       FIXED_NAMED_CAPTURES = %w[format version].freeze
 
-      attr_accessor :pattern, :translator, :app, :index, :regexp, :options
+      attr_accessor :pattern, :translator, :app, :index, :options
 
       alias attributes translator
 
@@ -31,7 +31,7 @@ module Grape
       end
 
       def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
+        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
       %i[
@@ -67,7 +67,6 @@ module Grape
         method_s = method.to_s
         method_upcase = Grape::Http::Headers.find_supported_method(method_s) || method_s.upcase
 
-        @suffix     = options[:suffix]
         @options    = options.merge(method: method_upcase)
         @pattern    = Pattern.new(pattern, **options)
         @translator = AttributeTranslator.new(**options, request_method: method_upcase)

data/lib/grape/util/base_inheritable.rb

@@ -5,8 +5,7 @@ module Grape
     # Base for classes which need to operate with own values kept
     # in the hash and inherited values kept in a Hash-like object.
     class BaseInheritable
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+      attr_accessor :inherited_values, :new_values
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
@@ -26,10 +25,14 @@ module Grape
       end
 
       def keys
-        combined = inherited_values.keys
-        combined.concat(new_values.keys)
-        combined.uniq!
-        combined
+        if new_values.any?
+          combined = inherited_values.keys
+          combined.concat(new_values.keys)
+          combined.uniq!
+          combined
+        else
+          inherited_values.keys
+        end
       end
 
       def key?(name)

data/lib/grape/util/reverse_stackable_values.rb

@@ -8,8 +8,10 @@ module Grape
       protected
 
       def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
         [].tap do |value|
-          value.concat(new_value) if new_value
+          value.concat(new_value)
           value.concat(inherited_value)
         end
       end

data/lib/grape/util/stackable_values.rb

@@ -29,9 +29,11 @@ module Grape
       protected
 
       def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
         [].tap do |value|
           value.concat(inherited_value)
-          value.concat(new_value) if new_value
+          value.concat(new_value)
         end
       end
     end

data/lib/grape/validations/types.rb

@@ -42,7 +42,6 @@ module Grape
         Grape::API::Boolean,
         String,
         Symbol,
-        Rack::Multipart::UploadedFile,
         TrueClass,
         FalseClass
       ].freeze
@@ -54,8 +53,7 @@ module Grape
         Set
       ].freeze
 
-      # Types for which Grape provides special coercion
-      # and type-checking logic.
+      # Special custom types provided by Grape.
       SPECIAL = {
         JSON => Json,
         Array[JSON] => JsonArray,
@@ -130,7 +128,6 @@ module Grape
         !primitive?(type) &&
           !structure?(type) &&
           !multiple?(type) &&
-          !special?(type) &&
           type.respond_to?(:parse) &&
           type.method(:parse).arity == 1
       end
@@ -143,7 +140,11 @@ module Grape
       def self.collection_of_custom?(type)
         (type.is_a?(Array) || type.is_a?(Set)) &&
           type.length == 1 &&
-          custom?(type.first)
+          (custom?(type.first) || special?(type.first))
+      end
+
+      def self.map_special(type)
+        SPECIAL.fetch(type, type)
       end
     end
   end

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

@@ -42,6 +42,9 @@ module Grape
       end
 
       def self.create_coercer_instance(type, method, strict)
+        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
+        type = Types.map_special(type)
+
         # Use a special coercer for multiply-typed parameters.
         if Types.multiple?(type)
           MultipleTypeCoercer.new(type, method)
@@ -55,10 +58,8 @@ module Grape
         # method is supplied.
         elsif Types.collection_of_custom?(type)
           Types::CustomTypeCollectionCoercer.new(
-            type.first, type.is_a?(Set)
+            Types.map_special(type.first), type.is_a?(Set)
           )
-        elsif Types.special?(type)
-          Types::SPECIAL[type].new
         elsif type.is_a?(Array)
           ArrayCoercer.new type, strict
         elsif type.is_a?(Set)

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

@@ -60,7 +60,7 @@ module Grape
         end
 
         def coerced?(val)
-          @type_check.call val
+          val.nil? || @type_check.call(val)
         end
 
         private

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

@@ -7,21 +7,23 @@ module Grape
       # Actual handling of these objects is provided by +Rack::Request+;
       # this class is here only to assert that rack's handling has succeeded.
       class File
-        def call(input)
-          return if input.nil?
-          return InvalidValue.new unless coerced?(input)
+        class << self
+          def parse(input)
+            return if input.nil?
+            return InvalidValue.new unless parsed?(input)
 
-          # Processing of multipart file objects
-          # is already taken care of by Rack::Request.
-          # Nothing to do here.
-          input
-        end
+            # Processing of multipart file objects
+            # is already taken care of by Rack::Request.
+            # Nothing to do here.
+            input
+          end
 
-        def coerced?(value)
-          # Rack::Request creates a Hash with filename,
-          # content type and an IO object. Do a bit of basic
-          # duck-typing.
-          value.is_a?(::Hash) && value.key?(:tempfile) && value[:tempfile].is_a?(Tempfile)
+          def parsed?(value)
+            # Rack::Request creates a Hash with filename,
+            # content type and an IO object. Do a bit of basic
+            # duck-typing.
+            value.is_a?(::Hash) && value.key?(:tempfile) && value[:tempfile].is_a?(Tempfile)
+          end
         end
       end
     end

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

@@ -12,35 +12,37 @@ module Grape
       # validation system will apply nested validation rules to
       # all returned objects.
       class Json
-        # Coerce the input into a JSON-like data structure.
-        #
-        # @param input [String] a JSON-encoded parameter value
-        # @return [Hash,Array<Hash>,nil]
-        def call(input)
-          return input if coerced?(input)
+        class << self
+          # Coerce the input into a JSON-like data structure.
+          #
+          # @param input [String] a JSON-encoded parameter value
+          # @return [Hash,Array<Hash>,nil]
+          def parse(input)
+            return input if parsed?(input)
 
-          # Allow nulls and blank strings
-          return if input.nil? || input =~ /^\s*$/
-          JSON.parse(input, symbolize_names: true)
-        end
+            # Allow nulls and blank strings
+            return if input.nil? || input.match?(/^\s*$/)
+            JSON.parse(input, symbolize_names: true)
+          end
 
-        # Checks that the input was parsed successfully
-        # and isn't something odd such as an array of primitives.
-        #
-        # @param value [Object] result of {#coerce}
-        # @return [true,false]
-        def coerced?(value)
-          value.is_a?(::Hash) || coerced_collection?(value)
-        end
+          # Checks that the input was parsed successfully
+          # and isn't something odd such as an array of primitives.
+          #
+          # @param value [Object] result of {#parse}
+          # @return [true,false]
+          def parsed?(value)
+            value.is_a?(::Hash) || coerced_collection?(value)
+          end
 
-        protected
+          protected
 
-        # Is the value an array of JSON-like objects?
-        #
-        # @param value [Object] result of {#coerce}
-        # @return [true,false]
-        def coerced_collection?(value)
-          value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+          # Is the value an array of JSON-like objects?
+          #
+          # @param value [Object] result of {#parse}
+          # @return [true,false]
+          def coerced_collection?(value)
+            value.is_a?(::Array) && value.all? { |i| i.is_a? ::Hash }
+          end
         end
       end
 
@@ -49,18 +51,20 @@ module Grape
       # objects and arrays of objects, but wraps single objects
       # in an Array.
       class JsonArray < Json
-        # See {Json#coerce}. Wraps single objects in an array.
-        #
-        # @param input [String] JSON-encoded parameter value
-        # @return [Array<Hash>]
-        def call(input)
-          json = super
-          Array.wrap(json) unless json.nil?
-        end
+        class << self
+          # See {Json#parse}. Wraps single objects in an array.
+          #
+          # @param input [String] JSON-encoded parameter value
+          # @return [Array<Hash>]
+          def parse(input)
+            json = super
+            Array.wrap(json) unless json.nil?
+          end
 
-        # See {Json#coerced_collection?}
-        def coerced?(value)
-          coerced_collection? value
+          # See {Json#coerced_collection?}
+          def parsed?(value)
+            coerced_collection? value
+          end
         end
       end
     end

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

@@ -11,10 +11,10 @@ module Grape
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
+          BigDecimal          => DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String              => DryTypes::Coercible::String,
-          BigDecimal          => DryTypes::Coercible::Decimal
+          String              => DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {

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

@@ -47,7 +47,9 @@ module Grape
         #     h[:list] = list
         #     h
         #     => #<Hashie::Mash list=[1, 2, 3, 4]>
-        params[attr_name] = new_value unless params[attr_name] == new_value
+        return if params[attr_name].class == new_value.class && params[attr_name] == new_value
+
+        params[attr_name] = new_value
       end
 
       private
@@ -65,21 +67,21 @@ module Grape
       end
 
       def coerce_value(val)
-        # define default values for structures, the dry-types lib which is used
-        # for coercion doesn't accept nil as a value, so it would fail
-        if val.nil?
-          return []      if type == Array || type.is_a?(Array)
-          return Set.new if type == Set
-          return {}      if type == Hash
-        end
-
-        converter.call(val)
-
+        val.nil? ? coerce_nil(val) : converter.call(val)
       # Some custom types might fail, so it should be treated as an invalid value
       rescue StandardError
         Types::InvalidValue.new
       end
 
+      def coerce_nil(val)
+        # define default values for structures, the dry-types lib which is used
+        # for coercion doesn't accept nil as a value, so it would fail
+        return []      if type == Array
+        return Set.new if type == Set
+        return {}      if type == Hash
+        val
+      end
+
       # Type to which the parameter will be coerced.
       #
       # @return [Class]

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

@@ -5,7 +5,7 @@ module Grape
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
         return unless params.respond_to?(:key?) && params.key?(attr_name)
-        return if Array.wrap(params[attr_name]).all? { |param| param.nil? || (param.to_s =~ (options_key?(:value) ? @option[:value] : @option)) }
+        return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
         raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
       end
     end

data/lib/grape/version.rb

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

data/spec/grape/path_spec.rb

@@ -87,12 +87,12 @@ module Grape
     describe '#namespace?' do
       it 'is false when the namespace is nil' do
         path = Path.new(anything, nil, anything)
-        expect(path.namespace?).to be nil
+        expect(path.namespace?).to be_falsey
       end
 
       it 'is false when the namespace starts with whitespace' do
         path = Path.new(anything, ' /foo', anything)
-        expect(path.namespace?).to be nil
+        expect(path.namespace?).to be_falsey
       end
 
       it 'is false when the namespace is the root path' do
@@ -109,12 +109,12 @@ module Grape
     describe '#path?' do
       it 'is false when the path is nil' do
         path = Path.new(nil, anything, anything)
-        expect(path.path?).to be nil
+        expect(path.path?).to be_falsey
       end
 
       it 'is false when the path starts with whitespace' do
         path = Path.new(' /foo', anything, anything)
-        expect(path.path?).to be nil
+        expect(path.path?).to be_falsey
       end
 
       it 'is false when the path is the root path' do

data/spec/grape/validations/types_spec.rb

@@ -17,7 +17,7 @@ describe Grape::Validations::Types do
     [
       Integer, Float, Numeric, BigDecimal,
       Grape::API::Boolean, String, Symbol,
-      Date, DateTime, Time, Rack::Multipart::UploadedFile
+      Date, DateTime, Time
     ].each do |type|
       it "recognizes #{type} as a primitive" do
         expect(described_class.primitive?(type)).to be_truthy

data/spec/grape/validations/validators/coerce_spec.rb

@@ -154,6 +154,36 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'coerces' do
+      context 'json' do
+        let(:headers) { { 'CONTENT_TYPE' => 'application/json', 'ACCEPT' => 'application/json' } }
+
+        it 'BigDecimal' do
+          subject.params do
+            requires :bigdecimal, type: BigDecimal
+          end
+          subject.post '/bigdecimal' do
+            "#{params[:bigdecimal].class} #{params[:bigdecimal].to_f}"
+          end
+
+          post '/bigdecimal', { bigdecimal: 45.1 }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('BigDecimal 45.1')
+        end
+
+        it 'Boolean' do
+          subject.params do
+            requires :boolean, type: Boolean
+          end
+          subject.post '/boolean' do
+            params[:boolean]
+          end
+
+          post '/boolean', { boolean: 'true' }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('true')
+        end
+      end
+
       it 'BigDecimal' do
         subject.params do
           requires :bigdecimal, coerce: BigDecimal
@@ -180,6 +210,23 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq(integer_class_name)
       end
 
+      it 'String' do
+        subject.params do
+          requires :string, coerce: String
+        end
+        subject.get '/string' do
+          params[:string].class
+        end
+
+        get '/string', string: 45
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('String')
+
+        get '/string', string: nil
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('NilClass')
+      end
+
       it 'is a custom type' do
         subject.params do
           requires :uri, coerce: SecureURIOnly
@@ -307,42 +354,60 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('TrueClass')
       end
 
-      it 'Rack::Multipart::UploadedFile' do
-        subject.params do
-          requires :file, type: Rack::Multipart::UploadedFile
-        end
-        subject.post '/upload' do
-          params[:file][:filename]
-        end
+      context 'File' do
+        let(:file) { Rack::Test::UploadedFile.new(__FILE__) }
+        let(:filename) { File.basename(__FILE__).to_s }
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+        it 'Rack::Multipart::UploadedFile' do
+          subject.params do
+            requires :file, type: Rack::Multipart::UploadedFile
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
 
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
-      end
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-      it 'File' do
-        subject.params do
-          requires :file, coerce: File
-        end
-        subject.post '/upload' do
-          params[:file][:filename]
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
         end
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+        it 'File' do
+          subject.params do
+            requires :file, coerce: File
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
+
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
 
-        post '/upload', file: { filename: 'fake file', tempfile: '/etc/passwd' }
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+          post '/upload', file: { filename: 'fake file', tempfile: '/etc/passwd' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
+        end
+
+        it 'collection' do
+          subject.params do
+            requires :files, type: Array[File]
+          end
+          subject.post '/upload' do
+            params[:files].first[:filename]
+          end
+
+          post '/upload', files: [file]
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
+        end
       end
 
       it 'Nests integers' do
@@ -478,6 +543,46 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('3')
       end
 
+      context 'Integer type and coerce_with potentially returning nil' do
+        before do
+          subject.params do
+            requires :int, type: Integer, coerce_with: (lambda do |val|
+              if val == '0'
+                nil
+              elsif val.match?(/^-?\d+$/)
+                val.to_i
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:int].class.to_s
+          end
+        end
+
+        it 'accepts value that coerces to nil' do
+          get '/', int: '0'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('NilClass')
+        end
+
+        it 'coerces to Integer' do
+          get '/', int: '1'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Integer')
+        end
+
+        it 'returns invalid value if coercion returns a wrong type' do
+          get '/', int: 'lol'
+
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('int is invalid')
+        end
+      end
+
       it 'must be supplied with :type or :coerce' do
         expect do
           subject.params do
@@ -647,6 +752,19 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('String')
       end
 
+      it 'respects nil values' do
+        subject.params do
+          optional :a, types: [File, String]
+        end
+        subject.get '/' do
+          params[:a].class.to_s
+        end
+
+        get '/', a: nil
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('NilClass')
+      end
+
       it 'fails when no coercion is possible' do
         subject.params do
           requires :a, types: [Boolean, Integer]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Michael Bleigh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-11 00:00:00.000000000 Z
+date: 2020-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -364,9 +364,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/ruby-grape/grape/issues
-  changelog_uri: https://github.com/ruby-grape/grape/blob/v1.3.1/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/grape/1.3.1
-  source_code_uri: https://github.com/ruby-grape/grape/tree/v1.3.1
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v1.3.2/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/1.3.2
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v1.3.2
 post_install_message: 
 rdoc_options: []
 require_paths: