Adding Fragment Cache to AMS

It's an upgrade based on the new Cache implementation #693.
It allows to use the Rails conventions to cache
specific attributes or associations.
It's based on the Cache Composition implementation.

README.md

@@ -271,6 +271,7 @@ a ```key``` option that will be the prefix of the object cache
 on a pattern ```"#{key}/#{object.id}-#{object.updated_at}"```.
 
 **[NOTE] Every object is individually cached.**
+
 **[NOTE] The cache is automatically expired after update an object but it's not deleted.**
 
 ```ruby
@@ -294,6 +295,25 @@ On this example every ```Post``` object will be cached with
 the key ```"post/#{post.id}-#{post.updated_at}"```. You can use this key to expire it as you want,
 but in this case it will be automatically expired after 3 hours.
 
+### Fragmenting Caching
+
+If there is some API endpoint that shouldn't be fully cached, you can still optmise it, using Fragment Cache on the attributes and relationships that you want to cache.
+
+You can define the attribute or relationships by using ```only``` or ```except``` option on cache method.
+
+Example:
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  cache key: 'post', expires_in: 3.hours, only: [:title]
+  attributes :title, :body
+
+  has_many :comments
+
+  url :post
+end
+```
+
 ## Getting Help
 
 If you find a bug, please report an [Issue](https://github.com/rails-api/active_model_serializers/issues/new).

lib/active_model/serializer.rb

@@ -8,20 +8,25 @@ class Serializer
 
     class << self
       attr_accessor :_attributes
+      attr_accessor :_attributes_keys
       attr_accessor :_associations
       attr_accessor :_urls
       attr_accessor :_cache
       attr_accessor :_cache_key
+      attr_accessor :_cache_only
+      attr_accessor :_cache_except
       attr_accessor :_cache_options
     end
 
     def self.inherited(base)
       base._attributes = []
+      base._attributes_keys = {}
       base._associations = {}
       base._urls = []
     end
 
     def self.attributes(*attrs)
+      attrs = attrs.first if attrs.first.class == Array
       @_attributes.concat attrs
 
       attrs.each do |attr|
@@ -33,6 +38,7 @@ def self.attributes(*attrs)
 
     def self.attribute(attr, options = {})
       key = options.fetch(:key, attr)
+      @_attributes_keys[attr] = {key: key} if key != attr
       @_attributes.concat [key]
       define_method key do
         object.read_attribute_for_serialization(attr)
@@ -43,6 +49,8 @@ def self.attribute(attr, options = {})
     def self.cache(options = {})
       @_cache = ActionController::Base.cache_store if Rails.configuration.action_controller.perform_caching
       @_cache_key = options.delete(:key)
+      @_cache_only = options.delete(:only)
+      @_cache_except = options.delete(:except)
       @_cache_options = (options.empty?) ? nil : options
     end
 

lib/active_model/serializer/adapter.rb

@@ -1,3 +1,5 @@
+require 'active_model/serializer/adapter/fragment_cache'
+
 module ActiveModel
   class Serializer
     class Adapter
@@ -11,6 +13,7 @@ class Adapter
       def initialize(serializer, options = {})
         @serializer = serializer
         @options = options
+        @klass = serializer.class
       end
 
       def serializable_hash(options = {})
@@ -32,8 +35,36 @@ def self.adapter_class(adapter)
         "ActiveModel::Serializer::Adapter::#{adapter.to_s.classify}".safe_constantize
       end
 
+      def fragment_cache(*args)
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
       private
 
+      def cache_check
+        if is_cached?
+          @klass._cache.fetch(cache_key, @klass._cache_options) do
+            yield
+          end
+        elsif is_fragment_cached?
+          FragmentCache.new(self, serializer, @options, @root).fetch
+        else
+          yield
+        end
+      end
+
+      def is_cached?
+        @klass._cache && !@klass._cache_only && !@klass._cache_except
+      end
+
+      def is_fragment_cached?
+        @klass._cache_only && !@klass._cache_except || !@klass._cache_only && @klass._cache_except
+      end
+
+      def cache_key
+        (@klass._cache_key) ? "#{@klass._cache_key}/#{serializer.object.id}-#{serializer.object.updated_at}" : serializer.object.cache_key
+      end
+
       def meta
         serializer.meta if serializer.respond_to?(:meta)
       end
@@ -50,20 +81,6 @@ def include_meta(json)
         json[meta_key] = meta if meta && root
         json
       end
-
-      private
-
-      def cached_object
-        klass = serializer.class
-        if klass._cache
-          _cache_key = (klass._cache_key) ? "#{klass._cache_key}/#{serializer.object.id}-#{serializer.object.updated_at}" : serializer.object.cache_key
-          klass._cache.fetch(_cache_key, klass._cache_options) do
-            yield
-          end
-        else
-          yield
-        end
-      end
     end
   end
 end

lib/active_model/serializer/adapter/fragment_cache.rb

@@ -0,0 +1,90 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class FragmentCache
+
+        attr_reader :serializer
+
+        def initialize(adapter, serializer, options, root)
+          @root       = root
+          @options    = options
+          @adapter    = adapter
+          @serializer = serializer
+        end
+
+        def fetch
+          klass = serializer.class
+          # It will split the serializer into two, one that will be cached and other wont
+          serializers = fragment_serializer(@serializer.object.class.name, klass)
+
+          # Instanciate both serializers
+          cached_serializer     = serializers[:cached].constantize.new(@serializer.object)
+          non_cached_serializer = serializers[:non_cached].constantize.new(@serializer.object)
+
+          # Get serializable hash from both
+          cached_hash     = @adapter.class.new(cached_serializer, @options).serializable_hash
+          non_cached_hash = @adapter.class.new(non_cached_serializer, @options).serializable_hash
+
+          # Merge both results
+          @adapter.fragment_cache(cached_hash, non_cached_hash)
+        end
+
+        private
+
+        # Add associations to non-cached Serializer
+        def fragment_associations(serializers, cached_attr, non_cached_attr)
+          associations            = @serializer.each_association
+          cached_associations     = associations.select {|k,v| cached_attr.include?(k)}
+          non_cached_associations = associations.select {|k,v| !cached_attr.include?(k)}
+
+          # Add cached associations to cached Serializer
+          cached_associations.each do |k,v|
+            serializers[:cached].constantize.public_send(v[:type], k, v[:association_options])
+          end
+
+          # Add not cached associations to non-cached Serializer
+          non_cached_associations.each do |k,v|
+            serializers[:non_cached].constantize.public_send(v[:type], k, v[:association_options])
+          end
+        end
+
+        def cached_attributes_and_association(klass, serializers)
+          cached_attributes     = (klass._cache_only) ? klass._cache_only : @serializer.attributes.keys.delete_if {|attr| klass._cache_except.include?(attr) }
+          non_cached_attributes = @serializer.attributes.keys.delete_if {|attr| cached_attributes.include?(attr) }
+
+          fragment_associations(serializers, cached_attributes, non_cached_attributes)
+
+          cached_attributes.each do |attribute|
+            options = @serializer.class._attributes_keys[attribute]
+            options ||= {}
+            # Add cached attributes to cached Serializer
+            serializers[:cached].constantize.attribute(attribute, options)
+          end
+
+          non_cached_attributes.each do |attribute|
+            options = @serializer.class._attributes_keys[attribute]
+            options ||= {}
+            # Add non-cached attributes to non-cached Serializer
+            serializers[:non_cached].constantize.attribute(attribute, options)
+          end
+        end
+
+        def fragment_serializer(name, klass)
+          cached     = "#{name.capitalize}CachedSerializer"
+          non_cached = "#{name.capitalize}NonCachedSerializer"
+
+          Object.const_set cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(cached)
+          Object.const_set non_cached, Class.new(ActiveModel::Serializer) unless Object.const_defined?(non_cached)
+
+          klass._cache_options ||= {}
+          klass._cache_options[:key] = klass._cache_key if klass._cache_key
+          cached.constantize.cache(klass._cache_options)
+
+          serializers = {cached: cached, non_cached: non_cached}
+          cached_attributes_and_association(klass, serializers)
+          serializers
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/adapter/json.rb

@@ -1,3 +1,5 @@
+require 'active_model/serializer/adapter/json/fragment_cache'
+
 module ActiveModel
   class Serializer
     class Adapter
@@ -6,7 +8,7 @@ def serializable_hash(options = {})
           if serializer.respond_to?(:each)
             @result = serializer.map{|s| self.class.new(s).serializable_hash }
           else
-            @result = cached_object do
+            @result = cache_check do
               @hash = serializer.attributes(options)
               serializer.each_association do |name, association, opts|
                 if association.respond_to?(:each)
@@ -31,6 +33,10 @@ def serializable_hash(options = {})
           @result
         end
       end
+
+      def fragment_cache(cached_hash, non_cached_hash)
+        Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
+      end
     end
   end
 end

lib/active_model/serializer/adapter/json/fragment_cache.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class Json < Adapter
+        class FragmentCache
+
+          def fragment_cache(cached_hash, non_cached_hash)
+            non_cached_hash.merge cached_hash
+          end
+
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/adapter/json_api.rb

@@ -1,3 +1,5 @@
+require 'active_model/serializer/adapter/json_api/fragment_cache'
+
 module ActiveModel
   class Serializer
     class Adapter
@@ -23,7 +25,7 @@ def serializable_hash(options = {})
               self.class.new(s, @options.merge(top: @top, fieldset: @fieldset)).serializable_hash[@root]
             end
           else
-            @hash = cached_object do
+            @hash = cache_check do
               @hash[@root] = attributes_for_serializer(serializer, @options)
               add_resource_links(@hash[@root], serializer)
               @hash
@@ -32,6 +34,10 @@ def serializable_hash(options = {})
           @hash
         end
 
+        def fragment_cache(cached_hash, non_cached_hash)
+          JsonApi::FragmentCache.new().fragment_cache(@root, cached_hash, non_cached_hash)
+        end
+
         private
 
         def add_links(resource, name, serializers)
@@ -91,7 +97,6 @@ def add_linked(resource_name, serializers, parent = nil)
           end
         end
 
-
         def attributes_for_serializer(serializer, options)
           if serializer.respond_to?(:each)
             result = []

lib/active_model/serializer/adapter/json_api/fragment_cache.rb

@@ -0,0 +1,26 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonApi < Adapter
+        class FragmentCache
+
+          def fragment_cache(root, cached_hash, non_cached_hash)
+            if root
+              hash              = {}
+              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].merge(core_non_cached[1]) : core_non_cached[1]
+              hash            = (root) ? { root => cached_resource } : cached_resource
+
+              hash.merge no_root_non_cache.merge no_root_cache
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

test/action_controller/json_api_linked_test.rb

@@ -110,12 +110,14 @@ def test_render_resource_with_nested_has_many_include
           "roles"=>[{
             "id" => "1",
             "name" => "admin",
+            "description" => nil,
             "links" => {
               "author" => "1"
             }
           }, {
             "id" => "2",
             "name" => "colab",
+            "description" => nil,
             "links" => {
               "author" => "1"
             }