lib/grape-swagger/entity/parser.rb in grape-swagger-entity-0.2.2 vs lib/grape-swagger/entity/parser.rb in grape-swagger-entity-0.2.3

@@ -25,23 +25,24 @@
         return unless params
 
         params.each_with_object({}) do |(entity_name, entity_options), memo|
           next if entity_options.fetch(:documentation, {}).fetch(:in, nil).to_s == 'header'
 
-          entity_name = entity_options[:as] if entity_options[:as]
+          final_entity_name = entity_options.fetch(:as, entity_name)
           documentation = entity_options[:documentation]
 
-          memo[entity_name] = if entity_options[:nesting]
-                                parse_nested(entity_name, entity_options, parent_model)
-                              else
-                                attribute_parser.call(entity_options)
-                              end
+          memo[final_entity_name] = if entity_options[:nesting]
+                                      parse_nested(entity_name, entity_options, parent_model)
+                                    else
+                                      attribute_parser.call(entity_options)
+                                    end
 
-          if documentation
-            memo[entity_name][:read_only] = documentation[:read_only].to_s == 'true' if documentation[:read_only]
-            memo[entity_name][:description] = documentation[:desc] if documentation[:desc]
+          next unless documentation
+          if documentation[:read_only]
+            memo[final_entity_name][:read_only] = documentation[:read_only].to_s == 'true'
           end
+          memo[final_entity_name][:description] = documentation[:desc] if documentation[:desc]
         end
       end
 
       def parse_nested(entity_name, entity_options, parent_model = nil)
         nested_entity = if parent_model.nil?
@@ -52,29 +53,41 @@
 
         params = nested_entity.nested_exposures.each_with_object({}) do |value, memo|
           memo[value.attribute] = value.send(:options)
         end
 
+        required = required_params(params)
+
         properties = parse_grape_entity_params(params, nested_entity)
         is_a_collection = entity_options[:documentation].is_a?(Hash) &&
                           entity_options[:documentation][:type].to_s.casecmp('array').zero?
 
         if is_a_collection
           {
             type: :array,
-            items: {
+            items: with_required({
               type: :object,
               properties: properties
-            },
-            description: entity_options[:desc] || ''
+            }, required)
           }
         else
-          {
+          with_required({
             type: :object,
-            properties: properties,
-            description: entity_options[:desc] || ''
-          }
+            properties: properties
+          }, required)
         end
+      end
+
+      def required_params(params)
+        params.select { |_, options| options.fetch(:documentation, {}).fetch(:required, false) }
+              .map { |(key, options)| [options.fetch(:as, key), options] }
+              .map(&:first)
+      end
+
+      def with_required(hash, required)
+        return hash if required.empty?
+        hash[:required] = required
+        hash
       end
     end
   end
 end