Add support for polymorphic includes

Author: sirdharma

lib/fast_jsonapi/object_serializer.rb

@@ -295,8 +295,7 @@ def validate_includes!(includes)
             relationships_to_serialize = klass.relationships_to_serialize || {}
             relationship_to_include = relationships_to_serialize[parsed_include]
             raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
-            raise NotImplementedError if relationship_to_include.polymorphic.is_a?(Hash)
-            klass = relationship_to_include.serializer.to_s.constantize
+            klass = relationship_to_include.serializer.to_s.constantize unless relationship_to_include.polymorphic.is_a?(Hash)
           end
         end
       end

lib/fast_jsonapi/serialization_core.rb

@@ -119,16 +119,22 @@ def get_included_records(record, includes_list, known_included_objects, fieldset
             next unless relationships_to_serialize && relationships_to_serialize[item]
             relationship_item = relationships_to_serialize[item]
             next unless relationship_item.include_relationship?(record, params)
-            raise NotImplementedError if relationship_item.polymorphic.is_a?(Hash)
-            record_type = relationship_item.record_type
-            serializer = relationship_item.serializer.to_s.constantize
+            unless relationship_item.polymorphic.is_a?(Hash)
+              record_type = relationship_item.record_type
+              serializer = relationship_item.serializer.to_s.constantize
+            end
             relationship_type = relationship_item.relationship_type
 
             included_objects = relationship_item.fetch_associated_object(record, params)
             next if included_objects.blank?
             included_objects = [included_objects] unless relationship_type == :has_many
 
             included_objects.each do |inc_obj|
+              if relationship_item.polymorphic.is_a?(Hash)
+                record_type = inc_obj.class.name.demodulize.underscore
+                serializer = self.compute_serializer_name(inc_obj.class.name.demodulize.to_sym).to_s.constantize
+              end
+
               if remaining_items(items)
                 serializer_records = serializer.get_included_records(inc_obj, remaining_items(items), known_included_objects, fieldsets, params)
                 included_records.concat(serializer_records) unless serializer_records.empty?

spec/lib/object_serializer_spec.rb

@@ -278,10 +278,24 @@ def advertising_campaign
       end
     end
 
-    it 'polymorphic throws an error that polymorphic is not supported' do
+    it 'polymorphic has_many: returns correct nested includes when serializable_hash is called' do
       options = {}
       options[:include] = [:groupees]
-      expect(-> { GroupSerializer.new([group], options)}).to raise_error(NotImplementedError)
+
+      serializable_hash = GroupSerializer.new([group], options).serializable_hash
+
+      persons_serialized = serializable_hash[:included].find_all { |included| included[:type] == :person }.map { |included| included[:id].to_i }
+      groups_serialized = serializable_hash[:included].find_all { |included| included[:type] == :group }.map { |included| included[:id].to_i }
+
+      persons = group.groupees.find_all { |groupee| groupee.is_a?(Person) }
+      persons.each do |person|
+        expect(persons_serialized).to include(person.id)
+      end
+
+      groups = group.groupees.find_all { |groupee| groupee.is_a?(Group) }
+      groups.each do |group|
+        expect(groups_serialized).to include(group.id)
+      end
     end
   end