Ensure complete declared params structure is present

Author: Tim Connor

lib/grape/dsl/inside_route.rb

@@ -70,10 +70,14 @@ def declared_hash(passed_params, options, declared_params, params_nested_path)
 
               next unless options[:include_missing] || passed_params.key?(declared_param) || (param_renaming && passed_params.key?(param_renaming))
 
-              if param_renaming
-                memo[optioned_param_key(param_renaming, options)] = passed_params[param_renaming]
-              else
-                memo[optioned_param_key(declared_param, options)] = passed_params[declared_param]
+              memo_key = optioned_param_key(param_renaming || declared_param, options)
+              passed_param = passed_params[param_renaming || declared_param]
+
+              params_nested_path_dup = params_nested_path.dup
+              params_nested_path_dup << declared_param.to_s
+
+              memo[memo_key] = handle_passed_param([], params_nested_path_dup) do
+                passed_param
               end
             end
           end
@@ -99,12 +103,14 @@ def declared_param_is_array?(params_nested_path)
         end
 
         def should_be_empty_hash?(passed_children_params, params_nested_path)
-          passed_children_params.empty? && declared_param_is_hash?(params_nested_path)
+          passed_children_params.empty? && declared_param_is_empty_hash?(params_nested_path)
         end
 
-        def declared_param_is_hash?(params_nested_path)
+        def declared_param_is_empty_hash?(params_nested_path)
           key = route_options_params_key(params_nested_path)
-          route_options_params[key] && route_options_params[key][:type] == 'Hash'
+          has_children = route_options_params.keys.any? { |k| k != key && k.start_with?(key) }
+
+          route_options_params[key] && route_options_params[key][:type] == 'Hash' && !has_children
         end
 
         def route_options_params

spec/grape/endpoint/declared_spec.rb

@@ -28,10 +28,14 @@ def app
           optional :nested_arr, type: Array do
             optional :eighth
           end
+          optional :empty_arr, type: Array
+          optional :empty_hash, type: Hash
         end
         optional :arr, type: Array do
           optional :nineth
         end
+        optional :empty_arr, type: Array
+        optional :empty_hash, type: Hash
       end
     end
 
@@ -103,7 +107,7 @@ def app
       end
       get '/declared?first=present'
       expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body).keys.size).to eq(5)
+      expect(JSON.parse(last_response.body).keys.size).to eq(7)
     end
 
     it 'has a optional param with default value all the time' do
@@ -122,7 +126,7 @@ def app
 
       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 4
+      expect(JSON.parse(last_response.body)['nested'].keys.size).to eq 6
     end
 
     it 'builds nested params when given array' do
@@ -145,45 +149,53 @@ def app
       expect(JSON.parse(last_response.body)['nested'].size).to eq 2
     end
 
-    context 'sets nested objects when the param is missing' do
-      it 'to be a hash when include_missing is true' do
-        subject.get '/declared' do
-          declared(params, include_missing: true)
-        end
+    context 'when the param is missing and include_missing=false' do
+      before do
+        subject.get('/declared') { declared(params, include_missing: false) }
+      end
 
+      it 'sets nested objects to be nil' do
         get '/declared?first=present'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)['nested']).to eq({})
+        expect(JSON.parse(last_response.body)['nested']).to be_nil
       end
+    end
 
-      it 'to be an array when include_missing is true' do
-        subject.get '/declared' do
-          declared(params, include_missing: true)
-        end
+    context 'when the param is missing and include_missing=true' do
+      before do
+        subject.get('/declared') { declared(params, include_missing: true) }
+      end
 
+      it 'sets objects with type=Hash to be a hash' do
         get '/declared?first=present'
         expect(last_response.status).to eq(200)
-        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
+        body = JSON.parse(last_response.body)
+        expect(body['empty_hash']).to eq({})
+        expect(body['nested']).to be_a(Hash)
+        expect(body['nested']['empty_hash']).to eq({})
+        expect(body['nested']['nested_two']).to be_a(Hash)
+      end
 
-        get '/declared?first=present&nested[fourth]=1'
+      it 'sets objects with type=Array to be an array' do
+        get '/declared?first=present'
         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
-        subject.get '/declared' do
-          declared(params, include_missing: false)
-        end
+        body = JSON.parse(last_response.body)
+        expect(body['empty_arr']).to eq([])
+        expect(body['arr']).to eq([])
+        expect(body['nested']['empty_arr']).to eq([])
+        expect(body['nested']['nested_arr']).to eq([])
+      end
 
+      it 'includes all declared children when type=Hash' do
         get '/declared?first=present'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)['nested']).to be_nil
+
+        body = JSON.parse(last_response.body)
+        expect(body['nested'].keys).to eq(%w[fourth fifth nested_two nested_arr empty_arr empty_hash])
+        expect(body['nested']['nested_two'].keys).to eq(%w[sixth nested_three])
+        expect(body['nested']['nested_two']['nested_three'].keys).to eq(%w[seventh])
       end
     end