cached_model 1.0.0 → 1.0.1

data/LICENSE

@@ -0,0 +1,30 @@
+All original code copyright 2005 Bob Cottrell and Eric Hodel, The Robot Co-op.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+4. Redistribution in Rails or any sub-projects of Rails is not allowed
+   until Rails runs without warnings with the ``-W2'' flag enabled.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/Manifest.txt

@@ -1,4 +1,6 @@
+LICENSE
 Manifest.txt
 README
 Rakefile
 lib/cached_model.rb
+test/test_cached_model.rb

data/Rakefile

@@ -8,7 +8,7 @@ $VERBOSE = nil
 
 spec = Gem::Specification.new do |s|
   s.name = 'cached_model'
-  s.version = '1.0.0'
+  s.version = '1.0.1'
   s.summary = 'An ActiveRecord::Base model that caches records'
   s.authors = 'Robert Cottrell, Eric Hodel'
   s.email = 'bob@robotcoop.com'
@@ -42,6 +42,14 @@ Rake::RDocTask.new :rdoc do |rd|
   rd.options << '-d' if `which dot` =~ /\/dot/
 end
 
+desc 'Generate RDoc for dev.robotcoop.com'
+Rake::RDocTask.new :dev_rdoc do |rd|
+  rd.rdoc_dir = '../../../www/trunk/dev/html/Libraries/cached_model'
+  rd.rdoc_files.add 'lib', 'README', 'LICENSE'
+  rd.main = 'README'
+  rd.options << '-d' if `which dot` =~ /\/dot/
+end
+
 desc 'Build Gem'
 Rake::GemPackageTask.new spec do |pkg|
   pkg.need_tar = true

data/lib/cached_model.rb

@@ -1,4 +1,7 @@
-require 'memcache_util'
+$TESTING = (defined? $TESTING) ? $TESTING : false
+
+require 'timeout'
+require 'memcache_util' unless $TESTING == :cached_model
 
 ##
 # An abstract ActiveRecord descendant that caches records in memcache and in
@@ -51,7 +54,7 @@ class CachedModel < ActiveRecord::Base
   end
 
   ##
-  # Invalidate the per-request cache.  This should be called from a before
+  # Invalidate the local process cache.  This should be called from a before
   # filter at the beginning of each request.
 
   def self.cache_reset
@@ -67,10 +70,15 @@ class CachedModel < ActiveRecord::Base
     # Only handle simple find requests.  If the request was more complicated,
     # let the base class handle it, but store the retrieved records in the
     # local cache in case we need them later.
-    if $TESTING or args.length != 1 or not Fixnum === args.first then
+    if ($TESTING and $TESTING != :cached_model) or
+       args.length != 1 or not Fixnum === args.first then
       records = super
-      if RAILS_ENV != 'test' and Array === records then
+      return records if RAILS_ENV == 'test'
+      case records
+      when Array then
         records.each { |r| r.cache_store }
+      when CachedModel then
+        records.cache_store
       end
       return records
     end
@@ -111,27 +119,15 @@ class CachedModel < ActiveRecord::Base
   # key, use a simple find call instead.
 
   def self.find_by_sql(*args)
-    unless @skip_find_hack or $TESTING then
+    unless @skip_find_hack or ($TESTING and $TESTING != :cached_model) then
       if args.first =~ /SELECT \* FROM #{table_name} WHERE \(#{table_name}\.#{primary_key} = '?(\d+)'?\) LIMIT 1/ then
-        return [self.find($1.to_i)]
+        return [find($1.to_i)]
       end
     end
 
     return super
   end
 
-  ##
-  # Delete the entry from the cache so that the next call goes to the database
-  # for the freshest copy of the record.  This will also ensure that if for
-  # some reason a stale copy of the record was cached we can get rid of it.
-
-  def update
-    cache_delete
-    val = super
-    cache_store
-    return val
-  end
-
   ##
   # Delete the entry from the cache now that it isn't in the DB.
 
@@ -147,21 +143,17 @@ class CachedModel < ActiveRecord::Base
   def reload
     cache_delete
     return super
+  ensure
+    cache_store
   end
 
   ##
-  # The local object cache.
-
-  def cache_local
-    return CachedModel.cache_local
-  end
-
-  ##
-  # Store this record in the cache.
+  # Store a new copy of ourselves into the cache.
 
-  def cache_store
-    cache_local[cache_key_memcache] = self
-    Cache.put cache_key_memcache, self, TTL
+  def update
+    return super
+  ensure
+    cache_store
   end
 
   ##
@@ -176,7 +168,7 @@ class CachedModel < ActiveRecord::Base
   # The local cache key for this record.
 
   def cache_key_local
-    return "#{self.class.name}:#{self.id}"
+    return "#{self.class}:#{id}"
   end
 
   ##
@@ -186,5 +178,23 @@ class CachedModel < ActiveRecord::Base
     return "#{KEY}:#{cache_key_local}"
   end
 
+  ##
+  # The local object cache.
+
+  def cache_local
+    return CachedModel.cache_local
+  end
+
+  ##
+  # Store this record in the cache without associations.  Storing associations
+  # leads to wasted cache space and hard-to-debug problems.
+
+  def cache_store
+    obj = dup
+    obj.send :instance_variable_set, :@attributes, attributes_before_type_cast
+    cache_local[cache_key_local] = obj
+    Cache.put cache_key_memcache, obj, TTL
+  end
+
 end
 

data/test/test_cached_model.rb

@@ -0,0 +1,305 @@
+require 'test/unit'
+
+$TESTING = :cached_model
+
+RAILS_ENV = 'production'
+
+module ActiveRecord; end
+
+class ActiveRecord::Base
+
+  @count = 1000
+
+  attr_accessor :id, :attributes
+
+  def self.next_id
+    @count += 1
+    return @count
+  end
+
+  def self.table_name
+    name.downcase
+  end
+
+  def self.primary_key
+    'id'
+  end
+
+  def self.find(*args)
+    args.flatten!
+    return [new] if args.length == 1 and Fixnum === args.first
+    return new if args.length == 2
+    return [new, new, new] if args.length == 3
+  end
+
+  def self.find_by_sql(query)
+    return [new]
+  end
+
+  def initialize
+    @id = ActiveRecord::Base.next_id
+    @attributes = { :data => 'data' }
+  end
+
+  def ==(other)
+    self.class == other.class and
+    id == other.id and
+    attributes_before_type_cast == other.attributes_before_type_cast
+  end
+
+  def attributes_before_type_cast
+    { :data => @attributes[:data] }
+  end
+
+  def destroy
+  end
+
+  def reload
+    @attributes[:data].succ!
+    @attributes[:extra] = nil
+  end
+
+  def update
+  end
+
+end
+
+require 'cached_model'
+
+class Concrete < CachedModel; end
+class STILameness < Concrete; end
+
+module Cache
+
+  @cache = {}
+  @ttl = {}
+
+  class << self; attr_accessor :cache, :ttl; end
+
+  def self.delete(key)
+    @cache.delete key
+    @ttl.delete key
+    return nil
+  end
+
+  def self.get(key)
+    @cache[key]
+  end
+
+  def self.put(key, value, ttl)
+    value = Marshal.load Marshal.dump(value)
+    @cache[key] = value
+    @ttl[key] = ttl
+  end
+
+end
+
+class << CachedModel
+
+  attr_writer :cache_local
+
+end
+
+class TestCachedModel < Test::Unit::TestCase
+
+  def setup
+    @model = Concrete.new
+    Cache.cache = {}
+    Cache.ttl = {}
+    CachedModel.cache_local = {}
+  end
+
+  def test_class_cache_delete
+    util_set
+
+    CachedModel.cache_delete @model.class, @model.id
+
+    assert_equal true, CachedModel.cache_local.empty?
+    assert_equal true, Cache.cache.empty?
+  end
+
+  def test_class_cache_reset
+    util_set
+
+    CachedModel.cache_reset
+    
+    assert_equal true, CachedModel.cache_local.empty?
+    assert_equal false, Cache.cache.empty?
+  end
+
+  def test_class_descends_from_active_record?
+    assert_equal true, Concrete.descends_from_active_record?
+    assert_equal false, STILameness.descends_from_active_record?
+  end
+
+  def test_class_find_complex
+    record = Concrete.find(1, :order => 'lock_version')
+    assert_equal @model.id + 1, record.id
+
+    assert_equal record, CachedModel.cache_local[record.cache_key_local]
+    assert_equal record, Cache.cache[record.cache_key_memcache]
+  end
+
+  def test_class_find_in_local_cache
+    util_set
+
+    record = Concrete.find(1, :order => 'lock_version')
+    assert_equal @model.id + 1, record.id
+
+    assert_equal record, CachedModel.cache_local[record.cache_key_local]
+    assert_equal record, Cache.cache[record.cache_key_memcache]
+  end
+
+  def test_class_find_in_memcache
+    util_set
+    CachedModel.cache_reset
+
+    record = Concrete.find @model.id
+    assert_equal @model, record
+
+    assert_equal record, CachedModel.cache_local[record.cache_key_local]
+  end
+
+  def test_class_find_multiple
+    ids = [@model.id + 1, @model.id + 2, @model.id + 3]
+    records = Concrete.find(*ids)
+    assert_equal ids, records.map { |r| r.id }
+
+    assert_equal ids.map { |i| "#{@model.class}:#{i}" },
+                 CachedModel.cache_local.keys
+    assert_equal ids.map { |i| "#{CachedModel::KEY}:#{@model.class}:#{i}" },
+                 Cache.cache.keys
+  end
+
+  def test_class_find_not_cached
+    record = Concrete.find @model.id + 1
+    assert_equal @model.id + 1, record.id
+
+    assert_equal record, CachedModel.cache_local[record.cache_key_local]
+    assert_equal record, Cache.cache[record.cache_key_memcache]
+  end
+
+  def test_class_find_by_sql
+    q = "SELECT * FROM concrete WHERE (concrete.id = #{@model.id + 1}) LIMIT 1"
+    record = Concrete.find_by_sql(q).first
+    assert_equal @model.id + 1, record.id
+
+    assert_equal record, CachedModel.cache_local[record.cache_key_local]
+    assert_equal record, Cache.cache[record.cache_key_memcache]
+  end
+
+  def test_class_find_by_sql_skip_hack
+    Concrete.instance_variable_set :@skip_find_hack, true
+    q = "SELECT * FROM concrete WHERE (concrete.id = #{@model.id + 1}) LIMIT 1"
+    record = Concrete.find_by_sql(q).first
+    assert_equal @model.id + 1, record.id
+
+    assert_equal true, CachedModel.cache_local.empty?
+    assert_equal true, Cache.cache.empty?
+  ensure
+    Concrete.instance_variable_set :@skip_find_hack, false
+  end
+
+  def test_class_name_of_active_record_descendant
+    assert_equal "Concrete",
+                 CachedModel.class_name_of_active_record_descendant(Concrete)
+    assert_equal "Concrete",
+                 CachedModel.class_name_of_active_record_descendant(STILameness)
+  end
+
+  def test_cache_delete
+    util_set
+
+    @model.cache_delete
+
+    assert_equal true, CachedModel.cache_local.empty?
+    assert_equal true, Cache.cache.empty?
+  end
+
+  def test_cache_key_local
+    assert_equal "#{@model.class}:#{@model.id}", @model.cache_key_local
+  end
+
+  def test_cache_key_memcache
+    assert_equal "#{CachedModel::KEY}:#{@model.class}:#{@model.id}",
+                 @model.cache_key_memcache
+  end
+
+  def test_cache_local
+    assert_same CachedModel.cache_local, @model.cache_local
+  end
+
+  def test_cache_store
+    @model.cache_store
+    assert_equal false, CachedModel.cache_local.empty?
+    assert_equal false, Cache.cache.empty?
+
+    assert_equal @model, CachedModel.cache_local[@model.cache_key_local]
+    assert_equal @model, Cache.cache[@model.cache_key_memcache]
+    assert_equal CachedModel::TTL, Cache.ttl[@model.cache_key_memcache]
+  end
+
+  def test_cache_store_with_attributes
+    @model.attributes[:extra] = 'extra'
+    @model.cache_store
+    assert_equal false, CachedModel.cache_local.empty?
+    assert_equal false, Cache.cache.empty?
+
+    local_model = CachedModel.cache_local[@model.cache_key_local]
+    mem_model = Cache.cache[@model.cache_key_memcache]
+    assert_equal @model, local_model
+    assert_equal @model, mem_model
+    assert_equal CachedModel::TTL, Cache.ttl[@model.cache_key_memcache]
+
+    expected = {:data => 'data'}
+
+    assert_equal expected, local_model.attributes
+    assert_equal expected, mem_model.attributes
+  end
+
+  def test_destroy
+    util_set
+
+    @model.destroy
+
+    assert_equal true, CachedModel.cache_local.empty?
+    assert_equal true, Cache.cache.empty?
+  end
+
+  def test_reload
+    util_set
+
+    @model.reload
+
+    assert_equal false, CachedModel.cache_local.empty?
+    assert_equal false, Cache.cache.empty?
+
+    assert_equal 'datb',
+                 CachedModel.cache_local[@model.cache_key_local].attributes[:data]
+    assert_equal 'datb',
+                 Cache.cache[@model.cache_key_memcache].attributes[:data]
+  end
+
+  def test_update
+    util_set
+
+    @model.attributes[:data] = 'atad'
+    @model.update
+
+    assert_equal false, CachedModel.cache_local.empty?
+    assert_equal false, Cache.cache.empty?
+
+    assert_equal 'atad',
+                 CachedModel.cache_local[@model.cache_key_local].attributes[:data]
+    assert_equal 'atad',
+                 Cache.cache[@model.cache_key_memcache].attributes[:data]
+  end
+
+  def util_set(klass = @model.class, id = @model.id, data = @model)
+    key = "#{klass}:#{id}"
+    CachedModel.cache_local[key] = data
+    Cache.cache["#{CachedModel::KEY}:#{key}"] = data
+  end
+
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11.6
 specification_version: 1
 name: cached_model
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-01-17 00:00:00 -08:00
+  version: 1.0.1
+date: 2006-01-30 00:00:00 -08:00
 summary: An ActiveRecord::Base model that caches records
 require_paths: 
 - lib
@@ -28,10 +28,12 @@ cert_chain:
 authors: 
 - Robert Cottrell, Eric Hodel
 files: 
+- LICENSE
 - Manifest.txt
 - README
 - Rakefile
 - lib/cached_model.rb
+- test/test_cached_model.rb
 test_files: []
 
 rdoc_options: []