kasket 0.8.1 → 0.8.2

data/kasket.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{kasket}
-  s.version = "0.8.1"
+  s.version = "0.8.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mick Staugaard", "Eric Chapweske"]
-  s.date = %q{2010-08-24}
+  s.date = %q{2010-08-31}
   s.description = %q{puts a cap on your queries}
   s.email = %q{mick@staugaard.com}
   s.extra_rdoc_files = [

data/lib/kasket.rb

@@ -14,7 +14,7 @@ module Kasket
   class Version
     MAJOR = 0
     MINOR = 8
-    PATCH = 1
+    PATCH = 2
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 
@@ -29,9 +29,18 @@ module Kasket
     ActiveRecord::Associations::HasOneThroughAssociation.send(:include, Kasket::ReloadAssociationMixin)
   end
 
+  def self.cache_store=(options)
+    @cache_store = ActiveSupport::Cache.lookup_store(options)
+  end
+
+  def self.cache
+    @cache_store ||= Rails.cache
+  end
+
   def clear_local
-    if Rails.cache.respond_to?(:with_local_cache)
-      Rails.cache.send(:local_cache).try(:clear)
+    if Kasket.cache.respond_to?(:with_local_cache)
+      Kasket.cache.send(:local_cache).try(:clear)
     end
   end
 end
+

data/lib/kasket/read_mixin.rb

@@ -13,7 +13,7 @@ module Kasket
         if query[:key].is_a?(Array)
           find_by_sql_with_kasket_on_id_array(sql, query)
         else
-          if value = Rails.cache.read(query[:key])
+          if value = Kasket.cache.read(query[:key])
             Array.wrap(value).collect { |record| instantiate(record.dup) }
           else
             store_in_kasket(query[:key], find_by_sql_without_kasket(sql))
@@ -25,7 +25,7 @@ module Kasket
     end
 
     def find_by_sql_with_kasket_on_id_array(sql, query)
-      key_value_map = Rails.cache.read_multi(*query[:key])
+      key_value_map = Kasket.cache.read_multi(*query[:key])
       missing_ids = []
 
       query[:key].each do |key|
@@ -50,18 +50,19 @@ module Kasket
 
       def store_in_kasket(key, records)
         if records.size == 1
-          Rails.cache.write(key, records.first.instance_variable_get(:@attributes).dup)
+          Kasket.cache.write(key, records.first.instance_variable_get(:@attributes).dup)
         elsif records.size <= Kasket::CONFIGURATION[:max_collection_size]
-          keys = records.map do |record|
-            key = kasket_key_for_id(record.id)
-            Rails.cache.write(key, record.instance_variable_get(:@attributes).dup)
-            key
+          instance_keys = records.map do |record|
+            instance_key = kasket_key_for_id(record.id)
+            Kasket.cache.write(instance_key, record.instance_variable_get(:@attributes).dup)
+            instance_key
           end
 
-          Rails.cache.write(key, keys) if key.is_a?(String)
+          Kasket.cache.write(key, instance_keys) if key.is_a?(String)
         end
         records
       end
 
   end
 end
+

data/lib/kasket/write_mixin.rb

@@ -4,7 +4,7 @@ module Kasket
     module ClassMethods
       def remove_from_kasket(ids)
         Array(ids).each do |id|
-          Rails.cache.delete(kasket_key_for_id(id))
+          Kasket.cache.delete(kasket_key_for_id(id))
         end
       end
 
@@ -14,8 +14,8 @@ module Kasket
       end
 
       def transaction_with_kasket_disabled(*args)
-        without_kasket do 
-          transaction_without_kasket_disabled(*args) { yield } 
+        without_kasket do
+          transaction_without_kasket_disabled(*args) { yield }
         end
       end
     end
@@ -27,7 +27,7 @@ module Kasket
 
       def store_in_kasket
         if !readonly? && kasket_key
-          Rails.cache.write(kasket_key, @attributes.dup)
+          Kasket.cache.write(kasket_key, @attributes.dup)
         end
       end
 
@@ -54,7 +54,7 @@ module Kasket
 
       def clear_kasket_indices
         kasket_keys.each do |key|
-          Rails.cache.delete(key)
+          Kasket.cache.delete(key)
         end
       end
 
@@ -72,7 +72,7 @@ module Kasket
       model_class.after_destroy :clear_kasket_indices
 
       model_class.alias_method_chain :reload, :kasket_clearing
-   
+
 
       class << model_class
         alias_method_chain :transaction, :kasket_disabled
@@ -81,3 +81,4 @@ module Kasket
     end
   end
 end
+

data/test/cache_expiry_test.rb

@@ -8,20 +8,20 @@ class CacheExpiryTest < ActiveSupport::TestCase
       post = Post.first
       @post = Post.find(post.id)
 
-      assert(Rails.cache.read(@post.kasket_key))
+      assert(Kasket.cache.read(@post.kasket_key))
     end
 
     should "be removed from cache when deleted" do
       @post.destroy
-      assert_nil(Rails.cache.read(@post.kasket_key))
+      assert_nil(Kasket.cache.read(@post.kasket_key))
     end
 
     should "clear all indices for instance when deleted" do
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
-      Rails.cache.expects(:delete).never
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
+      Kasket.cache.expects(:delete).never
 
       @post.destroy
     end
@@ -29,17 +29,17 @@ class CacheExpiryTest < ActiveSupport::TestCase
     should "be removed from cache when updated" do
       @post.title = "new_title"
       @post.save
-      assert_nil(Rails.cache.read(@post.kasket_key))
+      assert_nil(Kasket.cache.read(@post.kasket_key))
     end
 
     should "clear all indices for instance when updated" do
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'/first")
-      Rails.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
-      Rails.cache.expects(:delete).never
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "id=#{@post.id}")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='#{@post.title}'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "title='new_title'/first")
+      Kasket.cache.expects(:delete).with(Post.kasket_key_prefix + "blog_id=#{@post.blog_id}/id=#{@post.id}")
+      Kasket.cache.expects(:delete).never
 
       @post.title = "new_title"
       @post.save

data/test/dirty_test.rb

@@ -7,10 +7,10 @@ class DirtyTest < ActiveSupport::TestCase
     post = Post.first
 
     Post.cache { pots = Post.find(post.id) }
-    assert(Rails.cache.read(post.kasket_key))
+    assert(Kasket.cache.read(post.kasket_key))
 
     post.make_dirty!
 
-    assert_nil(Rails.cache.read(post.kasket_key))
+    assert_nil(Kasket.cache.read(post.kasket_key))
   end
 end

data/test/find_one_test.rb

@@ -5,36 +5,36 @@ class FindOneTest < ActiveSupport::TestCase
 
   should "cache find(id) calls" do
     post = Post.first
-    Rails.cache.write(post.kasket_key, nil)
+    Kasket.cache.write(post.kasket_key, nil)
     assert_equal(post, Post.find(post.id))
-    assert(Rails.cache.read(post.kasket_key))
+    assert(Kasket.cache.read(post.kasket_key))
     Post.connection.expects(:select_all).never
     assert_equal(post, Post.find(post.id))
   end
 
   should "only cache on indexed attributes" do
-    Rails.cache.expects(:read).twice
+    Kasket.cache.expects(:read).twice
     Post.find_by_id(1)
     Post.find_by_id(1, :conditions => {:blog_id => 2})
 
-    Rails.cache.expects(:read).never
+    Kasket.cache.expects(:read).never
     Post.first :conditions => {:blog_id => 2}
   end
 
   should "not use cache when using the :select option" do
     post = Post.first
-    assert_nil(Rails.cache.read(post.kasket_key))
+    assert_nil(Kasket.cache.read(post.kasket_key))
 
     Post.find(post.id, :select => 'title')
-    assert_nil(Rails.cache.read(post.kasket_key))
+    assert_nil(Kasket.cache.read(post.kasket_key))
 
     Post.find(post.id)
-    assert(Rails.cache.read(post.kasket_key))
+    assert(Kasket.cache.read(post.kasket_key))
 
-    Rails.cache.expects(:read)
+    Kasket.cache.expects(:read)
     Post.find(post.id, :select => nil)
 
-    Rails.cache.expects(:read).never
+    Kasket.cache.expects(:read).never
     Post.find(post.id, :select => 'title')
   end
 
@@ -42,7 +42,7 @@ class FindOneTest < ActiveSupport::TestCase
     post = Post.find(Post.first.id)
     other_blog = Blog.first(:conditions => "id != #{post.blog_id}")
 
-    assert(Rails.cache.read(post.kasket_key))
+    assert(Kasket.cache.read(post.kasket_key))
 
     assert_raise(ActiveRecord::RecordNotFound) do
       other_blog.posts.find(post.id)

data/test/find_some_test.rb

@@ -7,13 +7,13 @@ class FindSomeTest < ActiveSupport::TestCase
     post1 = Post.first
     post2 = Post.last
 
-    assert_nil(Rails.cache.read(post1.kasket_key))
-    assert_nil(Rails.cache.read(post2.kasket_key))
+    assert_nil(Kasket.cache.read(post1.kasket_key))
+    assert_nil(Kasket.cache.read(post2.kasket_key))
 
     Post.find(post1.id, post2.id)
 
-    assert(Rails.cache.read(post1.kasket_key))
-    assert(Rails.cache.read(post2.kasket_key))
+    assert(Kasket.cache.read(post1.kasket_key))
+    assert(Kasket.cache.read(post2.kasket_key))
     Post.connection.expects(:select_all).never
     Post.find(post1.id, post2.id)
   end
@@ -22,8 +22,8 @@ class FindSomeTest < ActiveSupport::TestCase
     post1 = Post.first
     post2 = Post.last
     assert_equal(post1, Post.find(post1.id))
-    assert(Rails.cache.read(post1.kasket_key))
-    assert_nil(Rails.cache.read(post2.kasket_key))
+    assert(Kasket.cache.read(post1.kasket_key))
+    assert_nil(Kasket.cache.read(post2.kasket_key))
 
     Post.expects(:find_by_sql_without_kasket).with("SELECT * FROM \"posts\" WHERE (\"posts\".\"id\" = #{post2.id}) ").returns([post2])
     found_posts = Post.find(post1.id, post2.id)

data/test/helper.rb

@@ -32,7 +32,7 @@ class ActiveSupport::TestCase
 
   setup :clear_cache
   def clear_cache
-    Rails.cache.clear
+    Kasket.cache.clear
   end
 end
 

data/test/read_mixin_test.rb

@@ -4,31 +4,31 @@ class ReadMixinTest < ActiveSupport::TestCase
 
   context "find by sql with kasket" do
     setup do
-      @database_results = [ { 'id' => 1, 'title' => 'Hello' }, { 'id' => 2, 'title' => 'World' } ]
+      @database_results = [ { 'id' => 1, 'title' => 'Hello' } ]
       @records = @database_results.map { |r| Post.send(:instantiate, r) }
       Post.stubs(:find_by_sql_without_kasket).returns(@records)
     end
 
     should "handle unsupported sql" do
-      Rails.cache.expects(:read).never
-      Rails.cache.expects(:write).never
+      Kasket.cache.expects(:read).never
+      Kasket.cache.expects(:write).never
       assert_equal @records, Post.find_by_sql_with_kasket('select unsupported sql statement')
     end
 
     should "read results" do
-      Rails.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @database_results.first)
+      Kasket.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @database_results.first)
       assert_equal [ @records.first ], Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)')
     end
 
     should "store results in kasket" do
       Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)')
 
-      assert_equal @database_results.first, Rails.cache.read("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1")
+      assert_equal @database_results.first, Kasket.cache.read("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1")
     end
 
     context "modifying results" do
       setup do
-        Rails.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @database_results.first)
+        Kasket.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @database_results.first)
         @record = Post.find_by_sql('SELECT * FROM `posts` WHERE (id = 1)').first
         @record.instance_variable_get(:@attributes)['id'] = 3
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kasket
 version: !ruby/object:Gem::Version 
-  hash: 61
+  hash: 59
   prerelease: false
   segments: 
   - 0
   - 8
-  - 1
-  version: 0.8.1
+  - 2
+  version: 0.8.2
 platform: ruby
 authors: 
 - Mick Staugaard
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-24 00:00:00 -07:00
+date: 2010-08-31 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency