cache_back 0.4.1 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/lib/cache_back/cache.rb

@@ -5,7 +5,16 @@ module CacheBack
     end
 
     def read(*args)
-      @local_cache[args[0]] ||= Rails.cache.read(*args)
+      result = @local_cache[args[0]] || Rails.cache.read(*args)
+      if result.is_a?(CachedModel)
+        result = result.instanciate_model
+      elsif result.is_a?(Array)
+        models = get_multi(result)
+        result = result.map { |key| models[key]}
+      end
+
+      @local_cache[args[0]] = result if result
+      result
     end
 
     def get_multi(keys)
@@ -16,7 +25,8 @@ module CacheBack
         if Rails.cache.respond_to?(:read_multi)
           missing_map = Rails.cache.read_multi(missing_keys)
           missing_map.each do |key, value|
-            @local_cache[key] = value
+            value = value.instanciate_model if value.is_a?(CachedModel)
+            missing_map[key] = @local_cache[key] = value
           end
           map.merge!(missing_map)
         else
@@ -31,6 +41,11 @@ module CacheBack
 
     def write(*args)
       @local_cache[args[0]] = args[1]
+
+      if args[1].is_a?(ActiveRecord::Base)
+        args[1] = CachedModel.new(args[1])
+      end
+
       Rails.cache.write(*args)
     end
 
@@ -42,5 +57,16 @@ module CacheBack
     def reset!
       @local_cache = {}
     end
+
+    class CachedModel
+      def initialize(model)
+        @name = model.class.name
+        @attributes = model.instance_variable_get(:@attributes)
+      end
+
+      def instanciate_model
+        @name.constantize.send(:instantiate, @attributes)
+      end
+    end
   end
 end

data/lib/cache_back/conditions_parser.rb

@@ -0,0 +1,72 @@
+module CacheBack
+  class ConditionsParser
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    def attribute_value_pairs(options, scope)
+      from_scope = attribute_value_pairs_for_conditions((scope || {})[:conditions])
+      return nil unless from_scope
+
+      from_options = attribute_value_pairs_for_conditions(options[:conditions])
+      return nil unless from_options
+
+      pairs = from_scope.inject(from_options) do |memo, pair|
+        attribute = pair[0]
+        if memo_pair = memo.find{ |p| p[0] == attribute}
+          memo_pair[0] = Array(memo_pair[0])
+          memo_pair[0] << pair[1]
+        else
+          memo << pair
+        end
+      end
+
+      pairs.sort! { |pair1, pair2| pair1[0] <=> pair2[0] }
+
+      pairs.map do |attribute, value|
+        if value.is_a?(Array)
+          value.flatten!
+          if value.size == 1
+            [attribute.to_sym, value[0]]
+          else
+            [attribute.to_sym, value]
+          end
+        else
+          [attribute.to_sym, value]
+        end
+      end
+    end
+
+    def attribute_value_pairs_for_conditions(conditions)
+      case conditions
+      when Hash
+        conditions.to_a.collect { |key, value| [key.to_s, value] }
+      when String
+        parse_indices_from_condition(conditions)
+      when Array
+        parse_indices_from_condition(*conditions)
+      when NilClass
+        []
+      end
+    end
+
+    AND = /\s+AND\s+/i
+    TABLE_AND_COLUMN = /(?:(?:`|")?(\w+)(?:`|")?\.)?(?:`|")?(\w+)(?:`|")?/ # Matches: `users`.id, `users`.`id`, users.id, id
+    VALUE = /'?(\d+|\?|(?:(?:[^']|'')*))'?/                     # Matches: 123, ?, '123', '12''3'
+    KEY_EQ_VALUE = /^\(?#{TABLE_AND_COLUMN}\s+=\s+#{VALUE}\)?$/ # Matches: KEY = VALUE, (KEY = VALUE)
+    ORDER = /^#{TABLE_AND_COLUMN}\s*(ASC|DESC)?$/i              # Matches: COLUMN ASC, COLUMN DESC, COLUMN
+
+    def parse_indices_from_condition(conditions = '', *values)
+      values = values.dup
+      conditions.split(AND).inject([]) do |indices, condition|
+        matched, table_name, column_name, sql_value = *(KEY_EQ_VALUE.match(condition))
+        if matched
+          value = sql_value == '?' ? values.shift : @model_class.columns_hash[column_name].type_cast(sql_value)
+          indices << [column_name, value]
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/cache_back/configuration_mixin.rb

@@ -1,4 +1,4 @@
-require 'activesupport'
+require 'active_support'
 
 module CacheBack
   autoload :ReadMixin, 'cache_back/read_mixin'
@@ -26,18 +26,54 @@ module CacheBack
       end
     end
 
-    def cache_back_key_for(id)
-      "cache_back/#{table_name}/version_#{inherited_cache_back_version}/#{id}"
+    def cache_back_key_for(attribute_value_pairs)
+      key = "cache_back/#{table_name}/version=#{inherited_cache_back_version}"
+      attribute_value_pairs.each do |attribute, value|
+        key << "/#{attribute}="
+        if value.is_a?(Array)
+          key << value.join(',')
+        else
+          key << value.to_s
+        end
+      end
+      key
+    end
+
+    def cache_back_key_for_id(id)
+      cache_back_key_for([['id', id]])
+    end
+
+    def cache_back_indices
+      result = @cache_back_indices || []
+      result += superclass.cache_back_indices unless self == ActiveRecord::Base
+      result.uniq
+    end
+
+    def has_cache_back_index_on?(sorted_attributes)
+      cache_back_indices.include?(sorted_attributes)
     end
 
     def has_cache_back(options = {})
-      @cache_back_version = options.delete(:version) || '1'
-      @cache_back_option = options
+      has_cache_back_on :id
+    end
+
+    def has_cache_back_on(*args)
+      options = args.extract_options!
+      attributes = args.sort! { |x, y| x.to_s <=> y.to_s }
+
+      @cache_back_version ||= options.delete(:version) || '1'
+      @cache_back_option ||= options
+
+      if attributes != [:id] && !cache_back_indices.include?([:id])
+        has_cache_back_on(:id)
+      end
+
+      @cache_back_indices ||= []
+      @cache_back_indices << attributes unless @cache_back_indices.include?(attributes)
 
       include WriteMixin unless instance_methods.include?('store_in_cache_back')
-      extend ReadMixin unless methods.include?('find_one_with_cache_back')
+      extend ReadMixin unless methods.include?('without_cache_back')
       extend DirtyMixin unless methods.include?('cache_back_dirty_methods')
     end
-
   end
 end

data/lib/cache_back/dirty_mixin.rb

@@ -6,7 +6,7 @@ module CacheBack
           alias_method("without_cache_back_update_#{method}", method)
           define_method(method) do |*args|
             result = send("without_cache_back_update_#{method}", *args)
-            store_in_cache_back
+            clear_cache_back_indices
             result
           end
         end

data/lib/cache_back/read_mixin.rb

@@ -1,29 +1,60 @@
+require 'cache_back/conditions_parser'
+
 module CacheBack
   module ReadMixin
 
     def self.extended(model_class)
       class << model_class
-        alias_method_chain :find_one, :cache_back
-        alias_method_chain :find_some, :cache_back
+        alias_method_chain :find_some, :cache_back unless methods.include?('find_some_without_cache_back')
+        alias_method_chain :find_every, :cache_back unless methods.include?('find_every_without_cache_back')
       end
     end
 
-    def find_one_with_cache_back(id, options)
-      if cache_safe?(options)
-        unless record = CacheBack.cache.read(cache_back_key_for(id))
-          record = find_one_without_cache_back(id, options)
-          record.store_in_cache_back if record
+    def without_cache_back(&block)
+      old_value = @use_cache_back || true
+      @use_cache_back = false
+      yield
+    ensure
+      @use_cache_back = old_value
+    end
+
+    def find_every_with_cache_back(options)
+      attribute_value_pairs = cache_back_conditions_parser.attribute_value_pairs(options, scope(:find)) if cache_safe?(options)
+
+      limit = (options[:limit] || (scope(:find) || {})[:limit])
+
+      if (limit.nil? || limit == 1) && attribute_value_pairs && has_cache_back_index_on?(attribute_value_pairs.map(&:first))
+        collection_key = cache_back_key_for(attribute_value_pairs)
+        collection_key << '/first' if limit == 1
+        unless records = CacheBack.cache.read(collection_key)
+          records = without_cache_back do
+            find_every_without_cache_back(options)
+          end
+
+          if records.size == 1
+            CacheBack.cache.write(collection_key, records[0])
+          elsif records.size <= CacheBack::CONFIGURATION[:max_collection_size]
+            records.each { |record| record.store_in_cache_back if record }
+            CacheBack.cache.write(collection_key, records.map(&:cache_back_key))
+          end
         end
 
-        record
+        Array(records)
       else
-        find_one_without_cache_back(id, options)
+        without_cache_back do
+          find_every_without_cache_back(options)
+        end
       end
     end
 
     def find_some_with_cache_back(ids, options)
-      if cache_safe?(options)
-        id_to_key_map = Hash[ids.uniq.map { |id| [id, cache_back_key_for(id)] }]
+      attribute_value_pairs = cache_back_conditions_parser.attribute_value_pairs(options, scope(:find)) if cache_safe?(options)
+      attribute_value_pairs << [:id, ids] if attribute_value_pairs
+
+      limit = (options[:limit] || (scope(:find) || {})[:limit])
+
+      if limit.nil? && attribute_value_pairs && has_cache_back_index_on?(attribute_value_pairs.map(&:first))
+        id_to_key_map = Hash[ids.uniq.map { |id| [id, cache_back_key_for_id(id)] }]
         cached_record_map = CacheBack.cache.get_multi(id_to_key_map.values)
 
         missing_keys = Hash[cached_record_map.select { |key, record| record.nil? }].keys
@@ -32,19 +63,30 @@ module CacheBack
 
         missing_ids = Hash[id_to_key_map.invert.select { |key, id| missing_keys.include?(key) }].values
 
-        db_records = find_some_without_cache_back(missing_ids, options)
+        db_records = without_cache_back do
+          find_some_without_cache_back(missing_ids, options)
+        end
         db_records.each { |record| record.store_in_cache_back if record }
 
         (cached_record_map.values + db_records).compact.uniq.sort { |x, y| x.id <=> y.id}
       else
-        find_some_without_cache_back(ids, options)
+        without_cache_back do
+          find_some_without_cache_back(ids, options)
+        end
       end
     end
 
     private
 
       def cache_safe?(options)
-        options[:select].nil?
+        @use_cache_back != false && [options, scope(:find) || {}].all? do |hash|
+          result = hash[:select].nil? && hash[:joins].nil? && hash[:order].nil? && hash[:offset].nil?
+          result && (options[:limit].nil? || options[:limit] == 1)
+        end
+      end
+
+      def cache_back_conditions_parser
+        @cache_back_conditions_parser ||= CacheBack::ConditionsParser.new(self)
       end
 
   end

data/lib/cache_back/reload_association_mixin.rb

@@ -0,0 +1,15 @@
+module CacheBack
+  module ReloadAssociationMixin
+    def reload_with_cache_back_clearing(*args)
+      # TODO we could calculate the right key to clear by parsing the association conditions.
+      # this would clear less keys, and we would not have to load the target
+      load_target
+      target.clear_cache_back_indices if target.respond_to?(:clear_cache_back_indices)
+      reload_without_cache_back_clearing(*args)
+    end
+
+    def self.included(base)
+      base.alias_method_chain :reload, :cache_back_clearing
+    end
+  end
+end

data/lib/cache_back/write_mixin.rb

@@ -3,7 +3,7 @@ module CacheBack
     module ClassMethods
       def remove_from_cache_back(ids)
         Array(ids).each do |id|
-          CacheBack.cache.delete(cache_back_key_for(id))
+          CacheBack.cache.delete(cache_back_key_for_id(id))
         end
       end
 
@@ -14,29 +14,35 @@ module CacheBack
     end
 
     module InstanceMethods
-      def shallow_clone
-        clone = self.class.new
-        clone.instance_variable_set("@attributes", instance_variable_get(:@attributes))
-        clone.instance_variable_set("@new_record", new_record?)
-        clone
-      end
-
       def cache_back_key
-        @cache_back_key ||= new_record? ? nil : self.class.cache_back_key_for(id)
+        @cache_back_key ||= new_record? ? nil : self.class.cache_back_key_for_id(id)
       end
 
       def store_in_cache_back
         if !readonly? && cache_back_key
-          CacheBack.cache.write(cache_back_key, shallow_clone, self.class.inherited_cache_back_options)
+          CacheBack.cache.write(cache_back_key, self, self.class.inherited_cache_back_options)
         end
       end
 
-      def remove_from_cache_back
-        CacheBack.cache.delete(cache_back_key) if cache_back_key
+      def clear_cache_back_indices
+        new_attributes = attributes.symbolize_keys
+
+        old_attributes = Hash[changes.map {|attribute, values| [attribute, values[0]]}].symbolize_keys
+        old_attributes.reverse_merge!(new_attributes)
+
+        self.class.cache_back_indices.each do |index|
+          old_key = self.class.cache_back_key_for(index.map { |attribute| [attribute, old_attributes[attribute]]})
+          new_key = self.class.cache_back_key_for(index.map { |attribute| [attribute, new_attributes[attribute]]})
+
+          [old_key, new_key].uniq.each do |key|
+            CacheBack.cache.delete(key)
+            CacheBack.cache.delete("#{key}/first")
+          end
+        end
       end
 
       def reload_with_cache_back_clearing(*args)
-        remove_from_cache_back
+        clear_cache_back_indices
         reload_without_cache_back_clearing(*args)
       end
     end
@@ -45,9 +51,9 @@ module CacheBack
       model_class.extend         ClassMethods
       model_class.send :include, InstanceMethods
 
-      #model_class.after_save :store_in_cache_back
-      model_class.after_update :remove_from_cache_back
-      model_class.after_destroy :remove_from_cache_back
+      model_class.after_save :clear_cache_back_indices
+      model_class.after_destroy :clear_cache_back_indices
+
       model_class.alias_method_chain :reload, :cache_back_clearing
 
       class << model_class

data/lib/cache_back.rb

@@ -1,23 +1,48 @@
 require 'rubygems'
-require 'activerecord'
+require 'active_record'
+require 'active_support'
 
 require 'cache_back/configuration_mixin'
+require 'cache_back/reload_association_mixin'
 require 'cache_back/cache'
 require 'cache_back/rack_middleware'
 
 module CacheBack
+  CONFIGURATION = {:max_collection_size => 100}
+
   module_function
 
   def cache
     Thread.current["cache_back_cache"] ||= Cache.new
   end
-end
 
-ActiveRecord::Base.extend(CacheBack::ConfigurationMixin)
+  def setup(options = {})
+    CONFIGURATION[:max_collection_size] = options[:max_collection_size] if options[:max_collection_size]
 
-begin
-  ActionController::Dispatcher.middleware.use(CacheBack::RackMiddleware)
-rescue NameError => e
-  
-end
+    ActiveRecord::Base.extend(CacheBack::ConfigurationMixin)
+    ActiveRecord::Associations::BelongsToAssociation.send(:include, CacheBack::ReloadAssociationMixin)
+    ActiveRecord::Associations::BelongsToPolymorphicAssociation.send(:include, CacheBack::ReloadAssociationMixin)
+    ActiveRecord::Associations::HasOneThroughAssociation.send(:include, CacheBack::ReloadAssociationMixin)
+
+    #sets up local cache clearing after each request
+    begin
+      ApplicationController.after_filter do
+        CacheBack.cache.reset!
+      end
+    rescue NameError => e
 
+    end
+
+    #sets up local cache clearing after each test case
+    begin
+      ActiveSupport::TestCase.class_eval do
+        setup :clear_cache
+        def clear_cache
+          CacheBack.cache.reset!
+          Rails.cache.clear if Rails.cache.respond_to?(:clear)
+        end
+      end
+    rescue NameError => e
+    end
+  end
+end

data/test/cache_expiry_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/helper'
+
+class CacheExpiryTest < ActiveSupport::TestCase
+  fixtures :blogs, :posts
+
+  Post.has_cache_back
+  Post.has_cache_back_on :title
+  Post.has_cache_back_on :blog_id
+
+  context "a cached object" do
+    setup do
+      post = Post.first
+      @post = Post.find(post.id)
+      assert(Rails.cache.read(@post.cache_back_key))
+    end
+
+    should "be removed from cache when deleted" do
+      @post.destroy
+      assert_nil(Rails.cache.read(@post.cache_back_key))
+    end
+
+    should "clear all indices for instance when deleted" do
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/id=#{@post.id}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/id=#{@post.id}/first")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=#{@post.title}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=#{@post.title}/first")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/blog_id=#{@post.blog_id}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/blog_id=#{@post.blog_id}/first")
+      CacheBack.cache.expects(:delete).never
+
+      @post.destroy
+    end
+
+    should "be removed from cache when updated" do
+      @post.title = "new title"
+      @post.save
+      assert_nil(Rails.cache.read(@post.cache_back_key))
+    end
+
+    should "clear all indices for instance when updated" do
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/id=#{@post.id}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/id=#{@post.id}/first")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=#{@post.title}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=#{@post.title}/first")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=new title")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/title=new title/first")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/blog_id=#{@post.blog_id}")
+      CacheBack.cache.expects(:delete).with("cache_back/posts/version=1/blog_id=#{@post.blog_id}/first")
+      CacheBack.cache.expects(:delete).never
+
+      @post.title = "new title"
+      @post.save
+    end
+  end
+end

data/test/dirty_test.rb

@@ -6,13 +6,14 @@ class DirtyTest < ActiveSupport::TestCase
   Post.has_cache_back
   Post.cache_back_dirty_methods :make_dirty!
 
-  should "update the cache when a dirty method is called" do
+  should "clear the indices when a dirty method is called" do
     post = Post.first
 
     pots = Post.find(post.id)
     assert(Rails.cache.read(post.cache_back_key))
 
-    CacheBack.cache.expects(:write)
     post.make_dirty!
+
+    assert_nil(Rails.cache.read(post.cache_back_key))
   end
 end

data/test/find_one_test.rb

@@ -30,4 +30,15 @@ class FindOneTest < ActiveSupport::TestCase
     CacheBack.cache.expects(:read).never
     Post.find(post.id, :select => 'title')
   end
+
+  should "respect scope" do
+    post = Post.find(Post.first.id)
+    other_blog = Blog.first(:conditions => "id != #{post.blog_id}")
+
+    assert(Rails.cache.read(post.cache_back_key))
+
+    assert_raise(ActiveRecord::RecordNotFound) do
+      other_blog.posts.find(post.id)
+    end
+  end
 end

data/test/find_some_test.rb

@@ -4,6 +4,7 @@ class FindSomeTest < ActiveSupport::TestCase
   fixtures :blogs, :posts
 
   Post.has_cache_back
+  Post.has_cache_back_on :blog_id
 
   should "cache find(id, id) calls" do
     post1 = Post.first
@@ -36,4 +37,13 @@ class FindSomeTest < ActiveSupport::TestCase
     found_posts = Post.find(post1.id, post2.id)
     assert_equal([post1, post2].map(&:id).sort, found_posts.map(&:id).sort)
   end
+
+  should "cache on index other than primary key" do
+    blog = blogs(:a_blog)
+    posts = Post.find_all_by_blog_id(blog.id)
+
+    Post.expects(:find_every_without_cache_back).never
+
+    assert_equal(posts, Post.find_all_by_blog_id(blog.id))
+  end
 end

data/test/fixtures/blogs.yml

@@ -1,2 +1,5 @@
 a_blog:
-  name: My Blog
+  name: My Blog
+
+other_blog:
+  name: Some Other Blog

data/test/fixtures/posts.yml

@@ -6,6 +6,10 @@ has_two_comments:
   blog: a_blog
   title: This post has a few comments
 
+on_other_blog:
+  blog: other_blog
+  title: This post has no comments
+
 has_many_comments:
   blog: a_blog
   title: A shit load of comments on this one

data/test/helper.rb

@@ -16,12 +16,14 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'cache_back'
 
+CacheBack.setup
+
 class ActiveSupport::TestCase
   include ActiveRecord::TestFixtures
 
   fixtures :all
 
-  setup :clear_cache
+  #setup :clear_cache
 
   def create_fixtures(*table_names)
     if block_given?

data/test/serialization_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/helper'
+
+class SerializationTest < ActiveSupport::TestCase
+  fixtures :blogs, :posts
+
+  Post.has_cache_back
+
+  should "store a CachedModel" do
+    post = Post.first
+    post.store_in_cache_back
+    assert_instance_of(CacheBack::Cache::CachedModel, Rails.cache.read(post.cache_back_key))
+  end
+
+  should "bring convert CachedModel to model instances" do
+    post = Post.first
+    post.store_in_cache_back
+
+    post = CacheBack.cache.read(post.cache_back_key)
+    assert_instance_of(Post, post)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cache_back
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - Mick Staugaard
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-26 00:00:00 -08:00
+date: 2009-11-29 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,11 +50,14 @@ files:
 - VERSION
 - lib/cache_back.rb
 - lib/cache_back/cache.rb
+- lib/cache_back/conditions_parser.rb
 - lib/cache_back/configuration_mixin.rb
 - lib/cache_back/dirty_mixin.rb
 - lib/cache_back/rack_middleware.rb
 - lib/cache_back/read_mixin.rb
+- lib/cache_back/reload_association_mixin.rb
 - lib/cache_back/write_mixin.rb
+- test/cache_expiry_test.rb
 - test/database.yml
 - test/dirty_test.rb
 - test/find_one_test.rb
@@ -64,6 +67,7 @@ files:
 - test/fixtures/posts.yml
 - test/helper.rb
 - test/schema.rb
+- test/serialization_test.rb
 has_rdoc: true
 homepage: http://github.com/staugaard/cache_back
 licenses: []
@@ -93,8 +97,10 @@ signing_key:
 specification_version: 3
 summary: A write back caching layer on active record
 test_files: 
+- test/cache_expiry_test.rb
 - test/dirty_test.rb
 - test/find_one_test.rb
 - test/find_some_test.rb
 - test/helper.rb
 - test/schema.rb
+- test/serialization_test.rb