cached_attribute 0.0.1

data/README.markdown

@@ -0,0 +1,43 @@
+CachedAttribute
+===============
+
+CachedAttribute is a plugin that allows expensive model attributes to be cached on a
+per-instance basis. It supports memoization, multiple cache stores, invalidation, and ttl.
+
+It can also be used to cached arbitrary methods based on their
+
+Example
+=======
+
+    class ComplicatedModel < ActiveRecord::Base
+      
+      def expensive_operation
+        ... something expensive ...
+      end
+      
+      # caches the calls to expensive_operation
+      cached_attribute :expensive_operation
+
+      class << self
+        def expensive_class_method(param1)
+          ... something expensive ...
+        end
+        cached_attribute :expensive_class_method
+      end
+
+    end
+
+    c = ComplicatedModel.new
+    c.expensive_operation # => slow
+    c.expensive_operation # => fast!
+
+    c.invalidate_expensive_operation
+    c.expensive_operation # => slow
+
+    ComplicatedModel.expensive_class_method('some string or something') # => slow
+    ComplicatedModel.expensive_class_method('some other string or something') # => slow
+    ComplicatedModel.expensive_class_method('some string or something') # => fast
+
+
+
+Copyright (c) 2009 Avvo, Inc., released under the MIT license

data/lib/cached_attribute.rb

@@ -0,0 +1,106 @@
+require 'digest/sha1'
+require 'pp'
+
+module CachedAttribute
+  module ClassMethods
+
+    #
+    # specifies that the attribute +attr+ should be cached. By default, the cache specified
+    # by the instance variable +Cache+ is used. +cached_attribute+ will also memoize the
+    # attribute by default.
+    #
+    # Options:
+    #
+    #   :ttl         - The ttl (in seconds) for the cached attribute. Defaults to 5 minutes.
+    #   :cache       - The cache store object to use for caching. Must respond to #get (with block)
+    #                  and #delete and #set or #put (key, value, expiry).
+    #   :identifier  - A block that takes a single parameter (of the object containing the cached
+    #                  attribute) and returns an identifier unique to that object. Defaults to
+    #                  lambda {|s| s.id}, which works fine for activerecord objects.
+    #   :memoize     - Whether the return value should be memoized into an instance variable.
+    #                  Defaults to true.
+    #
+    #
+    # Example:
+    #
+    #   class ComplicatedModel < ActiveRecord::Base
+    #
+    #     def expensive_operation
+    #       ... something expensive ...
+    #     end
+    #
+    #     # caches the calls to expensive_operation
+    #     cached_attribute :expensive_operation
+    #
+    #   end
+    #
+    def cached_attribute(attr, opts = {})
+
+      cache = opts[:cache] || (defined?(CACHE) && CACHE)
+      ttl = opts[:ttl] || 300
+
+      define_method("#{attr}_cache_key") do |*prms|
+        if prms.present?
+          identifier = prms.pretty_inspect # pretty inspect works nicely because it properly escpaes all the params into one string
+        else
+          identifier = opts[:identifier] ? opts[:identifier].call(self).to_s : self.id.to_s
+        end
+        # need to special case when we're caching class methods
+        klass_string = "#{self.class == Class ? self.name + '::self' : self.class.name}"
+        "#{klass_string}::#{attr}::#{Digest::SHA1.hexdigest(identifier)}"
+      end
+
+      define_method("#{attr}_with_caching") do |*prms|
+        if cache && (instance_variable_get("@#{attr}").nil? || prms.present?)
+          cache.fetch(send("#{attr}_cache_key", *prms), ttl) do
+            send("#{attr}_without_caching", *prms)
+          end
+        else
+          send("#{attr}_without_caching", *prms)
+        end
+      end
+
+      alias_method "#{attr}_without_caching", attr
+      alias_method attr, "#{attr}_with_caching"
+
+      unless opts[:memoize] == false
+
+        define_method("#{attr}_with_memoization") do |*prms|
+          value = instance_variable_get("@#{attr}")
+          if value.nil? || prms.present? # skip memoization if there are prms
+            value = instance_variable_set("@#{attr}", send("#{attr}_without_memoization", *prms))
+          end
+          value
+        end
+
+        alias_method "#{attr}_without_memoization", attr
+        alias_method attr, "#{attr}_with_memoization"
+      end
+
+      define_method("invalidate_#{attr}") do |*prms|
+        if cache
+          cache_key = send("#{attr}_cache_key", *prms)
+          cache.delete(cache_key)
+        end
+      end
+
+      # refreshs the cached attribute
+      define_method("refresh_#{attr}") do |*prms|
+        if cache
+          set_method = cache.respond_to?(:set) ? :set : :put
+          val = send("#{attr}_without_caching")
+          cache.send(set_method, send("#{attr}_cache_key", *prms), val, ttl)
+        end
+      end
+
+    end
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+end
+
+Object.instance_eval do
+  include CachedAttribute
+end

data/test/cached_attribute_test.rb

@@ -0,0 +1,170 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '../lib/cached_attribute')
+require 'init'
+require 'rubygems'
+require 'activesupport'
+
+class DummyCache
+
+  def self.reset
+    @data = {}
+    @cache_hit = false
+    @last_get = nil
+    @last_set = nil
+  end
+  reset
+
+  def self.cache_hit?
+    @cache_hit
+  end
+  
+  def self.last_set
+    @last_set
+  end
+
+  def self.last_get
+    @last_get
+  end
+  
+  def self.get(key, ttl = 60, &block)
+    
+    value, expires = @data[key]
+
+    if !value || expires < Time.now
+      if block
+        value, expires = set(key, block.call, ttl)
+      else
+        value, expires = Time.now
+      end
+    else
+      @cache_hit = true
+      @last_get = value
+    end
+    value
+  end
+
+  def self.delete(key)
+    @data[key] = nil
+  end
+
+  def self.set(key, value, ttl = 60)
+    @last_set = Time.now
+    @data[key] = [value, Time.now + ttl]
+  end
+
+end
+
+class BaseModel
+
+  class << self
+    def expensive_class_method(number)
+      number + 50
+    end
+    cached_attribute :expensive_class_method, :cache => DummyCache
+  end
+
+  def expensive_instance_method(p1, p2)
+    p1 + p2
+  end
+  cached_attribute :expensive_instance_method, :cache => DummyCache
+
+  def expensive_call
+    "hello" * 50
+  end
+
+  cached_attribute :expensive_call, :cache => DummyCache, :identifier => lambda {|s| 1}
+
+  def no_memoization
+    "hello" * 50
+  end
+
+  cached_attribute :no_memoization, :cache => DummyCache, :identifier => lambda {|s| 2}, :memoize => false
+
+  def low_ttl
+    "hello" * 50
+  end
+
+  cached_attribute :low_ttl, :cache => DummyCache, :identifier => lambda {|s| 3}, :memoize => false, :ttl => 1
+end
+
+class CachedAttributeTest < Test::Unit::TestCase
+  
+  def setup
+    DummyCache.reset
+    @m = BaseModel.new
+  end
+
+  def test_cached_attribute_method_put_on_class
+    assert BaseModel.respond_to?(:cached_attribute), "Cached attribute method was not found."
+  end
+
+  def test_cached_attribute_enabled
+    v = @m.no_memoization
+    assert !DummyCache.cache_hit?, "Cache should not be hit on initial call"
+    @m.no_memoization
+    assert DummyCache.cache_hit?, "Cache should be hit on the second call"
+    assert_equal(v, DummyCache.last_get)
+  end
+
+  def test_cached_attribute_memoizes_attribute
+    v1 = @m.expensive_call
+    assert_equal(v1, @m.instance_variable_get("@expensive_call"))
+    v2 = @m.expensive_call
+    assert_equal(v1, v2)
+  end
+
+  def test_cached_attribute_can_be_invalidated
+    @m.no_memoization
+    assert !DummyCache.cache_hit?, "Cache should not be hit on initial call"
+    @m.invalidate_no_memoization
+    @m.no_memoization
+    assert !DummyCache.cache_hit?, "Cache should not be hit after invalidation"
+  end
+
+  def test_ttl_should_work
+    @m.low_ttl
+    assert !DummyCache.cache_hit?, "Cache should not be hit on initial call"
+    sleep 1
+    @m.low_ttl
+    assert !DummyCache.cache_hit?, "Cache should not be hit after 1 second"
+  end
+
+  def test_refresh
+    @m.no_memoization
+    assert !DummyCache.cache_hit?, "Cache should not be hit on initial call"
+    last_set = DummyCache.last_set
+    @m.no_memoization
+    assert DummyCache.cache_hit?, "Cache should be a hit"
+    sleep 1
+    @m.refresh_no_memoization
+    next_set = DummyCache.last_set
+    @m.no_memoization
+    assert DummyCache.cache_hit?, "Cache should still be a hit"
+    assert(last_set < next_set)
+  end
+
+  def test_on_class_method_with_params
+    assert_equal(51, BaseModel.expensive_class_method(1))
+    assert !DummyCache.cache_hit?, 'First call should be miss'
+
+    assert_equal(51, BaseModel.expensive_class_method(1))
+    assert DummyCache.cache_hit?, 'Second call should be hit'
+  end
+
+  def test_on_instance_method_with_params
+    assert_equal(11, @m.expensive_instance_method(5, 6))
+    assert !DummyCache.cache_hit?, 'First call should be miss'
+
+    assert_equal(11, @m.expensive_instance_method(5, 6))
+    assert DummyCache.cache_hit?, 'Second call should be hit'
+  end
+
+  def test_class_method_key
+    assert_equal("BaseModel::self::expensive_class_method::#{Digest::SHA1.hexdigest([1].pretty_inspect)}", BaseModel.expensive_class_method_cache_key(1))
+  end
+
+  def test_instance_method_key
+    assert_equal("BaseModel::expensive_instance_method::#{Digest::SHA1.hexdigest([1].pretty_inspect)}", @m.expensive_instance_method_cache_key(1))
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: cached_attribute
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Justin Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-12 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: jweiss@avvo.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- lib/cached_attribute.rb
+- test/cached_attribute_test.rb
+- README.markdown
+homepage: http://code.avvo.com/2009/03/introducing-cached_attribute-cached-values-across-object-instances.html
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Cache values across object instances
+test_files:
+- test/cached_attribute_test.rb