active_model_serializers 0.10.0 → 0.10.7

data/lib/active_model_serializers/adapter/json_api/pagination_links.rb

@@ -2,6 +2,7 @@ module ActiveModelSerializers
   module Adapter
     class JsonApi < Base
       class PaginationLinks
+        MissingSerializationContextError = Class.new(KeyError)
         FIRST_PAGE = 1
 
         attr_reader :collection, :context
@@ -9,16 +10,23 @@ module ActiveModelSerializers
         def initialize(collection, adapter_options)
           @collection = collection
           @adapter_options = adapter_options
-          @context = adapter_options.fetch(:serialization_context)
+          @context = adapter_options.fetch(:serialization_context) do
+            fail MissingSerializationContextError, <<-EOF.freeze
+ JsonApi::PaginationLinks requires a ActiveModelSerializers::SerializationContext.
+ Please pass a ':serialization_context' option or
+ override CollectionSerializer#paginated? to return 'false'.
+            EOF
+          end
         end
 
         def as_json
-          per_page = collection.try(:per_page) || collection.try(:limit_value) || collection.size
-          pages_from.each_with_object({}) do |(key, value), hash|
-            params = query_parameters.merge(page: { number: value, size: per_page }).to_query
-
-            hash[key] = "#{url(adapter_options)}?#{params}"
-          end
+          {
+            self:  location_url,
+            first: first_page_url,
+            prev:  prev_page_url,
+            next:  next_page_url,
+            last:  last_page_url
+          }
         end
 
         protected
@@ -27,25 +35,39 @@ module ActiveModelSerializers
 
         private
 
-        def pages_from
-          return {} if collection.total_pages <= FIRST_PAGE
-
-          {}.tap do |pages|
-            pages[:self] = collection.current_page
+        def location_url
+          url_for_page(collection.current_page)
+        end
 
-            unless collection.current_page == FIRST_PAGE
-              pages[:first] = FIRST_PAGE
-              pages[:prev]  = collection.current_page - FIRST_PAGE
-            end
+        def first_page_url
+          url_for_page(1)
+        end
 
-            unless collection.current_page == collection.total_pages
-              pages[:next] = collection.current_page + FIRST_PAGE
-              pages[:last] = collection.total_pages
-            end
+        def last_page_url
+          if collection.total_pages == 0
+            url_for_page(FIRST_PAGE)
+          else
+            url_for_page(collection.total_pages)
           end
         end
 
-        def url(options)
+        def prev_page_url
+          return nil if collection.current_page == FIRST_PAGE
+          url_for_page(collection.current_page - FIRST_PAGE)
+        end
+
+        def next_page_url
+          return nil if collection.total_pages == 0 || collection.current_page == collection.total_pages
+          url_for_page(collection.next_page)
+        end
+
+        def url_for_page(number)
+          params = query_parameters.dup
+          params[:page] = { size: per_page, number: number }
+          "#{url(adapter_options)}?#{params.to_query}"
+        end
+
+        def url(options = {})
           @url ||= options.fetch(:links, {}).fetch(:self, nil) || request_url
         end
 
@@ -56,6 +78,10 @@ module ActiveModelSerializers
         def query_parameters
           @query_parameters ||= context.query_parameters
         end
+
+        def per_page
+          @per_page ||= collection.try(:per_page) || collection.try(:limit_value) || collection.size
+        end
       end
     end
   end

data/lib/active_model_serializers/adapter/json_api/relationship.rb

@@ -5,47 +5,99 @@ module ActiveModelSerializers
         # {http://jsonapi.org/format/#document-resource-object-related-resource-links Document Resource Object Related Resource Links}
         # {http://jsonapi.org/format/#document-links Document Links}
         # {http://jsonapi.org/format/#document-resource-object-linkage Document Resource Relationship Linkage}
-        # {http://jsonapi.org/format/#document-meta Docment Meta}
-        def initialize(parent_serializer, serializer, serializable_resource_options, args = {})
-          @object = parent_serializer.object
-          @scope = parent_serializer.scope
-          @association_options = args.fetch(:options, {})
+        # {http://jsonapi.org/format/#document-meta Document Meta}
+        def initialize(parent_serializer, serializable_resource_options, association)
+          @parent_serializer = parent_serializer
+          @association = association
           @serializable_resource_options = serializable_resource_options
-          @data = data_for(serializer)
-          @links = args.fetch(:links, {}).each_with_object({}) do |(key, value), hash|
-            hash[key] = ActiveModelSerializers::Adapter::JsonApi::Link.new(parent_serializer, value).as_json
-          end
-          meta = args.fetch(:meta, nil)
-          @meta = meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
         end
 
         def as_json
           hash = {}
-          hash[:data] = data if association_options[:include_data]
-          links = self.links
+
+          hash[:data] = data_for(association) if association.include_data?
+
+          links = links_for(association)
           hash[:links] = links if links.any?
-          meta = self.meta
+
+          meta = meta_for(association)
           hash[:meta] = meta if meta
+          hash[:meta] = {} if hash.empty?
 
           hash
         end
 
         protected
 
-        attr_reader :object, :scope, :data, :serializable_resource_options,
-          :association_options, :links, :meta
+        attr_reader :parent_serializer, :serializable_resource_options, :association
 
         private
 
-        def data_for(serializer)
-          if serializer.respond_to?(:each)
-            serializer.map { |s| ResourceIdentifier.new(s, serializable_resource_options).as_json }
-          elsif association_options[:virtual_value]
-            association_options[:virtual_value]
-          elsif serializer && serializer.object
-            ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+        # TODO(BF): Avoid db hit on belong_to_ releationship by using foreign_key on self
+        def data_for(association)
+          if association.collection?
+            data_for_many(association)
+          else
+            data_for_one(association)
           end
         end
+
+        def data_for_one(association)
+          if belongs_to_id_on_self?(association)
+            id = parent_serializer.read_attribute_for_serialization(association.reflection.foreign_key)
+            type =
+              if association.polymorphic?
+                # We can't infer resource type for polymorphic relationships from the serializer.
+                # We can ONLY know a polymorphic resource type by inspecting each resource.
+                association.lazy_association.serializer.json_key
+              else
+                association.reflection.type.to_s
+              end
+            ResourceIdentifier.for_type_with_id(type, id, serializable_resource_options)
+          else
+            # TODO(BF): Process relationship without evaluating lazy_association
+            serializer = association.lazy_association.serializer
+            if (virtual_value = association.virtual_value)
+              virtual_value
+            elsif serializer && association.object
+              ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+            else
+              nil
+            end
+          end
+        end
+
+        def data_for_many(association)
+          # TODO(BF): Process relationship without evaluating lazy_association
+          collection_serializer = association.lazy_association.serializer
+          if collection_serializer.respond_to?(:each)
+            collection_serializer.map do |serializer|
+              ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+            end
+          elsif (virtual_value = association.virtual_value)
+            virtual_value
+          else
+            []
+          end
+        end
+
+        def links_for(association)
+          association.links.each_with_object({}) do |(key, value), hash|
+            result = Link.new(parent_serializer, value).as_json
+            hash[key] = result if result
+          end
+        end
+
+        def meta_for(association)
+          meta = association.meta
+          meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
+        end
+
+        def belongs_to_id_on_self?(association)
+          parent_serializer.config.jsonapi_use_foreign_key_on_belongs_to_relationship &&
+            association.belongs_to? &&
+            parent_serializer.object.respond_to?(association.reflection.foreign_key)
+        end
       end
     end
   end

data/lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -2,15 +2,48 @@ module ActiveModelSerializers
   module Adapter
     class JsonApi
       class ResourceIdentifier
+        def self.type_for(serializer, serializer_type = nil, transform_options = {})
+          raw_type = serializer_type ? serializer_type : raw_type_from_serializer_object(serializer.object)
+          JsonApi.send(:transform_key_casing!, raw_type, transform_options)
+        end
+
+        def self.for_type_with_id(type, id, options)
+          type = inflect_type(type)
+          type = type_for(:no_class_needed, type, options)
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
+        end
+
+        def self.raw_type_from_serializer_object(object)
+          class_name = object.class.name # should use model_name
+          raw_type = class_name.underscore
+          raw_type = inflect_type(raw_type)
+          raw_type
+            .gsub!('/'.freeze, ActiveModelSerializers.config.jsonapi_namespace_separator)
+          raw_type
+        end
+
+        def self.inflect_type(type)
+          singularize = ActiveModelSerializers.config.jsonapi_resource_type == :singular
+          inflection = singularize ? :singularize : :pluralize
+          ActiveSupport::Inflector.public_send(inflection, type)
+        end
+
         # {http://jsonapi.org/format/#document-resource-identifier-objects Resource Identifier Objects}
         def initialize(serializer, options)
           @id   = id_for(serializer)
-          @type = JsonApi.send(:transform_key_casing!, type_for(serializer),
-            options)
+          @type = type_for(serializer, options)
         end
 
         def as_json
-          { id: id, type: type }
+          if id.blank?
+            { type: type }
+          else
+            { id: id.to_s, type: type }
+          end
         end
 
         protected
@@ -19,13 +52,9 @@ module ActiveModelSerializers
 
         private
 
-        def type_for(serializer)
-          return serializer._type if serializer._type
-          if ActiveModelSerializers.config.jsonapi_resource_type == :singular
-            serializer.object.class.model_name.singular
-          else
-            serializer.object.class.model_name.plural
-          end
+        def type_for(serializer, transform_options)
+          serializer_type = serializer._type
+          self.class.type_for(serializer, serializer_type, transform_options)
         end
 
         def id_for(serializer)

data/lib/active_model_serializers/adapter/json_api.rb

@@ -31,16 +31,27 @@ module ActiveModelSerializers
       autoload :Error
       autoload :Deserialization
 
+      def self.default_key_transform
+        :dash
+      end
+
+      def self.fragment_cache(cached_hash, non_cached_hash, root = true)
+        core_cached       = cached_hash.first
+        core_non_cached   = non_cached_hash.first
+        no_root_cache     = cached_hash.delete_if { |key, _value| key == core_cached[0] }
+        no_root_non_cache = non_cached_hash.delete_if { |key, _value| key == core_non_cached[0] }
+        cached_resource   = (core_cached[1]) ? core_cached[1].deep_merge(core_non_cached[1]) : core_non_cached[1]
+        hash = root ? { root => cached_resource } : cached_resource
+
+        hash.deep_merge no_root_non_cache.deep_merge no_root_cache
+      end
+
       def initialize(serializer, options = {})
         super
-        @include_tree = ActiveModel::Serializer::IncludeTree.from_include_args(options[:include])
+        @include_directive = JSONAPI::IncludeDirective.new(options[:include], allow_wildcard: true)
         @fieldset = options[:fieldset] || ActiveModel::Serializer::Fieldset.new(options.delete(:fields))
       end
 
-      def self.default_key_transform
-        :dash
-      end
-
       # {http://jsonapi.org/format/#crud Requests are transactional, i.e. success or failure}
       # {http://jsonapi.org/format/#document-top-level data and errors MUST NOT coexist in the same document.}
       def serializable_hash(*)
@@ -52,6 +63,11 @@ module ActiveModelSerializers
         self.class.transform_key_casing!(document, instance_options)
       end
 
+      def fragment_cache(cached_hash, non_cached_hash)
+        root = !instance_options.include?(:include)
+        self.class.fragment_cache(cached_hash, non_cached_hash, root)
+      end
+
       # {http://jsonapi.org/format/#document-top-level Primary data}
       # definition:
       #   ☐ toplevel_data (required)
@@ -174,18 +190,6 @@ module ActiveModelSerializers
         hash
       end
 
-      def fragment_cache(cached_hash, non_cached_hash)
-        root = false if instance_options.include?(:include)
-        core_cached       = cached_hash.first
-        core_non_cached   = non_cached_hash.first
-        no_root_cache     = cached_hash.delete_if { |key, _value| key == core_cached[0] }
-        no_root_non_cache = non_cached_hash.delete_if { |key, _value| key == core_non_cached[0] }
-        cached_resource   = (core_cached[1]) ? core_cached[1].deep_merge(core_non_cached[1]) : core_non_cached[1]
-        hash = root ? { root => cached_resource } : cached_resource
-
-        hash.deep_merge no_root_non_cache.deep_merge no_root_cache
-      end
-
       protected
 
       attr_reader :fieldset
@@ -231,17 +235,17 @@ module ActiveModelSerializers
         @primary = []
         @included = []
         @resource_identifiers = Set.new
-        serializers.each { |serializer| process_resource(serializer, true) }
-        serializers.each { |serializer| process_relationships(serializer, @include_tree) }
+        serializers.each { |serializer| process_resource(serializer, true, @include_directive) }
+        serializers.each { |serializer| process_relationships(serializer, @include_directive) }
 
         [@primary, @included]
       end
 
-      def process_resource(serializer, primary)
+      def process_resource(serializer, primary, include_slice = {})
         resource_identifier = ResourceIdentifier.new(serializer, instance_options).as_json
         return false unless @resource_identifiers.add?(resource_identifier)
 
-        resource_object = resource_object_for(serializer)
+        resource_object = resource_object_for(serializer, include_slice)
         if primary
           @primary << resource_object
         else
@@ -251,21 +255,22 @@ module ActiveModelSerializers
         true
       end
 
-      def process_relationships(serializer, include_tree)
-        serializer.associations(include_tree).each do |association|
-          process_relationship(association.serializer, include_tree[association.key])
+      def process_relationships(serializer, include_slice)
+        serializer.associations(include_slice).each do |association|
+          # TODO(BF): Process relationship without evaluating lazy_association
+          process_relationship(association.lazy_association.serializer, include_slice[association.key])
         end
       end
 
-      def process_relationship(serializer, include_tree)
+      def process_relationship(serializer, include_slice)
         if serializer.respond_to?(:each)
-          serializer.each { |s| process_relationship(s, include_tree) }
+          serializer.each { |s| process_relationship(s, include_slice) }
           return
         end
         return unless serializer && serializer.object
-        return unless process_resource(serializer, false)
+        return unless process_resource(serializer, false, include_slice)
 
-        process_relationships(serializer, include_tree)
+        process_relationships(serializer, include_slice)
       end
 
       # {http://jsonapi.org/format/#document-resource-object-attributes Document Resource Object Attributes}
@@ -289,21 +294,9 @@ module ActiveModelSerializers
       end
 
       # {http://jsonapi.org/format/#document-resource-objects Document Resource Objects}
-      def resource_object_for(serializer)
-        resource_object = cache_check(serializer) do
-          resource_object = ResourceIdentifier.new(serializer, instance_options).as_json
-
-          requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
-          attributes = attributes_for(serializer, requested_fields)
-          resource_object[:attributes] = attributes if attributes.any?
-          resource_object
-        end
+      def resource_object_for(serializer, include_slice = {})
+        resource_object = data_for(serializer, include_slice)
 
-        requested_associations = fieldset.fields_for(resource_object[:type]) || '*'
-        relationships = relationships_for(serializer, requested_associations)
-        resource_object[:relationships] = relationships if relationships.any?
-
-        links = links_for(serializer)
         # toplevel_links
         # definition:
         #   allOf
@@ -317,7 +310,10 @@ module ActiveModelSerializers
         # prs:
         #   https://github.com/rails-api/active_model_serializers/pull/1247
         #   https://github.com/rails-api/active_model_serializers/pull/1018
-        resource_object[:links] = links if links.any?
+        if (links = links_for(serializer)).any?
+          resource_object ||= {}
+          resource_object[:links] = links
+        end
 
         # toplevel_meta
         #   alias meta
@@ -327,12 +323,33 @@ module ActiveModelSerializers
         #   {
         #     :'git-ref' => 'abc123'
         #   }
-        meta = meta_for(serializer)
-        resource_object[:meta] = meta unless meta.blank?
+        if (meta = meta_for(serializer)).present?
+          resource_object ||= {}
+          resource_object[:meta] = meta
+        end
 
         resource_object
       end
 
+      def data_for(serializer, include_slice)
+        data = serializer.fetch(self) do
+          resource_object = ResourceIdentifier.new(serializer, instance_options).as_json
+          break nil if resource_object.nil?
+
+          requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
+          attributes = attributes_for(serializer, requested_fields)
+          resource_object[:attributes] = attributes if attributes.any?
+          resource_object
+        end
+        data.tap do |resource_object|
+          next if resource_object.nil?
+          # NOTE(BF): the attributes are cached above, separately from the relationships, below.
+          requested_associations = fieldset.fields_for(resource_object[:type]) || '*'
+          relationships = relationships_for(serializer, requested_associations, include_slice)
+          resource_object[:relationships] = relationships if relationships.any?
+        end
+      end
+
       # {http://jsonapi.org/format/#document-resource-object-relationships Document Resource Object Relationship}
       # relationships
       # definition:
@@ -428,17 +445,13 @@ module ActiveModelSerializers
       #     id: 'required-id',
       #     meta: meta
       #   }.reject! {|_,v| v.nil? }
-      def relationships_for(serializer, requested_associations)
-        include_tree = ActiveModel::Serializer::IncludeTree.from_include_args(requested_associations)
-        serializer.associations(include_tree).each_with_object({}) do |association, hash|
-          hash[association.key] = Relationship.new(
-            serializer,
-            association.serializer,
-            instance_options,
-            options: association.options,
-            links: association.links,
-            meta: association.meta
-          ).as_json
+      def relationships_for(serializer, requested_associations, include_slice)
+        include_directive = JSONAPI::IncludeDirective.new(
+          requested_associations,
+          allow_wildcard: true
+        )
+        serializer.associations(include_directive, include_slice).each_with_object({}) do |association, hash|
+          hash[association.key] = Relationship.new(serializer, instance_options, association).as_json
         end
       end
 
@@ -467,7 +480,8 @@ module ActiveModelSerializers
       #   }.reject! {|_,v| v.nil? }
       def links_for(serializer)
         serializer._links.each_with_object({}) do |(name, value), hash|
-          hash[name] = Link.new(serializer, value).as_json
+          result = Link.new(serializer, value).as_json
+          hash[name] = result if result
         end
       end
 

data/lib/active_model_serializers/adapter.rb

@@ -5,11 +5,13 @@ module ActiveModelSerializers
     private_constant :ADAPTER_MAP if defined?(private_constant)
 
     class << self # All methods are class functions
+      # :nocov:
       def new(*args)
         fail ArgumentError, 'Adapters inherit from Adapter::Base.' \
           "Adapter.new called with args: '#{args.inspect}', from" \
           "'caller[0]'."
       end
+      # :nocov:
 
       def configured_adapter
         lookup(ActiveModelSerializers.config.adapter)
@@ -51,6 +53,10 @@ module ActiveModelSerializers
         self
       end
 
+      def registered_name(adapter_class)
+        ADAPTER_MAP.key adapter_class
+      end
+
       # @param  adapter [String, Symbol, Class] name to fetch adapter by
       # @return [ActiveModelSerializers::Adapter] subclass of Adapter
       # @raise  [UnknownAdapterError]

data/lib/active_model_serializers/deprecate.rb

@@ -36,8 +36,7 @@ module ActiveModelSerializers
           target = is_a?(Module) ? "#{self}." : "#{self.class}#"
           msg = ["NOTE: #{target}#{name} is deprecated",
                  replacement == :none ? ' with no replacement' : "; use #{replacement} instead",
-                 "\n#{target}#{name} called from #{ActiveModelSerializers.location_of_caller.join(":")}"
-                ]
+                 "\n#{target}#{name} called from #{ActiveModelSerializers.location_of_caller.join(':')}"]
           warn "#{msg.join}."
           send old, *args, &block
         end

data/lib/active_model_serializers/deserialization.rb

@@ -6,8 +6,10 @@ module ActiveModelSerializers
       Adapter::JsonApi::Deserialization.parse(*args)
     end
 
+    # :nocov:
     def jsonapi_parse!(*args)
       Adapter::JsonApi::Deserialization.parse!(*args)
     end
+    # :nocov:
   end
 end

data/lib/active_model_serializers/lookup_chain.rb

@@ -0,0 +1,80 @@
+module ActiveModelSerializers
+  module LookupChain
+    # Standard appending of Serializer to the resource name.
+    #
+    # Example:
+    #   Author => AuthorSerializer
+    BY_RESOURCE = lambda do |resource_class, _serializer_class, _namespace|
+      serializer_from(resource_class)
+    end
+
+    # Uses the namespace of the resource to find the serializer
+    #
+    # Example:
+    #  British::Author => British::AuthorSerializer
+    BY_RESOURCE_NAMESPACE = lambda do |resource_class, _serializer_class, _namespace|
+      resource_namespace = namespace_for(resource_class)
+      serializer_name = serializer_from(resource_class)
+
+      "#{resource_namespace}::#{serializer_name}"
+    end
+
+    # Uses the controller namespace of the resource to find the serializer
+    #
+    # Example:
+    #  Api::V3::AuthorsController => Api::V3::AuthorSerializer
+    BY_NAMESPACE = lambda do |resource_class, _serializer_class, namespace|
+      resource_name = resource_class_name(resource_class)
+      namespace ? "#{namespace}::#{resource_name}Serializer" : nil
+    end
+
+    # Allows for serializers to be defined in parent serializers
+    # - useful if a relationship only needs a different set of attributes
+    #   than if it were rendered independently.
+    #
+    # Example:
+    #   class BlogSerializer < ActiveModel::Serializer
+    #     class AuthorSerialier < ActiveModel::Serializer
+    #     ...
+    #     end
+    #
+    #     belongs_to :author
+    #     ...
+    #   end
+    #
+    #  The belongs_to relationship would be rendered with
+    #    BlogSerializer::AuthorSerialier
+    BY_PARENT_SERIALIZER = lambda do |resource_class, serializer_class, _namespace|
+      return if serializer_class == ActiveModel::Serializer
+
+      serializer_name = serializer_from(resource_class)
+      "#{serializer_class}::#{serializer_name}"
+    end
+
+    DEFAULT = [
+      BY_PARENT_SERIALIZER,
+      BY_NAMESPACE,
+      BY_RESOURCE_NAMESPACE,
+      BY_RESOURCE
+    ].freeze
+
+    module_function
+
+    def namespace_for(klass)
+      klass.name.deconstantize
+    end
+
+    def resource_class_name(klass)
+      klass.name.demodulize
+    end
+
+    def serializer_from_resource_name(name)
+      "#{name}Serializer"
+    end
+
+    def serializer_from(klass)
+      name = resource_class_name(klass)
+      serializer_from_resource_name(name)
+    end
+  end
+end