active_model_serializers 0.10.0 → 0.10.12

data/lib/active_model_serializers/adapter/base.rb

@@ -1,4 +1,6 @@
-require 'active_model_serializers/key_transform'
+# frozen_string_literal: true
+
+require 'case_transform'
 
 module ActiveModelSerializers
   module Adapter
@@ -8,6 +10,40 @@ module ActiveModelSerializers
         ActiveModelSerializers::Adapter.register(subclass)
       end
 
+      # Sets the default transform for the adapter.
+      #
+      # @return [Symbol] the default transform for the adapter
+      def self.default_key_transform
+        :unaltered
+      end
+
+      # Determines the transform to use in order of precedence:
+      #   adapter option, global config, adapter default.
+      #
+      # @param options [Object]
+      # @return [Symbol] the transform to use
+      def self.transform(options)
+        return options[:key_transform] if options && options[:key_transform]
+        ActiveModelSerializers.config.key_transform || default_key_transform
+      end
+
+      # Transforms the casing of the supplied value.
+      #
+      # @param value [Object] the value to be transformed
+      # @param options [Object] serializable resource options
+      # @return [Symbol] the default transform for the adapter
+      def self.transform_key_casing!(value, options)
+        CaseTransform.send(transform(options), value)
+      end
+
+      def self.cache_key
+        @cache_key ||= ActiveModelSerializers::Adapter.registered_name(self)
+      end
+
+      def self.fragment_cache(cached_hash, non_cached_hash)
+        non_cached_hash.merge cached_hash
+      end
+
       attr_reader :serializer, :instance_options
 
       def initialize(serializer, options = {})
@@ -15,10 +51,6 @@ module ActiveModelSerializers
         @instance_options = options
       end
 
-      def cached_name
-        @cached_name ||= self.class.name.demodulize.underscore
-      end
-
       # Subclasses that implement this method must first call
       #   options = serialization_options(options)
       def serializable_hash(_options = nil)
@@ -29,14 +61,12 @@ module ActiveModelSerializers
         serializable_hash(options)
       end
 
-      def fragment_cache(cached_hash, non_cached_hash)
-        non_cached_hash.merge cached_hash
+      def cache_key
+        self.class.cache_key
       end
 
-      def cache_check(serializer)
-        serializer.cache_check(self) do
-          yield
-        end
+      def fragment_cache(cached_hash, non_cached_hash)
+        self.class.fragment_cache(cached_hash, non_cached_hash)
       end
 
       private
@@ -50,34 +80,6 @@ module ActiveModelSerializers
       def root
         serializer.json_key.to_sym if serializer.json_key
       end
-
-      class << self
-        # Sets the default transform for the adapter.
-        #
-        # @return [Symbol] the default transform for the adapter
-        def default_key_transform
-          :unaltered
-        end
-
-        # Determines the transform to use in order of precedence:
-        #   adapter option, global config, adapter default.
-        #
-        # @param options [Object]
-        # @return [Symbol] the transform to use
-        def transform(options)
-          return options[:key_transform] if options && options[:key_transform]
-          ActiveModelSerializers.config.key_transform || default_key_transform
-        end
-
-        # Transforms the casing of the supplied value.
-        #
-        # @param value [Object] the value to be transformed
-        # @param options [Object] serializable resource options
-        # @return [Symbol] the default transform for the adapter
-        def transform_key_casing!(value, options)
-          KeyTransform.send(transform(options), value)
-        end
-      end
     end
   end
 end

data/lib/active_model_serializers/adapter/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class Json < Base

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi
@@ -189,7 +191,7 @@ module ActiveModelSerializers
 
           polymorphic = (options[:polymorphic] || []).include?(assoc_name.to_sym)
           if polymorphic
-            hash["#{prefix_key}_type".to_sym] = assoc_data.present? ? assoc_data['type'] : nil
+            hash["#{prefix_key}_type".to_sym] = assoc_data.present? ? assoc_data['type'].classify : nil
           end
 
           hash
@@ -205,7 +207,7 @@ module ActiveModelSerializers
         # @api private
         def transform_keys(hash, options)
           transform = options[:key_transform] || :underscore
-          KeyTransform.send(transform, hash)
+          CaseTransform.send(transform, hash)
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi < Base

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi < Base

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi
@@ -71,7 +73,7 @@ module ActiveModelSerializers
           hash[:href] = @href if defined?(@href)
           hash[:meta] = @meta if defined?(@meta)
 
-          hash
+          hash.any? ? hash : nil
         end
 
         protected

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi

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

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi < Base
       class PaginationLinks
+        MissingSerializationContextError = Class.new(KeyError)
         FIRST_PAGE = 1
 
         attr_reader :collection, :context
@@ -9,16 +12,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 +37,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 +80,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Adapter
     class JsonApi
@@ -5,47 +7,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

@@ -1,16 +1,51 @@
+# frozen_string_literal: true
+
 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?
+            nil
+          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 +54,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)