Add required type and property

Author: MaximeRVY

lib/grape-swagger/entity.rb

@@ -2,6 +2,7 @@
 require 'grape-entity'
 
 require 'grape-swagger/entity/version'
+require 'grape-swagger/entity/helper'
 require 'grape-swagger/entity/attribute_parser'
 require 'grape-swagger/entity/parser'
 

lib/grape-swagger/entity/attribute_parser.rb

@@ -12,7 +12,7 @@ def call(entity_options)
         entity_model = model_from(entity_options)
 
         if entity_model
-          name = endpoint.nil? ? entity_model.to_s.demodulize : endpoint.send(:expose_params_from_model, entity_model)
+          name = GrapeSwagger::Entity::Helper.model_name(entity_model, endpoint)
 
           entity_model_type = entity_model_type(name, entity_options)
           return entity_model_type unless documentation

lib/grape-swagger/entity/helper.rb

@@ -0,0 +1,13 @@
+module GrapeSwagger
+  module Entity
+    class Helper
+      def self.model_name(entity_model, endpoint)
+        if endpoint.nil?
+          entity_model.to_s.demodulize
+        else
+          endpoint.send(:expose_params_from_model, entity_model)
+        end
+      end
+    end
+  end
+end

lib/grape-swagger/entity/parser.rb

@@ -27,7 +27,7 @@ def initialize(original, renamed)
 
       def extract_params(exposure)
         root_exposures =
-          if superclass_contains_discriminator?(exposure)
+          if discriminator(exposure)
             root_exposures_without_parent(exposure)
           else
             exposure.root_exposures
@@ -45,7 +45,7 @@ def extract_params(exposure)
         end
       end
 
-      def superclass_contains_discriminator?(exposure)
+      def discriminator(exposure)
         exposure.superclass.root_exposures.detect do |value|
           value.documentation.try(:[], :is_discriminator)
         end
@@ -81,15 +81,19 @@ def parse_grape_entity_params(params, parent_model = nil)
           memo[final_entity_name][:readOnly] = documentation[:read_only].to_s == 'true' if documentation[:read_only]
           memo[final_entity_name][:description] = documentation[:desc] if documentation[:desc]
         end
-        if superclass_contains_discriminator?(model)
-          respond_with_all_of(parsed, params)
+
+        discriminator = discriminator(model)
+        if discriminator
+          respond_with_all_of(parsed, params, discriminator)
         else
           [parsed, required_params(params)]
         end
       end
 
-      def respond_with_all_of(parsed, params)
+      def respond_with_all_of(parsed, params, discriminator)
         parent_name =
+          GrapeSwagger::Entity::Helper.model_name(model.superclass, endpoint)
+
           if endpoint.nil?
             model.superclass.to_s.demodulize
           else
@@ -100,11 +104,27 @@ def respond_with_all_of(parsed, params)
             {
               '$ref' => "#/definitions/#{parent_name}"
             },
-            [parsed, required_params(params)]
+            [
+              add_discriminator(parsed, discriminator),
+              required_params(params).push(discriminator.attribute)
+            ]
           ]
         }
       end
 
+      def add_discriminator(parsed, discriminator)
+        model_name = GrapeSwagger::Entity::Helper.model_name(model, endpoint)
+
+        parsed.merge(
+          {
+            discriminator.attribute => {
+              type: 'string',
+              enum: [model_name]
+            }
+          }
+        )
+      end
+
       def parse_nested(entity_name, entity_options, parent_model = nil)
         nested_entity = if parent_model.nil?
                           model.root_exposures.find_by(entity_name)

spec/grape-swagger/entity/parser_spec.rb

@@ -62,8 +62,13 @@
         it 'parses the model with allOf' do
           expect(properties).to include(:allOf)
           all_of = properties[:allOf]
+          child_property = all_of.last.first
+          child_required = all_of.last.last
           expect(all_of.first['$ref']).to eq('#/definitions/Parent')
-          expect(all_of.last.first[:name][:type]).to eq('string')
+          expect(child_property[:name][:type]).to eq('string')
+          expect(child_property[:type][:type]).to eq('string')
+          expect(child_property[:type][:enum]).to eq(['Child'])
+          expect(child_required).to include(:type)
         end
       end
     end