cache_back 0.3.4 → 0.4.1

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.4.1

data/lib/cache_back/cache.rb

@@ -8,6 +8,27 @@ module CacheBack
       @local_cache[args[0]] ||= Rails.cache.read(*args)
     end
 
+    def get_multi(keys)
+      map = Hash[keys.zip(keys.map { |key| @local_cache[key] })]
+      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|
+            @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(*args)
       @local_cache[args[0]] = args[1]
       Rails.cache.write(*args)
@@ -22,4 +43,4 @@ module CacheBack
       @local_cache = {}
     end
   end
-end
+end

data/lib/cache_back/read_mixin.rb

@@ -4,18 +4,41 @@ module CacheBack
     def self.extended(model_class)
       class << model_class
         alias_method_chain :find_one, :cache_back
+        alias_method_chain :find_some, :cache_back
       end
     end
 
     def find_one_with_cache_back(id, options)
-      record = cache_safe?(options) ? CacheBack.cache.read(cache_back_key_for(id)) : nil
+      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
+        end
 
-      if record.nil?
-        record = find_one_without_cache_back(id, options)
-        record.store_in_cache_back if record
+        record
+      else
+        find_one_without_cache_back(id, options)
       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)] }]
+        cached_record_map = CacheBack.cache.get_multi(id_to_key_map.values)
+
+        missing_keys = Hash[cached_record_map.select { |key, record| record.nil? }].keys
+
+        return cached_record_map.values if missing_keys.empty?
 
-      record
+        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.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)
+      end
     end
 
     private

data/test/find_one_test.rb

@@ -8,10 +8,10 @@ class FindOneTest < ActiveSupport::TestCase
   should "cache find(id) calls" do
     post = Post.first
     assert_nil(Rails.cache.read(post.cache_back_key))
-    Post.find(post.id)
+    assert_equal(post, Post.find(post.id))
     assert(Rails.cache.read(post.cache_back_key))
     Post.connection.expects(:select_all).never
-    Post.find(post.id)
+    assert_equal(post, Post.find(post.id))
   end
 
   should "not use cache when using the :select option" do

data/test/find_some_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/helper'
+
+class FindSomeTest < ActiveSupport::TestCase
+  fixtures :blogs, :posts
+
+  Post.has_cache_back
+
+  should "cache find(id, id) calls" do
+    post1 = Post.first
+    post2 = Post.last
+
+    assert_nil(Rails.cache.read(post1.cache_back_key))
+    assert_nil(Rails.cache.read(post2.cache_back_key))
+
+    Post.find(post1.id, post2.id)
+
+    assert(Rails.cache.read(post1.cache_back_key))
+    assert(Rails.cache.read(post2.cache_back_key))
+
+    Post.connection.expects(:select_all).never
+    Post.find(post1.id, post2.id)
+  end
+
+  should "only lookup the records that are not in the cache" do
+    post1 = Post.first
+    post2 = Post.last
+    assert_equal(post1, Post.find(post1.id))
+    assert(Rails.cache.read(post1.cache_back_key))
+    assert_nil(Rails.cache.read(post2.cache_back_key))
+
+    Post.expects(:find_some_without_cache_back).with([post2.id], {}).returns([post2])
+    found_posts = Post.find(post1.id, post2.id)
+    assert_equal([post1, post2].map(&:id).sort, found_posts.map(&:id).sort)
+
+    Post.expects(:find_some_without_cache_back).never
+    found_posts = Post.find(post1.id, post2.id)
+    assert_equal([post1, post2].map(&:id).sort, found_posts.map(&:id).sort)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cache_back
 version: !ruby/object:Gem::Version 
-  version: 0.3.4
+  version: 0.4.1
 platform: ruby
 authors: 
 - Mick Staugaard
@@ -58,6 +58,7 @@ files:
 - test/database.yml
 - test/dirty_test.rb
 - test/find_one_test.rb
+- test/find_some_test.rb
 - test/fixtures/blogs.yml
 - test/fixtures/comments.yml
 - test/fixtures/posts.yml
@@ -94,5 +95,6 @@ summary: A write back caching layer on active record
 test_files: 
 - test/dirty_test.rb
 - test/find_one_test.rb
+- test/find_some_test.rb
 - test/helper.rb
 - test/schema.rb