cached-models 0.0.2 → 0.0.3

data/CHANGELOG

@@ -1,3 +1,61 @@
+*0.0.3 (October 22nd, 2008)*
+
+* Tagged v0.0.3
+
+* Test cases cleanup
+
+* Sugar syntax for AssociationCollection#size
+
+* Use loaded collection, instead of read from cache, when use scoped find form AssociationCollection
+
+  author.posts.find(1) # no cache read for #find
+
+* Use loaded collection, instead of read from cache, when use #size, #empty? and #any? from AssociationCollection. Added support for :uniq option.
+
+* Reduced cache overhead using read instead of fetch for access to AssociationCollection. Enhanced Mocha expectactions.
+
+  # BEFORE
+  author.posts # => cache fetch
+  
+  # NOW
+  author.posts # => cache read
+
+* Fixed typos in CHANGELOG and README
+
+* Don't instantiate ivar when read from AssociationCollection if options[:cached] == true
+
+* Reduced by half cache lookups when read from AssociationCollection
+
+  # BEFORE
+  author.posts # => cache read + cache fetch
+
+  # NOW
+  author.posts # => cache fetch
+
+* Fixed Mocha expectations
+
+* Fixed clear, delete and destroy cases for AssociationCollection
+
+  author.posts.delete(post)
+  author.posts.delete_all
+  author.posts.destroy
+  author.posts.destroy_all
+  author.posts.clear
+
+* Fixed concurrency issues, using Thread#current to store cached_associations instead of ivar
+
+* Make sure tests suite runs in 'test' environment. Introduced SKIP_MOCHA env variable, in order to run tests directly on cache
+
+  $ rake cached_models SKIP_MOCHA=true
+
+* Bypass cache for will_paginate on association collection
+
+  author.posts.paginate(:all, :page => 1, :per_page => 10)
+
+* Make sure habtm and has_one are safely used
+
+
+
 *0.0.2 (October 10th, 2008)*
 
 * Updated README with new installation instructions

data/README

@@ -8,7 +8,7 @@ Check for news and tutorials at the {project home page}[http://www.lucaguidi.com
 
 = Usage
 
-Using Memcached and Rails 2.2.1
+Using Memcached and Rails 2.1.1
 
 Make sure to configure your current environment with:
 

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 
-version = '0.0.2'
+version = '0.0.3'
 repositories = %w( origin rubyforge )
 
 desc 'Default: run unit tests.'

data/about.yml

@@ -1,8 +1,8 @@
 author: Luca Guidi
 email: guidi.luca@gmail.com
 homepage: http://lucaguidi.com/pages/cached_models
-summary: CachedModels provides to your models a transparent approach to use Rails internal caching mechanism.
-description: CachedModels provides to your models a transparent approach to use Rails internal caching mechanism.
+summary: CachedModels provides to your ActiveRecord models a transparent approach to use ActiveSupport caching mechanism.
+description: CachedModels provides to your ActiveRecord models a transparent approach to use ActiveSupport caching mechanism.
 license: MIT
-rails_version: 2.1.1+
-version: 0.0.1
+rails_version: 2.1.0+
+version: 0.0.3

data/cached-models.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name               = "cached-models"
-  s.version            = "0.0.2"
-  s.date               = "2008-10-10"
+  s.version            = "0.0.3"
+  s.date               = "2008-10-22"
   s.summary            = "Transparent caching policy for your models"
   s.author             = "Luca Guidi"
   s.email              = "guidi.luca@gmail.com"
@@ -9,9 +9,8 @@ Gem::Specification.new do |s|
   s.description        = "CachedModels provides to your ActiveRecord models a transparent approach to use ActiveSupport caching mechanism."
   s.has_rdoc           = true
   s.rubyforge_project  = %q{cached-models}
-  s.files              = ["CHANGELOG", "MIT-LICENSE", "README", "Rakefile", "about.yml", "cached-models.gemspec", "init.rb", "install.rb", "lib/activerecord/lib/active_record.rb", "lib/activerecord/lib/active_record/associations.rb", "lib/activerecord/lib/active_record/associations/association_collection.rb", "lib/activerecord/lib/active_record/associations/association_proxy.rb", "lib/activerecord/lib/active_record/associations/has_many_association.rb", "lib/activerecord/lib/active_record/base.rb", "lib/cached-models.rb", "lib/cached_models.rb", "setup.rb", "tasks/cached_models_tasks.rake", "test/active_record/associations/has_many_association_test.rb", "test/active_record/base_test.rb", "test/fixtures/authors.yml", "test/fixtures/blogs.yml", "test/fixtures/comments.yml", "test/fixtures/posts.yml", "test/fixtures/tags.yml", "test/models/author.rb", "test/models/blog.rb", "test/models/comment.rb", "test/models/post.rb", "test/models/tag.rb", "test/test_helper.rb", "uninstall.rb"]
-  s.test_files         = ["test/active_record/associations/has_many_association_test.rb",
-    "test/active_record/base_test.rb"]
+  s.files              = ["CHANGELOG", "MIT-LICENSE", "README", "Rakefile", "about.yml", "cached-models.gemspec", "init.rb", "install.rb", "lib/activerecord/lib/active_record.rb", "lib/activerecord/lib/active_record/associations.rb", "lib/activerecord/lib/active_record/associations/association_collection.rb", "lib/activerecord/lib/active_record/associations/association_proxy.rb", "lib/activerecord/lib/active_record/associations/has_many_association.rb", "lib/activerecord/lib/active_record/base.rb", "lib/cached-models.rb", "lib/cached_models.rb", "setup.rb", "tasks/cached_models_tasks.rake", "test/active_record/associations/has_and_belongs_to_many_association_test.rb", "test/active_record/associations/has_many_association_test.rb", "test/active_record/associations/has_one_association_test.rb", "test/active_record/base_test.rb", "test/fixtures/addresses.yml", "test/fixtures/authors.yml", "test/fixtures/blogs.yml", "test/fixtures/categories.yml", "test/fixtures/categories_posts.yml", "test/fixtures/comments.yml", "test/fixtures/posts.yml", "test/fixtures/tags.yml", "test/models/address.rb", "test/models/author.rb", "test/models/blog.rb", "test/models/category.rb", "test/models/comment.rb", "test/models/post.rb", "test/models/tag.rb", "test/test_helper.rb", "uninstall.rb"]
+  s.test_files         = ["test/active_record/associations/has_and_belongs_to_many_association_test.rb", "test/active_record/associations/has_many_association_test.rb", "test/active_record/associations/has_one_association_test.rb", "test/active_record/base_test.rb"]
   s.extra_rdoc_files   = ['README', 'CHANGELOG']
   
   s.add_dependency("activesupport", ["> 2.1.0"])

data/lib/activerecord/lib/active_record/associations.rb

@@ -251,11 +251,15 @@ module ActiveRecord
         end
 
         if options[:cached]
-          method_name = "belongs_to_after_save_for_#{reflection.name}".to_sym
-          define_method(method_name) do
+          after_save_method_name = "belongs_to_after_save_for_#{reflection.name}".to_sym
+          after_destroy_method_name = "belongs_to_after_destroy_for_#{reflection.name}".to_sym
+          define_method(after_save_method_name) do
             send(reflection.name).expire_cache_for(self.class.name)
           end
-          after_save method_name
+
+          alias_method after_destroy_method_name, after_save_method_name
+          after_save after_save_method_name
+          after_destroy after_destroy_method_name
         end
 
         add_single_associated_validation_callbacks(reflection.name) if options[:validate] == true
@@ -277,19 +281,19 @@ module ActiveRecord
 
           unless association.respond_to?(:loaded?)
             association = association_proxy_class.new(self, reflection)
-            instance_variable_set(ivar, association)
+            if options[:cached]
+              cache_write(reflection, association)
+            else
+              instance_variable_set(ivar, association)
+            end
           end
 
           if force_reload
             association.reload
-            cache_delete(reflection) if options[:cached]
+            cache_write(reflection, association) if options[:cached]
           end
 
-          if options[:cached]
-            cache_fetch(reflection, association)
-          else
-            association
-          end
+          association
         end
 
         method_name = "#{reflection.name.to_s.singularize}_ids"
@@ -306,6 +310,27 @@ module ActiveRecord
         end
       end
 
+      def has_and_belongs_to_many(association_id, options = {}, &extension)
+        reflection = create_has_and_belongs_to_many_reflection(association_id, options, &extension)
+
+        add_multiple_associated_validation_callbacks(reflection.name) unless options[:validate] == false
+        add_multiple_associated_save_callbacks(reflection.name)
+        collection_accessor_methods(reflection, HasAndBelongsToManyAssociation, options)
+
+        # Don't use a before_destroy callback since users' before_destroy
+        # callbacks will be executed after the association is wiped out.
+        old_method = "destroy_without_habtm_shim_for_#{reflection.name}"
+        class_eval <<-end_eval unless method_defined?(old_method)
+          alias_method :#{old_method}, :destroy_without_callbacks
+          def destroy_without_callbacks
+            #{reflection.name}.clear
+            #{old_method}
+          end
+        end_eval
+
+        add_association_callbacks(reflection.name, options)
+      end
+
       def collection_accessor_methods(reflection, association_proxy_class, options, writer = true)
         collection_reader_method(reflection, association_proxy_class, options)
 

data/lib/activerecord/lib/active_record/associations/association_collection.rb

@@ -4,22 +4,18 @@ module ActiveRecord
   module Associations
     class AssociationCollection < AssociationProxy #:nodoc:
       def find(*args)
+        options       = args.extract_options!
         expects_array = args.first.kind_of?(Array)
-        ids           = args.flatten.compact.uniq.map(&:to_i)
+        args          = args.flatten.compact.uniq
 
-        if @reflection.options[:cached]
-          result = @owner.send(:cache_read, @reflection)
-          if result
-            result = result.select { |record| ids.include? record.id }
-            result = expects_array ? result : result.first
-            return result
-          end
+        if @reflection.options[:cached] && !args.first.is_a?(Symbol)
+          result = self.select { |record| args.map(&:to_i).include? record.id }
+          return expects_array ? result : result.first
         end
 
-        options = args.extract_options!
-
         # If using a custom finder_sql, scan the entire collection.
         if @reflection.options[:finder_sql]
+          ids = args.flatten.compact.uniq.map(&:to_i)
           if ids.size == 1
             id = ids.first
             record = load_target.detect { |r| id == r.id }
@@ -72,13 +68,49 @@ module ActiveRecord
         result && self
       end
 
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |record| raise_on_type_mismatch(record) }
+
+        @owner.transaction do
+          records.each { |record| callback(:before_remove, record) }
+
+          old_records = records.reject {|r| r.new_record? }
+          delete_records(old_records) if old_records.any?
+
+          records.each do |record|
+            @target.delete(record)
+            callback(:after_remove, record)
+          end
+        end
+
+        @owner.send(:cache_write, @reflection, self) if @reflection.options[:cached]
+      end
+
+      # Removes all records from this association.  Returns +self+ so method calls may be chained.
+      def clear
+        return self if length.zero? # forces load_target if it hasn't happened already
+
+        if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
+          destroy_all
+        else
+          delete_all
+        end
+
+        @owner.send(:cache_write, @reflection, self) if @reflection.options[:cached]
+
+        self
+      end
+
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
       # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
       # and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
       def size
         if @reflection.options[:cached]
-          result = @owner.send(:cache_read, @reflection)
-          return result.to_ary.size if result
+          returning result = self.to_ary do
+            @reflection.options[:uniq] ? result.uniq.size : result.size
+          end
         end
 
         if @owner.new_record? || (loaded? && !@reflection.options[:uniq])

data/lib/activerecord/lib/active_record/base.rb

@@ -36,7 +36,10 @@ module ActiveRecord
       end
 
       def cache_write(reflection, value)
-        cached_associations[reflection.name] = rails_cache.write(reflection_cache_key(reflection), value)
+        # This is a workaround for:
+        # http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/1239-railscachewrite-returns-false-with-memcachestore
+        rails_cache.write(reflection_cache_key(reflection), value)
+        cached_associations[reflection.name] = true
       end
 
       def cache_delete(reflection)
@@ -63,7 +66,8 @@ module ActiveRecord
       end
       
       def cached_associations
-        @cached_associations ||= {}
+        cached_associations = (Thread.current[:cached_associations] ||= {})
+        cached_associations[cache_key] ||= {}
       end
   end
-end
+end

data/tasks/cached_models_tasks.rake

@@ -1,9 +1,11 @@
+# RAILS_ENV = "test"
+
 require 'rubygems'
 require 'active_record'
 require 'active_record/fixtures'
 
 path_to_fixtures = File.dirname(__FILE__) + '/../test/fixtures'
-fixtures = %w( authors blogs posts comments tags )
+fixtures = %w( addresses authors blogs posts categories categories_posts comments tags )
 
 desc 'Run default task (test)'
 task :cached_models => 'cached_models:test'
@@ -21,6 +23,17 @@ namespace :cached_models do
   desc 'Create CachedModels test database tables'
   task :create_tables => :environment do
     ActiveRecord::Schema.define do
+      create_table :addresses, :force => true do |t|
+        t.integer :author_id
+        t.string :street
+        t.string :zip
+        t.string :city
+        t.string :state
+        t.string :country
+
+        t.timestamps
+      end
+
       create_table :authors, :force => true do |t|
         t.integer :blog_id
         t.string  :first_name
@@ -32,7 +45,7 @@ namespace :cached_models do
       
       create_table :blogs, :force => true do |t|
         t.string :title
-        
+
         t.timestamps
       end
       
@@ -46,19 +59,30 @@ namespace :cached_models do
         t.timestamps
       end
       
+      create_table :categories, :force => true do |t|
+        t.string :name
+
+        t.timestamps
+      end
+
+      create_table :categories_posts, :force => true do |t|
+        t.integer :category_id
+        t.integer :post_id
+      end
+
       create_table :comments, :force => true do |t|
         t.integer :post_id
         t.string :email
         t.text :text
-        
+
         t.timestamps
       end
-      
+
       create_table :tags, :force => true do |t|
         t.integer :taggable_id
         t.string :taggable_type
         t.string :name
-        
+
         t.timestamps
       end
     end
@@ -66,10 +90,13 @@ namespace :cached_models do
 
   desc 'Drops CachedModels test database tables'
   task :drop_tables => :environment do
+    ActiveRecord::Base.connection.drop_table :addresses
     ActiveRecord::Base.connection.drop_table :authors
     ActiveRecord::Base.connection.drop_table :posts
     ActiveRecord::Base.connection.drop_table :comments
     ActiveRecord::Base.connection.drop_table :tags
+    ActiveRecord::Base.connection.drop_table :categories
+    ActiveRecord::Base.connection.drop_table :categories_posts
   end
 
   desc 'Load fixtures'

data/test/active_record/associations/has_and_belongs_to_many_association_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class HasAndBelongsToManyAssociationTest < Test::Unit::TestCase
+  include ActiveRecord::Associations
+  
+  def test_should_not_raise_exception
+    assert_nothing_raised ArgumentError do
+      posts(:welcome).categories
+      categories(:announcements).posts
+    end
+  end
+end

data/test/active_record/associations/has_many_association_test.rb

@@ -10,7 +10,7 @@ class HasManyAssociationTest < Test::Unit::TestCase
 
   uses_mocha 'HasManyAssociationTest' do
     def test_should_always_use_cache_for_all_instances_which_reference_the_same_record
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
       expected = authors(:luca).cached_posts
       actual = Author.first.cached_posts
       assert_equal expected, actual
@@ -20,26 +20,10 @@ class HasManyAssociationTest < Test::Unit::TestCase
       author = authors(:luca)
       old_cache_key = author.cache_key
 
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
       cache.expects(:delete).with("#{cache_key}/cached_posts").returns true
-
-      author.cached_posts # force cache loading
-      author.update_attributes :first_name => author.first_name.upcase
-
-      # assert_not_equal old_cache_key, author.cache_key
-      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
-    end
-
-    def test_should_not_expire_cache_on_update_on_missing_updated_at
-      author = authors(:luca)
-      old_cache_key = author.cache_key
-
-      author.stubs(:[]).with(:updated_at).returns nil
-      author.expects(:[]).with('blog_id').returns author.blog_id
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      cache.expects(:delete).with("#{cache_key}/cached_posts").never
-      cache.expects(:delete).with("#{cache_key}/cached_comments").never
-      cache.expects(:delete).with("#{cache_key}/cached_posts_with_comments").never
+      cache.expects(:delete).with("#{cache_key}/cached_comments").returns true
+      cache.expects(:delete).with("#{cache_key}/cached_posts_with_comments").returns true
 
       author.cached_posts # force cache loading
       author.update_attributes :first_name => author.first_name.upcase
@@ -49,90 +33,70 @@ class HasManyAssociationTest < Test::Unit::TestCase
     end
 
     def test_should_use_cache_when_find_with_scope
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
       post = authors(:luca).cached_posts.find(posts(:welcome).id)
       assert_equal posts(:welcome), post
     end
 
     def test_should_use_cache_when_find_with_scope_using_multiple_ids
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
       ids = posts_by_author(:luca).map(&:id)
-      assert_equal posts_by_author(:luca),
-        authors(:luca).cached_posts.find(ids)
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts.find(ids)
     end
 
     def test_should_use_cache_when_fetch_first_from_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
-
-      assert_equal [ posts_by_author(:luca).first ],
-        authors(:luca).cached_posts.first(1)
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal [ posts_by_author(:luca).first ], authors(:luca).cached_posts.first(1)
     end
 
     def test_should_use_cache_when_fetch_last_from_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
-
-      assert_equal [ posts_by_author(:luca).last ],
-        authors(:luca).cached_posts.last(1)
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal [ posts_by_author(:luca).last ], authors(:luca).cached_posts.last(1)
     end
 
-    def test_should_use_cache_when_reset_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-
+    def test_should_unload_cache_when_reset_collection
+      cache.expects(:read).with("#{cache_key}/cached_posts").times(2).returns association_proxy
       assert_false authors(:luca).cached_posts.reset
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
-    def test_should_expire_cache_when_delete_all_elements_from_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
-
-      authors(:luca).cached_posts.delete_all
-      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
-    end
-
-    def test_should_expire_cache_when_destroy_all_elements_from_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
-
-      authors(:luca).cached_posts.destroy_all
-      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
-    end
-
-    def test_should_use_cache_on_collection_sum
-      cache.expects(:fetch).with("#{blogs(:weblog).cache_key}/authors").returns authors_association_proxy
-
-      assert_equal authors_by_blog(:weblog).map(&:age).sum,
-        blogs(:weblog).authors.sum(:age)
+    def test_should_not_use_cache_on_collection_sum
+      # calculations aren't supported for now
+      cache.expects(:read).with("#{blogs(:weblog).cache_key}/authors").never
+      assert_equal authors_by_blog(:weblog).map(&:age).sum, blogs(:weblog).authors.sum(:age)
     end
 
     def test_should_not_use_cache_on_false_cached_option
-      cache.expects(:fetch).never
+      cache.expects(:read).never
       authors(:luca).posts
       authors(:luca).posts(true) # force reload
     end
     
     def test_should_cache_associated_objects
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
-
+      cache.expects(:read).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
       posts = authors(:luca).cached_posts
       assert_equal posts, authors(:luca).cached_posts
     end
+
+    def test_should_safely_use_pagination
+      # pagination for now bypass cache and using database.
+      # the expectation is due to #cached_posts invocation.
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      posts = authors(:luca).cached_posts.paginate(:all, :page => 1, :per_page => 1)
+      assert_equal [ posts_by_author(:luca).first ], posts
+    end
     
     def test_should_reload_association_and_refresh_the_cache_on_force_reload
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
-
+      cache.expects(:read).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
+      cache.expects(:write).times(3).returns true
       reloaded_posts = authors(:luca).cached_posts(true)
       assert_equal reloaded_posts, authors(:luca).cached_posts
     end
     
     def test_should_cache_associated_ids
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      cache.expects(:fetch).with("#{cache_key}/cached_post_ids").times(2).returns(posts_by_author(:luca).map(&:id))
-      ids = authors(:luca).cached_post_ids
+      ids = posts_by_author(:luca).map(&:id)
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns(posts_by_author(:luca))
+      cache.expects(:fetch).with("#{cache_key}/cached_post_ids").returns ids
       assert_equal ids, authors(:luca).cached_post_ids
     end
     
@@ -142,94 +106,67 @@ class HasManyAssociationTest < Test::Unit::TestCase
     end
     
     def test_should_cache_all_eager_loaded_objects
-      cache.expects(:fetch).with("#{cache_key}/cached_posts_with_comments").times(2).returns(posts_by_author(:luca, true))
+      cache.expects(:read).with("#{cache_key}/cached_posts_with_comments").returns(posts_by_author(:luca, true))
       posts = authors(:luca).cached_posts_with_comments
       assert_equal posts, authors(:luca).cached_posts_with_comments
     end
     
     def test_should_not_cache_eager_loaded_objects_on_false_cached_option
-      cache.expects(:fetch).never
+      cache.expects(:read).never
       authors(:luca).posts_with_comments
     end
     
     def test_should_cache_polymorphic_associations
-      cache.expects(:fetch).with("#{posts(:cached_models).cache_key}/cached_tags").times(2).returns(tags_by_post(:cached_models))
+      cache.expects(:read).with("#{posts(:cached_models).cache_key}/cached_tags").returns(tags_by_post(:cached_models))
       tags = posts(:cached_models).cached_tags
       assert_equal tags, posts(:cached_models).cached_tags
     end
     
     def test_should_not_cache_polymorphic_associations_on_false_cached_option
-      cache.expects(:fetch).never
+      cache.expects(:read).never
       posts(:cached_models).tags
     end
     
     def test_should_cache_habtm_associations
-      cache.expects(:fetch).with("#{cache_key}/cached_comments").times(2).returns(comments_by_author(:luca))
+      cache.expects(:read).with("#{cache_key}/cached_comments").returns(comments_by_author(:luca))
       comments = authors(:luca).cached_comments
       assert_equal comments, authors(:luca).cached_comments
     end
     
     def test_should_not_cache_habtm_associations_on_false_cached_option
-      cache.expects(:fetch).never
+      cache.expects(:read).never
       authors(:luca).comments
     end
 
     def test_should_refresh_cache_when_associated_elements_change
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      
+      cache.expects(:read).with("#{cache_key}/cached_posts").never
+      cache.expects(:delete).with("#{cache_key}/cached_posts").returns true
       post = authors(:luca).cached_posts.last # force cache loading and fetch a post
       post.update_attributes :title => 'Cached Models!'
-      
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
     def test_should_refresh_cache_when_pushing_element_to_association
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:read).with("#{cache_key}/cached_posts").times(2).returns association_proxy
       cache.expects(:write).with("#{cache_key}/cached_posts", association_proxy).returns true
-
       post = create_post :author_id => nil
       authors(:luca).cached_posts << post
-
-      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
-    end
-
-    def test_should_refresh_caches_when_pushing_element_to_association_belonging_to_another_model
-      cache.expects(:fetch).with("#{authors(:chuck).cache_key}/cached_posts").times(2).returns association_proxy(:chuck)
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-
-      post = authors(:chuck).cached_posts.last
-      authors(:luca).cached_posts << post
-
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
-      assert_equal posts_by_author(:chuck), authors(:chuck).cached_posts
-    end
-
-    def test_should_refresh_caches_when_pushing_element_to_polymorphic_association_belonging_to_another_model
-      cache.expects(:fetch).with("#{posts(:welcome).cache_key}/cached_tags").times(2).returns tags_association_proxy
-      cache.expects(:fetch).with("#{posts(:cached_models).cache_key}/cached_tags").times(2).returns tags_association_proxy(:cached_models)
-      tag = posts(:welcome).cached_tags.last
-
-      posts(:cached_models).cached_tags << tag
-
-      # NOTE for some weird reason the assertion fails, even if the collections are equals.
-      # I forced the comparision between the ids.
-      assert_equal tags_by_post(:cached_models).map(&:id).sort,
-        posts(:cached_models).cached_tags.map(&:id).sort
-      assert_equal tags_by_post(:welcome), posts(:welcome).cached_tags
     end
 
     def test_should_not_use_cache_when_pushing_element_to_association_on_false_cached_option
       cache.expects(:write).never
-
       post = create_post :author_id => nil
       authors(:luca).posts << post
     end
 
     def test_should_not_use_cache_when_pushing_element_to_association_belonging_to_anotner_model_on_false_cached_option
       cache.expects(:delete).with("#{blogs(:weblog).cache_key}/posts").never
+      cache.expects(:delete).with("#{cache_key}/cached_posts_with_comments").never
+      cache.expects(:delete).with("#{cache_key}/cached_posts").returns true
+      cache.expects(:delete).with("#{posts(:cached_models).cache_key}/cached_tags").returns true
       post = blogs(:weblog).posts.last
       blogs(:blog).posts << post
-
       assert_equal posts_by_blog(:blog), blogs(:blog).posts
     end
 
@@ -237,109 +174,126 @@ class HasManyAssociationTest < Test::Unit::TestCase
       cache.expects(:delete).never
       tag = posts(:welcome).tags.last
       posts(:cached_models).tags << tag
-      
       assert_equal tags_by_post(:cached_models), posts(:cached_models).tags
     end
-    
-    def test_should_update_cache_when_pushing_element_with_build
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
 
+    def test_should_update_cache_when_directly_assigning_a_new_collection
+      posts = [ posts_by_author(:luca).first ]
+      cache.expects(:read).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      authors(:luca).cached_posts = posts
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_use_cache_for_collection_size
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal posts_by_author(:luca).size, authors(:luca).cached_posts.size
+    end
+
+    def test_should_use_cache_and_return_uniq_records_for_collection_size_on_uniq_option
+      cache.expects(:read).with("#{cache_key}/uniq_cached_posts").never # wuh?!
+      assert_equal posts_by_author(:luca).size, authors(:luca).uniq_cached_posts.size
+    end
+
+    def test_should_use_cache_for_collection_length
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal posts_by_author(:luca).length, authors(:luca).cached_posts.length
+    end
+
+    def test_should_use_cache_for_collection_empty
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal posts_by_author(:luca).empty?, authors(:luca).cached_posts.empty?
+    end
+
+    def test_should_use_cache_for_collection_any
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      assert_equal posts_by_author(:luca).any?, authors(:luca).cached_posts.any?
+    end
+
+    def test_should_use_cache_for_collection_include
+      cache.expects(:read).with("#{cache_key}/cached_posts").returns association_proxy
+      post = posts_by_author(:luca).first
+      assert authors(:luca).cached_posts.include?(post)
+    end
+  end
+
+  uses_memcached 'HasManyAssociationTest' do
+    def test_should_refresh_caches_when_pushing_element_to_association_belonging_to_another_model
+      post = authors(:chuck).cached_posts.last
+      authors(:luca).cached_posts << post
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+      assert_equal posts_by_author(:chuck), authors(:chuck).cached_posts
+    end
+
+    def test_should_refresh_caches_when_pushing_element_to_polymorphic_association_belonging_to_another_model
+      tag = posts(:welcome).cached_tags.last
+      posts(:cached_models).cached_tags << tag
+
+      # NOTE for some weird reason the assertion fails, even if the collections are equals.
+      # I forced the comparision between the ids.
+      assert_equal tags_by_post(:cached_models).map(&:id).sort,
+        posts(:cached_models).cached_tags.map(&:id).sort
+    end
+
+    def test_should_update_cache_when_pushing_element_with_build
       author = authors(:luca)
       post = author.cached_posts.build post_options
       post.save
-      
       assert_equal posts_by_author(:luca), author.cached_posts
     end
-    
-    def test_should_update_cache_when_pushing_element_with_create
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
 
+    def test_should_update_cache_when_pushing_element_with_create
       author = authors(:luca)
       author.cached_posts.create post_options(:title => "CM Overview")
-      
       assert_equal posts_by_author(:luca), author.cached_posts
     end
 
     def test_should_update_cache_when_pushing_element_with_create_bang_method
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-
       author = authors(:luca)
       author.cached_posts.create! post_options(:title => "CM Overview!!")
-
       assert_equal posts_by_author(:luca), author.cached_posts
     end
 
-    def test_should_update_cache_when_deleting_element_from_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+    def test_should_expire_cache_when_delete_all_elements_from_collection
+      authors(:luca).cached_posts.delete_all
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
 
-      authors(:luca).cached_posts.delete(posts_by_author(:luca).first)
+    def test_should_expire_cache_when_destroy_all_elements_from_collection
+      authors(:luca).cached_posts.destroy_all
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
     def test_should_update_cache_when_clearing_collection
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      authors(:luca).cached_posts.clear
-      
+      authors(:luca).cached_posts.clear      
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
     def test_should_update_cache_when_clearing_collection_with_dependent_destroy_option
-      cache.expects(:fetch).with("#{cache_key}/cached_dependent_posts").times(2).returns association_proxy
       authors(:luca).cached_dependent_posts.clear
-
       assert_equal posts_by_author(:luca), authors(:luca).cached_dependent_posts
     end
-    
-    def test_should_update_cache_when_directly_assigning_a_new_collection
-      posts = [ posts_by_author(:luca).first ]
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-      authors(:luca).cached_posts = posts
 
+    def test_should_update_cache_when_deleting_element_from_collection
+      authors(:luca).cached_posts.delete(posts_by_author(:luca).first)
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
     def test_should_update_cache_when_replace_collection
       post = create_post; post.save
       posts = [ posts_by_author(:luca).first, post ]
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
       authors(:luca).cached_posts.replace(posts)
-
       assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
 
-    def test_should_use_cache_for_collection_size
-      # cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
-
-      assert_equal posts_by_author(:luca).size,
-        authors(:luca).cached_posts.size
-    end
-
-    def test_should_use_cache_for_collection_length
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-
-      assert_equal posts_by_author(:luca).length,
-        authors(:luca).cached_posts.length
-    end
-
-    def test_should_use_cache_for_collection_empty
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-
-      assert_equal posts_by_author(:luca).empty?,
-        authors(:luca).cached_posts.empty?
-    end
-
-    def test_should_use_cache_for_collection_any
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
-
-      assert_equal posts_by_author(:luca).any?,
-        authors(:luca).cached_posts.any?
-    end
+    def test_should_not_expire_cache_on_update_on_missing_updated_at
+      author = authors(:luca)
+      old_cache_key = author.cache_key
 
-    def test_should_use_cache_for_collection_include
-      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+      author.cached_posts # force cache loading
+      author.update_attributes :first_name => author.first_name.upcase
 
-      post = posts_by_author(:luca).first
-      assert authors(:luca).cached_posts.include?(post)
+      # assert_not_equal old_cache_key, author.cache_key
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
     end
   end
 

data/test/active_record/associations/has_one_association_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class HasOneAssociationTest < Test::Unit::TestCase
+  include ActiveRecord::Associations
+
+  def test_should_not_raise_exception_when_use_has_one
+    assert_nothing_raised ArgumentError do
+      authors(:luca).address
+      addresses(:luca).author
+    end
+  end
+end

data/test/fixtures/addresses.yml

@@ -0,0 +1,7 @@
+luca:
+  author_id: 1
+  street: 1 infinite loop
+  zip: 95014
+  city: Cupertino
+  state: California
+  country: United States

data/test/fixtures/categories.yml

@@ -0,0 +1,3 @@
+announcements:
+  id: 1
+  name: Announcements

data/test/fixtures/categories_posts.yml

@@ -0,0 +1,3 @@
+welcome_announcements:
+  category_id: 1
+  post_id: 1

data/test/models/address.rb

@@ -0,0 +1,3 @@
+class Address < ActiveRecord::Base
+  belongs_to :author
+end

data/test/models/author.rb

@@ -2,9 +2,11 @@ class Author < ActiveRecord::Base
   belongs_to :blog, :cached => true
   has_many :posts
   has_many :cached_posts, :cached => true, :class_name => 'Post'
+  has_many :uniq_cached_posts, :cached => true, :class_name => 'Post', :uniq => true
   has_many :cached_dependent_posts, :cached => true, :class_name => 'Post', :dependent => :destroy
   has_many :posts_with_comments, :class_name => 'Post', :include => :comments
   has_many :cached_posts_with_comments, :class_name => 'Post', :include => :comments, :cached => true
   has_many :comments, :through => :posts
   has_many :cached_comments, :through => :posts, :source => :comments, :cached => true
+  has_one :address
 end

data/test/models/category.rb

@@ -0,0 +1,3 @@
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+end

data/test/models/post.rb

@@ -4,4 +4,5 @@ class Post < ActiveRecord::Base
   has_many :comments
   has_many :tags, :as => :taggable
   has_many :cached_tags, :as => :taggable, :class_name => 'Tag', :cached => true
+  has_and_belongs_to_many :categories
 end

data/test/test_helper.rb

@@ -1,4 +1,4 @@
-ENV["RAILS_ENV"] = "test"
+RAILS_ENV = "test" unless defined? RAILS_ENV
 
 require 'test/unit'
 require 'rubygems'
@@ -17,6 +17,28 @@ require 'post'
 Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures"
 ActionController::IntegrationTest.fixture_path = Test::Unit::TestCase.fixture_path
 
+module WillPaginate #:nodoc:
+  def paginate(*args)
+    options = args.extract_options!
+    current_page, per_page = options[:page], options[:per_page]
+    offset = (current_page - 1) * per_page
+
+    count_options = options.except :page, :per_page
+    find_options = count_options.except(:count).update(:offset => offset, :limit => per_page) 
+
+    args << find_options
+    @reflection.klass.find(*args)
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class AssociationCollection < AssociationProxy #:nodoc:
+      include WillPaginate
+    end
+  end
+end
+
 class Test::Unit::TestCase
   self.use_transactional_fixtures = true
   self.use_instantiated_fixtures  = false
@@ -40,3 +62,27 @@ def uses_mocha(description)
 rescue LoadError
   $stderr.puts "Skipping #{description} tests. `gem install mocha` and try again."
 end
+
+def uses_memcached(description)
+  require 'memcache'
+  MemCache.new('localhost').stats
+  yield
+rescue MemCache::MemCacheError
+  $stderr.puts "Skipping #{description} tests. Start memcached and try again."
+end
+
+if ENV['SKIP_MOCHA'] == 'true'
+  class Object
+    def expects(*args)
+      self
+    end
+
+    def method_missing(method_name, *args, &block)
+    end
+  end
+
+  class NilClass
+    def method_missing(method_name, *args, &block)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cached-models
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Luca Guidi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-10 00:00:00 +02:00
+date: 2008-10-22 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,15 +60,22 @@ files:
 - lib/cached_models.rb
 - setup.rb
 - tasks/cached_models_tasks.rake
+- test/active_record/associations/has_and_belongs_to_many_association_test.rb
 - test/active_record/associations/has_many_association_test.rb
+- test/active_record/associations/has_one_association_test.rb
 - test/active_record/base_test.rb
+- test/fixtures/addresses.yml
 - test/fixtures/authors.yml
 - test/fixtures/blogs.yml
+- test/fixtures/categories.yml
+- test/fixtures/categories_posts.yml
 - test/fixtures/comments.yml
 - test/fixtures/posts.yml
 - test/fixtures/tags.yml
+- test/models/address.rb
 - test/models/author.rb
 - test/models/blog.rb
+- test/models/category.rb
 - test/models/comment.rb
 - test/models/post.rb
 - test/models/tag.rb
@@ -101,5 +108,7 @@ signing_key:
 specification_version: 2
 summary: Transparent caching policy for your models
 test_files: 
+- test/active_record/associations/has_and_belongs_to_many_association_test.rb
 - test/active_record/associations/has_many_association_test.rb
+- test/active_record/associations/has_one_association_test.rb
 - test/active_record/base_test.rb