grape 1.3.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1ba205b72fd823b11e700753891784fdfbd6791f591b790a99ac3433cb8fe23
-  data.tar.gz: '09e64a0d93415b28fdb179fbb5d7ef0d03e00dcb976fd885c0c655d6ac041345'
+  metadata.gz: d63fb79e412ead32064ad4994e171e65962131a04afb20d12957942c744f4df8
+  data.tar.gz: 9a9f4fb654e346eabb8a0b902d5e49ae54dc567797789c98c76f2a2fe2e2daa9
 SHA512:
-  metadata.gz: 06fcd2157bcfcc6e71876df09b34a318c600761b79fb99ad77739521d056950ee8391dfd050efd43618f7f99f11990623e276b32d15a27e92015ec3a56c6c08b
-  data.tar.gz: 5463bbd0347950765c9d92e859965e90dd69d7d1f781fd188386cf39597c196f5ba2dc697dbee4f896a70f6498c1e43034a33db8460ea9a719218a7d5df46d6f
+  metadata.gz: b75afa355e6a2b8200d72a2c4407bc78646648832a94d576bff06bdebde90d54b1897df09a560665bd9f58e735f9832a110b63bbcaabe14a4e2ee3c97e743b57
+  data.tar.gz: 18a4ea057230ae0e6cfe16f92e5043339b66026a94d29bd8c897d2482577cb279ec4e202f41a643605a3ea09c748fa159fddc36977a3c4828b5b64daef080272

data/CHANGELOG.md

@@ -1,6 +1,24 @@
+### 1.3.3 (2020/05/23)
+
+#### Features
+
+* [#2048](https://github.com/ruby-grape/grape/issues/2034): Grape Enterprise support is now available [via TideLift](https://tidelift.com/subscription/request-a-demo?utm_source=rubygems-grape&utm_medium=referral&utm_campaign=enterprise) - [@dblock](https://github.com/dblock).
+* [#2039](https://github.com/ruby-grape/grape/pull/2039): Travis - update rails versions - [@ericproulx](https://github.com/ericproulx).
+* [#2038](https://github.com/ruby-grape/grape/pull/2038): Travis - update ruby versions - [@ericproulx](https://github.com/ericproulx).
+* [#2050](https://github.com/ruby-grape/grape/pull/2050): Refactor route public_send to AttributeTranslator - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2049](https://github.com/ruby-grape/grape/pull/2049): Coerce an empty string to nil in case of the bool type - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2043](https://github.com/ruby-grape/grape/pull/2043): Modify declared for nested array and hash - [@kadotami](https://github.com/kadotami).
+* [#2040](https://github.com/ruby-grape/grape/pull/2040): Fix a regression with Array of type nil - [@ericproulx](https://github.com/ericproulx).
+* [#2054](https://github.com/ruby-grape/grape/pull/2054): Coercing of nested arrays - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2050](https://github.com/ruby-grape/grape/pull/2053): Fix broken multiple mounts - [@Jack12816](https://github.com/Jack12816).
+
 ### 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).

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2019 Michael Bleigh, Intridea Inc. and Contributors.
+Copyright (c) 2010-2020 Michael Bleigh, Intridea Inc. and Contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -12,6 +12,7 @@
 - [What is Grape?](#what-is-grape)
 - [Stable Release](#stable-release)
 - [Project Resources](#project-resources)
+- [Grape for Enterprise](#grape-for-enterprise)
 - [Installation](#installation)
 - [Basic Usage](#basic-usage)
 - [Mounting](#mounting)
@@ -141,6 +142,7 @@
     - [format_response.grape](#format_responsegrape)
   - [Monitoring Products](#monitoring-products)
 - [Contributing to Grape](#contributing-to-grape)
+- [Security](#security)
 - [License](#license)
 - [Copyright](#copyright)
 
@@ -154,7 +156,7 @@ content negotiation, versioning and much more.
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, 1.3.2.
+You're reading the documentation for the stable release of Grape, **1.3.3**.
 
 ## Project Resources
 
@@ -163,6 +165,14 @@ You're reading the documentation for the stable release of Grape, 1.3.2.
 * Need help? Try [Grape Google Group](http://groups.google.com/group/ruby-grape) or [Gitter](https://gitter.im/ruby-grape/grape)
 * [Follow us on Twitter](https://twitter.com/grapeframework)
 
+## Grape for Enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of Grape are working with Tidelift to deliver commercial support and maintenance. Save time, reduce risk, and improve code health, while paying the maintainers of Grape. Click [here](https://tidelift.com/subscription/request-a-demo?utm_source=rubygems-grape&utm_medium=referral&utm_campaign=enterprise) for more details.
+
+In 2020, we plan to use the money towards gathering Grape contributors for dinner in New York City.
+
 ## Installation
 
 Ruby 2.4 or newer is required.
@@ -3850,7 +3860,7 @@ Grape integrates with following third-party tools:
 * **Librato Metrics** - [grape-librato](https://github.com/seanmoon/grape-librato) gem
 * **[Skylight](https://www.skylight.io/)** - [skylight](https://github.com/skylightio/skylight-ruby) gem, [documentation](https://docs.skylight.io/grape/)
 * **[AppSignal](https://www.appsignal.com)** - [appsignal-ruby](https://github.com/appsignal/appsignal-ruby) gem, [documentation](http://docs.appsignal.com/getting-started/supported-frameworks.html#grape)
-* **[ElasticAPM](https://www.elastic.co/products/apm) - [elastic-apm](https://github.com/elastic/apm-agent-ruby) gem, [documentation](https://www.elastic.co/guide/en/apm/agent/ruby/3.x/getting-started-rack.html#getting-started-grape)
+* **[ElasticAPM](https://www.elastic.co/products/apm)** - [elastic-apm](https://github.com/elastic/apm-agent-ruby) gem, [documentation](https://www.elastic.co/guide/en/apm/agent/ruby/3.x/getting-started-rack.html#getting-started-grape)
 
 ## Contributing to Grape
 
@@ -3859,10 +3869,14 @@ features and discuss issues.
 
 See [CONTRIBUTING](CONTRIBUTING.md).
 
+## Security
+
+See [SECURITY](SECURITY.md) for details.
+
 ## License
 
-MIT License. See LICENSE for details.
+MIT License. See [LICENSE](LICENSE) for details.
 
 ## Copyright
 
-Copyright (c) 2010-2019 Michael Bleigh, Intridea Inc. and Contributors.
+Copyright (c) 2010-2020 Michael Bleigh, Intridea Inc. and Contributors.

data/UPGRADING.md

@@ -1,6 +1,65 @@
 Upgrading Grape
 ===============
 
+### Upgrading to >= 1.4.0
+
+#### Nil values for structures
+
+Nil values always been a special case when dealing with types especially with the following structures:
+ - Array
+ - Hash
+ - Set
+ 
+The behaviour for these structures has change through out the latest releases. For instance:
+
+```ruby
+class Api < Grape::API
+  params do
+    require :my_param, type: Array[Integer]
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil }
+  # 1.3.1 = []
+  # 1.3.2 = nil
+end
+```
+For now on, `nil` values stay `nil` values for all types, including arrays, sets and hashes.
+
+If you want to have the same behavior as 1.3.1, apply a `default` validator
+
+```ruby
+class Api < Grape::API
+  params do
+    require :my_param, type: Array[Integer], default: []
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil } # => []
+end
+```
+
+#### Default validator
+
+Default validator is now applied for `nil` values.
+
+```ruby
+class Api < Grape::API
+  params do
+    requires :my_param, type: Integer, default: 0
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil } #=> before: nil, after: 0
+end
+```
+
 ### Upgrading to >= 1.3.0
 
 #### Ruby

data/lib/grape/api/instance.rb

@@ -205,11 +205,12 @@ module Grape
             route_settings[:requirements] = route.requirements
             route_settings[:path] = route.origin
             route_settings[:methods] ||= []
-            route_settings[:methods] << route.request_method
+            if route.request_method == '*' || route_settings[:methods].include?('*')
+              route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS
+            else
+              route_settings[:methods] << route.request_method
+            end
             route_settings[:endpoint] = route.app
-
-            # using the :any shorthand produces [nil] for route methods, substitute all manually
-            route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS if route_settings[:methods].include?('*')
           end
         end
 

data/lib/grape/dsl/inside_route.rb

@@ -28,36 +28,38 @@ module Grape
       # Methods which should not be available in filters until the before filter
       # has completed
       module PostBeforeFilter
-        def declared(passed_params, options = {}, declared_params = nil)
+        def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
           options = options.reverse_merge(include_missing: true, include_parent_namespaces: true)
           declared_params ||= optioned_declared_params(**options)
 
           if passed_params.is_a?(Array)
-            declared_array(passed_params, options, declared_params)
+            declared_array(passed_params, options, declared_params, params_nested_path)
           else
-            declared_hash(passed_params, options, declared_params)
+            declared_hash(passed_params, options, declared_params, params_nested_path)
           end
         end
 
         private
 
-        def declared_array(passed_params, options, declared_params)
+        def declared_array(passed_params, options, declared_params, params_nested_path)
           passed_params.map do |passed_param|
-            declared(passed_param || {}, options, declared_params)
+            declared(passed_param || {}, options, declared_params, params_nested_path)
           end
         end
 
-        def declared_hash(passed_params, options, declared_params)
+        def declared_hash(passed_params, options, declared_params, params_nested_path)
           declared_params.each_with_object(passed_params.class.new) do |declared_param, memo|
             if declared_param.is_a?(Hash)
               declared_param.each_pair do |declared_parent_param, declared_children_params|
+                params_nested_path_dup = params_nested_path.dup
+                params_nested_path_dup << declared_parent_param.to_s
                 next unless options[:include_missing] || passed_params.key?(declared_parent_param)
 
                 passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
                 memo_key = optioned_param_key(declared_parent_param, options)
 
-                memo[memo_key] = handle_passed_param(declared_parent_param, passed_children_params) do
-                  declared(passed_children_params, options, declared_children_params)
+                memo[memo_key] = handle_passed_param(passed_children_params, params_nested_path_dup) do
+                  declared(passed_children_params, options, declared_children_params, params_nested_path_dup)
                 end
               end
             else
@@ -77,19 +79,34 @@ module Grape
           end
         end
 
-        def handle_passed_param(declared_param, passed_children_params, &_block)
-          should_be_empty_array?(declared_param, passed_children_params) ? [] : yield
+        def handle_passed_param(passed_children_params, params_nested_path, &_block)
+          if should_be_empty_hash?(passed_children_params, params_nested_path)
+            {}
+          elsif should_be_empty_array?(passed_children_params, params_nested_path)
+            []
+          else
+            yield
+          end
         end
 
-        def should_be_empty_array?(declared_param, passed_children_params)
-          declared_param_is_array?(declared_param) && passed_children_params.empty?
+        def should_be_empty_array?(passed_children_params, params_nested_path)
+          passed_children_params.empty? && declared_param_is_array?(params_nested_path)
         end
 
-        def declared_param_is_array?(declared_param)
-          key = declared_param.to_s
+        def declared_param_is_array?(params_nested_path)
+          key = route_options_params_key(params_nested_path)
           route_options_params[key] && route_options_params[key][:type] == 'Array'
         end
 
+        def should_be_empty_hash?(passed_children_params, params_nested_path)
+          passed_children_params.empty? && declared_param_is_hash?(params_nested_path)
+        end
+
+        def declared_param_is_hash?(params_nested_path)
+          key = route_options_params_key(params_nested_path)
+          route_options_params[key] && route_options_params[key][:type] == 'Hash'
+        end
+
         def route_options_params
           options[:route_options][:params] || {}
         end
@@ -98,6 +115,12 @@ module Grape
           options[:stringify] ? declared_param.to_s : declared_param.to_sym
         end
 
+        def route_options_params_key(params_nested_path)
+          key = params_nested_path[0]
+          key += '[' + params_nested_path[1..-1].join('][') + ']' if params_nested_path.size > 1
+          key
+        end
+
         def optioned_declared_params(**options)
           declared_params = if options[:include_parent_namespaces]
                               # Declared params including parent namespaces

data/lib/grape/router.rb

@@ -7,15 +7,6 @@ module Grape
   class Router
     attr_reader :map, :compiled
 
-    class Any < AttributeTranslator
-      attr_reader :pattern, :index
-      def initialize(pattern, index, **attributes)
-        @pattern = pattern
-        @index = index
-        super(attributes)
-      end
-    end
-
     class NormalizePathCache < Grape::Util::Cache
       def initialize
         @cache = Hash.new do |h, path|
@@ -64,7 +55,7 @@ module Grape
 
     def associate_routes(pattern, **options)
       @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Any.new(pattern, @neutral_map.length, **options)
+      @neutral_map << Grape::Router::AttributeTranslator.new(options.merge(pattern: pattern, index: @neutral_map.length))
     end
 
     def call(env)

data/lib/grape/router/attribute_translator.rb

@@ -6,10 +6,31 @@ module Grape
     class AttributeTranslator
       attr_reader :attributes, :request_method, :requirements
 
+      ROUTE_ATTRIBUTES = %i[
+        prefix
+        version
+        settings
+        format
+        description
+        http_codes
+        headers
+        entity
+        details
+        requirements
+        request_method
+        namespace
+      ].freeze
+
+      ROUTER_ATTRIBUTES = %i[pattern index].freeze
+
       def initialize(attributes = {})
         @attributes = attributes
-        @request_method = attributes[:request_method]
-        @requirements = attributes[:requirements]
+      end
+
+      (ROUTER_ATTRIBUTES + ROUTE_ATTRIBUTES).each do |attr|
+        define_method attr do
+          attributes[attr]
+        end
       end
 
       def to_h

data/lib/grape/router/route.rb

@@ -18,6 +18,7 @@ module Grape
 
       extend Forwardable
       def_delegators :pattern, :path, :origin
+      delegate Grape::Router::AttributeTranslator::ROUTE_ATTRIBUTES => :attributes
 
       def method_missing(method_id, *arguments)
         match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
@@ -34,25 +35,6 @@ module Grape
         ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
-      %i[
-        prefix
-        version
-        settings
-        format
-        description
-        http_codes
-        headers
-        entity
-        details
-        requirements
-        request_method
-        namespace
-      ].each do |method_name|
-        define_method method_name do
-          attributes.public_send method_name
-        end
-      end
-
       def route_method
         warn_route_methods(:method, caller(1).shift, :request_method)
         request_method

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

@@ -6,7 +6,7 @@ module Grape
   module Validations
     module Types
       # Coerces elements in an array. It might be an array of strings or integers or
-      # anything else.
+      # an array of arrays of integers.
       #
       # It could've been possible to use an +of+
       # method (https://dry-rb.org/gems/dry-types/1.2/array-with-member/)
@@ -14,16 +14,17 @@ module Grape
       # behavior of Virtus which was used earlier, a `Grape::Validations::Types::PrimitiveCoercer`
       # maintains Virtus behavior in coercing.
       class ArrayCoercer < DryTypeCoercer
+        register_collection Array
+
         def initialize(type, strict = false)
           super
 
           @coercer = scope::Array
-          @elem_coercer = PrimitiveCoercer.new(type.first, strict)
+          @subtype = type.first
         end
 
         def call(_val)
           collection = super
-
           return collection if collection.is_a?(InvalidValue)
 
           coerce_elements collection
@@ -31,11 +32,15 @@ module Grape
 
         protected
 
+        attr_reader :subtype
+
         def coerce_elements(collection)
+          return if collection.nil?
+
           collection.each_with_index do |elem, index|
             return InvalidValue.new if reject?(elem)
 
-            coerced_elem = @elem_coercer.call(elem)
+            coerced_elem = elem_coercer.call(elem)
 
             return coerced_elem if coerced_elem.is_a?(InvalidValue)
 
@@ -45,11 +50,15 @@ module Grape
           collection
         end
 
-        # This method maintaine logic which was defined by Virtus for arrays.
+        # This method maintains logic which was defined by Virtus for arrays.
         # Virtus doesn't allow nil in arrays.
         def reject?(val)
           val.nil?
         end
+
+        def elem_coercer
+          @elem_coercer ||= DryTypeCoercer.coercer_instance_for(subtype, strict)
+        end
       end
     end
   end

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

@@ -60,12 +60,8 @@ module Grape
           Types::CustomTypeCollectionCoercer.new(
             Types.map_special(type.first), type.is_a?(Set)
           )
-        elsif type.is_a?(Array)
-          ArrayCoercer.new type, strict
-        elsif type.is_a?(Set)
-          SetCoercer.new type, strict
         else
-          PrimitiveCoercer.new type, strict
+          DryTypeCoercer.coercer_instance_for(type, strict)
         end
       end
 

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

@@ -17,8 +17,41 @@ module Grape
       # but check its type. More information there
       # https://dry-rb.org/gems/dry-types/1.2/built-in-types/
       class DryTypeCoercer
+        class << self
+          # Registers a collection coercer which could be found by a type,
+          # see +collection_coercer_for+ method below. This method is meant for inheritors.
+          def register_collection(type)
+            DryTypeCoercer.collection_coercers[type] = self
+          end
+
+          # Returns a collection coercer which corresponds to a given type.
+          # Example:
+          #
+          #    collection_coercer_for(Array)
+          #    #=> Grape::Validations::Types::ArrayCoercer
+          def collection_coercer_for(type)
+            collection_coercers[type]
+          end
+
+          # Returns an instance of a coercer for a given type
+          def coercer_instance_for(type, strict = false)
+            return PrimitiveCoercer.new(type, strict) if type.class == Class
+
+            # in case of a collection (Array[Integer]) the type is an instance of a collection,
+            # so we need to figure out the actual type
+            collection_coercer_for(type.class).new(type, strict)
+          end
+
+          protected
+
+          def collection_coercers
+            @collection_coercers ||= {}
+          end
+        end
+
         def initialize(type, strict = false)
           @type = type
+          @strict = strict
           @scope = strict ? DryTypes::Strict : DryTypes::Params
         end
 
@@ -27,6 +60,8 @@ module Grape
         #
         # @param val [Object]
         def call(val)
+          return if val.nil?
+
           @coercer[val]
         rescue Dry::Types::CoercionError => _e
           InvalidValue.new
@@ -34,7 +69,7 @@ module Grape
 
         protected
 
-        attr_reader :scope, :type
+        attr_reader :scope, :type, :strict
       end
     end
   end

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

@@ -36,7 +36,7 @@ module Grape
 
         def call(val)
           return InvalidValue.new if reject?(val)
-          return nil if val.nil?
+          return nil if val.nil? || treat_as_nil?(val)
           return '' if val == ''
 
           super
@@ -46,7 +46,7 @@ module Grape
 
         attr_reader :type
 
-        # This method maintaine logic which was defined by Virtus. For example,
+        # This method maintains logic which was defined by Virtus. For example,
         # dry-types is ok to convert an array or a hash to a string, it is supported,
         # but Virtus wouldn't accept it. So, this method only exists to not introduce
         # breaking changes.
@@ -55,6 +55,13 @@ module Grape
             (val.is_a?(String) && type == Hash) ||
             (val.is_a?(Hash) && type == String)
         end
+
+        # Dry-Types treats an empty string as invalid. However, Grape considers an empty string as
+        # absence of a value and coerces it into nil. See a discussion there
+        # https://github.com/ruby-grape/grape/pull/2045
+        def treat_as_nil?(val)
+          val == '' && type == Grape::API::Boolean
+        end
       end
     end
   end

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

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 require 'set'
-require_relative 'dry_type_coercer'
+require_relative 'array_coercer'
 
 module Grape
   module Validations
     module Types
       # Takes the given array and converts it to a set. Every element of the set
       # is also coerced.
-      class SetCoercer < DryTypeCoercer
+      class SetCoercer < ArrayCoercer
+        register_collection Set
+
         def initialize(type, strict = false)
           super
 
-          @elem_coercer = PrimitiveCoercer.new(type.first, strict)
+          @coercer = nil
         end
 
         def call(value)
@@ -25,7 +27,7 @@ module Grape
 
         def coerce_elements(collection)
           collection.each_with_object(Set.new) do |elem, memo|
-            coerced_elem = @elem_coercer.call(elem)
+            coerced_elem = elem_coercer.call(elem)
 
             return coerced_elem if coerced_elem.is_a?(InvalidValue)
 

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

@@ -33,7 +33,7 @@ module Grape
         #   the coerced result, or an instance
         #   of {InvalidValue} if the value could not be coerced.
         def call(value)
-          return InvalidValue.new unless value.is_a? Array
+          return unless value.is_a? Array
 
           value =
             if @method

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

@@ -67,21 +67,12 @@ module Grape
       end
 
       def coerce_value(val)
-        val.nil? ? coerce_nil(val) : converter.call(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/default.rb

@@ -9,7 +9,6 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        return if params.key? attr_name
         params[attr_name] = if @default.is_a? Proc
                               @default.call
                             elsif @default.frozen? || !duplicatable?(@default)

data/lib/grape/version.rb

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

data/spec/grape/api/instance_spec.rb

@@ -51,4 +51,54 @@ describe Grape::API::Instance do
       expect(an_instance.top_level_setting.parent).to be_nil
     end
   end
+
+  context 'with multiple moutes' do
+    let(:first) do
+      Class.new(Grape::API::Instance) do
+        namespace(:some_namespace) do
+          route :any, '*path' do
+            error!('Not found! (1)', 404)
+          end
+        end
+      end
+    end
+    let(:second) do
+      Class.new(Grape::API::Instance) do
+        namespace(:another_namespace) do
+          route :any, '*path' do
+            error!('Not found! (2)', 404)
+          end
+        end
+      end
+    end
+    let(:root_api) do
+      first_instance = first
+      second_instance = second
+      Class.new(Grape::API) do
+        mount first_instance
+        mount first_instance
+        mount second_instance
+      end
+    end
+
+    it 'does not raise a FrozenError on first instance' do
+      expect { patch '/some_namespace/anything' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the first instance' do
+      patch '/some_namespace/anything'
+      expect(last_response.body).to eq 'Not found! (1)'
+    end
+
+    it 'does not raise a FrozenError on second instance' do
+      expect { get '/another_namespace/other' }.not_to \
+        raise_error
+    end
+
+    it 'responds the correct body at the second instance' do
+      get '/another_namespace/foobar'
+      expect(last_response.body).to eq 'Not found! (2)'
+    end
+  end
 end

data/spec/grape/endpoint_spec.rb

@@ -296,9 +296,12 @@ describe Grape::Endpoint do
               optional :seventh
             end
           end
+          optional :nested_arr, type: Array do
+            optional :eighth
+          end
         end
-        optional :nested_arr, type: Array do
-          optional :eighth
+        optional :arr, type: Array do
+          optional :nineth
         end
       end
     end
@@ -390,7 +393,7 @@ describe Grape::Endpoint do
 
       get '/declared?first=present&nested[fourth]=1'
       expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body)['nested'].keys.size).to eq 3
+      expect(JSON.parse(last_response.body)['nested'].keys.size).to eq 4
     end
 
     it 'builds nested params when given array' do
@@ -421,7 +424,7 @@ describe Grape::Endpoint do
 
         get '/declared?first=present'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)['nested']).to be_a(Hash)
+        expect(JSON.parse(last_response.body)['nested']).to eq({})
       end
 
       it 'to be an array when include_missing is true' do
@@ -431,7 +434,17 @@ describe Grape::Endpoint do
 
         get '/declared?first=present'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)['nested_arr']).to be_a(Array)
+        expect(JSON.parse(last_response.body)['arr']).to be_a(Array)
+      end
+
+      it 'to be an array when nested and include_missing is true' do
+        subject.get '/declared' do
+          declared(params, include_missing: true)
+        end
+
+        get '/declared?first=present&nested[fourth]=1'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)['nested']['nested_arr']).to be_a(Array)
       end
 
       it 'to be nil when include_missing is false' do

data/spec/grape/validations/types/array_coercer_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::ArrayCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'an array of primitives' do
+      let(:type) { Array[String] }
+
+      it 'coerces elements in the array' do
+        expect(subject.call([10, 20])).to eq(%w[10 20])
+      end
+    end
+
+    context 'an array of arrays' do
+      let(:type) { Array[Array[Integer]] }
+
+      it 'coerces elements in the nested array' do
+        expect(subject.call([%w[10 20]])).to eq([[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([[10], [20]])
+      end
+    end
+
+    context 'an array of sets' do
+      let(:type) { Array[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq([Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([Set[10], Set[20]])
+      end
+    end
+  end
+end

data/spec/grape/validations/types/primitive_coercer_spec.rb

@@ -7,7 +7,7 @@ describe Grape::Validations::Types::PrimitiveCoercer do
 
   subject { described_class.new(type, strict) }
 
-  describe '.call' do
+  describe '#call' do
     context 'Boolean' do
       let(:type) { Grape::API::Boolean }
 
@@ -26,6 +26,10 @@ describe Grape::Validations::Types::PrimitiveCoercer do
       it 'returns an error when the given value cannot be coerced' do
         expect(subject.call(123)).to be_instance_of(Grape::Validations::Types::InvalidValue)
       end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
     end
 
     context 'String' do

data/spec/grape/validations/types/set_coercer_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::SetCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'a set of primitives' do
+      let(:type) { Set[String] }
+
+      it 'coerces elements to the set' do
+        expect(subject.call([10, 20])).to eq(Set['10', '20'])
+      end
+    end
+
+    context 'a set of sets' do
+      let(:type) { Set[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq(Set[Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq(Set[Set[10], Set[20]])
+      end
+    end
+
+    context 'a set of sets of arrays' do
+      let(:type) { Set[Set[Array[Integer]]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([[['10'], ['20']]])).to eq(Set[Set[Array[10], Array[20]]])
+      end
+    end
+  end
+end

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

@@ -424,6 +424,79 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq(integer_class_name)
       end
+
+      context 'nil values' do
+        context 'primitive types' do
+          Grape::Validations::Types::PRIMITIVES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'structures types' do
+          Grape::Validations::Types::STRUCTURES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'special types' do
+          Grape::Validations::Types::SPECIAL.each_key do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          context 'variant-member-type collections' do
+            [
+              Array[Integer, String],
+              [Integer, String, Array[Integer, String]]
+            ].each do |type|
+              it 'respects the nil value' do
+                subject.params do
+                  requires :param, type: type
+                end
+                subject.get '/nil_value' do
+                  params[:param].class
+                end
+
+                get '/nil_value', param: nil
+                expect(last_response.status).to eq(200)
+                expect(last_response.body).to eq('NilClass')
+              end
+            end
+          end
+        end
+      end
     end
 
     context 'using coerce_with' do
@@ -752,19 +825,6 @@ 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]

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

@@ -298,4 +298,125 @@ describe Grape::Validations::DefaultValidator do
       end
     end
   end
+
+  context 'optional with nil as value' do
+    subject do
+      Class.new(Grape::API) do
+        default_format :json
+      end
+    end
+
+    def app
+      subject
+    end
+
+    context 'primitive types' do
+      [
+        [Integer, 0],
+        [Integer, 42],
+        [Float, 0.0],
+        [Float, 4.2],
+        [BigDecimal, 0.0],
+        [BigDecimal, 4.2],
+        [Numeric, 0],
+        [Numeric, 42],
+        [Date, Date.today],
+        [DateTime, DateTime.now],
+        [Time, Time.now],
+        [Time, Time.at(0)],
+        [Grape::API::Boolean, false],
+        [String, ''],
+        [String, 'non-empty-string'],
+        [Symbol, :symbol],
+        [TrueClass, true],
+        [FalseClass, false]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'structures types' do
+      [
+        [Hash, {}],
+        [Hash, { test: 'non-empty' }],
+        [Array, []],
+        [Array, ['non-empty']],
+        [Array[Integer], []],
+        [Set, []],
+        [Set, [1]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'special types' do
+      [
+        [JSON, ''],
+        [JSON, { test: 'non-empty-string' }.to_json],
+        [Array[JSON], []],
+        [Array[JSON], [{ test: 'non-empty-string' }.to_json]],
+        [::File, ''],
+        [::File, { test: 'non-empty-string' }.to_json],
+        [Rack::Multipart::UploadedFile, ''],
+        [Rack::Multipart::UploadedFile, { test: 'non-empty-string' }.to_json]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'variant-member-type collections' do
+      [
+        [Array[Integer, String], [0, '']],
+        [Array[Integer, String], [42, 'non-empty-string']],
+        [[Integer, String, Array[Integer, String]], [0, '', [0, '']]],
+        [[Integer, String, Array[Integer, String]], [42, 'non-empty-string', [42, 'non-empty-string']]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+  end
 end

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

@@ -319,7 +319,7 @@ describe Grape::Validations::ValuesValidator do
       expect(last_response.status).to eq 200
     end
 
-    it 'allows for an optional param with a list of values' do
+    it 'accepts for an optional param with a list of values' do
       put('/optional_with_array_of_string_values', optional: nil)
       expect(last_response.status).to eq 200
     end

data/spec/grape/validations_spec.rb

@@ -574,7 +574,7 @@ describe Grape::Validations do
         # NOTE: with body parameters in json or XML or similar this
         # should actually fail with: children[parents][name] is missing.
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[1][parents] is missing')
+        expect(last_response.body).to eq('children[1][parents] is missing, children[0][parents][1][name] is missing, children[0][parents][1][name] is empty')
       end
 
       it 'errors when a parameter is not present in array within array' do
@@ -615,7 +615,7 @@ describe Grape::Validations do
 
         get '/within_array', children: [name: 'Jay']
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[0][parents] is missing')
+        expect(last_response.body).to eq('children[0][parents] is missing, children[0][parents][0][name] is missing, children[0][parents][0][name] is empty')
       end
 
       it 'errors when param is not an Array' do
@@ -763,7 +763,7 @@ describe Grape::Validations do
         expect(last_response.status).to eq(200)
         put_with_json '/within_array', children: [name: 'Jay']
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[0][parents] is missing')
+        expect(last_response.body).to eq('children[0][parents] is missing, children[0][parents][0][name] is missing')
       end
     end
 
@@ -838,7 +838,7 @@ describe Grape::Validations do
       it 'does internal validations if the outer group is present' do
         get '/nested_optional_group', items: [{ key: 'foo' }]
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('items[0][required_subitems] is missing')
+        expect(last_response.body).to eq('items[0][required_subitems] is missing, items[0][required_subitems][0][value] is missing')
 
         get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
         expect(last_response.status).to eq(200)
@@ -858,7 +858,7 @@ describe Grape::Validations do
       it 'handles validation within arrays' do
         get '/nested_optional_group', items: [{ key: 'foo' }]
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('items[0][required_subitems] is missing')
+        expect(last_response.body).to eq('items[0][required_subitems] is missing, items[0][required_subitems][0][value] is missing')
 
         get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
         expect(last_response.status).to eq(200)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors:
 - Michael Bleigh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -332,7 +332,9 @@ files:
 - spec/grape/validations/multiple_attributes_iterator_spec.rb
 - spec/grape/validations/params_scope_spec.rb
 - spec/grape/validations/single_attribute_iterator_spec.rb
+- spec/grape/validations/types/array_coercer_spec.rb
 - spec/grape/validations/types/primitive_coercer_spec.rb
+- spec/grape/validations/types/set_coercer_spec.rb
 - spec/grape/validations/types_spec.rb
 - spec/grape/validations/validators/all_or_none_spec.rb
 - spec/grape/validations/validators/allow_blank_spec.rb
@@ -364,9 +366,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.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
+  changelog_uri: https://github.com/ruby-grape/grape/blob/v1.3.3/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/grape/1.3.3
+  source_code_uri: https://github.com/ruby-grape/grape/tree/v1.3.3
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -415,6 +417,8 @@ test_files:
 - spec/grape/api_remount_spec.rb
 - spec/grape/validations/types_spec.rb
 - spec/grape/validations/attributes_iterator_spec.rb
+- spec/grape/validations/types/array_coercer_spec.rb
+- spec/grape/validations/types/set_coercer_spec.rb
 - spec/grape/validations/types/primitive_coercer_spec.rb
 - spec/grape/validations/validators/regexp_spec.rb
 - spec/grape/validations/validators/default_spec.rb