kasket 0.6.4 → 0.7.0

data/lib/kasket.rb

@@ -5,7 +5,6 @@ require 'active_support'
 require 'kasket/active_record_patches'
 
 module Kasket
-  autoload :Cache, 'kasket/cache'
   autoload :ConfigurationMixin, 'kasket/configuration_mixin'
   autoload :ReloadAssociationMixin, 'kasket/reload_association_mixin'
   autoload :RackMiddleware, 'kasket/rack_middleware'
@@ -15,17 +14,13 @@ module Kasket
 
   class Version
     MAJOR = 0
-    MINOR = 6
-    PATCH = 4
+    MINOR = 7
+    PATCH = 0
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 
   module_function
 
-  def cache
-    Thread.current["kasket_cache"] ||= Cache.new
-  end
-
   def setup(options = {})
     CONFIGURATION[:max_collection_size] = options[:max_collection_size] if options[:max_collection_size]
 
@@ -33,34 +28,11 @@ module Kasket
     ActiveRecord::Associations::BelongsToAssociation.send(:include, Kasket::ReloadAssociationMixin)
     ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, Kasket::ReloadAssociationMixin)
     ActiveRecord::Associations::HasOneThroughAssociation.send(:include, Kasket::ReloadAssociationMixin)
+  end
 
-    #sets up local cache clearing before each request.
-    #this is done to make it work for non rack rails and for functional tests
-    begin
-      ApplicationController.before_filter do
-        Kasket.cache.clear_local
-      end
-    rescue NameError => e
-      puts('WARNING: The kasket before filter did not register (this is OK in the test environment)')
-    end
-
-    #sets up local cache clearing on rack
-    begin
-      ActionController::Dispatcher.middleware.use(Kasket::RackMiddleware)
-    rescue NameError => e
-      puts('WARNING: The kasket rack middleware is not in your rack stack (this is OK in the test environment)')
-    end
-
-    #sets up local cache clearing after each test case
-    begin
-      ActiveSupport::TestCase.class_eval do
-        setup :clear_cache
-        def clear_cache
-          Kasket.cache.clear_local
-          Rails.cache.clear if Rails.cache.respond_to?(:clear)
-        end
-      end
-    rescue NameError => e
+  def clear_local
+    if Rails.cache.respond_to?(:with_local_cache)
+      Rails.cache.send(:local_cache).try(:clear)
     end
   end
 end

data/lib/kasket/read_mixin.rb

@@ -11,8 +11,8 @@ module Kasket
       sql = sanitize_sql(sql)
       query = kasket_parser.parse(sql) if use_kasket?
       if query && has_kasket_index_on?(query[:index])
-        if value = Kasket.cache.read(query[:key])
-          Array.wrap(value).collect! { |record| instantiate(record.clone) }
+        if value = Rails.cache.read(query[:key])
+          Array.wrap(value).collect! { |record| instantiate(record.dup) }
         else
           store_in_kasket(query[:key], find_by_sql_without_kasket(sql))
         end
@@ -25,14 +25,14 @@ module Kasket
 
       def store_in_kasket(key, records)
         if records.size == 1
-          Kasket.cache.write(key, records.first.instance_variable_get(:@attributes))
-        else
+          Rails.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)
-            Kasket.cache.write(key, record.instance_variable_get(:@attributes))
+            Rails.cache.write(key, record.instance_variable_get(:@attributes).dup)
             key
           end
-          Kasket.cache.write(key, keys)
+          Rails.cache.write(key, keys)
         end
         records
       end

data/lib/kasket/reload_association_mixin.rb

@@ -2,7 +2,7 @@ module Kasket
   module ReloadAssociationMixin
     def reload_with_kasket_clearing(*args)
       if loaded?
-        clear_local_kasket_indices if respond_to?(:clear_local_kasket_indices)
+        Kasket.clear_local if include?(WriteMixin)
       else
         target_class = proxy_reflection.options[:polymorphic] ? association_class : proxy_reflection.klass
         Kasket.cache.delete_matched_local(/^#{target_class.kasket_key_prefix}/) if target_class.respond_to?(:kasket_key_prefix)

data/lib/kasket/write_mixin.rb

@@ -4,7 +4,7 @@ module Kasket
     module ClassMethods
       def remove_from_kasket(ids)
         Array(ids).each do |id|
-          Kasket.cache.delete(kasket_key_for_id(id))
+          Rails.cache.delete(kasket_key_for_id(id))
         end
       end
 
@@ -21,7 +21,7 @@ module Kasket
 
       def store_in_kasket
         if !readonly? && kasket_key
-          Kasket.cache.write(kasket_key, @attributes)
+          Rails.cache.write(kasket_key, @attributes.dup)
         end
       end
 
@@ -48,18 +48,12 @@ module Kasket
 
       def clear_kasket_indices
         kasket_keys.each do |key|
-          Kasket.cache.delete(key)
-        end
-      end
-
-      def clear_local_kasket_indices
-        kasket_keys.each do |key|
-          Kasket.cache.delete_local(key)
+          Rails.cache.delete(key)
         end
       end
 
       def reload_with_kasket_clearing(*args)
-        clear_local_kasket_indices
+        Kasket.clear_local
         reload_without_kasket_clearing(*args)
       end
     end

data/test/cache_expiry_test.rb

@@ -17,11 +17,11 @@ class CacheExpiryTest < ActiveSupport::TestCase
     end
 
     should "clear all indices for instance when deleted" do
-      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
+      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
 
       @post.destroy
     end
@@ -33,13 +33,13 @@ class CacheExpiryTest < ActiveSupport::TestCase
     end
 
     should "clear all indices for instance when updated" do
-      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
+      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
 
       @post.title = "new title"
       @post.save

data/test/find_one_test.rb

@@ -13,11 +13,11 @@ class FindOneTest < ActiveSupport::TestCase
   end
 
   should "only cache on indexed attributes" do
-    Kasket.cache.expects(:read).twice
+    Rails.cache.expects(:read).twice
     Post.find_by_id(1)
     Post.find_by_id(1, :conditions => {:blog_id => 2})
 
-    Kasket.cache.expects(:read).never
+    Rails.cache.expects(:read).never
     Post.first :conditions => {:blog_id => 2}
   end
 
@@ -31,10 +31,10 @@ class FindOneTest < ActiveSupport::TestCase
     Post.find(post.id)
     assert(Rails.cache.read(post.kasket_key))
 
-    Kasket.cache.expects(:read)
+    Rails.cache.expects(:read)
     Post.find(post.id, :select => nil)
 
-    Kasket.cache.expects(:read).never
+    Rails.cache.expects(:read).never
     Post.find(post.id, :select => 'title')
   end
 

data/test/helper.rb

@@ -34,6 +34,11 @@ class ActiveSupport::TestCase
   self.use_transactional_fixtures = true
 
   self.use_instantiated_fixtures  = false
+
+  setup :clear_cache
+  def clear_cache
+    Rails.cache.clear
+  end
 end
 
 ActiveSupport::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"

data/test/read_mixin_test.rb

@@ -10,24 +10,25 @@ class ReadMixinTest < ActiveSupport::TestCase
     end
 
     should "handle unsupported sql" do
+      Rails.cache.expects(:read).never
+      Rails.cache.expects(:write).never
       assert_equal @records, Post.find_by_sql_with_kasket('select unsupported sql statement')
-      assert Kasket.cache.local.empty?
     end
 
     should "read results" do
-      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)'), Kasket.cache.inspect
+      Rails.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, Kasket.cache.read("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1"), Kasket.cache.inspect
+      assert_equal @database_results.first, Rails.cache.read("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1")
     end
 
     context "modifying results" do
       setup do
-        Kasket.cache.write("kasket-#{Kasket::Version::STRING}/posts/version=3558/id=1", @database_results.first)
+        Rails.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,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kasket
 version: !ruby/object:Gem::Version 
-  version: 0.6.4
+  version: 0.7.0
 platform: ruby
 authors: 
 - Mick Staugaard
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-09 00:00:00 -08:00
+date: 2010-01-04 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,16 +70,13 @@ files:
 - Rakefile
 - lib/kasket.rb
 - lib/kasket/active_record_patches.rb
-- lib/kasket/cache.rb
 - lib/kasket/configuration_mixin.rb
 - lib/kasket/dirty_mixin.rb
 - lib/kasket/query_parser.rb
-- lib/kasket/rack_middleware.rb
 - lib/kasket/read_mixin.rb
 - lib/kasket/reload_association_mixin.rb
 - lib/kasket/write_mixin.rb
 - test/cache_expiry_test.rb
-- test/cache_test.rb
 - test/database.yml
 - test/dirty_test.rb
 - test/find_one_test.rb
@@ -121,7 +118,6 @@ specification_version: 3
 summary: A write back caching layer on active record
 test_files: 
 - test/cache_expiry_test.rb
-- test/cache_test.rb
 - test/dirty_test.rb
 - test/find_one_test.rb
 - test/find_some_test.rb

data/lib/kasket/cache.rb

@@ -1,77 +0,0 @@
-module Kasket
-  class Cache
-    def initialize
-      clear_local
-    end
-
-    def read(*args)
-      result = @local_cache[args[0]] || Rails.cache.read(*args)
-      if result.is_a?(Array) && result.first.is_a?(String)
-        models = get_multi(result)
-        result = result.map { |key| models[key] }
-      end
-
-      @local_cache[args[0]] = result if result
-      result
-    end
-
-    def get_multi(keys)
-      map = Hash[*keys.zip(keys.map { |key| @local_cache[key] }).flatten]
-      missing_keys = map.select { |key, value| value.nil? }.map(&:first)
-
-      unless missing_keys.empty?
-        if Rails.cache.respond_to?(:read_multi)
-          missing_map = Rails.cache.read_multi(missing_keys)
-          missing_map.each do |key, value|
-            missing_map[key] = @local_cache[key] = value
-          end
-          map.merge!(missing_map)
-        else
-          missing_keys.each do |key|
-            map[key] = read(key)
-          end
-        end
-      end
-
-      map
-    end
-
-    def write(key, value)
-      if storable?(value)
-        @local_cache[key] = value.duplicable? ? value.dup : value
-        Rails.cache.write(key, value.duplicable? ? value.dup : value) # Fix due to Rails.cache freezing values in 2.3.4
-      end
-      value
-    end
-
-    def delete(*args)
-      @local_cache.delete(args[0])
-      Rails.cache.delete(*args)
-    end
-
-    def delete_local(*keys)
-      keys.each do |key|
-        @local_cache.delete(key)
-      end
-    end
-
-    def delete_matched_local(matcher)
-      @local_cache.delete_if { |k,v| k =~ matcher }
-    end
-
-    def clear_local
-      @local_cache = {}
-    end
-
-    def local
-      @local_cache
-    end
-
-    protected
-
-      def storable?(value)
-        !value.is_a?(Array) || value.size <= Kasket::CONFIGURATION[:max_collection_size]
-      end
-
-  end
-end

data/lib/kasket/rack_middleware.rb

@@ -1,13 +0,0 @@
-module Kasket
-  class RackMiddleware
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    ensure
-      Kasket.cache.clear_local
-    end
-  end
-end

data/test/cache_test.rb

@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class CacheTest < ActiveSupport::TestCase
-
-  context "Cache" do
-    setup do
-      @cache = Kasket::Cache.new
-    end
-
-    context "reading" do
-
-      should "work with non collection values" do
-        @cache.write('key', 'value')
-        assert_equal 'value', @cache.read('key')
-      end
-
-      should "fetch original results of stored collections" do
-        @cache.write('key1', 'value1')
-        @cache.write('key2', 'value2')
-        @cache.write('key3', 'value3')
-        @cache.write('collection_key', [ 'key1', 'key2', 'key3'])
-
-        assert_equal [ 'value1', 'value2', 'value3'], @cache.read('collection_key')
-      end
-
-      should "not impact original object" do
-        record = { 'id' => 1, 'color' => 'red' }
-        @cache.write('key', record)
-        record['id'] = 2
-
-        assert_not_equal record, @cache.read('key')
-      end
-
-    end
-
-    context "writing" do
-      setup do
-        @cache.write('key', 'value')
-      end
-
-      should "store the object locally" do
-        assert_equal 'value', @cache.local['key']
-      end
-
-      should "persist the object" do
-        @cache.clear_local
-        assert_equal 'value', @cache.read('key')
-      end
-
-      should "respect max collection size" do
-        original_max = Kasket::CONFIGURATION[:max_collection_size]
-        Kasket::CONFIGURATION[:max_collection_size] = 2
-
-        @cache.write('key', [ 'a', 'b'])
-        assert_equal 2, @cache.read('key').size
-
-        @cache.write('key2', ['a', 'b', 'c'])
-        assert_equal nil, @cache.read('key2')
-
-        Kasket::CONFIGURATION[:max_collection_size] = original_max
-      end
-
-    end
-
-    should "delete" do
-      @cache.write('key', 'value')
-      @cache.delete('key')
-
-      assert_equal nil, @cache.local['key']
-      assert_equal nil, @cache.read('key')
-    end
-
-    should "delete matched local" do
-      @cache.write('key1', 'value1')
-      @cache.write('key2', 'value2')
-      @cache.delete_matched_local(/2/)
-
-      assert_equal nil, @cache.local['key2']
-      assert_equal 'value1', @cache.local['key1']
-      assert_equal 'value2', @cache.read('key2')
-    end
-
-    should "delete local" do
-      @cache.write('key1', 'value1')
-      @cache.write('key2', 'value2')
-      @cache.delete_local('key1', 'key2')
-
-      assert_equal nil, @cache.local['key1']
-      assert_equal nil, @cache.local['key2']
-      assert_equal 'value1', @cache.read('key1')
-      assert_equal 'value2', @cache.read('key2')
-    end
-
-    should "clear local" do
-      @cache.write('key1', 'value1')
-      @cache.clear_local
-
-      assert @cache.local.blank?
-    end
-
-  end
-end