jsonapi-resources 0.4.4 → 0.5.0

data/lib/jsonapi/resource_serializer.rb

@@ -7,21 +7,24 @@ module JSONAPI
     #     Example: ['comments','author','comments.tags','author.posts']
     # fields:
     #     Purpose: determines which fields are serialized for a resource type. This encompasses both attributes and
-    #              association ids in the links section for a resource. Fields are global for a resource type.
+    #              relationship ids in the links section for a resource. Fields are global for a resource type.
     #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
     # key_formatter: KeyFormatter class to override the default configuration
     # base_url: a string to prepend to generated resource links
 
-    def initialize(primary_resource_klass, options = {})
-      @primary_resource_klass = primary_resource_klass
-      @primary_class_name = @primary_resource_klass._type
+    attr_reader :url_generator
 
-      @fields =  options.fetch(:fields, {})
-      @include = options.fetch(:include, [])
+    def initialize(primary_resource_klass, options = {})
+      @primary_class_name = primary_resource_klass._type
+      @fields             = options.fetch(:fields, {})
+      @include            = options.fetch(:include, [])
       @include_directives = options[:include_directives]
-      @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
-      @route_formatter = options.fetch(:route_formatter, JSONAPI.configuration.route_formatter)
-      @base_url = options.fetch(:base_url, '')
+      @key_formatter      = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
+      @url_generator      = generate_link_builder(primary_resource_klass, options)
+      @always_include_to_one_linkage_data = options.fetch(:always_include_to_one_linkage_data,
+                                                          JSONAPI.configuration.always_include_to_one_linkage_data)
+      @always_include_to_many_linkage_data = options.fetch(:always_include_to_many_linkage_data,
+                                                           JSONAPI.configuration.always_include_to_many_linkage_data)
     end
 
     # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
@@ -51,24 +54,24 @@ module JSONAPI
       primary_hash
     end
 
-    def serialize_to_links_hash(source, requested_association)
-      if requested_association.is_a?(JSONAPI::Association::HasOne)
-        data = has_one_linkage(source, requested_association)
+    def serialize_to_links_hash(source, requested_relationship)
+      if requested_relationship.is_a?(JSONAPI::Relationship::ToOne)
+        data = to_one_linkage(source, requested_relationship)
       else
-        data = has_many_linkage(source, requested_association)
+        data = to_many_linkage(source, requested_relationship)
       end
 
       {
         links: {
-          self: self_link(source, requested_association),
-          related: related_link(source, requested_association)
+          self: self_link(source, requested_relationship),
+          related: related_link(source, requested_relationship)
         },
         data: data
       }
     end
 
     def find_link(query_params)
-      "#{@base_url}/#{formatted_module_path_from_klass(@primary_resource_klass)}#{@route_formatter.format(@primary_resource_klass._type.to_s)}?#{query_params.to_query}"
+      url_generator.query_link(query_params)
     end
 
     private
@@ -81,18 +84,18 @@ module JSONAPI
       if source.respond_to?(:to_ary)
         source.each do |resource|
           id = resource.id
-          if already_serialized?(@primary_class_name, id)
+          if already_serialized?(resource.class._type, id)
             set_primary(@primary_class_name, id)
           end
 
-          add_included_object(@primary_class_name, id, object_hash(resource,  include_directives), true)
+          add_included_object(id, object_hash(resource,  include_directives), true)
         end
       else
         return {} if source.nil?
 
         resource = source
         id = resource.id
-        add_included_object(@primary_class_name, id, object_hash(source,  include_directives), true)
+        add_included_object(id, object_hash(source, include_directives), true)
       end
     end
 
@@ -131,60 +134,60 @@ module JSONAPI
       fields.each_with_object({}) do |name, hash|
         format = source.class._attribute_options(name)[:format]
         unless name == :id
-          hash[format_key(name)] = format_value(source.send(name), format)
+          hash[format_key(name)] = format_value(source.public_send(name), format)
         end
       end
     end
 
     def relationship_data(source, include_directives)
-      associations = source.class._associations
+      relationships = source.class._relationships
       requested = requested_fields(source.class._type)
-      fields = associations.keys
+      fields = relationships.keys
       fields = requested & fields unless requested.nil?
 
       field_set = Set.new(fields)
 
-      included_associations = source.fetchable_fields & associations.keys
+      included_relationships = source.fetchable_fields & relationships.keys
 
       data = {}
 
-      associations.each_with_object(data) do |(name, association), hash|
-        if included_associations.include? name
+      relationships.each_with_object(data) do |(name, relationship), hash|
+        if included_relationships.include? name
           ia = include_directives[:include_related][name]
 
           include_linkage = ia && ia[:include]
           include_linked_children = ia && !ia[:include_related].empty?
 
           if field_set.include?(name)
-            hash[format_key(name)] = link_object(source, association, include_linkage)
+            hash[format_key(name)] = link_object(source, relationship, include_linkage)
           end
 
-          type = association.type
+          type = relationship.type
 
           # If the object has been serialized once it will be in the related objects list,
           # but it's possible all children won't have been captured. So we must still go
-          # through the associations.
+          # through the relationships.
           if include_linkage || include_linked_children
-            if association.is_a?(JSONAPI::Association::HasOne)
-              resource = source.send(name)
+            if relationship.is_a?(JSONAPI::Relationship::ToOne)
+              resource = source.public_send(name)
               if resource
                 id = resource.id
-                type = association.type_for_source(source)
-                associations_only = already_serialized?(type, id)
-                if include_linkage && !associations_only
-                  add_included_object(type, id, object_hash(resource, ia))
-                elsif include_linked_children || associations_only
+                type = relationship.type_for_source(source)
+                relationships_only = already_serialized?(type, id)
+                if include_linkage && !relationships_only
+                  add_included_object(id, object_hash(resource, ia))
+                elsif include_linked_children || relationships_only
                   relationship_data(resource, ia)
                 end
               end
-            elsif association.is_a?(JSONAPI::Association::HasMany)
-              resources = source.send(name)
+            elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
+              resources = source.public_send(name)
               resources.each do |resource|
                 id = resource.id
-                associations_only = already_serialized?(type, id)
-                if include_linkage && !associations_only
-                  add_included_object(type, id, object_hash(resource, ia))
-                elsif include_linked_children || associations_only
+                relationships_only = already_serialized?(type, id)
+                if include_linkage && !relationships_only
+                  add_included_object(id, object_hash(resource, ia))
+                elsif include_linked_children || relationships_only
                   relationship_data(resource, ia)
                 end
               end
@@ -196,46 +199,30 @@ module JSONAPI
 
     def relationship_links(source)
       links = {}
-      links[:self] = self_href(source)
+      links[:self] = url_generator.self_link(source)
 
       links
     end
 
-    def formatted_module_path(source)
-      formatted_module_path_from_klass(source.class)
-    end
-
-    def formatted_module_path_from_klass(klass)
-      klass.name =~ /::[^:]+\Z/ ? (@route_formatter.format($`).freeze.gsub('::', '/') + '/').downcase : ''
-    end
-
-    def self_href(source)
-      "#{@base_url}/#{formatted_module_path(source)}#{@route_formatter.format(source.class._type.to_s)}/#{source.id}"
-    end
-
     def already_serialized?(type, id)
       type = format_key(type)
       @included_objects.key?(type) && @included_objects[type].key?(id)
     end
 
-    def format_route(route)
-      @route_formatter.format(route.to_s)
-    end
-
-    def self_link(source, association)
-      "#{self_href(source)}/relationships/#{format_route(association.name)}"
+    def self_link(source, relationship)
+      url_generator.relationships_self_link(source, relationship)
     end
 
-    def related_link(source, association)
-      "#{self_href(source)}/#{format_route(association.name)}"
+    def related_link(source, relationship)
+      url_generator.relationships_related_link(source, relationship)
     end
 
-    def has_one_linkage(source, association)
+    def to_one_linkage(source, relationship)
       linkage = {}
-      linkage_id = foreign_key_value(source, association)
+      linkage_id = foreign_key_value(source, relationship)
 
       if linkage_id
-        linkage[:type] = format_key(association.type_for_source(source))
+        linkage[:type] = format_key(relationship.type_for_source(source))
         linkage[:id] = linkage_id
       else
         linkage = nil
@@ -243,9 +230,9 @@ module JSONAPI
       linkage
     end
 
-    def has_many_linkage(source, association)
+    def to_many_linkage(source, relationship)
       linkage = []
-      linkage_types_and_values = foreign_key_types_and_values(source, association)
+      linkage_types_and_values = foreign_key_types_and_values(source, relationship)
 
       linkage_types_and_values.each do |type, value|
         linkage.append({type: format_key(type), id: value})
@@ -253,48 +240,49 @@ module JSONAPI
       linkage
     end
 
-    def link_object_has_one(source, association)
+    def link_object_to_one(source, relationship, include_linkage)
+      include_linkage = include_linkage | @always_include_to_one_linkage_data | relationship.always_include_linkage_data
       link_object_hash = {}
       link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, association)
-      link_object_hash[:links][:related] = related_link(source, association)
-      link_object_hash[:data] = has_one_linkage(source, association)
+      link_object_hash[:links][:self] = self_link(source, relationship)
+      link_object_hash[:links][:related] = related_link(source, relationship)
+      link_object_hash[:data] = to_one_linkage(source, relationship) if include_linkage
       link_object_hash
     end
 
-    def link_object_has_many(source, association, include_linkage)
+    def link_object_to_many(source, relationship, include_linkage)
       link_object_hash = {}
       link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, association)
-      link_object_hash[:links][:related] = related_link(source, association)
-      link_object_hash[:data] = has_many_linkage(source, association) if include_linkage
+      link_object_hash[:links][:self] = self_link(source, relationship)
+      link_object_hash[:links][:related] = related_link(source, relationship)
+      link_object_hash[:data] = to_many_linkage(source, relationship) if include_linkage
       link_object_hash
     end
 
-    def link_object(source, association, include_linkage = false)
-      if association.is_a?(JSONAPI::Association::HasOne)
-        link_object_has_one(source, association)
-      elsif association.is_a?(JSONAPI::Association::HasMany)
-        link_object_has_many(source, association, include_linkage)
+    def link_object(source, relationship, include_linkage = false)
+      if relationship.is_a?(JSONAPI::Relationship::ToOne)
+        link_object_to_one(source, relationship, include_linkage)
+      elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
+        link_object_to_many(source, relationship, include_linkage)
       end
     end
 
-    # 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)
+    # Extracts the foreign key value for a to_one relationship.
+    def foreign_key_value(source, relationship)
+      foreign_key = relationship.foreign_key
+      value = source.public_send(foreign_key)
       IdValueFormatter.format(value)
     end
 
-    def foreign_key_types_and_values(source, association)
-      if association.is_a?(JSONAPI::Association::HasMany)
-        if association.polymorphic?
-          source.model.send(association.name).pluck(:type, :id).map do |type, id|
+    def foreign_key_types_and_values(source, relationship)
+      if relationship.is_a?(JSONAPI::Relationship::ToMany)
+        if relationship.polymorphic?
+          source.model.public_send(relationship.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)]
+          source.public_send(relationship.foreign_key).map do |value|
+            [relationship.type, IdValueFormatter.format(value)]
           end
         end
       end
@@ -307,12 +295,13 @@ module JSONAPI
     end
 
     # Collects the hashes for all objects processed by the serializer
-    def add_included_object(type, id, object_hash, primary = false)
-      type = format_key(type)
+    def add_included_object(id, object_hash, primary = false)
+      type = object_hash['type']
 
       @included_objects[type] = {} unless @included_objects.key?(type)
 
       if already_serialized?(type, id)
+        @included_objects[type][id][:object_hash].merge!(object_hash)
         set_primary(type, id) if primary
       else
         @included_objects[type].store(id, primary: primary, object_hash: object_hash)
@@ -327,5 +316,13 @@ module JSONAPI
       value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
       value_formatter.format(value)
     end
+
+    def generate_link_builder(primary_resource_klass, options)
+      LinkBuilder.new(
+        base_url: options.fetch(:base_url, ''),
+        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
+        primary_resource_klass: primary_resource_klass,
+      )
+    end
   end
 end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.4.4'
+    VERSION = '0.5.0'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -102,7 +102,7 @@ module JSONAPI
             serializer.serialize_to_hash(result.resources)
           when JSONAPI::LinksObjectOperationResult
             serializer.serialize_to_links_hash(result.parent_resource,
-                                               result.association)
+                                               result.relationship)
           when JSONAPI::OperationResult
             {}
           end

data/lib/jsonapi/routing_ext.rb

@@ -45,13 +45,13 @@ module ActionDispatch
 
         def jsonapi_relationships(options = {})
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
-          res._associations.each do |association_name, association|
-            if association.is_a?(JSONAPI::Association::HasMany)
-              jsonapi_links(association_name, options)
-              jsonapi_related_resources(association_name, options)
+          res._relationships.each do |relationship_name, relationship|
+            if relationship.is_a?(JSONAPI::Relationship::ToMany)
+              jsonapi_links(relationship_name, options)
+              jsonapi_related_resources(relationship_name, options)
             else
-              jsonapi_link(association_name, options)
-              jsonapi_related_resource(association_name, options)
+              jsonapi_link(relationship_name, options)
+              jsonapi_related_resource(relationship_name, options)
             end
           end
         end
@@ -100,7 +100,7 @@ module ActionDispatch
 
         def jsonapi_link(*links)
           link_type = links.first
-          formatted_association_name = format_route(link_type)
+          formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
@@ -109,24 +109,24 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'show_association', association: link_type.to_s, via: [:get]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
           end
 
           if methods.include?(:update)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'update_association', association: link_type.to_s, via: [:put, :patch]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
           end
 
           if methods.include?(:destroy)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'destroy_association', association: link_type.to_s, via: [:delete]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
           end
         end
 
         def jsonapi_links(*links)
           link_type = links.first
-          formatted_association_name = format_route(link_type)
+          formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
@@ -135,61 +135,61 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'show_association', association: link_type.to_s, via: [:get]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
           end
 
           if methods.include?(:create)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'create_association', association: link_type.to_s, via: [:post]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'create_relationship', relationship: link_type.to_s, via: [:post]
           end
 
           if methods.include?(:update)
-            match "relationships/#{formatted_association_name}", controller: options[:controller],
-                                                                 action: 'update_association', association: link_type.to_s, via: [:put, :patch]
+            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
+                                                                  action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
           end
 
           if methods.include?(:destroy)
-            match "relationships/#{formatted_association_name}/:keys", controller: options[:controller],
-                                                                       action: 'destroy_association', association: link_type.to_s, via: [:delete]
+            match "relationships/#{formatted_relationship_name}/:keys", controller: options[:controller],
+                                                                        action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
           end
         end
 
-        def jsonapi_related_resource(*association)
+        def jsonapi_related_resource(*relationship)
           source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
-          options = association.extract_options!.dup
+          options = relationship.extract_options!.dup
 
-          association_name = association.first
-          association = source._associations[association_name]
+          relationship_name = relationship.first
+          relationship = source._relationships[relationship_name]
 
-          formatted_association_name = format_route(association.name)
+          formatted_relationship_name = format_route(relationship.name)
 
-          if association.polymorphic?
-            options[:controller] ||= association.class_name.underscore.pluralize
+          if relationship.polymorphic?
+            options[:controller] ||= relationship.class_name.underscore.pluralize
           else
-            related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(association.class_name.underscore.pluralize))
+            related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore.pluralize))
             options[:controller] ||= related_resource._type.to_s
           end
 
-          match "#{formatted_association_name}", controller: options[:controller],
-                                                 association: association.name, source: resource_type_with_module_prefix(source._type),
-                                                 action: 'get_related_resource', via: [:get]
+          match "#{formatted_relationship_name}", controller: options[:controller],
+                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                                                  action: 'get_related_resource', via: [:get]
         end
 
-        def jsonapi_related_resources(*association)
+        def jsonapi_related_resources(*relationship)
           source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
-          options = association.extract_options!.dup
+          options = relationship.extract_options!.dup
 
-          association_name = association.first
-          association = source._associations[association_name]
+          relationship_name = relationship.first
+          relationship = source._relationships[relationship_name]
 
-          formatted_association_name = format_route(association.name)
-          related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(association.class_name.underscore))
+          formatted_relationship_name = format_route(relationship.name)
+          related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
 
-          match "#{formatted_association_name}", controller: options[:controller],
-                                                 association: association.name, source: resource_type_with_module_prefix(source._type),
-                                                 action: 'get_related_resources', via: [:get]
+          match "#{formatted_relationship_name}", controller: options[:controller],
+                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                                                  action: 'get_related_resources', via: [:get]
         end
 
         private