ngmoco-cache-money 0.2.9

data/lib/memcached_wrapper.rb

@@ -0,0 +1,233 @@
+# require 'memcache'
+# require 'memcached'
+
+#typically MemCache/Memcached can be used via the following in rails/init.rb:
+#$memcache = MemCache.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+#$memcache = Memcached::Rails.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+
+#this wrapper lets both work.
+
+####### they have MemCache installed (don't need the wrapper)
+if defined? MemCache
+
+Rails.logger.info("cache-money: MemCache installed")
+#TODO add logging?
+class MemcachedWrapper < ::MemCache
+end
+
+########## they have Memcached installed (do need the wrapper)
+elsif defined? Memcached
+Rails.logger.info("cache-money: Memcached installed")
+
+class Memcached
+  alias :get_multi :get #:nodoc:
+end
+
+class MemcachedWrapper < ::Memcached
+  DEFAULTS = { :servers => '127.0.0.1:11211' }
+
+  attr_reader :logger
+
+  # See Memcached#new for details.
+  def initialize(*args)
+      opts = DEFAULTS.merge(args.last.is_a?(Hash) ? args.pop : {})
+
+      if opts.respond_to?(:symbolize_keys!)
+        opts.symbolize_keys!
+      else
+        opts = symbolize_keys(opts)
+      end
+      
+      servers = Array(
+        args.any? ? args.unshift : opts.delete(:servers)
+      ).flatten.compact
+
+      opts[:prefix_key] ||= "#{opts[:namespace]}:"
+
+      @logger = opts[:logger]
+      @debug  = opts[:debug]
+
+      super(servers, opts)      
+  end
+
+  def symbolize_keys(opts)
+    # Destructively convert all keys to symbols.
+    if opts.kind_of?(Hash) && !opts.kind_of?(HashWithIndifferentAccess)
+      opts.keys.each do |key|
+        unless key.is_a?(Symbol)
+          opts[key.to_sym] = opts[key]
+          opts.delete(key)
+        end
+      end
+    end
+    opts
+  end
+  
+  def namespace
+    options[:prefix_key]
+  end
+
+  # Wraps Memcached::Rails#add to return a text string - for cache money
+  def add(key, value, ttl=@default_ttl, raw=false)
+    super(key, value, ttl, !raw)
+    stored
+  rescue Memcached::NotStored
+    not_stored
+  rescue Memcached::Error
+    log_error($!)
+    log_error($!) if logger
+    not_stored
+  end
+
+  def replace(key, value, ttl = @default_ttl, raw = false)
+    super(key, value, ttl, !raw)
+    stored
+  rescue Memcached::NotStored
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+    not_stored
+  end
+  
+  # Wraps Memcached#get so that it doesn't raise. This has the side-effect of preventing you from 
+  # storing <tt>nil</tt> values.
+  def get(key, raw=false)
+    logger.debug("Memcached get: #{key.inspect}") if logger && @debug
+    value = super(key, !raw)
+    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
+    value
+  rescue Memcached::NotFound
+    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
+    nil
+  rescue TypeError
+    log_error($!) if logger
+    delete(key)
+    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
+    nil
+  rescue Memcached::Error
+    log_error($!) if logger
+    nil
+  end
+
+  def fetch(key, expiry = 0, raw = false)
+    value = get(key, !raw)
+
+    if value.nil? && block_given?
+      value = yield
+      add(key, value, expiry, !raw)
+    end
+
+    value
+  end
+
+  # Wraps Memcached#cas so that it doesn't raise. Doesn't set anything if no value is present.
+  def cas(key, ttl=@default_ttl, raw=false, &block)
+    super(key, ttl, !raw, &block)
+    stored
+  rescue Memcached::NotFound
+  rescue TypeError
+    log_error($!) if logger
+    delete(key)
+    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
+  rescue Memcached::Error
+    if $!.is_a?(Memcached::ClientError)
+      raise $!
+    end
+    log_error($!) if logger
+  end
+  
+  def get_multi(*keys)
+    keys.flatten!
+    super(keys, true)
+  rescue TypeError
+    log_error($!) if logger
+    keys.each { |key| delete(key) }
+    logger.debug("Memcached deleted: #{keys.inspect}") if logger && @debug
+    {}
+  rescue Memcached::Error
+    log_error($!) if logger
+    {}
+  end
+
+  def set(key, value, ttl=@default_ttl, raw=false)
+    super(key, value, ttl, !raw)
+    stored
+  rescue Memcached::Error
+    log_error($!) if logger
+    not_stored
+  end
+
+  def append(key, value)
+    super(key, value)
+    stored
+  rescue Memcached::NotStored
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def prepend(key, value)
+    super(key, value)
+    stored
+  rescue Memcached::NotStored
+    not_stored
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def delete(key)
+    super(key)
+    deleted
+  rescue Memcached::NotFound
+    not_found
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+  
+  def incr(*args)
+    super
+  rescue Memcached::NotFound
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  def decr(*args)
+    super
+  rescue Memcached::NotFound
+  rescue Memcached::Error
+    log_error($!) if logger
+  end
+
+  alias :reset :quit
+  alias :close :quit #nodoc
+  alias :flush_all :flush
+  alias :compare_and_swap :cas
+  alias :"[]" :get
+  alias :"[]=" :set    
+
+private
+
+  def stored
+    "STORED\r\n"
+  end
+  
+  def deleted
+    "DELETED\r\n"
+  end
+  
+  def not_stored
+    "NOT_STORED\r\n"
+  end
+  
+  def not_found
+    "NOT_FOUND\r\n"
+  end
+
+  def log_error(err)
+    logger.error("#{err}: \n\t#{err.backtrace.join("\n\t")}") if logger
+  end
+  
+end
+else
+  Rails.logger.warn 'unable to determine memcache implementation'
+end #include the wraper

data/rails/init.rb

@@ -0,0 +1,39 @@
+yml = YAML.load(IO.read(File.join(RAILS_ROOT, "config", "memcached.yml")))
+memcache_config = yml[RAILS_ENV]
+memcache_config.symbolize_keys! if memcache_config.respond_to?(:symbolize_keys!)
+
+if defined?(DISABLE_CACHE_MONEY) || memcache_config.nil? || memcache_config[:cache_money] != true
+  Rails.logger.info 'cache-money disabled'
+  class ActiveRecord::Base
+    def self.index(*args)
+    end
+  end
+else
+  Rails.logger.info 'cache-money enabled'
+  require 'cache_money'
+
+  memcache_config[:logger] = Rails.logger
+  $memcache = MemcachedWrapper.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
+
+  #ActionController::Base.cache_store = :cache_money_mem_cache_store
+  ActionController::Base.session_options[:cache] = $memcache if memcache_config[:sessions]
+  #silence_warnings {
+  #  Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(:cache_money_mem_cache_store)
+  #}
+
+  $local = Cash::Local.new($memcache)
+  $lock  = Cash::Lock.new($memcache)
+  $cache = Cash::Transactional.new($local, $lock)
+
+  class ActiveRecord::Base
+    is_cached(:repository => $cache)
+
+    def <=>(other)
+      if self.id == other.id then 
+        0
+      else
+        self.id < other.id ? -1 : 1
+      end
+    end
+  end
+end

data/spec/cash/accessor_spec.rb

@@ -0,0 +1,174 @@
+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 '#fetch([])' do
+          it 'returns the empty hash' do
+            Story.fetch([]).should == {}
+          end
+        end
+        
+        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:1/yabba" => "doo",
+              "Story:1/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:1/yabba" => "dabba",
+              "Story:1/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 '#add' do
+      describe 'when the value already exists' do
+        describe 'when a block is given' do
+          it 'yields to the block' do
+            Story.set("count", 1)
+            Story.add("count", 1) { "yield me" }.should == "yield me"
+          end
+        end
+        
+        describe 'when no block is given' do
+          it 'does not error' do
+            Story.set("count", 1)
+            lambda { Story.add("count", 1) }.should_not raise_error
+          end
+        end
+      end
+
+      describe 'when the value does not already exist' do
+        it 'adds the key to the cache' do
+          Story.add("count", 1)
+          Story.get("count").should == 1
+        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
+
+    describe '#cache_key' do
+      it 'uses the version number' do
+        Story.version 1
+        Story.cache_key("foo").should == "Story:1/foo"
+
+        Story.version 2
+        Story.cache_key("foo").should == "Story:2/foo"
+      end
+    end
+  end
+end

data/spec/cash/active_record_spec.rb

@@ -0,0 +1,211 @@
+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, ...)' do
+          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 'finds the object in the correct order' do
+              story = Story.create!
+              Story.find(:first, :conditions => []).should == story
+            end
+          end
+        
+          describe "#find(:first, :conditions => '...')" do
+            it "coerces ruby values to the appropriate database values" do
+              story1 = Story.create! :title => 'a story', :published => true
+              story2 = Story.create! :title => 'another story', :published => false
+              Story.find(:first, :conditions => 'published = 0').should == story2
+            end
+          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
+
+        it "handles after_find on model" do
+          class AfterFindStory < Story
+            def after_find
+              self.title
+            end
+          end
+          lambda do
+            AfterFindStory.create!(:title => 'a story') 
+          end.should_not raise_error(ActiveRecord::MissingAttributeError)
+        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