cache-machine 0.1.9 → 0.1.10

data/.gitignore

@@ -1,3 +1,9 @@
+# Packed ge
+*.gem
+
+# RubyMine metadata
+.idea
+
 # test database
 db
 

data/Gemfile

@@ -2,6 +2,7 @@ source "http://rubygems.org"
 
 gem "rails"
 gem "activemodel"
+gem "activesupport"
 
 group :development do
   gem "bundler", "~> 1.0.0"

data/Gemfile.lock

@@ -94,6 +94,7 @@ PLATFORMS
 
 DEPENDENCIES
   activemodel
+  activesupport
   bundler (~> 1.0.0)
   jeweler (~> 1.6.2)
   rails

data/VERSION

@@ -1 +1 @@
-0.1.9
+0.1.10

data/cache-machine.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cache-machine}
-  s.version = "0.1.9"
+  s.version = "0.1.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sergei Zinin", "Kevin Goslar"]
-  s.date = %q{2011-10-13}
+  s.date = %q{2011-10-22}
   s.description = %q{A Ruby on Rails framework to support cache management based on explicitely modeled caching dependencies.}
   s.email = %q{kgoslar@partyearth.com}
   s.extra_rdoc_files = [
@@ -29,15 +29,20 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rails>, [">= 0"])
       s.add_runtime_dependency(%q<activemodel>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
     else
       s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<activemodel>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
     end
   else
     s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<activemodel>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
   end

data/lib/cache_machine/cache.rb

@@ -4,13 +4,38 @@ 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?
+      @enabled
+    end
+
+    # Returns currently set formats.
+    #
+    # @return [Array<Symbol>]
     def self.formats
       @formats
     end
 
+    # Enables/disables cache.
+    #
+    # @param [ false, true ] is_enabled
+    def self.enabled= is_enabled
+      @enabled = is_enabled
+    end
+
+    # Sets default formats.
+    #
+    # @note Empty format entry will always be present.
+    #
+    # @param [ Array<Symbol> ] formats
     def self.formats= formats
       @formats = [nil] | [*formats]
     end
@@ -21,46 +46,68 @@ module CacheMachine
     end
 
     module ClassMethods
+
       # Initializes tracking associations to write and reset cache.
-      # +associations+ parameter is to represent cache map with hash.
       #
-      # ==== Examples
-      #   # Cache associated collections
+      # @example Cache associated collections.
       #   acts_as_cache_machine_for :cats, :dogs
-      #
-      #   # Cache result of method to be expired when collection changes.
+      # @example Cache result of method to be expired when collection changes.
       #   acts_as_cache_machine_for :cats => :cat_ids
-      #
-      #   # Cache and expire dependent collections (_mouse_ change invalidates all other collection caches by chain)
+      # @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 cache key of +anything+ with timestamp attached.
+      # 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
 
       # 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
 
+      # Resets all timestams for all formats.
       def reset_timestamps
         CacheMachine::Cache.formats.each { |format| reset_timestamp format }
       end

data/lib/cache_machine/cache/map.rb

@@ -1,7 +1,6 @@
 module CacheMachine
   module Cache
 
-    # Module to write and expire association cache by given map.
     module Map
       extend ActiveSupport::Concern
 
@@ -14,7 +13,10 @@ module CacheMachine
       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 => []}
@@ -22,20 +24,32 @@ module CacheMachine
         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
-          options[:timestamp] = block if 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.now.to_i.to_s
+              Time.zone.now.to_i.to_s
             end
           end
         end
 
-        # Deletes cache of collection with name +association_id+ for each object associated with +record+
-        # Called only when <tt>has_many :through</tt> collection changed.
+        # Deletes cache of collection associated via many-to-many.
+        #
+        # @param [ ActiveRecord::Base ]
         def delete_association_cache_on record, reflection
           pk = record.class.primary_key
 
@@ -50,8 +64,10 @@ module CacheMachine
           end
         end
 
-        # Overwrites +has_many+ of +ActiveRecord+ class to hook Cache Machine.
-        def has_many(association_id, options = {})
+        # 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.
@@ -62,11 +78,15 @@ module CacheMachine
           hook_cache_machine_on association_id if should_be_on_hook
         end
 
-        # Overwrites +has_and_belongs_to_many+ of +ActiveRecord+ class to hook Cache Machine.
-        def has_and_belongs_to_many(association_id, options = {})
+        # 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.
+
+            # If relation is many-to-many track collection changes.
             options[:after_add] = \
             options[:before_remove] = :delete_association_cache_on
           end
@@ -76,7 +96,9 @@ module CacheMachine
 
         protected
 
-          # Hooks Cache Machine on association with name +association_id+.
+          # 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 }
@@ -104,48 +126,65 @@ module CacheMachine
       end
 
       module InstanceMethods
-        # Returns cache key of +_member+.
-        # TODO: describe options.
+
+        # Returns cache key of the member.
+        #
+        # @param [ Symbol ] _member
+        # @param [ Hash ] options
+        #
+        # @return [ String ]
         def cache_key_of _member, options = {}
-          [self.class.name, self.to_param, _member, options[:format], options[:page] || 1].compact.join '_'
+          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 +_member+ from cache map.
-        # TODO: Describe options.
-        # TODO: Describe timestamp features (we can pass methods or fields as timestamps too).
-        #       Or we can use define_timestamp +:expires_in => 20.hours+.
+        # 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
-          cache_key = if timestamp = options[:timestamp]
-            # Make key dependent on collection timestamp and optional timestamp.
-            [timestamped_key_of(_member, options), instance_eval(&timestamp)].join '_'
-          else
-            cache_key_of(_member, options)
-          end
-
-          expires_in = if expires_at = options[:expires_at]
-            expires_at = expires_at.call if expires_at.kind_of? Proc
+          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.now
+              if expires_at.kind_of? Time
+                expires_at - Time.zone.now
+              else
+                raise ArgumentError, "expires_at is not a Time"
+              end
             else
-              raise ArgumentError, "expires_at is not a Time"
+              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
-            options[:expires_in]
+            yield
           end
-
-          CacheMachine::Logger.info "CACHE_MACHINE (fetch_cache_of): reading '#{cache_key}'."
-          Rails.cache.fetch(cache_key, :expires_in => expires_in, &block)
         end
 
         # Removes all caches using map.
         def delete_all_caches
-          self.class.cache_map.keys.each do |cached_collection|
-            delete_cache_of cached_collection
-          end
+          self.class.cache_map.to_a.flatten.uniq.each &method(:delete_cache_of)
         end
 
-        # Recursively deletes cache by map for +_member+.
+        # 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]
@@ -153,7 +192,9 @@ module CacheMachine
           end
         end
 
-        # Deletes cache of only +_member+ ignoring cache map.
+        # 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
@@ -164,24 +205,38 @@ module CacheMachine
           reset_timestamp_of _member
         end
 
-        # Returns timestamp cache key for +anything+.
+        # 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 '_'
+          [self.class.name, self.to_param, anything, 'timestamp'].join '/'
         end
 
-        # Returns timestamp of +anything+ from memcached.
+        # Returns timestamp of anything from memcached.
+        #
+        # @param [ String, Symbol ] anything
+        #
+        # @return [ String ]
         def timestamp_of anything
-          key = timestamp_key_of anything
-          CacheMachine::Logger.info "CACHE_MACHINE (timestamp_of): reading timestamp '#{key}'."
-          Rails.cache.fetch(key) { Time.now.to_i.to_s }
+          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 cache key of +anything+ with timestamp attached.
+        #
+        # @return [ String ]
         def timestamped_key_of anything, options = {}
-          [cache_key_of(anything, options), timestamp_of(anything)].join '_'
+          [cache_key_of(anything, options), timestamp_of(anything)].join '/'
         end
 
-        # Deletes cache of +anything+ from memory.
+        # 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}'."
@@ -190,8 +245,10 @@ module CacheMachine
 
         protected
 
-          # Deletes cache of associated collection what contains +record+.
-          # Called only when <tt>has_many :through</tt> collection changed.
+          # 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.

data/lib/cache_machine/helpers/cache_helper.rb

@@ -1,6 +1,18 @@
 module CacheMachine
   module Helpers
     module CacheHelper
+
+      # Returns cached EHTML content.
+      #
+      # @example Return html from cache.
+      #   = cache_for @instance, :association do
+      #     %div= @instance.associated_records
+      #
+      # @param [ ActiveRecord::Base ] record
+      # @param [ Symbol ] cacheable
+      # @param [ Hash ] options
+      #
+      # @return [ String ]
       def cache_for record, cacheable, options = {}, &block
         record.fetch_cache_of(cacheable, options.merge(:format => :ehtml)) { capture &block }
       end

data/lib/cache_machine/logger.rb

@@ -16,7 +16,11 @@ module CacheMachine
       end
 
       # Sets the log level for CacheMachine.
-      # Call like this in your your code, best in development.rb: ActiveRecord::CacheMachine::Logger.level = :info
+      #
+      # @example Call like this in your your code, best in development.rb:
+      #   ActiveRecord::CacheMachine::Logger.level = :info
+      #
+      # @param [Symbol] value
       def level= value
         @@level = LOGGING_LEVELS[value] or raise "CACHE_MACHINE: Unknown log level: '#{value}'."
         if @@level <= LOGGING_LEVELS[:info]
@@ -25,6 +29,9 @@ module CacheMachine
       end
 
       # Logs the given entry with the given log level.
+      #
+      # @param [ Symbol ] level
+      # @param [ String ] text
       def write level, text
         if @@level <= (LOGGING_LEVELS[level] or raise "CACHE_MACHINE: Unknown log level: '#{level}'.")
           puts text

data/spec/fixtures.rb

@@ -0,0 +1,86 @@
+TARGET_TABLE_NAME       = "cachers"
+HABTM_TABLE_NAME        = "has_and_belongs_to_many_cacheables"
+HABTM_JOINS_TABLE_NAME  = [TARGET_TABLE_NAME, HABTM_TABLE_NAME].join('_')
+HABTM_ASSOCIATION_NAME  = HABTM_TABLE_NAME.singularize
+HM_TABLE_NAME           = "has_many_cacheables"
+HMT_JOINS_TABLE_NAME    = "joins"
+HMT_TABLE_NAME          = "has_many_through_cacheables"
+HO_TABLE_NAME           = "hs_one_cacheables"
+POLY_TABLE_NAME         = "polymorphics"
+TARGET_ASSOCIATION_NAME = TARGET_TABLE_NAME.singularize
+HMT_ASSOCIATION_NAME    = HMT_TABLE_NAME.singularize
+
+class TestMigration < ActiveRecord::Migration
+  def self.up
+    self.down
+    create_table(HABTM_TABLE_NAME)
+    create_table(HM_TABLE_NAME) { |t| t.references TARGET_ASSOCIATION_NAME }
+    create_table(HMT_TABLE_NAME)
+    create_table(HMT_JOINS_TABLE_NAME) { |t| [TARGET_ASSOCIATION_NAME, HMT_ASSOCIATION_NAME].each &t.method(:references) }
+    create_table(POLY_TABLE_NAME) { |t| t.references(:polymorhicable); t.string(:polymorhicable_type) }
+    create_table(TARGET_TABLE_NAME) { |t| t.string :name; t.integer(:parent_id) }
+    create_table(HABTM_JOINS_TABLE_NAME, :id => false) { |t| [TARGET_ASSOCIATION_NAME, HABTM_ASSOCIATION_NAME].each &t.method(:references) }
+  end
+
+  def self.down
+    drop_table POLY_TABLE_NAME        if ActiveRecord::Base.connection.tables.include?(POLY_TABLE_NAME)
+    drop_table TARGET_TABLE_NAME      if ActiveRecord::Base.connection.tables.include?(TARGET_TABLE_NAME)
+    drop_table HABTM_TABLE_NAME       if ActiveRecord::Base.connection.tables.include?(HABTM_TABLE_NAME)
+    drop_table HM_TABLE_NAME          if ActiveRecord::Base.connection.tables.include?(HM_TABLE_NAME)
+    drop_table HMT_TABLE_NAME         if ActiveRecord::Base.connection.tables.include?(HMT_TABLE_NAME)
+    drop_table HO_TABLE_NAME          if ActiveRecord::Base.connection.tables.include?(HO_TABLE_NAME)
+    drop_table HMT_JOINS_TABLE_NAME   if ActiveRecord::Base.connection.tables.include?(HMT_JOINS_TABLE_NAME)
+    drop_table HABTM_JOINS_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HABTM_JOINS_TABLE_NAME)
+  end
+end
+TestMigration.up
+
+class HasManyCacheable < ActiveRecord::Base
+  set_table_name HM_TABLE_NAME
+  belongs_to :cacher, :class_name => 'Cacher'
+end
+
+class HasManyThroughCacheable < ActiveRecord::Base
+  set_table_name HMT_TABLE_NAME
+
+  has_many :joins, :class_name => 'Join'
+  has_many :cachers, :through => :joins, :class_name => 'Cacher'
+end
+
+class Join < ActiveRecord::Base
+  set_table_name HMT_JOINS_TABLE_NAME
+
+  belongs_to :cacher, :class_name => 'Cacher'
+  belongs_to :has_many_through_cacheable, :class_name => 'HasManyThroughCacheable'
+end
+
+class HasAndBelongsToManyCacheable < ActiveRecord::Base
+  set_table_name HABTM_TABLE_NAME
+  has_and_belongs_to_many :cachers, :class_name => 'Cacher'
+end
+
+class Polymorphic < ActiveRecord::Base
+  set_table_name POLY_TABLE_NAME
+  belongs_to :polymorhicable, :polymorphic => true
+end
+
+class Cacher < ActiveRecord::Base
+  set_table_name TARGET_TABLE_NAME
+
+  cache_map :polymorphics,
+            :child_cachers,
+            :has_many_cacheables => :dependent_cache,
+            :has_many_through_cacheables => :dependent_cache,
+            :has_and_belongs_to_many_cacheables => :dependent_cache
+
+  define_timestamp(:dynamic_timestamp) { execute_timestamp }
+
+  has_and_belongs_to_many :has_and_belongs_to_many_cacheables, :class_name => 'HasAndBelongsToManyCacheable'
+  has_many :has_many_cacheables, :class_name => 'HasManyCacheable'
+  has_many :joins, :class_name => 'Join'
+  has_many :has_many_through_cacheables, :through => :joins, :class_name => 'HasManyThroughCacheable'
+  has_many :polymorphics, :as => :polymorhicable
+  has_many :child_cachers, :class_name => 'Cacher', :foreign_key => 'parent_id', :primary_key => 'id'
+
+  def to_param; name end
+end

data/spec/lib/cache_machine_spec.rb

@@ -1,258 +1,159 @@
 require 'spec_helper'
+require 'fixtures'
 
 describe CacheMachine do
-  TARGET_TABLE_NAME = "cachers"
-  HABTM_TABLE_NAME = "has_and_belongs_to_many_cacheables"
-  HABTM_JOINS_TABLE_NAME = [TARGET_TABLE_NAME, HABTM_TABLE_NAME].join('_')
-  HABTM_ASSOCIATION_NAME = HABTM_TABLE_NAME.singularize
-  HM_TABLE_NAME = "has_many_cacheables"
-  HMT_JOINS_TABLE_NAME = "joins"
-  HMT_TABLE_NAME = "has_many_through_cacheables"
-  HO_TABLE_NAME = "hs_one_cacheables"
-  POLY_TABLE_NAME = "polymorphics"
-  TARGET_ASSOCIATION_NAME = TARGET_TABLE_NAME.singularize
-  HMT_ASSOCIATION_NAME = HMT_TABLE_NAME.singularize
-
-  class TestMigration < ActiveRecord::Migration
-    def self.up
-      self.down
-      create_table(HABTM_TABLE_NAME)
-      create_table(HM_TABLE_NAME) { |t| t.references TARGET_ASSOCIATION_NAME }
-      create_table(HMT_TABLE_NAME)
-      create_table(HMT_JOINS_TABLE_NAME) { |t| [TARGET_ASSOCIATION_NAME, HMT_ASSOCIATION_NAME].each &t.method(:references) }
-      create_table(POLY_TABLE_NAME) { |t| t.references(:polymorhicable); t.string(:polymorhicable_type) }
-      create_table(TARGET_TABLE_NAME) { |t| t.string :name; t.integer(:parent_id) }
-      create_table(HABTM_JOINS_TABLE_NAME, :id => false) { |t| [TARGET_ASSOCIATION_NAME, HABTM_ASSOCIATION_NAME].each &t.method(:references) }
-    end
+  subject { Cacher.create(:name => 'foo') }
 
-    def self.down
-      drop_table POLY_TABLE_NAME if ActiveRecord::Base.connection.tables.include? POLY_TABLE_NAME
-      drop_table TARGET_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(TARGET_TABLE_NAME)
-      drop_table HABTM_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HABTM_TABLE_NAME)
-      drop_table HM_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HM_TABLE_NAME)
-      drop_table HMT_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HMT_TABLE_NAME)
-      drop_table HO_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HO_TABLE_NAME)
-      drop_table HMT_JOINS_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HMT_JOINS_TABLE_NAME)
-      drop_table HABTM_JOINS_TABLE_NAME if ActiveRecord::Base.connection.tables.include?(HABTM_JOINS_TABLE_NAME)
+  describe "#cache_key_of" do
+    it "generates association cache keys" do
+      subject.cache_key_of(:anything).should eql("Cacher/foo/anything/1")
+      subject.cache_key_of(:anything, :format => :ehtml).should eql("Cacher/foo/anything/ehtml/1")
+      subject.cache_key_of(:anything, :page => 2).should eql("Cacher/foo/anything/2")
+      subject.cache_key_of(:anything, :format => :ehtml, :page => 2).should eql("Cacher/foo/anything/ehtml/2")
     end
   end
-  TestMigration.up
-
-  class HasManyCacheable < ActiveRecord::Base
-    set_table_name HM_TABLE_NAME
-    belongs_to :cacher, :class_name => 'Cacher'
-  end
-
-  class HasManyThroughCacheable < ActiveRecord::Base
-    set_table_name HMT_TABLE_NAME
-
-    has_many :joins, :class_name => 'Join'
-    has_many :cachers, :through => :joins, :class_name => 'Cacher'
-  end
-
-  class Join < ActiveRecord::Base
-    set_table_name HMT_JOINS_TABLE_NAME
-
-    belongs_to :cacher, :class_name => 'Cacher'
-    belongs_to :has_many_through_cacheable, :class_name => 'HasManyThroughCacheable'
-  end
-
-  class HasAndBelongsToManyCacheable < ActiveRecord::Base
-    set_table_name HABTM_TABLE_NAME
-    has_and_belongs_to_many :cachers, :class_name => 'Cacher'
-  end
-
-  class Polymorphic < ActiveRecord::Base
-    set_table_name POLY_TABLE_NAME
-    belongs_to :polymorhicable, :polymorphic => true
-  end
 
-  class Cacher < ActiveRecord::Base
-    set_table_name TARGET_TABLE_NAME
-
-    cache_map :polymorphics,
-              :child_cachers,
-              :has_many_cacheables => :dependent_cache,
-              :has_many_through_cacheables => :dependent_cache,
-              :has_and_belongs_to_many_cacheables => :dependent_cache
-
-    define_timestamp(:dynamic_timestamp) { execute_timestamp }
-    define_timestamp(:static_timestamp)
-
-    has_and_belongs_to_many :has_and_belongs_to_many_cacheables, :class_name => 'HasAndBelongsToManyCacheable'
-    has_many :has_many_cacheables, :class_name => 'HasManyCacheable'
-    has_many :joins, :class_name => 'Join'
-    has_many :has_many_through_cacheables, :through => :joins, :class_name => 'HasManyThroughCacheable'
-    has_many :polymorphics, :as => :polymorhicable
-    has_many :child_cachers, :class_name => 'Cacher', :foreign_key => 'parent_id', :primary_key => 'id'
-
-    def to_param; name end
-  end
-
-  subject { Cacher.create(:name => 'foo') }
-
-  it "generates association cache keys" do
-    subject.cache_key_of(:has_many_cacheables, :format => :ehtml).should eql("Cacher_foo_has_many_cacheables_ehtml_1")
-  end
+  describe "#fetch_cache_of" do
+    it "stores association cache" do
+      subject.fetch_cache_of(:has_many_cacheables) { 'cache' }
+      subject.fetch_cache_of(:has_many_cacheables).should == 'cache'
+    end
 
-  it "stores association cache" do
-    subject.fetch_cache_of(:has_many_cacheables) { 'cache' }
-    cached_result = subject.fetch_cache_of(:has_many_cacheables) { 'fresh cache' }
-    cached_result.should eql('cache')
-  end
+    context "timestamps" do
+      it "works with timestamps" do
+        subject.should_receive(:cache_key_of).with(:anything, hash_including(:timestamp => :dynamic_timestamp)).and_return "returned stamp"
+        Rails.cache.should_receive(:fetch).with("returned stamp", :expires_in => nil).once
+        subject.fetch_cache_of(:anything, :timestamp => :dynamic_timestamp)
+      end
 
-  describe "defines timestamp" do
+      it "calls for instance methods" do
+        subject.should_receive(:execute_timestamp).once
+        subject.fetch_cache_of(:anything, :timestamp => :dynamic_timestamp)
+      end
 
-    context "dynamic" do
-      it "works" do
-        subject.stub!(:execute_timestamp).and_return(1)
-        subject.fetch_cache_of(:something, :timestamp => :dynamic_timestamp) { "cache" }
-        sleep(2)
-        subject.fetch_cache_of(:something, :timestamp => :dynamic_timestamp) { "foo" }.should eql("cache")
-        subject.stub!(:execute_timestamp).and_return(2)
-        sleep(2)
-        subject.fetch_cache_of(:something, :timestamp => :dynamic_timestamp) { "fresh cache" }.should eql("fresh cache")
+      it "passes expires_in param" do
+        Rails.cache.should_receive(:fetch).with(anything(), :expires_in => 10.minutes).once
+        subject.fetch_cache_of(:anything, :expires_in => 10.minutes)
       end
-    end
 
-    context "static" do
-      it "works" do
-        sleep(2)
-        subject.fetch_cache_of(:something, :timestamp => :static_timestamp) { "cache" }
-        sleep(2)
-        subject.fetch_cache_of(:something, :timestamp => :static_timestamp) { "foo" }.should eql("cache")
+      it "passes expires_at param" do
+        Time.stub_chain("zone.now").and_return(Time.parse('01/01/01'))
+        Rails.cache.should_receive(:fetch).with(anything(), :expires_in => 10.minutes).once
+        subject.fetch_cache_of(:anything, :expires_at => 10.minutes.from_now)
       end
     end
   end
 
-  context "deletes cache" do
-
+  context "resets cache" do
     describe "#delete_all_caches" do
       it "removes all caches using map" do
-        subject.fetch_cache_of(:polymorphics) { 'cache' }
-        subject.fetch_cache_of(:dependent_cache) { 'cache' }
-
+        subject.should_receive(:delete_cache_of).with(:polymorphics).once
+        subject.should_receive(:delete_cache_of).with(:child_cachers).once
+        subject.should_receive(:delete_cache_of).with(:has_many_cacheables).once
+        subject.should_receive(:delete_cache_of).with(:dependent_cache).once
+        subject.should_receive(:delete_cache_of).with(:has_many_through_cacheables).once
+        subject.should_receive(:delete_cache_of).with(:has_and_belongs_to_many_cacheables).once
         subject.delete_all_caches
-
-        subject.fetch_cache_of(:polymorphics) { 'new cache' }.should == 'new cache'
-        subject.fetch_cache_of(:dependent_cache) { 'new cache' }.should == 'new cache'
       end
     end
 
-    context "of polymorphic associations" do
-      it "works" do
-        cached_result = subject.fetch_cache_of(:polymorphics) { 'cache' }
-        subject.polymorphics.create
-        cached_result = subject.fetch_cache_of(:polymorphics) { 'new cache' }
-
-        cached_result.should eql('new cache')
+    describe "#delete_cache_of" do
+      it "resets cache" do
+        subject.fetch_cache_of(:anything) { 'cache' }
+        subject.delete_cache_of :anything
+        subject.fetch_cache_of(:anything).should be_nil
       end
-    end
 
-    context "of paginated content" do
-      before :each do
+      it "resets cache by map" do
+        subject.fetch_cache_of(:dependent_cache) { 'cache' }
         subject.delete_cache_of :has_many_cacheables
+        subject.fetch_cache_of(:dependent_cache).should be_nil
       end
 
-      it "works" do
-        subject.fetch_cache_of(:has_many_cacheables, :page => 1) { 'page 1' }.should eql('page 1')
-        subject.fetch_cache_of(:has_many_cacheables, :page => 2) { 'page 2' }.should eql('page 2')
-        subject.delete_cache_of(:has_many_cacheables)
-        subject.fetch_cache_of(:has_many_cacheables, :page => 1) { 'fresh page 1' }.should eql('fresh page 1')
-        subject.fetch_cache_of(:has_many_cacheables, :page => 2) { 'fresh page 2' }.should eql('fresh page 2')
-      end
-    end
+      context "callbacks" do
+        context "on polymorphic associations" do
+          it "resets cache on add new item to associated collection" do
+            subject.fetch_cache_of(:polymorphics) { 'cache' }
+            subject.polymorphics.create
+            subject.fetch_cache_of(:polymorphics).should be_nil
+          end
+        end
 
-    context "of self-join association" do
-      it "works" do
-        subject.fetch_cache_of(:child_cachers) { 'cache' }
-        child = Cacher.create(:parent_id => subject.id)
-        cached_result = subject.fetch_cache_of(:child_cachers) { 'new cache' }
+        context "on self-join associations" do
+          it "resets cache on add new item to associated collection" do
+            subject.fetch_cache_of(:child_cachers) { 'cache' }
+            Cacher.create(:parent_id => subject.id)
+            subject.fetch_cache_of(:child_cachers).should be_nil
+          end
+        end
 
-        cached_result.should eql('new cache')
-      end
-    end
+        context "on has_many associations" do
+          let(:new_entry) { HasManyCacheable.create }
 
-    context "of any member on has_many" do
-      before :each do
-        @existing_entry = subject.has_many_cacheables.create
-        @new_entry = HasManyCacheable.create
-        subject.fetch_cache_of(:has_many_cacheables) { 'cache' }
-      end
+          before :each do
+            @existing_entry = subject.has_many_cacheables.create
+            subject.fetch_cache_of(:has_many_cacheables) { 'cache' }
+          end
 
-      after :each do
-        cached_result = subject.fetch_cache_of(:has_many_cacheables) { 'fresh cache' }
-        cached_result.should eql('fresh cache')
-        subject.delete_cache_of(:has_many_cacheables)
+          after :each do
+            subject.fetch_cache_of(:has_many_cacheables).should be_nil
+            subject.delete_cache_of(:has_many_cacheables)
+          end
+
+          it("on update entry in collection")  { @existing_entry.save }
+          it("on add new entry in collection") { subject.has_many_cacheables << new_entry }
+          it("on destroy intem in collection") { subject.has_many_cacheables.destroy @existing_entry }
+          it("on destroy intem")               { HasManyCacheable.destroy @existing_entry }
+        end
       end
 
-      it("works") { subject.delete_cache_of(:has_many_cacheables) }
-      it("on update entry in collection") { @existing_entry.save }
-      it("on add new entry in collection") { subject.has_many_cacheables << @new_entry }
-      it("on destroy intem in collection") { subject.has_many_cacheables.destroy @existing_entry }
-      it("on destroy intem") { HasManyCacheable.destroy @existing_entry }
+      context "has_many :through associations" do
+        let(:new_entry) { HasManyThroughCacheable.create }
 
-      context "by chain" do
-        it "works" do
-          subject.fetch_cache_of(:dependent_cache) { 'cache' }
-          subject.has_many_cacheables.create
-          subject.fetch_cache_of(:dependent_cache) { 'fresh cache' }.should eql('fresh cache')
+        before :each do
+          @existing_entry = subject.has_many_through_cacheables.create
+          subject.fetch_cache_of(:has_many_through_cacheables) { 'cache' }
         end
-      end
-    end
 
-    context "of any member on has_many :through" do
-      before :each do
-        @existing_entry = subject.has_many_through_cacheables.create
-        @new_entry = HasManyThroughCacheable.create
-        subject.fetch_cache_of(:has_many_through_cacheables) { 'cache' }
-      end
+        after :each do
+          subject.fetch_cache_of(:has_many_through_cacheables).should be_nil
+          subject.delete_cache_of(:has_many_through_cacheables)
+        end
 
-      after :each do
-        cached_result = subject.fetch_cache_of(:has_many_through_cacheables) { 'fresh cache' }
-        cached_result.should eql('fresh cache')
-        subject.delete_cache_of(:has_many_through_cacheables)
+        it("on update entry in collection")  { @existing_entry.save }
+        it("on add new entry in collection") { subject.has_many_through_cacheables << new_entry }
+        it("on destroy intem in collection") { subject.has_many_through_cacheables.destroy @existing_entry }
+        it("on destroy intem")               { HasManyThroughCacheable.destroy @existing_entry }
       end
 
-      it("works") { subject.delete_cache_of(:has_many_through_cacheables) }
-      it("on update entry in collection") { @existing_entry.save }
-      it("on add new entry in collection") { subject.has_many_through_cacheables << @new_entry }
-      it("on destroy intem in collection") { subject.has_many_through_cacheables.destroy @existing_entry }
-      it("on destroy intem") { HasManyThroughCacheable.destroy @existing_entry }
+      context "has_and_belongs_to_many associations" do
+        let(:new_entry) { HasAndBelongsToManyCacheable.create }
+        before :each do
+          @existing_entry = subject.has_and_belongs_to_many_cacheables.create
+          subject.fetch_cache_of(:has_and_belongs_to_many_cacheables) { 'cache' }
+        end
 
-      context "by chain" do
-        it "works" do
-          subject.fetch_cache_of(:dependent_cache) { 'cache' }
-          subject.has_many_through_cacheables.create
-          subject.fetch_cache_of(:dependent_cache) { 'fresh cache' }.should eql('fresh cache')
+        after :each do
+          subject.fetch_cache_of(:has_and_belongs_to_many_cacheables).should be_nil
+          subject.delete_cache_of(:has_and_belongs_to_many_cacheables)
         end
-      end
-    end
 
-    context "of any member on has_and_belongs_to_many" do
-      before :each do
-        @existing_entry = subject.has_and_belongs_to_many_cacheables.create
-        @new_entry = HasAndBelongsToManyCacheable.create
-        subject.fetch_cache_of(:has_and_belongs_to_many_cacheables) { 'cache' }
+        it("on update entry in collection")  { @existing_entry.save }
+        it("on add new entry in collection") { subject.has_and_belongs_to_many_cacheables << new_entry }
+        it("on destroy intem in collection") { subject.has_and_belongs_to_many_cacheables.destroy @existing_entry }
+        it("on destroy intem")               { HasAndBelongsToManyCacheable.destroy @existing_entry }
       end
 
-      after :each do
-        cached_result = subject.fetch_cache_of(:has_and_belongs_to_many_cacheables) { 'fresh cache' }
-        cached_result.should eql('fresh cache')
-        subject.delete_cache_of(:has_and_belongs_to_many_cacheables)
-      end
+      context "paginated content" do
+        it "works" do
+          subject.delete_cache_of :has_many_cacheables
+          subject.fetch_cache_of(:has_many_cacheables, :page => 1) { 'page 1' }.should eql('page 1')
+          subject.fetch_cache_of(:has_many_cacheables, :page => 2) { 'page 2' }.should eql('page 2')
 
-      it("works") { subject.delete_cache_of(:has_and_belongs_to_many_cacheables) }
-      it("on update entry in collection") { @existing_entry.save }
-      it("on add new entry in collection") { subject.has_and_belongs_to_many_cacheables << @new_entry }
-      it("on destroy intem in collection") { subject.has_and_belongs_to_many_cacheables.destroy @existing_entry }
-      it("on destroy intem") { HasAndBelongsToManyCacheable.destroy @existing_entry }
+          subject.delete_cache_of(:has_many_cacheables)
 
-      context "by chain" do
-        it "works" do
-          subject.fetch_cache_of(:dependent_cache) { 'cache' }
-          subject.has_and_belongs_to_many_cacheables.create
-          subject.fetch_cache_of(:dependent_cache) { 'fresh cache' }.should eql('fresh cache')
+          subject.fetch_cache_of(:has_many_cacheables, :page => 1).should be_nil
+          subject.fetch_cache_of(:has_many_cacheables, :page => 2).should be_nil
         end
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cache-machine
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 1
-  - 9
-  version: 0.1.9
+  - 10
+  version: 0.1.10
 platform: ruby
 authors: 
 - Sergei Zinin
@@ -16,7 +16,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-13 00:00:00 Z
+date: 2011-10-22 00:00:00 +08:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -47,9 +48,23 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: activesupport
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -61,11 +76,11 @@ dependencies:
         - 0
         version: 1.0.0
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: jeweler
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -77,7 +92,7 @@ dependencies:
         - 2
         version: 1.6.2
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
 description: A Ruby on Rails framework to support cache management based on explicitely modeled caching dependencies.
 email: kgoslar@partyearth.com
 executables: []
@@ -103,8 +118,10 @@ files:
 - lib/cache_machine/helpers/cache_helper.rb
 - lib/cache_machine/logger.rb
 - lib/cache_machine/railtie.rb
+- spec/fixtures.rb
 - spec/lib/cache_machine_spec.rb
 - spec/spec_helper.rb
+has_rdoc: true
 homepage: http://github.com/partyearth/cache-machine
 licenses: 
 - MIT
@@ -134,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: A Ruby on Rails framework to support cache management based on explicitely modeled caching dependencies.