nkallen-cache-money 0.2.1

data/lib/cash/query/select.rb

@@ -0,0 +1,16 @@
+module Cash
+  module Query
+    class Select < Abstract
+      delegate :find_every_without_cache, :to => :@active_record
+
+      protected
+      def miss(_, miss_options)
+        find_every_without_cache(miss_options)
+      end
+
+      def uncacheable
+        find_every_without_cache(@options1)
+      end
+    end
+  end
+end

data/lib/cash/transactional.rb

@@ -0,0 +1,42 @@
+module Cash
+  class Transactional
+    attr_reader :memcache
+
+    def initialize(memcache, lock)
+      @memcache, @cache = [memcache, memcache]
+      @lock = lock
+    end
+
+    def transaction
+      exception_was_raised = false
+      begin_transaction
+      result = yield
+    rescue Object => e
+      exception_was_raised = true
+      raise
+    ensure
+      begin
+        @cache.flush unless exception_was_raised
+      ensure
+        end_transaction
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @cache.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      @cache.respond_to?(method)
+    end
+
+    private
+    def begin_transaction
+      @cache = Buffered.push(@cache, @lock)
+    end
+
+    def end_transaction
+      @cache = @cache.pop
+    end
+  end
+end

data/lib/cash/util/array.rb

@@ -0,0 +1,9 @@
+class Array
+  alias_method :count, :size
+
+  def to_hash
+    keys_and_values_without_nils = reject { |key, value| value.nil? }
+    shallow_flattened_keys_and_values_without_nils = keys_and_values_without_nils.inject([]) { |result, pair| result += pair }
+    Hash[*shallow_flattened_keys_and_values_without_nils]
+  end
+end

data/lib/cash/write_through.rb

@@ -0,0 +1,72 @@
+module Cash
+  module WriteThrough
+    DEFAULT_TTL = 12.hours
+
+    def self.included(active_record_class)
+      active_record_class.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+      def self.included(active_record_class)
+        active_record_class.class_eval do
+          after_create :add_to_caches
+          after_update :update_caches
+          after_destroy :remove_from_caches
+        end
+      end
+
+      def add_to_caches
+        InstanceMethods.unfold(self.class, :add_to_caches, self)
+      end
+
+      def update_caches
+        InstanceMethods.unfold(self.class, :update_caches, self)
+      end
+
+      def remove_from_caches
+        return if new_record?
+        InstanceMethods.unfold(self.class, :remove_from_caches, self)
+      end
+
+      def expire_caches
+        InstanceMethods.unfold(self.class, :expire_caches, self)
+      end
+
+      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
+
+      private
+      def self.unfold(klass, operation, object)
+        while klass < ActiveRecord::Base && klass.ancestors.include?(WriteThrough)
+          klass.send(operation, object)
+          klass = klass.superclass
+        end
+      end
+    end
+
+    module ClassMethods
+      def add_to_caches(object)
+        indices.each { |index| index.add(object) }
+      end
+
+      def update_caches(object)
+        indices.each { |index| index.update(object) }
+      end
+
+      def remove_from_caches(object)
+        indices.each { |index| index.remove(object) }
+      end
+
+      def expire_caches(object)
+        indices.each { |index| index.delete(object) }
+      end
+    end
+  end
+end

data/spec/cash/accessor_spec.rb

@@ -0,0 +1,133 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+module Cash
+  describe Accessor do
+    describe '#fetch' do
+      describe '#fetch("...")' do
+        describe 'when there is a cache miss' do
+          it 'returns nil' do
+            Story.fetch("yabba").should be_nil
+          end
+        end
+
+        describe 'when there is a cache hit' do
+          it 'returns the value of the cache' do
+            Story.set("yabba", "dabba")
+            Story.fetch("yabba").should == "dabba"
+          end
+        end
+      end
+
+      describe '#fetch([...])', :shared => true do
+        describe 'when there is a total cache miss' do
+          it 'yields the keys to the block' do
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| ["doo", "doo"] }.should == {
+              "Story/yabba" => "doo",
+              "Story/dabba" => "doo"
+            }
+          end
+        end
+
+        describe 'when there is a partial cache miss' do
+          it 'yields just the missing ids to the block' do
+            Story.set("yabba", "dabba")
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| "doo" }.should == {
+              "Story/yabba" => "dabba",
+              "Story/dabba" => "doo"
+            }
+          end
+        end
+      end
+    end
+
+    describe '#get' do
+      describe '#get("...")' do
+        describe 'when there is a cache miss' do
+          it 'returns the value of the block' do
+            Story.get("yabba") { "dabba" }.should == "dabba"
+          end
+
+          it 'adds to the cache' do
+            Story.get("yabba") { "dabba" }
+            Story.get("yabba").should == "dabba"
+          end
+        end
+
+        describe 'when there is a cache hit' do
+          before do
+            Story.set("yabba", "dabba")
+          end
+
+          it 'returns the value of the cache' do
+            Story.get("yabba") { "doo" }.should == "dabba"
+          end
+
+          it 'does nothing to the cache' do
+            Story.get("yabba") { "doo" }
+            Story.get("yabba").should == "dabba"
+          end
+        end
+      end
+
+      describe '#get([...])' do
+        it_should_behave_like "#fetch([...])"
+      end
+    end
+
+    describe '#incr' do
+      describe 'when there is a cache hit' do
+        before do
+          Story.set("count", 0)
+        end
+
+        it 'increments the value of the cache' do
+          Story.incr("count", 2)
+          Story.get("count", :raw => true).should =~ /2/
+        end
+
+        it 'returns the new cache value' do
+          Story.incr("count", 2).should == 2
+        end
+      end
+
+      describe 'when there is a cache miss' do
+        it 'initializes the value of the cache to the value of the block' do
+          Story.incr("count", 1) { 5 }
+          Story.get("count", :raw => true).should =~ /5/
+        end
+
+        it 'returns the new cache value' do
+          Story.incr("count", 1) { 2 }.should == 2
+        end
+      end
+    end
+
+    describe '#decr' do
+      describe 'when there is a cache hit' do
+        before do
+          Story.incr("count", 1) { 10 }
+        end
+
+        it 'decrements the value of the cache' do
+          Story.decr("count", 2)
+          Story.get("count", :raw => true).should =~ /8/
+        end
+
+        it 'returns the new cache value' do
+          Story.decr("count", 2).should == 8
+        end
+      end
+
+      describe 'when there is a cache miss' do
+        it 'initializes the value of the cache to the value of the block' do
+          Story.decr("count", 1) { 5 }
+          Story.get("count", :raw => true).should =~ /5/
+        end
+
+        it 'returns the new cache value' do
+          Story.decr("count", 1) { 2 }.should == 2
+        end
+      end
+    end
+  end
+end

data/spec/cash/active_record_spec.rb

@@ -0,0 +1,190 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+module Cash
+  describe Finders do
+    describe 'when the cache is populated' do
+      describe "#find" do
+        describe '#find(id...)' do
+          describe '#find(id)' do
+            it "returns an active record" do
+              story = Story.create!(:title => 'a story')
+              Story.find(story.id).should == story
+            end
+          end
+
+          describe 'when the object is destroyed' do
+            describe '#find(id)' do
+              it "raises an error" do
+                story = Story.create!(:title => "I am delicious")
+                story.destroy
+                lambda { Story.find(story.id) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+
+          describe '#find(id1, id2, ...)' do
+            it "returns an array" do
+              story1, story2 = Story.create!, Story.create!
+              Story.find(story1.id, story2.id).should == [story1, story2]
+            end
+
+            describe "#find(id, nil)" do
+              it "ignores the nils" do
+                story = Story.create!
+                Story.find(story.id, nil).should == story
+              end
+            end
+          end
+
+          describe 'when given nonexistent ids' do
+            describe 'when given one nonexistent id' do
+              it 'raises an error' do
+                lambda { Story.find(1) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+
+            describe 'when given multiple nonexistent ids' do
+               it "raises an error" do
+                lambda { Story.find(1, 2, 3) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+
+
+            describe '#find(nil)' do
+              it 'raises an error' do
+                lambda { Story.find(nil) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+        end
+
+        describe '#find(object)' do
+          it "coerces arguments to integers" do
+            story = Story.create!
+            Story.find(story.id.to_s).should == story
+          end
+        end
+
+        describe '#find([...])' do
+          describe 'when given an array with valid ids' do
+            it "#finds the object with that id" do
+              story = Story.create!
+              Story.find([story.id]).should == [story]
+            end
+          end
+
+          describe '#find([])' do
+            it 'returns the empty array' do
+              Story.find([]).should == []
+            end
+          end
+
+          describe 'when given nonexistent ids' do
+            it 'raises an error' do
+              lambda { Story.find([1, 2, 3]) }.should raise_error(ActiveRecord::RecordNotFound)
+            end
+          end
+
+          describe 'when given limits and offsets' do
+            describe '#find([1, 2, ...], :limit => ..., :offset => ...)' do
+              it "returns the correct slice of objects" do
+                character1 = Character.create!(:name => "Sam", :story_id => 1)
+                character2 = Character.create!(:name => "Sam", :story_id => 1)
+                character3 = Character.create!(:name => "Sam", :story_id => 1)
+                Character.find(
+                  [character1.id, character2.id, character3.id],
+                  :conditions => { :name => "Sam", :story_id => 1 }, :limit => 2
+                ).should == [character1, character2]
+              end
+            end
+
+            describe '#find([1], :limit => 0)' do
+              it "raises an error" do
+                character = Character.create!(:name => "Sam", :story_id => 1)
+                lambda do
+                  Character.find([character.id], :conditions => { :name => "Sam", :story_id => 1 }, :limit => 0)
+                end.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+        end
+
+        describe '#find(:first, ..., :offset => ...)' do
+          it "#finds the object in the correct order" do
+            story1 = Story.create!(:title => 'title1')
+            story2 = Story.create!(:title => story1.title)
+            Story.find(:first, :conditions => { :title => story1.title }, :offset => 1).should == story2
+          end
+        end
+
+        describe '#find(:first, :conditions => [])' do
+          it 'works' do
+            story = Story.create!
+            Story.find(:first, :conditions => []).should == story
+          end
+        end
+      end
+
+      describe '#find_by_attr' do
+        describe '#find_by_attr(nil)' do
+          it 'returns nil' do
+            Story.find_by_id(nil).should == nil
+          end
+        end
+
+        describe 'when given non-existent ids' do
+          it 'returns nil' do
+            Story.find_by_id(-1).should == nil
+          end
+        end
+      end
+
+      describe '#find_all_by_attr' do
+        describe 'when given non-existent ids' do
+          it "does not raise an error" do
+            lambda { Story.find_all_by_id([-1, -2, -3]) }.should_not raise_error
+          end
+        end
+      end
+    end
+
+    describe 'when the cache is partially populated' do
+      describe '#find(:all, :conditions => ...)' do
+        it "returns the correct records" do
+          story1 = Story.create!(:title => title = 'once upon a time...')
+          $memcache.flush_all
+          story2 = Story.create!(:title => title)
+          Story.find(:all, :conditions => { :title => story1.title }).should == [story1, story2]
+        end
+      end
+
+      describe '#find(id1, id2, ...)' do
+        it "returns the correct records" do
+          story1 = Story.create!(:title => 'story 1')
+          $memcache.flush_all
+          story2 = Story.create!(:title => 'story 2')
+          Story.find(story1.id, story2.id).should == [story1, story2]
+        end
+      end
+    end
+
+    describe 'when the cache is not populated' do
+      describe '#find(id)' do
+        it "returns the correct records" do
+          story = Story.create!(:title => 'a story')
+          $memcache.flush_all
+          Story.find(story.id).should == story
+        end
+      end
+
+      describe '#find(id1, id2, ...)' do
+        it "handles finds with multiple ids correctly" do
+          story1 = Story.create!
+          story2 = Story.create!
+          $memcache.flush_all
+          Story.find(story1.id, story2.id).should == [story1, story2]
+        end
+      end
+    end
+  end
+end