class ActiveModelSerializers::CachedSerializer

def self.object_cache_key(serializer, adapter_instance)

Returns:
  • (String, nil) - the cache_key of the serializer or nil
def self.object_cache_key(serializer, adapter_instance)
  return unless serializer.present? && serializer.object.present?
  cached_serializer = new(serializer)
  cached_serializer.cached? ? cached_serializer.cache_key(adapter_instance) : nil
end

def self.object_cache_keys(serializers, adapter_instance, include_tree)

Returns:
  • (Array) - all cache_key of collection_serializer

Parameters:
  • include_tree (ActiveModel::Serializer::IncludeTree) --
  • adapter_instance (ActiveModelSerializers::Adapter::Base) --
  • serializers (ActiveModel::Serializer::CollectionSerializer) --
def self.object_cache_keys(serializers, adapter_instance, include_tree)
  cache_keys = []
  serializers.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|
          cache_keys << object_cache_key(sub_serializer, adapter_instance)
        end
      else
        cache_keys << object_cache_key(association.serializer, adapter_instance)
      end
    end
  end
  cache_keys.compact.uniq
end

def cache_check(adapter_instance)

def cache_check(adapter_instance)
  if cached?
    @klass._cache.fetch(cache_key(adapter_instance), @klass._cache_options) do
      yield
    end
  elsif fragment_cached?
    FragmentCache.new(adapter_instance, @cached_serializer, adapter_instance.instance_options).fetch
  else
    yield
  end
end

def cache_key(adapter_instance)

def cache_key(adapter_instance)
  return @cache_key if defined?(@cache_key)
  parts = []
  parts << object_cache_key
  parts << adapter_instance.cached_name
  parts << @klass._cache_digest unless @klass._skip_digest?
  @cache_key = parts.join('/')
end

def cached?

def cached?
  @klass.cache_enabled?
end

def fragment_cached?

def fragment_cached?
  @klass.fragment_cache_enabled?
end

def initialize(serializer)

def initialize(serializer)
  @cached_serializer = serializer
  @klass             = @cached_serializer.class
end

def object_cache_key

Pass the `key` option to the `cache` declaration or override this method to customize the cache key
Use object's cache_key if available, else derive a key from the object
def object_cache_key
  if @cached_serializer.object.respond_to?(:cache_key)
    @cached_serializer.object.cache_key
  elsif (cache_key = (@klass._cache_key || @klass._cache_options[:key]))
    object_time_safe = @cached_serializer.object.updated_at
    object_time_safe = object_time_safe.strftime('%Y%m%d%H%M%S%9N') if object_time_safe.respond_to?(:strftime)
    "#{cache_key}/#{@cached_serializer.object.id}-#{object_time_safe}"
  else
    fail UndefinedCacheKey, "#{@cached_serializer.object.class} must define #cache_key, or the 'key:' option must be passed into '#{@klass}.cache'"
  end
end