Add inheritance and discriminator attributes

Author: MaximeRVY

lib/grape-swagger/entity/attribute_parser.rb

@@ -39,7 +39,7 @@ def call(entity_options)
           add_attribute_documentation(param, documentation)
 
           add_extension_documentation(param, documentation)
-
+          add_discriminator_extension(param, documentation)
           param
         end
       end
@@ -128,6 +128,10 @@ def add_array_documentation(param, documentation)
       def add_extension_documentation(param, documentation)
         GrapeSwagger::DocMethods::Extensions.add_extensions_to_root(documentation, param)
       end
+
+      def add_discriminator_extension(param, documentation)
+        param[:documentation] = { is_discriminator: true } if documentation.key?(:is_discriminator)
+      end
     end
   end
 end

lib/grape-swagger/entity/parser.rb

@@ -26,7 +26,13 @@ def initialize(original, renamed)
       end
 
       def extract_params(exposure)
-        exposure.root_exposures.each_with_object({}) do |value, memo|
+        root_exposures =
+          if superclass_contains_discriminator?(exposure)
+            root_exposures_without_parent(exposure)
+          else
+            exposure.root_exposures
+          end
+        root_exposures.each_with_object({}) do |value, memo|
           if value.for_merge && (value.respond_to?(:entity_class) || value.respond_to?(:using_class_name))
             entity_class = value.respond_to?(:entity_class) ? value.entity_class : value.using_class_name
 
@@ -39,6 +45,18 @@ def extract_params(exposure)
         end
       end
 
+      def superclass_contains_discriminator?(exposure)
+        exposure.superclass.root_exposures.detect do |value|
+          value.documentation[:is_discriminator]
+        end
+      end
+
+      def root_exposures_without_parent(exposure)
+        exposure.root_exposures.select do |value|
+          exposure.superclass.root_exposures.find_by(value.attribute).nil?
+        end
+      end
+
       def parse_grape_entity_params(params, parent_model = nil)
         return unless params
 
@@ -63,8 +81,28 @@ 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)
+        else
+          [parsed, required_params(params)]
+        end
+      end
 
-        [parsed, required_params(params)]
+      def respond_with_all_of(parsed, params)
+        parent_name =
+          if endpoint.nil?
+            model.superclass.to_s.demodulize
+          else
+            endpoint.send(:expose_params_from_model, model.superclass)
+          end
+        {
+          allOf: [
+            {
+              '$ref' => "#/definitions/#{parent_name}"
+            },
+            [parsed, required_params(params)]
+          ]
+        }
       end
 
       def parse_nested(entity_name, entity_options, parent_model = nil)

spec/grape-swagger/entity/parser_spec.rb

@@ -2,31 +2,69 @@
 require_relative '../../../spec/support/shared_contexts/this_api'
 
 describe GrapeSwagger::Entity::Parser do
-  include_context 'this api'
+  context 'this api' do
+    include_context 'this api'
 
-  describe '#call' do
-    let(:parsed_entity) { described_class.new(ThisApi::Entities::Something, endpoint).call }
-    let(:properties) { parsed_entity.first }
-    let(:required) { parsed_entity.last }
+    describe '#call' do
+      let(:parsed_entity) { described_class.new(ThisApi::Entities::Something, endpoint).call }
+      let(:properties) { parsed_entity.first }
+      let(:required) { parsed_entity.last }
 
-    context 'when no endpoint is passed' do
-      let(:endpoint) { nil }
+      context 'when no endpoint is passed' do
+        let(:endpoint) { nil }
 
-      it 'parses the model with the correct :using definition' do
-        expect(properties[:kind]['$ref']).to eq('#/definitions/Kind')
-        expect(properties[:kind2]['$ref']).to eq('#/definitions/Kind')
-        expect(properties[:kind3]['$ref']).to eq('#/definitions/Kind')
+        it 'parses the model with the correct :using definition' do
+          expect(properties[:kind]['$ref']).to eq('#/definitions/Kind')
+          expect(properties[:kind2]['$ref']).to eq('#/definitions/Kind')
+          expect(properties[:kind3]['$ref']).to eq('#/definitions/Kind')
+        end
+
+        it 'merges attributes that have merge: true defined' do
+          expect(properties[:merged_attribute]).to be_nil
+          expect(properties[:code][:type]).to eq('string')
+          expect(properties[:message][:type]).to eq('string')
+          expect(properties[:attr][:type]).to eq('string')
+        end
+
+        it 'hides hidden attributes' do
+          expect(properties).to_not include(:hidden_attr)
+        end
       end
+    end
+  end
+  context 'inheritance api' do
+    include_context 'inheritance api'
 
-      it 'merges attributes that have merge: true defined' do
-        expect(properties[:merged_attribute]).to be_nil
-        expect(properties[:code][:type]).to eq('string')
-        expect(properties[:message][:type]).to eq('string')
-        expect(properties[:attr][:type]).to eq('string')
+    describe '#call for Parent' do
+      let(:parsed_entity) do
+        described_class.new(InheritanceApi::Entities::Parent, endpoint).call
       end
+      let(:properties) { parsed_entity.first }
+
+      context 'when no endpoint is passed' do
+        let(:endpoint) { nil }
+
+        it 'parses the model with discriminator' do
+          expect(properties[:type][:documentation]).to eq(is_discriminator: true)
+        end
+      end
+    end
+
+    describe '#call for Child' do
+      let(:parsed_entity) do
+        described_class.new(InheritanceApi::Entities::Child, endpoint).call
+      end
+      let(:properties) { parsed_entity }
+
+      context 'when no endpoint is passed' do
+        let(:endpoint) { nil }
 
-      it 'hides hidden attributes' do
-        expect(properties).to_not include(:hidden_attr)
+        it 'parses the model with allOf' do
+          expect(properties).to include(:allOf)
+          all_of = properties[:allOf]
+          expect(all_of.first['$ref']).to eq('#/definitions/Parent')
+          expect(all_of.last.first[:name][:type]).to eq('string')
+        end
       end
     end
   end

spec/spec_helper.rb

@@ -7,6 +7,7 @@
 
 require 'rack'
 require 'rack/test'
+require 'pry'
 
 RSpec.configure do |config|
   require 'rspec/expectations'

spec/support/shared_contexts/inheritance_api.rb

@@ -0,0 +1,16 @@
+shared_context 'inheritance api' do
+  before :all do
+    module InheritanceApi
+      module Entities
+        class Parent < Grape::Entity
+          expose :type, documentation: { type: 'string', is_discriminator: true, required: true }
+          expose :id, documentation: { type: 'integer' }
+        end
+
+        class Child < Parent
+          expose :name, documentation: { type: 'string', desc: 'Name' }
+        end
+      end
+    end
+  end
+end