active_model_serializers 0.10.0 → 0.10.6

data/lib/active_model/serializer/{caching.rb → concerns/caching.rb}

@@ -7,10 +7,9 @@ module ActiveModel
       included do
         with_options instance_writer: false, instance_reader: false do |serializer|
           serializer.class_attribute :_cache         # @api private : the cache store
-          serializer.class_attribute :_fragmented    # @api private : @see ::fragmented
           serializer.class_attribute :_cache_key     # @api private : when present, is first item in cache_key.  Ignored if the serializable object defines #cache_key.
-          serializer.class_attribute :_cache_only    # @api private : when fragment caching, whitelists cached_attributes. Cannot combine with except
-          serializer.class_attribute :_cache_except  # @api private : when fragment caching, blacklists cached_attributes. Cannot combine with only
+          serializer.class_attribute :_cache_only    # @api private : when fragment caching, whitelists fetch_attributes. Cannot combine with except
+          serializer.class_attribute :_cache_except  # @api private : when fragment caching, blacklists fetch_attributes. Cannot combine with only
           serializer.class_attribute :_cache_options # @api private : used by CachedSerializer, passed to _cache.fetch
           #  _cache_options include:
           #    expires_in
@@ -19,7 +18,7 @@ module ActiveModel
           #    race_condition_ttl
           #  Passed to ::_cache as
           #    serializer.cache_store.fetch(cache_key, @klass._cache_options)
-          #  Passed as second argument to serializer.cache_store.fetch(cache_key, self.class._cache_options)
+          #  Passed as second argument to serializer.cache_store.fetch(cache_key, serializer_class._cache_options)
           serializer.class_attribute :_cache_digest_file_path # @api private : Derived at inheritance
         end
       end
@@ -41,9 +40,9 @@ module ActiveModel
 
       module ClassMethods
         def inherited(base)
-          super
           caller_line = caller[1]
           base._cache_digest_file_path = caller_line
+          super
         end
 
         def _cache_digest
@@ -69,19 +68,27 @@ module ActiveModel
           _cache_options && _cache_options[:skip_digest]
         end
 
-        def cached_attributes
-          _cache_only ? _cache_only : _attributes - _cache_except
-        end
-
-        def non_cached_attributes
-          _attributes - cached_attributes
+        # @api private
+        # maps attribute value to explicit key name
+        # @see Serializer::attribute
+        # @see Serializer::fragmented_attributes
+        def _attributes_keys
+          _attributes_data
+            .each_with_object({}) do |(key, attr), hash|
+            next if key == attr.name
+            hash[attr.name] = { key: key }
+          end
         end
 
-        # @api private
-        # Used by FragmentCache on the CachedSerializer
-        #  to call attribute methods on the fragmented cached serializer.
-        def fragmented(serializer)
-          self._fragmented = serializer
+        def fragmented_attributes
+          cached = _cache_only ? _cache_only : _attributes - _cache_except
+          cached = cached.map! { |field| _attributes_keys.fetch(field, field) }
+          non_cached = _attributes - cached
+          non_cached = non_cached.map! { |field| _attributes_keys.fetch(field, field) }
+          {
+            cached: cached,
+            non_cached: non_cached
+          }
         end
 
         # Enables a serializer to be automatically cached
@@ -163,10 +170,11 @@ module ActiveModel
 
         # Read cache from cache_store
         # @return [Hash]
-        def cache_read_multi(collection_serializer, adapter_instance, include_tree)
+        # Used in CollectionSerializer to set :cached_attributes
+        def cache_read_multi(collection_serializer, adapter_instance, include_directive)
           return {} if ActiveModelSerializers.config.cache_store.blank?
 
-          keys = object_cache_keys(collection_serializer, adapter_instance, include_tree)
+          keys = object_cache_keys(collection_serializer, adapter_instance, include_directive)
 
           return {} if keys.blank?
 
@@ -176,21 +184,23 @@ module ActiveModel
         # Find all cache_key for the collection_serializer
         # @param serializers [ActiveModel::Serializer::CollectionSerializer]
         # @param adapter_instance [ActiveModelSerializers::Adapter::Base]
-        # @param include_tree [ActiveModel::Serializer::IncludeTree]
+        # @param include_directive [JSONAPI::IncludeDirective]
         # @return [Array] all cache_key of collection_serializer
-        def object_cache_keys(collection_serializer, adapter_instance, include_tree)
+        def object_cache_keys(collection_serializer, adapter_instance, include_directive)
           cache_keys = []
 
           collection_serializer.each do |serializer|
             cache_keys << object_cache_key(serializer, adapter_instance)
 
-            serializer.associations(include_tree).each do |association|
-              if association.serializer.respond_to?(:each)
-                association.serializer.each do |sub_serializer|
+            serializer.associations(include_directive).each do |association|
+              # TODO(BF): Process relationship without evaluating lazy_association
+              association_serializer = association.lazy_association.serializer
+              if association_serializer.respond_to?(:each)
+                association_serializer.each do |sub_serializer|
                   cache_keys << object_cache_key(sub_serializer, adapter_instance)
                 end
               else
-                cache_keys << object_cache_key(association.serializer, adapter_instance)
+                cache_keys << object_cache_key(association_serializer, adapter_instance)
               end
             end
           end
@@ -202,117 +212,70 @@ module ActiveModel
         def object_cache_key(serializer, adapter_instance)
           return unless serializer.present? && serializer.object.present?
 
-          serializer.class.cache_enabled? ? serializer.cache_key(adapter_instance) : nil
+          (serializer.class.cache_enabled? || serializer.class.fragment_cache_enabled?) ? serializer.cache_key(adapter_instance) : nil
         end
       end
 
-      # Get attributes from @cached_attributes
-      # @return [Hash] cached attributes
-      # def cached_attributes(fields, adapter_instance)
-      def cached_fields(fields, adapter_instance)
-        cache_check(adapter_instance) do
-          attributes(fields)
+      ### INSTANCE METHODS
+      def fetch_attributes(fields, cached_attributes, adapter_instance)
+        key = cache_key(adapter_instance)
+        cached_attributes.fetch(key) do
+          fetch(adapter_instance, serializer_class._cache_options, key) do
+            attributes(fields, true)
+          end
         end
       end
 
-      def cache_check(adapter_instance)
-        if self.class.cache_enabled?
-          self.class.cache_store.fetch(cache_key(adapter_instance), self.class._cache_options) do
+      def fetch(adapter_instance, cache_options = serializer_class._cache_options, key = nil)
+        if serializer_class.cache_store
+          key ||= cache_key(adapter_instance)
+          serializer_class.cache_store.fetch(key, cache_options) do
             yield
           end
-        elsif self.class.fragment_cache_enabled?
-          fetch_fragment_cache(adapter_instance)
         else
           yield
         end
       end
 
-      # 1. Create a CachedSerializer and NonCachedSerializer from the serializer class
-      # 2. Serialize the above two with the given adapter
-      # 3. Pass their serializations to the adapter +::fragment_cache+
-      #
-      # It will split the serializer into two, one that will be cached and one that will not
-      #
-      # Given a resource name
-      # 1. Dynamically creates a CachedSerializer and NonCachedSerializer
-      #   for a given class 'name'
-      # 2. Call
-      #       CachedSerializer.cache(serializer._cache_options)
-      #       CachedSerializer.fragmented(serializer)
-      #       NonCachedSerializer.cache(serializer._cache_options)
-      # 3. Build a hash keyed to the +cached+ and +non_cached+ serializers
-      # 4. Call +cached_attributes+ on the serializer class and the above hash
-      # 5. Return the hash
-      #
-      # @example
-      #   When +name+ is <tt>User::Admin</tt>
-      #   creates the Serializer classes (if they don't exist).
-      #     CachedUser_AdminSerializer
-      #     NonCachedUser_AdminSerializer
-      #
-      # Given a hash of its cached and non-cached serializers
-      # 1. Determine cached attributes from serializer class options
-      # 2. Add cached attributes to cached Serializer
-      # 3. Add non-cached attributes to non-cached Serializer
-      def fetch_fragment_cache(adapter_instance)
-        serializer_class_name = self.class.name.gsub('::'.freeze, '_'.freeze)
-        self.class._cache_options ||= {}
-        self.class._cache_options[:key] = self.class._cache_key if self.class._cache_key
-
-        cached_serializer = _get_or_create_fragment_cached_serializer(serializer_class_name)
-        cached_hash = ActiveModelSerializers::SerializableResource.new(
-          object,
-          serializer: cached_serializer,
-          adapter: adapter_instance.class
-        ).serializable_hash
-
-        non_cached_serializer = _get_or_create_fragment_non_cached_serializer(serializer_class_name)
-        non_cached_hash = ActiveModelSerializers::SerializableResource.new(
-          object,
-          serializer: non_cached_serializer,
-          adapter: adapter_instance.class
-        ).serializable_hash
-
+      # 1. Determine cached fields from serializer class options
+      # 2. Get non_cached_fields and fetch cache_fields
+      # 3. Merge the two hashes using adapter_instance#fragment_cache
+      def fetch_attributes_fragment(adapter_instance, cached_attributes = {})
+        serializer_class._cache_options ||= {}
+        serializer_class._cache_options[:key] = serializer_class._cache_key if serializer_class._cache_key
+        fields = serializer_class.fragmented_attributes
+
+        non_cached_fields = fields[:non_cached].dup
+        non_cached_hash = attributes(non_cached_fields, true)
+        include_directive = JSONAPI::IncludeDirective.new(non_cached_fields - non_cached_hash.keys)
+        non_cached_hash.merge! associations_hash({}, { include_directive: include_directive }, adapter_instance)
+
+        cached_fields = fields[:cached].dup
+        key = cache_key(adapter_instance)
+        cached_hash =
+          cached_attributes.fetch(key) do
+            fetch(adapter_instance, serializer_class._cache_options, key) do
+              hash = attributes(cached_fields, true)
+              include_directive = JSONAPI::IncludeDirective.new(cached_fields - hash.keys)
+              hash.merge! associations_hash({}, { include_directive: include_directive }, adapter_instance)
+            end
+          end
         # Merge both results
         adapter_instance.fragment_cache(cached_hash, non_cached_hash)
       end
 
-      def _get_or_create_fragment_cached_serializer(serializer_class_name)
-        cached_serializer = _get_or_create_fragment_serializer "Cached#{serializer_class_name}"
-        cached_serializer.cache(self.class._cache_options)
-        cached_serializer.type(self.class._type)
-        cached_serializer.fragmented(self)
-        self.class.cached_attributes.each do |attribute|
-          options = self.class._attributes_keys[attribute] || {}
-          cached_serializer.attribute(attribute, options)
-        end
-        cached_serializer
-      end
-
-      def _get_or_create_fragment_non_cached_serializer(serializer_class_name)
-        non_cached_serializer = _get_or_create_fragment_serializer "NonCached#{serializer_class_name}"
-        non_cached_serializer.type(self.class._type)
-        non_cached_serializer.fragmented(self)
-        self.class.non_cached_attributes.each do |attribute|
-          options = self.class._attributes_keys[attribute] || {}
-          non_cached_serializer.attribute(attribute, options)
-        end
-        non_cached_serializer
-      end
-
-      def _get_or_create_fragment_serializer(name)
-        return Object.const_get(name) if Object.const_defined?(name)
-        Object.const_set(name, Class.new(ActiveModel::Serializer))
-      end
-
       def cache_key(adapter_instance)
         return @cache_key if defined?(@cache_key)
 
         parts = []
         parts << object_cache_key
-        parts << adapter_instance.cached_name
-        parts << self.class._cache_digest unless self.class._skip_digest?
-        @cache_key = parts.join('/')
+        parts << adapter_instance.cache_key
+        parts << serializer_class._cache_digest unless serializer_class._skip_digest?
+        @cache_key = expand_cache_key(parts)
+      end
+
+      def expand_cache_key(parts)
+        ActiveSupport::Cache.expand_cache_key(parts)
       end
 
       # Use object's cache_key if available, else derive a key from the object
@@ -320,14 +283,18 @@ module ActiveModel
       def object_cache_key
         if object.respond_to?(:cache_key)
           object.cache_key
-        elsif (serializer_cache_key = (self.class._cache_key || self.class._cache_options[:key]))
+        elsif (serializer_cache_key = (serializer_class._cache_key || serializer_class._cache_options[:key]))
           object_time_safe = object.updated_at
           object_time_safe = object_time_safe.strftime('%Y%m%d%H%M%S%9N') if object_time_safe.respond_to?(:strftime)
           "#{serializer_cache_key}/#{object.id}-#{object_time_safe}"
         else
-          fail UndefinedCacheKey, "#{object.class} must define #cache_key, or the 'key:' option must be passed into '#{self.class}.cache'"
+          fail UndefinedCacheKey, "#{object.class} must define #cache_key, or the 'key:' option must be passed into '#{serializer_class}.cache'"
         end
       end
+
+      def serializer_class
+        @serializer_class ||= self.class
+      end
     end
   end
 end

data/lib/active_model/serializer/error_serializer.rb

@@ -1,10 +1,14 @@
-class ActiveModel::Serializer::ErrorSerializer < ActiveModel::Serializer
-  # @return [Hash<field_name,Array<error_message>>]
-  def as_json
-    object.errors.messages
-  end
+module ActiveModel
+  class Serializer
+    class ErrorSerializer < ActiveModel::Serializer
+      # @return [Hash<field_name,Array<error_message>>]
+      def as_json
+        object.errors.messages
+      end
 
-  def success?
-    false
+      def success?
+        false
+      end
+    end
   end
 end

data/lib/active_model/serializer/errors_serializer.rb

@@ -1,27 +1,32 @@
 require 'active_model/serializer/error_serializer'
-class ActiveModel::Serializer::ErrorsSerializer
-  include Enumerable
-  delegate :each, to: :@serializers
-  attr_reader :object, :root
 
-  def initialize(resources, options = {})
-    @root = options[:root]
-    @object = resources
-    @serializers = resources.map do |resource|
-      serializer_class = options.fetch(:serializer) { ActiveModel::Serializer::ErrorSerializer }
-      serializer_class.new(resource, options.except(:serializer))
-    end
-  end
+module ActiveModel
+  class Serializer
+    class ErrorsSerializer
+      include Enumerable
+      delegate :each, to: :@serializers
+      attr_reader :object, :root
 
-  def success?
-    false
-  end
+      def initialize(resources, options = {})
+        @root = options[:root]
+        @object = resources
+        @serializers = resources.map do |resource|
+          serializer_class = options.fetch(:serializer) { ActiveModel::Serializer::ErrorSerializer }
+          serializer_class.new(resource, options.except(:serializer))
+        end
+      end
 
-  def json_key
-    nil
-  end
+      def success?
+        false
+      end
 
-  protected
+      def json_key
+        nil
+      end
 
-  attr_reader :serializers
+      protected
+
+      attr_reader :serializers
+    end
+  end
 end

data/lib/active_model/serializer/has_many_reflection.rb

@@ -1,9 +1,9 @@
 module ActiveModel
   class Serializer
     # @api private
-    class HasManyReflection < CollectionReflection
-      def macro
-        :has_many
+    class HasManyReflection < Reflection
+      def collection?
+        true
       end
     end
   end

data/lib/active_model/serializer/has_one_reflection.rb

@@ -1,10 +1,7 @@
 module ActiveModel
   class Serializer
     # @api private
-    class HasOneReflection < SingularReflection
-      def macro
-        :has_one
-      end
+    class HasOneReflection < Reflection
     end
   end
 end

data/lib/active_model/serializer/lazy_association.rb

@@ -0,0 +1,95 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    LazyAssociation = Struct.new(:reflection, :association_options) do
+      REFLECTION_OPTIONS = %i(key links polymorphic meta serializer virtual_value namespace).freeze
+
+      delegate :collection?, to: :reflection
+
+      def reflection_options
+        @reflection_options ||= reflection.options.dup.reject { |k, _| !REFLECTION_OPTIONS.include?(k) }
+      end
+
+      def object
+        @object ||= reflection.value(
+          association_options.fetch(:parent_serializer),
+          association_options.fetch(:include_slice)
+        )
+      end
+      alias_method :eval_reflection_block, :object
+
+      def include_data?
+        eval_reflection_block if reflection.block
+        reflection.include_data?(
+          association_options.fetch(:include_slice)
+        )
+      end
+
+      # @return [ActiveModel::Serializer, nil]
+      def serializer
+        return @serializer if defined?(@serializer)
+        if serializer_class
+          serialize_object!(object)
+        elsif !object.nil? && !object.instance_of?(Object)
+          cached_result[:virtual_value] = object
+        end
+        @serializer = cached_result[:serializer]
+      end
+
+      def virtual_value
+        cached_result[:virtual_value] || reflection_options[:virtual_value]
+      end
+
+      def serializer_class
+        return @serializer_class if defined?(@serializer_class)
+        serializer_for_options = { namespace: namespace }
+        serializer_for_options[:serializer] = reflection_options[:serializer] if reflection_options.key?(:serializer)
+        @serializer_class = association_options.fetch(:parent_serializer).class.serializer_for(object, serializer_for_options)
+      end
+
+      private
+
+      def cached_result
+        @cached_result ||= {}
+      end
+
+      def serialize_object!(object)
+        if collection?
+          if (serializer = instantiate_collection_serializer(object)).nil?
+            # BUG: per #2027, JSON API resource relationships are only id and type, and hence either
+            # *require* a serializer or we need to be a little clever about figuring out the id/type.
+            # In either case, returning the raw virtual value will almost always be incorrect.
+            #
+            # Should be reflection_options[:virtual_value] or adapter needs to figure out what to do
+            # with an object that is non-nil and has no defined serializer.
+            cached_result[:virtual_value] = object.try(:as_json) || object
+          else
+            cached_result[:serializer] = serializer
+          end
+        else
+          cached_result[:serializer] = instantiate_serializer(object)
+        end
+      end
+
+      def instantiate_serializer(object)
+        serializer_options = association_options.fetch(:parent_serializer_options).except(:serializer)
+        serializer_options[:serializer_context_class] = association_options.fetch(:parent_serializer).class
+        serializer = reflection_options.fetch(:serializer, nil)
+        serializer_options[:serializer] = serializer if serializer
+        serializer_class.new(object, serializer_options)
+      end
+
+      def instantiate_collection_serializer(object)
+        serializer = catch(:no_serializer) do
+          instantiate_serializer(object)
+        end
+        serializer
+      end
+
+      def namespace
+        reflection_options[:namespace] ||
+          association_options.fetch(:parent_serializer_options)[:namespace]
+      end
+    end
+  end
+end