recursive type_check

lib/grape/validations/types/custom_type_coercer.rb

@@ -103,13 +103,25 @@ def infer_type_check(type)
             # passed, or if the type also implements a parse() method.
             type
           elsif type.is_a?(Enumerable)
-            ->(value) { value.respond_to?(:all?) && value.all? { |item| item.is_a? type[0] } }
+            lambda do |value|
+              value.is_a?(Enumerable) && value.all? do |val|
+                recursive_type_check(type.first, val)
+              end
+            end
           else
             # By default, do a simple type check
             ->(value) { value.is_a? type }
           end
         end
 
+        def recursive_type_check(type, value)
+          if type.is_a?(Enumerable) && value.is_a?(Enumerable)
+            value.all? { |val| recursive_type_check(type.first, val) }
+          else
+            !type.is_a?(Enumerable) && value.is_a?(type)
+          end
+        end
+
         # Enforce symbolized keys for complex types
         # by wrapping the coercion method such that
         # any Hash objects in the immediate heirarchy

spec/grape/validations/validators/coerce_spec.rb

@@ -631,10 +631,17 @@ def self.parsed?(value)
         get '/coerce_nested_strings', values: 'a,b,c,d'
         expect(last_response.status).to eq(200)
         expect(JSON.parse(last_response.body)).to eq([%w[a b c d]])
+        expect(last_response.status).to eq(400)
+
+        get '/coerce_nested_strings', values: [%w[a c], %w[b]]
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq([%w[a c], %w[b]])
 
-        get '/coerce_nested_strings', values: [%w[a], %w[b]]
+        get '/coerce_nested_strings', values: [[]]
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq([%w[a], %w[b]])
+        expect(JSON.parse(last_response.body)).to eq([[]])
+
+        get '/coerce_nested_strings', values: [['a', { bar: 0 }], ['b']]
       end
 
       it 'parses parameters with Array[Integer] type' do