Merge pull request #288 from cerebris/rebase/274

lgebhardt · lgebhardt · commit 8ad3491ec52e · 2015-07-05T10:32:48.000-04:00
Rebase/274 Add support for creating resources with polymorphic has one.
diff --git a/README.md b/README.md
diff --git a/lib/jsonapi/acts_as_resource_controller.rb b/lib/jsonapi/acts_as_resource_controller.rb
@@ -86,8 +86,7 @@ def ensure_correct_media_type
     end
 
     def setup_request
-      @request = JSONAPI::Request.new(params,                                               context: context,
-                                                                                            key_formatter: key_formatter)
+      @request = JSONAPI::Request.new(params, context: context, key_formatter: key_formatter)
       render_errors(@request.errors) unless @request.errors.empty?
     rescue => e
       handle_exceptions(e)
diff --git a/lib/jsonapi/request.rb b/lib/jsonapi/request.rb
@@ -392,9 +392,7 @@ def parse_params(params, allowed_fields)
         when 'relationships'
           value.each do |link_key, link_value|
             param = unformat_key(link_key)
-
             association = @resource_klass._association(param)
-
             if association.is_a?(JSONAPI::Association::HasOne)
               if link_value.nil?
                 linkage = nil
@@ -404,12 +402,17 @@ def parse_params(params, allowed_fields)
 
               links_object = parse_has_one_links_object(linkage)
               if !association.polymorphic? && links_object[:type] && (links_object[:type].to_s != association.type.to_s)
-                raise JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+                fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
               end
 
               unless links_object[:id].nil?
                 association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
-                checked_has_one_associations[param] = association_resource.verify_key(links_object[:id], @context)
+                association_id = association_resource.verify_key(links_object[:id], @context)
+                if association.polymorphic?
+                  checked_has_one_associations[param] = { id: association_id, type: unformat_key(links_object[:type].to_s) }
+                else
+                  checked_has_one_associations[param] = association_id
+                end
               else
                 checked_has_one_associations[param] = nil
               end
@@ -426,12 +429,12 @@ def parse_params(params, allowed_fields)
 
               # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
               # association's type.
-              # TODO: Support Polymorphic associations
+              # ToDo: Support Polymorphic associations
 
               if links_object.length == 0
                 checked_has_many_associations[param] = []
               else
-                if links_object.length > 1 || !links_object.key?(unformat_key(association.type).to_s)
+                if links_object.length > 1 || !links_object.has_key?(unformat_key(association.type).to_s)
                   fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
                 end
 
@@ -519,19 +522,19 @@ def parse_update_association_operation(data, association_type, parent_key)
       association = resource_klass._association(association_type)
       if association.is_a?(JSONAPI::Association::HasOne)
         if association.polymorphic?
-          object_params = {relationships: {format_key(association.name) => {data: data}}}
+          object_params = { relationships: { format_key(association.name) => { data: data } } }
           verified_param_set = parse_params(object_params, updatable_fields)
 
           @operations.push JSONAPI::ReplacePolymorphicHasOneAssociationOperation.new(
                              resource_klass,
                              context: @context,
                              resource_id: parent_key,
                              association_type: association_type,
-                             key_value: verified_param_set[:has_one].values[0],
-                             key_type: data['type']
+                             key_value: verified_param_set[:has_one].values[0][:id],
+                             key_type: verified_param_set[:has_one].values[0][:type]
                            )
         else
-          object_params = {relationships: {format_key(association.name) => {data: data}}}
+          object_params = { relationships: { format_key(association.name) => { data: data } } }
           verified_param_set = parse_params(object_params, updatable_fields)
 
           @operations.push JSONAPI::ReplaceHasOneAssociationOperation.new(
@@ -542,7 +545,7 @@ def parse_update_association_operation(data, association_type, parent_key)
                              key_value: verified_param_set[:has_one].values[0]
                            )
         end
-      else
+      elsif association.is_a?(JSONAPI::Association::HasMany)
         unless association.acts_as_set
           fail JSONAPI::Exceptions::HasManySetReplacementForbidden.new
         end
diff --git a/lib/jsonapi/resource.rb b/lib/jsonapi/resource.rb
@@ -196,10 +196,10 @@ def _replace_has_one_link(association_type, association_key_value)
     end
 
     def _replace_polymorphic_has_one_link(association_type, key_value, key_type)
-      association = self.class._associations[association_type]
+      association = self.class._associations[association_type.to_sym]
 
-      send("#{association.foreign_key}=", key_value)
-      send("#{association.polymorphic_type}=", key_type.singularize.capitalize)
+      model.send("#{association.foreign_key}=", key_value)
+      model.send("#{association.polymorphic_type}=", key_type.to_s.classify)
 
       @save_needed = true
 
@@ -239,7 +239,12 @@ def _replace_fields(field_data)
         if value.nil?
           remove_has_one_link(association_type)
         else
-          replace_has_one_link(association_type, value)
+          case value
+          when Hash
+            replace_polymorphic_has_one_link(association_type.to_s, value.fetch(:id), value.fetch(:type))
+          else
+            replace_has_one_link(association_type, value)
+          end
         end
       end if field_data[:has_one]
 
@@ -714,6 +719,9 @@ def _associate(klass, *attrs)
               end
 
               return records.collect do |record|
+                if association.polymorphic?
+                  resource_klass = Resource.resource_for(self.class.module_path + record.class.to_s.underscore)
+                end
                 resource_klass.new(record, @context)
               end
             end unless method_defined?(attr)
diff --git a/lib/jsonapi/resource_serializer.rb b/lib/jsonapi/resource_serializer.rb
@@ -1,5 +1,6 @@
 module JSONAPI
   class ResourceSerializer
+
     # Options can include
     # include:
     #     Purpose: determines which objects will be side loaded with the source objects in a linked section
@@ -232,6 +233,7 @@ def related_link(source, association)
     def has_one_linkage(source, association)
       linkage = {}
       linkage_id = foreign_key_value(source, association)
+
       if linkage_id
         linkage[:type] = format_key(association.type_for_source(source))
         linkage[:id] = linkage_id
@@ -243,9 +245,10 @@ def has_one_linkage(source, association)
 
     def has_many_linkage(source, association)
       linkage = []
-      linkage_ids = foreign_key_value(source, association)
-      linkage_ids.each do |linkage_id|
-        linkage.append(type: format_key(association.type), id: linkage_id)
+      linkage_types_and_values = foreign_key_types_and_values(source, association)
+
+      linkage_types_and_values.each do |type, value|
+        linkage.append({type: format_key(type), id: value})
       end
       linkage
     end
@@ -276,15 +279,24 @@ def link_object(source, association, include_linkage = false)
       end
     end
 
-    # Extracts the foreign key value for an association.
+    # Extracts the foreign key value for a has_one association.
     def foreign_key_value(source, association)
       foreign_key = association.foreign_key
       value = source.send(foreign_key)
+      IdValueFormatter.format(value)
+    end
 
+    def foreign_key_types_and_values(source, association)
       if association.is_a?(JSONAPI::Association::HasMany)
-        value.map { |value| IdValueFormatter.format(value) }
-      elsif association.is_a?(JSONAPI::Association::HasOne)
-        IdValueFormatter.format(value)
+        if association.polymorphic?
+          source.model.send(association.name).pluck(:type, :id).map do |type, id|
+            [type.pluralize, IdValueFormatter.format(id)]
+          end
+        else
+          source.send(association.foreign_key).map do |value|
+            [association.type, IdValueFormatter.format(value)]
+          end
+        end
       end
     end
 
diff --git a/test/controllers/controller_test.rb b/test/controllers/controller_test.rb
@@ -1944,7 +1944,13 @@ def test_get_related_resource
                "related" => "http://test.host/people/1/hair_cut"
              },
              "data" => nil
-            }
+           },
+           vehicles: {
+             links: {
+               self: "http://test.host/people/1/relationships/vehicles",
+               related: "http://test.host/people/1/vehicles"
+             }
+           }
          }
         }
       },
diff --git a/test/fixtures/active_record.rb b/test/fixtures/active_record.rb
@@ -187,13 +187,19 @@
     t.string  :name
     t.timestamps null: false
   end
+
+  create_table :vehicles, force: true do |t|
+    t.string :type
+    t.integer :person_id
+  end
 end
 
 ### MODELS
 class Person < ActiveRecord::Base
   has_many :posts, foreign_key: 'author_id'
   has_many :comments, foreign_key: 'author_id'
   has_many :expense_entries, foreign_key: 'employee_id', dependent: :restrict_with_exception
+  has_many :vehicles
   belongs_to :preferences
   belongs_to :hair_cut
 
@@ -368,6 +374,16 @@ class Picture < ActiveRecord::Base
   belongs_to :imageable, polymorphic: true
 end
 
+class Vehicle < ActiveRecord::Base
+  belongs_to :person
+end
+
+class Car < Vehicle
+end
+
+class Boat < Vehicle
+end
+
 class Document < ActiveRecord::Base
   has_many :pictures, as: :imageable
 end
@@ -576,6 +592,7 @@ class PersonResource < JSONAPI::Resource
 
   has_many :comments
   has_many :posts
+  has_many :vehicles, polymorphic: true
 
   has_one :preferences
   has_one :hair_cut
@@ -595,6 +612,16 @@ def self.verify_custom_filter(filter, values, context)
   end
 end
 
+class VehicleResource < JSONAPI::Resource
+  has_one :person
+end
+
+class CarResource < VehicleResource
+end
+
+class BoatResource < VehicleResource
+end
+
 class CommentResource < JSONAPI::Resource
   attributes :body
   has_one :post
@@ -825,10 +852,6 @@ class CategoryResource < JSONAPI::Resource
 class PictureResource < JSONAPI::Resource
   attribute :name
   has_one :imageable, polymorphic: true
-
-  def imageable_type=(type)
-    model.imageable_type = type
-  end
 end
 
 class DocumentResource < JSONAPI::Resource
@@ -892,6 +915,9 @@ def subject
     EmployeeResource = EmployeeResource.dup
     FriendResource = FriendResource.dup
     HairCutResource = HairCutResource.dup
+    VehicleResource = VehicleResource.dup
+    CarResource = CarResource.dup
+    BoatResource = BoatResource.dup
   end
 end
 
diff --git a/test/fixtures/vehicles.yml b/test/fixtures/vehicles.yml
@@ -0,0 +1,8 @@
+car:
+  id: 1
+  type: Car
+  person_id: 1
+boat:
+  id: 2
+  type: Boat
+  person_id: 1
diff --git a/test/unit/serializer/polymorphic_serializer_test.rb b/test/unit/serializer/polymorphic_serializer_test.rb
diff --git a/test/unit/serializer/serializer_test.rb b/test/unit/serializer/serializer_test.rb
