ashleym1972-cache-money 0.2.6 → 0.2.7

data/lib/cache_money.rb

@@ -14,7 +14,7 @@ require 'cash/config'
 require 'cash/accessor'
 
 require 'cash/request'
-require 'cash/mock'
+require 'cash/fake'
 require 'cash/local'
 
 require 'cash/query/abstract'
@@ -28,8 +28,8 @@ require 'cash/util/marshal'
 class ActiveRecord::Base
   def self.is_cached(options = {})
     options.assert_valid_keys(:ttl, :repository, :version)
-    include Cash
-    ::Cash::Config::Config.create(self, options)
+    include Cash unless ancestors.include?(Cash)
+    Cash::Config::Config.create(self, options)
   end
 end
 

data/lib/cash/accessor.rb

@@ -11,8 +11,10 @@ module Cash
       def fetch(keys, options = {}, &block)
         case keys
         when Array
+          return {} if keys.empty?
+          
           keys = keys.collect { |key| cache_key(key) }
-          hits = repository.get_multi(keys)
+          hits = repository.get_multi(*keys)
           if (missed_keys = keys - hits.keys).any?
             missed_values = block.call(missed_keys)
             hits.merge!(missed_keys.zip(Array(missed_values)).to_hash_without_nils)

data/lib/cash/buffered.rb

@@ -62,7 +62,7 @@ module Cash
       buffer_command Command.new(:delete, key, *options)
     end
 
-    def get_multi(keys)
+    def get_multi(*keys)
       values = keys.collect { |key| get(key) }
       keys.zip(values).to_hash_without_nils
     end

data/lib/cash/config.rb

@@ -1,5 +1,10 @@
 module Cash
   module Config
+    def self.create(active_record, options, indices = [])
+      active_record.cache_config = Config.new(active_record, options)
+      indices.each { |i| active_record.index i.attributes, i.options }
+    end
+    
     def self.included(a_module)
       a_module.module_eval do
         extend ClassMethods
@@ -38,11 +43,6 @@ module Cash
     class Config
       attr_reader :active_record, :options
 
-      def self.create(active_record, options, indices = [])
-        active_record.cache_config = new(active_record, options)
-        indices.each { |i| active_record.index i.attributes, i.options }
-      end
-
       def initialize(active_record, options = {})
         @active_record, @options = active_record, options
       end
@@ -64,7 +64,7 @@ module Cash
       end
 
       def inherit(active_record)
-        self.class.create(active_record, @options, indices)
+        Cash::Config.create(active_record, @options, indices)
       end
     end
   end

data/lib/cash/fake.rb

@@ -0,0 +1,83 @@
+module Cash
+  class Fake < HashWithIndifferentAccess
+    attr_accessor :servers
+
+    def get_multi(*keys)
+      slice(*keys).collect { |k,v| [k, Marshal.load(v)] }.to_hash
+    end
+
+    def set(key, value, ttl = 0, raw = false)
+      self[key] = marshal(value, raw)
+    end
+
+    def get(key, raw = false)
+      if raw
+        self[key]
+      else
+        if self.has_key?(key)
+          Marshal.load(self[key])
+        else
+          nil
+        end
+      end
+    end
+
+    def incr(key, amount = 1)
+      if self.has_key?(key)
+        self[key] = (self[key].to_i + amount).to_s
+        self[key].to_i
+      end
+    end
+
+    def decr(key, amount = 1)
+      if self.has_key?(key)
+        self[key] = (self[key].to_i - amount).to_s
+        self[key].to_i
+      end
+    end
+
+    def add(key, value, ttl = 0, raw = false)
+      return false if self.has_key?(key)
+
+      self[key] = marshal(value, raw)
+      true
+    end
+
+    def append(key, value)
+      set(key, get(key, true).to_s + value.to_s, nil, true)
+    end
+
+    def namespace
+      nil
+    end
+
+    def flush_all
+      clear
+    end
+
+    def stats
+      {}
+    end
+
+    def reset_runtime
+      [0, Hash.new(0)]
+    end
+
+    private
+    def marshal(value, raw)
+      if raw
+        value.to_s
+      else
+        Marshal.dump(value)
+      end
+    end
+
+    def unmarshal(marshaled_obj)
+      Marshal.load(marshaled_obj)
+    end
+
+    def deep_clone(obj)
+      unmarshal(marshal(obj))
+    end
+  end
+end

data/lib/cash/index.rb

@@ -22,15 +22,13 @@ module Cash
 
     module Commands
       def add(object)
-        clone = object.shallow_clone
         _, new_attribute_value_pairs = old_and_new_attribute_value_pairs(object)
-        add_to_index_with_minimal_network_operations(new_attribute_value_pairs, clone)
+        add_to_index_with_minimal_network_operations(new_attribute_value_pairs, object)
       end
 
       def update(object)
-        clone = object.shallow_clone
         old_attribute_value_pairs, new_attribute_value_pairs = old_and_new_attribute_value_pairs(object)
-        update_index_with_minimal_network_operations(old_attribute_value_pairs, new_attribute_value_pairs, clone)
+        update_index_with_minimal_network_operations(old_attribute_value_pairs, new_attribute_value_pairs, object)
       end
 
       def remove(object)
@@ -70,7 +68,7 @@ module Cash
     include Attributes
 
     def serialize_object(object)
-      primary_key? ? object : object.id
+      primary_key? ? object.shallow_clone : object.id
     end
 
     def matches?(query)
@@ -105,7 +103,7 @@ module Cash
     end
 
     def add_object_to_primary_key_cache(attribute_value_pairs, object)
-      set(cache_key(attribute_value_pairs), [object], :ttl => ttl)
+      set(cache_key(attribute_value_pairs), [serialize_object(object)], :ttl => ttl)
     end
 
     def cache_key(attribute_value_pairs)

data/lib/cash/local.rb

@@ -14,7 +14,20 @@ module Cash
     end
 
     def method_missing(method, *args, &block)
-      @remote_cache.send(method, *args, &block)
+      autoload_missing_constants do
+        @remote_cache.send(method, *args, &block)
+      end
+    end
+    
+    def autoload_missing_constants
+      yield if block_given?
+    rescue ArgumentError, MemCache::MemCacheError => error
+      lazy_load ||= Hash.new { |hash, hash_key| hash[hash_key] = true; false }
+      if error.to_s[/undefined class|referred/] && !lazy_load[error.to_s.split.last.constantize]
+        retry
+      else
+        raise error
+      end
     end
   end
 

data/lib/cash/lock.rb

@@ -2,19 +2,19 @@ module Cash
   class Lock
     class Error < RuntimeError; end
 
+    INITIAL_WAIT = 1
     DEFAULT_RETRY = 5
     DEFAULT_EXPIRY = 30
 
     def initialize(cache)
       @cache = cache
-      @runtime = Benchmark::Tms.new
     end
 
-    def synchronize(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY)
+    def synchronize(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY, initial_wait = INITIAL_WAIT)
       if recursive_lock?(key)
         yield
       else
-        acquire_lock(key, lock_expiry, retries)
+        acquire_lock(key, lock_expiry, retries, initial_wait)
         begin
           yield
         ensure
@@ -23,14 +23,12 @@ module Cash
       end
     end
 
-    def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY)
+    def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY, initial_wait = INITIAL_WAIT)
       retries.times do |count|
-        begin
-          response = @cache.add("lock/#{key}", Process.pid, lock_expiry)
-          return if response == "STORED\r\n"
-          raise Error if count == retries - 1
-        end
-        exponential_sleep(count) unless count == retries - 1
+        response = @cache.add("lock/#{key}", Process.pid, lock_expiry)
+        return if response == "STORED\r\n"
+        raise Error if count == retries - 1
+        exponential_sleep(count, initial_wait) unless count == retries - 1
       end
       raise Error, "Couldn't acquire memcache lock for: #{key}"
     end
@@ -39,8 +37,8 @@ module Cash
       @cache.delete("lock/#{key}")
     end
 
-    def exponential_sleep(count)
-      @runtime += Benchmark::measure { sleep((2**count) / 2.0) }
+    def exponential_sleep(count, initial_wait)
+      sleep((2**count) / initial_wait)
     end
 
     private

data/lib/cash/query/abstract.rb

@@ -33,7 +33,7 @@ module Cash
       def order
         @order ||= begin
           if order_sql = @options1[:order] || @options2[:order]
-            matched, table_name, column_name, direction = *(ORDER.match(order_sql))
+            matched, table_name, column_name, direction = *(ORDER.match(order_sql.to_s))
             [column_name, direction =~ DESC ? :desc : :asc]
           else
             ['id', :asc]

data/rails/init.rb

@@ -10,9 +10,9 @@ if memcache_config.nil? || memcache_config[:cache_money].nil?
 else
   require 'cache_money'
 
-  ##$memcache = Rails.cache
   memcache_config[:logger] = Rails.logger
   $memcache = MemCache.new(memcache_config[:servers], memcache_config)
+  # $memcache = Memcached::Rails.new(memcache_config['servers'], memcache_config)
 
   ActionController::Base.cache_store = :cache_money_mem_cache_store
   ActionController::Base.session_options[:cache] = $memcache if memcache_options[:sessions]

data/spec/cash/accessor_spec.rb

@@ -19,6 +19,12 @@ module Cash
       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 == {
@@ -104,9 +110,18 @@ module Cash
 
     describe '#add' do
       describe 'when the value already exists' do
-        it 'yields to the block' do
-          Story.set("count", 1)
-          Story.add("count", 1) { "yield me" }.should == "yield me"
+        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
 

data/spec/cash/active_record_spec.rb

@@ -109,27 +109,28 @@ module Cash
           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
+        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
-        end
 
-        describe '#find(:first, :conditions => [])' do
-          it 'works' do
-            story = Story.create!
-            Story.find(:first, :conditions => []).should == story
+          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
-        end
         
-        describe "#find(:first, :conditions => '...')" do
-          it "uses the active record instance to typecast values extracted from the conditions" do
-            story1 = Story.create! :title => 'a story', :published => true
-            story2 = Story.create! :title => 'another story', :published => false
-            Story.get('published/false').should == [story2.id]
-            Story.find(:first, :conditions => 'published = 0').should == story2
+          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

data/spec/cash/finders_spec.rb

@@ -22,7 +22,7 @@ module Cash
           end
 
           describe '#find(:first, ...)' do
-            describe '#find(:first, :conditions => { :id => ?})' do
+            describe '#find(:first, :conditions => { :id => ? })' do
               it "does not use the database" do
                 story = Story.create!
                 mock(Story.connection).execute.never
@@ -99,6 +99,15 @@ module Cash
                       .should == story
                   end
                 end
+                
+                describe 'when the attributes must be coerced to sql values' do
+                  it 'does not use the database' do
+                    story1 = Story.create!(:published => true)
+                    story2 = Story.create!(:published => false)
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => 'published = 0').should == story2
+                  end
+                end
               end
 
               describe '#find(:first, :conditions => [...])' do

data/spec/cash/lock_spec.rb

@@ -31,7 +31,7 @@ module Cash
         $memcache.get("lock/lock_key").should == nil
       end
 
-      specify "does not block on recursive lock acquisition" do
+      it "does not block on recursive lock acquisition" do
         $lock.synchronize('lock_key') do
           lambda { $lock.synchronize('lock_key') {} }.should_not raise_error
         end
@@ -39,43 +39,64 @@ module Cash
     end
 
     describe '#acquire_lock' do
-      specify "creates a lock at a given cache key" do
+      it "creates a lock at a given cache key" do
         $memcache.get("lock/lock_key").should == nil
         $lock.acquire_lock("lock_key")
         $memcache.get("lock/lock_key").should_not == nil
       end
 
-      specify "retries specified number of times" do
-        $lock.acquire_lock('lock_key')
-        as_another_process do
-          mock($memcache).add("lock/lock_key", Process.pid, timeout = 10) { "NOT_STORED\r\n" }.times(3)
-          stub($lock).exponential_sleep
-          lambda { $lock.acquire_lock('lock_key', timeout, 3) }.should raise_error
+      describe 'when given a timeout for the lock' do
+        it "correctly sets timeout on memcache entries" do
+          mock($memcache).add('lock/lock_key', Process.pid, timeout = 10) { true }
+          $lock.acquire_lock('lock_key', timeout)
         end
       end
 
-      specify "correctly sets timeout on memcache entries" do
-        mock($memcache).add('lock/lock_key', Process.pid, timeout = 10) { "STORED\r\n" }
-        $lock.acquire_lock('lock_key', timeout)
-      end
-
-      specify "prevents two processes from acquiring the same lock at the same time" do
-        $lock.acquire_lock('lock_key')
-        as_another_process do
-          lambda { $lock.acquire_lock('lock_key') }.should raise_error
+      describe 'when to processes contend for a lock' do
+        it "prevents two processes from acquiring the same lock at the same time" do
+          $lock.acquire_lock('lock_key')
+          as_another_process do
+            stub($lock).exponential_sleep
+            lambda { $lock.acquire_lock('lock_key') }.should raise_error
+          end
+        end
+        
+        describe 'when given a number of times to retry' do
+          it "retries specified number of times" do
+            $lock.acquire_lock('lock_key')
+            as_another_process do
+              mock($memcache).add("lock/lock_key", Process.pid, timeout = 10) { false }.times(retries = 3)
+              stub($lock).exponential_sleep
+              lambda { $lock.acquire_lock('lock_key', timeout, retries) }.should raise_error
+            end
+          end
+        end
+        
+        describe 'when given an initial wait' do
+          it 'sleeps exponentially starting with the initial wait' do
+            mock($lock).sleep(initial_wait = 0.123)
+            mock($lock).sleep(2 * initial_wait)
+            mock($lock).sleep(4 * initial_wait)
+            mock($lock).sleep(8 * initial_wait)
+            $lock.acquire_lock('lock_key')
+            as_another_process do
+              lambda { $lock.acquire_lock('lock_key', Lock::DEFAULT_EXPIRY, Lock::DEFAULT_RETRY, initial_wait) }.should raise_error
+            end            
+          end
         end
-      end
 
-      def as_another_process
-        current_pid = Process.pid
-        stub(Process).pid { current_pid + 1 }
-        yield
+        def as_another_process
+          current_pid = Process.pid
+          stub(Process).pid { current_pid + 1 }
+          yield
+        end
+        
       end
 
     end
 
     describe '#release_lock' do
-      specify "deletes the lock for a given cache key" do
+      it "deletes the lock for a given cache key" do
         $memcache.get("lock/lock_key").should == nil
         $lock.acquire_lock("lock_key")
         $memcache.get("lock/lock_key").should_not == nil

data/spec/cash/order_spec.rb

@@ -87,6 +87,12 @@ module Cash
               FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.id').should == @fairy_tales
               FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.`id`').should == @fairy_tales
             end
+            
+            describe 'when the order is passed as a symbol' do
+              it 'works' do
+                FairyTale.find(:all, :conditions => { :title => @title }, :order => :id)
+              end
+            end
           end
 
           describe 'when the cache is not populated' do

data/spec/cash/transactional_spec.rb

@@ -73,14 +73,14 @@ module Cash
           it 'returns a hash' do
             @cache.set('key1', @value)
             @cache.set('key2', @value)
-            @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value, 'key2' => @value }
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
           end
         end
 
         describe 'when there are misses' do
           it 'only returns results for hits' do
             @cache.set('key1', @value)
-            @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value }
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value }
           end
         end
       end
@@ -203,7 +203,7 @@ module Cash
             @cache.transaction do
               @cache.set('key1', @value)
               @cache.set('key2', [])
-              @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value, 'key2' => [] }
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => [] }
             end
           end
         end
@@ -213,7 +213,7 @@ module Cash
             @cache.transaction do
               @cache.set('key1', @value)
               @cache.set('key2', @value)
-              @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value, 'key2' => @value }
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
             end
           end
         end
@@ -222,7 +222,7 @@ module Cash
           it 'only returns results for hits' do
             @cache.transaction do
               @cache.set('key1', @value)
-              @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value }
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value }
             end
           end
         end
@@ -286,8 +286,8 @@ module Cash
           @cache.transaction do
             @cache.set('key1', @value)
             @cache.set('key2', @value)
-            @cache.get_multi(['key1', 'key2']).should == { 'key1' => @value, 'key2' => @value }
-            $memcache.get_multi(['key1', 'key2']).should == {}
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
+            $memcache.get_multi('key1', 'key2').should == {}
           end
         end
 

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@ require 'spec'
 require 'pp'
 require 'cache_money'
 require 'memcache'
+# require 'memcached'
 require File.join(dir, '../config/environment')
 
 Spec::Runner.configure do |config|
@@ -13,9 +14,9 @@ Spec::Runner.configure do |config|
   config.before :suite do
     load File.join(dir, "../db/schema.rb")
 
-    config = YAML.load(IO.read((File.expand_path(File.dirname(__FILE__) + "/../config/memcache.yml"))))['test']
-    $memcache = MemCache.new(config)
-    $memcache.servers = config['servers']
+    config = YAML.load(IO.read((File.expand_path(File.dirname(__FILE__) + "/../config/memcached.yml"))))['test']
+    $memcache = MemCache.new(config['servers'], config)
+    # $memcache = Memcached::Rails.new(config['servers'], config)
     $lock = Cash::Lock.new($memcache)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ashleym1972-cache-money
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - Nick Kallen
@@ -61,7 +61,7 @@ files:
 - lib/cash/index.rb
 - lib/cash/local.rb
 - lib/cash/lock.rb
-- lib/cash/mock.rb
+- lib/cash/fake.rb
 - lib/cash/query/abstract.rb
 - lib/cash/query/calculation.rb
 - lib/cash/query/primary_key.rb
@@ -103,7 +103,7 @@ specification_version: 2
 summary: Write-through and Read-through Cacheing for ActiveRecord
 test_files: 
 - config/environment.rb
-- config/memcache.yml
+- config/memcached.yml
 - db/schema.rb
 - spec/cash/accessor_spec.rb
 - spec/cash/active_record_spec.rb

data/lib/cash/mock.rb

@@ -1,154 +0,0 @@
-module Cash
-  class Mock < HashWithIndifferentAccess
-    attr_accessor :servers
-
-    class CacheEntry
-      attr_reader :value
-      
-      def self.default_ttl
-        1_000_000
-      end
-
-      def self.now
-        Time.now
-      end
-      
-      def initialize(value, raw, ttl)
-        if raw
-          @value = value.to_s
-        else
-          @value = Marshal.dump(value)
-        end
-        
-        if ttl.zero?
-          @ttl = self.class.default_ttl
-        else
-          @ttl = ttl
-        end
-        
-        @expires_at = self.class.now + @ttl
-      end
-      
-      
-      def expired?
-        self.class.now > @expires_at
-      end
-      
-      def increment(amount = 1)
-        @value = (@value.to_i + amount).to_s
-      end
-      
-      def decrement(amount = 1)
-        @value = (@value.to_i - amount).to_s
-      end
-      
-      def unmarshal
-        Marshal.load(@value)
-      end
-      
-      def to_i
-        @value.to_i
-      end
-    end
-    
-    attr_accessor :logging
-    
-    def initialize
-      @logging = false
-    end
-    
-    def get_multi(keys)
-      slice(*keys).collect { |k,v| [k, v.unmarshal] }.to_hash_without_nils
-    end
-
-    def set(key, value, ttl = CacheEntry.default_ttl, raw = false)
-      log "< set #{key} #{ttl}"
-      self[key] = CacheEntry.new(value, raw, ttl)
-      log('> STORED')
-    end
-
-    def get(key, raw = false)
-      log "< get #{key}"
-      unless self.has_unexpired_key?(key)
-        log('> END')
-        return nil
-      end
-      
-      log("> sending key #{key}")
-      log('> END')
-      if raw
-        self[key].value
-      else
-        self[key].unmarshal
-      end
-    end
-    
-    def delete(key, options = {})
-      log "< delete #{key}"
-      if self.has_unexpired_key?(key)
-        log "> DELETED"
-        super(key)
-      else
-        log "> NOT FOUND"
-      end
-    end
-
-    def incr(key, amount = 1)
-      if self.has_unexpired_key?(key)
-        self[key].increment(amount)
-        self[key].to_i
-      end
-    end
-
-    def decr(key, amount = 1)
-      if self.has_unexpired_key?(key)
-        self[key].decrement(amount)
-        self[key].to_i
-      end
-    end
-
-    def add(key, value, ttl = CacheEntry.default_ttl, raw = false)
-      if self.has_unexpired_key?(key)
-        "NOT_STORED\r\n"
-      else
-        set(key, value, ttl, raw)
-        "STORED\r\n"
-      end
-    end
-
-    def append(key, value)
-      set(key, get(key, true).to_s + value.to_s, nil, true)
-    end
-
-    def namespace
-      nil
-    end
-
-    def flush_all
-      log('< flush_all')
-      clear
-    end
-
-    def stats
-      {}
-    end
-
-    def reset_runtime
-      [0, Hash.new(0)]
-    end
-
-    def has_unexpired_key?(key)
-      self.has_key?(key) && !self[key].expired?
-    end
-    
-    def log(message)
-      return unless logging
-      logger.debug(message)
-    end
-    
-    def logger
-      @logger ||= ActiveSupport::BufferedLogger.new(Rails.root.join('log/cash_mock.log'))
-    end
-    
-  end
-end