cache-machine 0.1.10 → 0.2.0

data/lib/cache_machine/adapters/rails.rb

@@ -0,0 +1,58 @@
+module CacheMachine
+  module Adapters
+    require "cache_machine/adapter"
+
+    class Rails < CacheMachine::Adapter
+
+      def initialize(*options)
+        CacheMachine::Logger.info "CACHE_MACHINE: initialized default Rails adapter"
+      end
+
+      def append_id_to_map(target, association, id)
+        key = get_map_key(target, association)
+        ::Rails.cache.write(key, (::Rails.cache.read(key) || []) | [id])
+      end
+
+      def append_id_to_reverse_map(resource, association, target, id)
+        key = get_reverse_map_key(resource, association, target)
+        ::Rails.cache.write(key, (::Rails.cache.read(key) || []) | [id])
+      end
+
+      def association_ids(target, association)
+        ::Rails.cache.fetch(get_map_key(target, association)) do
+          target.association_ids(association)
+        end
+      end
+
+      def fetch(key, options = {}, &block)
+        ::Rails.cache.fetch(get_content_key(key), options, &block)
+      end
+
+      def fetch_timestamp(name, options = {}, &block)
+        ::Rails.cache.fetch(get_timestamp_key(name), options, &block)
+      end
+
+      def delete(key)
+        ::Rails.cache.delete(key)
+      end
+
+      def delete_content(key)
+        delete(get_content_key(key))
+      end
+
+      def reset_timestamp(name)
+        ::Rails.cache.delete(get_timestamp_key(name))
+      end
+
+      def reverse_association_ids(resource, association, target)
+        ::Rails.cache.fetch(get_reverse_map_key(resource, association, target)) do
+          target.cache_map_ids(resource, association)
+        end
+      end
+
+      def write_timestamp(name, &block)
+        ::Rails.cache.write(get_timestamp_key(name), &block)
+      end
+    end
+  end
+end

data/lib/cache_machine/cache.rb

@@ -1,29 +1,19 @@
+require "cache_machine/adapters/rails"
 require "cache_machine/cache/map"
 
 module CacheMachine
   module Cache
-    extend ActiveSupport::Concern
 
     # Enable cache by default.
     @enabled = true
 
-    # Supported by default cache formats.
-    @formats = [nil, :ehtml, :html, :json, :xml]
-
     # Returns if cache is enabled.
     #
     # @return [ false, true ]
-    def self.enabled?
+    def self.enabled
       @enabled
     end
 
-    # Returns currently set formats.
-    #
-    # @return [Array<Symbol>]
-    def self.formats
-      @formats
-    end
-
     # Enables/disables cache.
     #
     # @param [ false, true ] is_enabled
@@ -31,87 +21,46 @@ module CacheMachine
       @enabled = is_enabled
     end
 
-    # Sets default formats.
-    #
-    # @note Empty format entry will always be present.
+    # Returns adapter used for storing maps of cache.
     #
-    # @param [ Array<Symbol> ] formats
-    def self.formats= formats
-      @formats = [nil] | [*formats]
+    # @return [CacheMachine::Adapter]
+    def self.map_adapter
+      @map_adapter ||= CacheMachine::Adapters::Rails.new
     end
 
-    included do
-      after_save    { self.class.reset_timestamps }
-      after_destroy { self.class.reset_timestamps }
+    # Sets adapter used for storing maps of cache.
+    #
+    # @param [CacheMachine::Adapter]
+    def self.map_adapter=(adapter)
+      @map_adapter = adapter
     end
 
-    module ClassMethods
-
-      # Initializes tracking associations to write and reset cache.
-      #
-      # @example Cache associated collections.
-      #   acts_as_cache_machine_for :cats, :dogs
-      # @example Cache result of method to be expired when collection changes.
-      #   acts_as_cache_machine_for :cats => :cat_ids
-      # @example Cache and expire dependent collections (_mouse_ change invalidates all other collection caches by chain)
-      #   acts_as_cache_machine_for :mouses => :cats, :cats => [:dogs, :bears], :dogs, :bears
-      #
-      # @param [ Hash<Symbol, Array> ] associations Cache Map
-      def acts_as_cache_machine_for *associations
-        Time.zone ||= ActiveSupport::TimeZone[0]
-
-        include CacheMachine::Cache::Map
-        cache_associated(associations)
-      end
-      alias :cache_map :acts_as_cache_machine_for
-
-      # Returns timestamp of class collection.
-      #
-      # @example Return timestamp of the class.
-      #   MyActiveRecordClass.timestamp
-      #
-      # @param [ Symbol ] format
-      #
-      # @return [ String ]
-      def timestamp format = nil
-        Rails.cache.fetch(timestamp_key format) { Time.now.to_i.to_s }
-      end
-
-      # Returns cache key to fetch timestamp from memcached.
-      #
-      # @param [ Symbol ] format
-      #
-      # @return [ String ]
-      def timestamp_key format = nil
-        [self.name, format, 'timestamp'].join '_'
-      end
+    # Returns adapter used for storing content being cached.
+    #
+    # @return [CacheMachine::Adapter]
+    def self.storage_adapter
+      @storage_adapter ||= CacheMachine::Adapters::Rails.new
+    end
 
-      # Returns cache key of anything with timestamp attached.
-      #
-      # @example Return timestamped key of the class.
-      #   MyActiveRecordClass.timestamped_key
-      #
-      # @param [Symbol] format
-      #
-      # @return [ String ]
-      def timestamped_key format = nil
-        [timestamp_key(format), timestamp(format)].join '_'
-      end
+    # Sets adapter used for storing content being cached.
+    #
+    # @param [CacheMachine::Adapter]
+    def self.storage_adapter=(adapter)
+      @storage_adapter = adapter
+    end
 
-      # Resets timestamp of class collection.
-      #
-      # @param [ Symbol ] format
-      def reset_timestamp format = nil
-        cache_key = timestamp_key format
-        CacheMachine::Logger.info "CACHE_MACHINE (reset_timestamp): deleting '#{cache_key}'."
-        Rails.cache.delete(cache_key)
-      end
+    # Returns adapter used for storing content being cached.
+    #
+    # @return [CacheMachine::Adapter]
+    def self.timestamps_adapter
+      @timestamps_adapter ||= CacheMachine::Adapters::Rails.new
+    end
 
-      # Resets all timestams for all formats.
-      def reset_timestamps
-        CacheMachine::Cache.formats.each { |format| reset_timestamp format }
-      end
+    # Sets adapter used for storing content being cached.
+    #
+    # @param [CacheMachine::Adapter]
+    def self.timestamps_adapter=(adapter)
+      @timestamps_adapter = adapter
     end
   end
 end
-

data/lib/cache_machine/cache/associations.rb

@@ -0,0 +1,29 @@
+module CacheMachine
+  module Cache
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do
+        # Returns ids of an association.
+        #
+        # @param [ String, Symbol ] association
+        #
+        # @return [ Array ]
+        def association_ids(association)
+          pk = self.class.reflect_on_association(association).klass.primary_key.to_sym
+          send(association).map &pk
+        end
+
+        # Returns associated relation from cache.
+        #
+        # @param [ String, Symbol ] association_name
+        #
+        # @return [ ActiveRecord::Relation ]
+        def associated_from_cache(association_name)
+          klass = self.class.reflect_on_association(association_name).klass
+          klass.where(klass.primary_key => CacheMachine::Cache::map_adapter.association_ids(self, association_name))
+        end
+      end
+    end
+  end
+end

data/lib/cache_machine/cache/class_timestamp.rb

@@ -0,0 +1,31 @@
+module CacheMachine
+  module Cache
+    module ClassTimestamp
+      extend ActiveSupport::Concern
+
+      included do
+        after_destroy { self.class.reset_timestamp }
+        after_save    { self.class.reset_timestamp }
+      end
+
+      module ClassMethods
+
+        # Returns timestamp of class collection.
+        #
+        # @example Return timestamp of the class.
+        #   MyActiveRecordClass.timestamp
+        #
+        # @return [ String ]
+        def timestamp
+          CacheMachine::Cache::timestamps_adapter.fetch_timestamp(self.name) { Time.now.to_i.to_s }
+        end
+
+        # Resets timestamp of class collection.
+        #
+        def reset_timestamp
+          CacheMachine::Cache::timestamps_adapter.reset_timestamp(self.name)
+        end
+      end
+    end
+  end
+end

data/lib/cache_machine/cache/collection.rb

@@ -0,0 +1,131 @@
+module CacheMachine
+  module Cache
+    module Collection
+      extend ActiveSupport::Concern
+
+      DEFAULT_DEPENDENCY_OPTIONS = { :on => :after_save, :scopes => :scoped, :members => [] }
+
+      included do
+        include CacheMachine::Cache::Associations
+        include CacheMachine::Cache::Scope
+
+        cattr_accessor :cache_map_members
+        self.cache_map_members = {}
+
+        # Updates cache map per collection update.
+        #
+        # @param resource_instance
+        # @param [ String, Symbol ] collection_name
+        def update_cache_map!(resource_instance, collection_name)
+          resource_id = resource_instance.send(resource_instance.class.primary_key)
+          collection_id = self.send(self.class.primary_key)
+          CacheMachine::Cache.map_adapter.append_id_to_map(resource_instance, collection_name, collection_id)
+          CacheMachine::Cache.map_adapter.append_id_to_reverse_map(resource_instance.class, collection_name, self, resource_id)
+        end
+
+        # Updates cache of the related resources.
+        #
+        # @param [ Class ] cache_resource
+        def update_resource_collections_cache!(cache_resource)
+          self.class.cache_map_members[cache_resource].each do |collection_name, options|
+            cache_map_ids = CacheMachine::Cache::map_adapter.reverse_association_ids(cache_resource, collection_name, self)
+            unless cache_map_ids.empty?
+              (options[:members] + [collection_name]).each do |member|
+                CacheMachine::Cache::Map.reset_cache_on_map(cache_resource, cache_map_ids, member)
+              end
+            end
+          end
+        end
+
+        # Updates cache of the related resource.
+        #
+        # @param [ Class ] cache_resource
+        def update_dependent_cache!(cache_resource = nil)
+          if cache_resource
+            update_resource_collections_cache!(cache_resource)
+          else
+            self.class.cache_map_members.keys.each &:update_resource_collections_cache!
+          end
+        end
+
+        # Returns all ids from resource associated with this collection member.
+        #
+        # @param [ Class ] cache_resource
+        # @param [ String, Symbol ] collection_name
+        #
+        # @return [ Array ]
+        def cache_map_ids(cache_resource, collection_name)
+          pk                  = self.class.primary_key.to_sym
+          resource_table_name = cache_resource.table_name
+          resource_pk         = cache_resource.primary_key.to_sym
+
+          cache_resource.under_cache_scopes.joins(collection_name).
+              where(collection_name => { pk => self.send(pk) }).
+              select("#{resource_table_name}.#{resource_pk}").to_a.map &resource_pk
+        end
+      end
+
+      module ClassMethods
+
+        # Builds cache dependency.
+        #
+        # @param [ Class ] cache_resource
+        # @param [ String, Symbol ] collection_name
+        # @param [ Hash ] options
+        def register_cache_dependency(cache_resource, collection_name, options = {})
+          return if self.cache_map_members[cache_resource].try('[]', collection_name)
+
+          options.reverse_merge!(CacheMachine::Cache::Collection::DEFAULT_DEPENDENCY_OPTIONS)
+
+          # Register scopes.
+          self.cache_scopes = [*options[:scopes]]
+
+          # Save dependency options.
+          (self.cache_map_members[cache_resource] ||= {}).tap do |resource_collection|
+            resource_collection[collection_name] = options
+          end
+
+          # Prepare callbacks to be executed when it is time to expire the cache.
+          reset_cache_proc = Proc.new do
+            update_resource_collections_cache!(cache_resource)
+          end
+
+          # Bind callbacks.
+          [*options[:on]].each { |callback| self.send(callback, &reset_cache_proc) }
+
+          # When new element appears - update maps.
+          cache_resource.send(:add_association_callbacks, collection_name,
+                              :after_add => lambda { |resource_instance, collection_instance|
+                                collection_instance.update_cache_map!(resource_instance, collection_name)
+                              })
+
+          # Hook on '<<', 'concat' operations.
+          #cache_resource.send(:add_association_callbacks, collection_name,
+          #                    :after_add => lambda { |resource_instance, collection_instance|
+          #                      collection_instance.update_resource_collections_cache!(resource_instance.class)
+          #                    })
+        end
+
+        # Resets cache of associated resource instance.
+        #
+        # @param resource_instance
+        # @param [ String, Symbol ] association_name
+        def reset_resource_cache(resource_instance, association_name)
+          CacheMachine::Cache::Map.reset_cache_on_map(resource_instance.class,
+                                                      resource_instance.send(resource_instance.class.primary_key),
+                                                      association_name)
+
+          collection = self.cache_map_members[resource_instance.class][association_name]
+
+          if collection
+            collection[:members].each do |member|
+              CacheMachine::Cache::Map.reset_cache_on_map(resource_instance.class,
+                                                          resource_instance.send(resource_instance.class.primary_key),
+                                                          member)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cache_machine/cache/map.rb

@@ -1,262 +1,118 @@
 module CacheMachine
   module Cache
+    require 'cache_machine/cache/mapper'
 
-    module Map
-      extend ActiveSupport::Concern
+    class Map
+      cattr_accessor :registered_models
+      self.registered_models = []
 
-      included do
-        CacheMachine::Logger.info "CACHE_MACHINE: bind cache-map on class #{self.name}"
+      cattr_accessor :registered_maps
+      self.registered_maps = []
 
-        # Stores associations map to be cached.
-        cattr_accessor :cache_map
-        self.cache_map = {}
+      # Draws cache dependency graph.
+      #
+      # @return [ nil ]
+      def draw(&block)
+        self.class.registered_maps << block
+        nil
       end
 
-      module ClassMethods
-
-        # Fills cache map.
-        #
-        # @param [ Hash<Symbol, Array> ] associations
-        def cache_associated associations
-          [*associations].each do |association|
-            self.cache_map.merge! association.is_a?(Hash) ? association : {association => []}
-          end
-        end
-
-        # Defines timestamp for object.
-        #
-        # @example Define timestamp to be updated every hour.
-        #   class MyModel < ActiveRecord::Base
-        #     include CacheMachine::Cache
-        #     define_timestamp(:my_timestamp, :expires_in => 1.hour) { my_optional_value }
-        #   end
-        #
-        # @param [ String, Symbol ] timestamp_name
-        # @param [ Hash ] options
-        def define_timestamp timestamp_name, options = {}, &block
-          if block_given?
-            options[:timestamp] = block
-          end
-
-          define_method timestamp_name do
-            fetch_cache_of(timestamp_key_of(timestamp_name), options) do
-              CacheMachine::Logger.info "CACHE_MACHINE (define_timestamp): deleting old timestamp '#{timestamp_name}'."
-              delete_cache_of timestamp_name # Case when cache expired by time.
-              Time.zone.now.to_i.to_s
+      # Fills association map in cache.
+      #
+      # @param [ Class ] resource
+      def self.fill_associations_map(resource)
+        resource.under_cache_scopes.
+                 select("#{resource.table_name}.#{resource.primary_key}").find_each do |instance|
+          resource.cached_collections.each do |collection_name|
+            CacheMachine::Cache::map_adapter.association_ids(instance, collection_name)
+            association_class = resource.reflect_on_association(collection_name).klass
+            association_class.under_cache_scopes.
+                              select("#{association_class.table_name}.#{association_class.primary_key}").
+                              find_each do |associated_instance|
+              CacheMachine::Cache::map_adapter.reverse_association_ids(resource, collection_name, associated_instance)
             end
           end
         end
-
-        # Deletes cache of collection associated via many-to-many.
-        #
-        # @param [ ActiveRecord::Base ]
-        def delete_association_cache_on record, reflection
-          pk = record.class.primary_key
-
-          joining = unless reflection.options[:source_type]
-            reflection.through_reflection ? { reflection.through_reflection.name => reflection.source_reflection.name } : reflection.name
-          else
-            reflection.name
-          end
-
-          self.joins(joining).where(reflection.table_name => { pk => record.send(pk) }).find_each do |cache_source_record|
-            cache_source_record.delete_cache_of reflection.name
-          end
-        end
-
-        # Hooks association changes.
-        #
-        # @private
-        def has_many(association_id, options = {}) #:nodoc:
-          # Ensure what collection should be tracked.
-          if (should_be_on_hook = self.cache_map.keys.include?(association_id)) && options[:through]
-            # If relation is _many_to_many_ track collection changes.
-            options[:after_add] = \
-            options[:before_remove] = :delete_association_cache_on
-          end
-          super
-          hook_cache_machine_on association_id if should_be_on_hook
-        end
-
-        # Hooks association changes.
-        #
-        # @private
-        def has_and_belongs_to_many(association_id, options = {}) #:nodoc:
-
-          # Ensure what collection should be tracked.
-          if(should_be_on_hook = self.cache_map.keys.include?(association_id))
-
-            # If relation is many-to-many track collection changes.
-            options[:after_add] = \
-            options[:before_remove] = :delete_association_cache_on
-          end
-          super
-          hook_cache_machine_on association_id if should_be_on_hook
-        end
-
-        protected
-
-          # Hooks Cache Machine.
-          #
-          # @param [ Symbol ] association_id
-          def hook_cache_machine_on association_id
-            reset_cache_proc = Proc.new do |reflection, target_class, &block|
-              block ||= lambda { target_class.delete_association_cache_on self, reflection }
-
-              reflection.klass.after_save     &block
-              reflection.klass.before_destroy &block
-            end
-
-            case (reflection = (target_class = self).reflect_on_association association_id)
-            when ActiveRecord::Reflection::ThroughReflection
-              # If association is _many_to_many_ it should reset its cache for all associated objects with class +target_class+.
-              reset_cache_proc.call(reflection, target_class)
-            when ActiveRecord::Reflection::AssociationReflection
-              if reflection.macro == :has_and_belongs_to_many
-                reset_cache_proc.call(reflection, target_class)
-              else
-                # If association is _has_many_ or _has_one_ it should reset its cache for associated object with class +target_class+.
-                reset_cache_proc.call(reflection) do
-                  target_class.where((reflection.options[:primary_key] || :id) =>
-                                 send(reflection.options[:foreign_key] || reflection.primary_key_name)).first.try(:delete_cache_of, association_id)
-                end
-              end
-            end
-          end
       end
 
-      module InstanceMethods
-
-        # Returns cache key of the member.
-        #
-        # @param [ Symbol ] _member
-        # @param [ Hash ] options
-        #
-        # @return [ String ]
-        def cache_key_of _member, options = {}
-          timestamp = instance_eval(&options[:timestamp]) if options.has_key? :timestamp
-
-          [ self.class.name,
-            self.to_param,
-            _member,
-            options[:format],
-            options[:page] || 1,
-            timestamp ].flatten.compact.join '/'
-        end
-
-        # Fetches cache of the member.
-        #
-        # @example Fetch cache of associated collection to be refreshed every hour.
-        #   @instance.fetch_cache_of :association, :timestamp => lambda { custom_instance_method },
-        #                                          :expires_in => 1.hour
-        #
-        # @param [ Symbol ] _member
-        # @param [ Hash ] options
-        #
-        # @return [ * ]
-        def fetch_cache_of _member, options = {}, &block
-          if CacheMachine::Cache::enabled?
-            expires_in = if expires_at = options[:expires_at]
-              if expires_at.kind_of? Proc
-                expires_at = expires_at.call
-              end
-
-              if expires_at.kind_of? Time
-                expires_at - Time.zone.now
-              else
-                raise ArgumentError, "expires_at is not a Time"
-              end
-            else
-              options[:expires_in]
-            end
-
-            CacheMachine::Logger.info "CACHE_MACHINE (fetch_cache_of): reading '#{cache_key}'."
-            Rails.cache.fetch(cache_key_of(_member, options), :expires_in => expires_in, &block)
-          else
-            yield
-          end
-        end
-
-        # Removes all caches using map.
-        def delete_all_caches
-          self.class.cache_map.to_a.flatten.uniq.each &method(:delete_cache_of)
-        end
-
-        # Recursively deletes cache by map starting from the member.
-        #
-        # @param [ Symbol ] _member
-        def delete_cache_of _member
-          delete_cache_of_only _member
-          if chain = self.class.cache_map[_member]
-            [*chain].each &method(:delete_cache_of)
-          end
-        end
-
-        # Deletes cache of the only member ignoring cache map.
-        #
-        # @param [ Symbol ] _member
-        def delete_cache_of_only _member
-          CacheMachine::Cache.formats.each do |cache_format|
-            page_nr = 0; begin
-              cache_key = cache_key_of(_member, {:format => cache_format, :page => page_nr += 1})
-              CacheMachine::Logger.info "CACHE_MACHINE (delete_cache_of_only): deleting '#{cache_key}'"
-            end while Rails.cache.delete(cache_key)
-          end
-          reset_timestamp_of _member
-        end
-
-        # Returns timestamp cache key for anything.
-        #
-        # @param [ String, Symbol ] anything
-        #
-        # @return [ String ]
-        def timestamp_key_of anything
-          [self.class.name, self.to_param, anything, 'timestamp'].join '/'
-        end
+      # Returns cache key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.resource_cache_key(resource, id, member)
+        "#{resource}##{id}:#{member}"
+      end
 
-        # Returns timestamp of anything from memcached.
-        #
-        # @param [ String, Symbol ] anything
-        #
-        # @return [ String ]
-        def timestamp_of anything
-          if CacheMachine::Cache::enabled?
-            key = timestamp_key_of anything
-            CacheMachine::Logger.info "CACHE_MACHINE (timestamp_of): reading timestamp '#{key}'."
-            Rails.cache.fetch(key) { Time.zone.now.to_i.to_s }
-          else
-            Time.zone.now.to_i.to_s
-          end
-        end
+      # Returns timestamp key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.timestamp_key(resource, id, member)
+        "#{resource}##{id}:#{member}_timestamp"
+      end
 
-        # Returns cache key of +anything+ with timestamp attached.
-        #
-        # @return [ String ]
-        def timestamped_key_of anything, options = {}
-          [cache_key_of(anything, options), timestamp_of(anything)].join '/'
-        end
+      # Returns cache key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.timestamped_resource_member_key(resource, id, member, timestamp)
+        key = timestamp_key(resource, id, member)
+        collection_timestamp = CacheMachine::Cache::timestamps_adapter.fetch_timestamp(key) { Time.now.to_i.to_s }
+        "#{key}_#{collection_timestamp}_#{timestamp}"
+      end
 
-        # Deletes cache of anything from memory.
-        def reset_timestamp_of anything
-          cache_key = timestamp_key_of anything
-          CacheMachine::Logger.info "CACHE_MACHINE (reset_timestamp_of): deleting '#{cache_key}'."
-          Rails.cache.delete(cache_key)
+      # Returns cache key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric, Array ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.reset_cache_on_map(resource, ids, member)
+        [*ids].each do |id|
+          key = resource_cache_key(resource, id, member)
+          CacheMachine::Logger.info "Deleting cache by map: #{key}"
+          CacheMachine::Cache::storage_adapter.delete_content(key)
+
+          key = timestamp_key(resource, id, member)
+          CacheMachine::Logger.info "CACHE_MACHINE (reset_timestamp_of): deleting '#{key}'."
+          CacheMachine::Cache::timestamps_adapter.reset_timestamp(key)
         end
+      end
 
-        protected
-
-          # Deletes cache of associated collection what contains record.
-          # Called only when many-to-many collection changed.
-          #
-          # @param [ ActiveRecord::Base ] record
-          def delete_association_cache_on record
-
-            # Find all associations with +record+ by its class.
-            associations = self.class.reflect_on_all_associations.find_all { |association| association.klass == record.class }
+      # Returns cache key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric, Array ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.reset_resource_cache(resource, id, member)
+        key = resource_cache_key(resource, id, member)
+        CacheMachine::Logger.info "Deleting cache by map: #{key}"
+        CacheMachine::Cache::storage_adapter.delete_content(key)
+      end
 
-            # Delete cache of each associated collection what may contain +record+.
-            associations.map(&:name).each &method(:delete_cache_of)
-          end
+      # Returns cache key for cache resource.
+      #
+      # @param [ Class ] resource
+      # @param [ String, Numeric, Array ] id
+      # @param [ String, Symbol ] member
+      #
+      # @return [ String ]
+      def self.reset_resource_timestamp(resource, id, member)
+        key = timestamp_key(resource, id, member)
+        CacheMachine::Logger.info "CACHE_MACHINE (reset_timestamp_of): deleting '#{key}'."
+        CacheMachine::Cache::timestamps_adapter.reset_timestamp(key)
       end
     end
   end