cache_value 0.3.0 → 0.4.4

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.4

data/cache_value.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cache_value}
-  s.version = "0.3.0"
+  s.version = "0.4.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Crawley"]
-  s.date = %q{2010-01-07}
+  s.date = %q{2010-06-10}
   s.email = %q{tcrawley@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -35,7 +35,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/tobias/cache_value}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Easy value caching}
   s.test_files = [
     "test/cache_machine_test.rb",

data/lib/cache_value/cache_machine.rb

@@ -1,80 +1,108 @@
 require 'active_support/core_ext/array'
 require 'active_support/core_ext/class'
+require 'active_support/core_ext/float'
 require 'active_support/inflector'
 require 'active_support/cache'
 require 'cache_value/util'
+require 'benchmark'
 
 module CacheValue
   class CacheMachine
-    extend Util
-    
+    include Util
+
     class << self
 
       def cache_store=(*store_option)
-        @cache_store = store_option ? ActiveSupport::Cache.lookup_store(store_option) : nil
-      end
-      
-      def cache_store
-        @cache_store ||= ActiveSupport::Cache.lookup_store(:file_store, default_storage_dir)
+        @cache_store = store_option ? ActiveSupport::Cache.lookup_store(*store_option) : nil
       end
 
-      def default_storage_dir
-        if !defined?(RAILS_ROOT)
-          raise ConfigurationException.new('Not running under rails. Set the cache_store type ' +
-                                           'and location manually using CacheValue::CacheMachine.cache_store=')
-        end
-        
-        File.join(RAILS_ROOT, 'tmp', 'cache_value_caches')
+      def cache_store
+        @cache_store ||= ActiveSupport::Cache.lookup_store(:mem_cache_store)
       end
 
       def lookup(object, method, options, arguments = nil)
-        value, last_cached = fetch_and_parse(object, method, arguments)
-        if !last_cached or !cached_value_is_still_valid?(value, last_cached, object, method, options)
-          value = call_and_store_value(object, method, arguments)
-        end
-        
-        value
+        new(object, method, options, arguments).lookup
       end
-      
-      def cache_key(object, method, arguments = nil)
-        if !object.respond_to?(:cache_key)
+    end
+
+    attr_accessor :object, :cached_method, :options, :arguments
+
+    def initialize(object, method, options, arguments)
+      self.object = object
+      self.cached_method = method
+      self.options = options
+      self.arguments = arguments
+    end
+
+    def lookup
+      value = fetch_and_parse
+      value = call_and_store_value unless @fetched
+      value
+    end
+
+    def cache_key
+      if !@cache_key
+        options = process_options
+        if !options[:cache_key] and !object.respond_to?(:cache_key)
           raise ConfigurationException.new("object of class #{object.class.name} does not respond to :cache_key")
         end
-        
-        key = object.cache_key.gsub('/', '_') + "_#{method}"
+
+        cache_key = options[:cache_key] || object.cache_key
+        key = cache_key.gsub('/', '_') + "_#{cached_method}"
         key << '_' + hex_digest(arguments) if arguments
-        key
+        #logger.debug "cache_value: cache_key = #{key}"
+        @cache_key = key
       end
+      @cache_key
+    end
 
-      def fetch_and_parse(object, method, arguments = nil)
-        data = cache_store.fetch(cache_key(object, method, arguments))
-        if data
-          YAML::load(data)
-        else
-          [nil, nil]
-        end
+    def fetch_and_parse
+      key = cache_key
+      data = nil
+      time = Benchmark.realtime do
+        data = self.class.cache_store.fetch(key)
+      end
+      if data
+        @fetched = true
+        logger.info "cache_value: retrieved #{key} (#{(time*1000).round(1)}ms)"
+        YAML::load(data)
+      else
+        @fetched = false
+        nil
       end
+    end
 
-      def call_and_store_value(object, method, arguments = nil)
-        without_method = caching_method_names(method).first
+    def call_and_store_value
+      without_method = caching_method_names(cached_method).first
+      value = nil
+      time = Benchmark.realtime do
         value = arguments ? object.send(without_method, *arguments) : object.send(without_method)
-        cache_store.write(cache_key(object, method, arguments), [value, Time.now].to_yaml)
-        
-        value
       end
 
-      def cached_value_is_still_valid?(value, cached_age, object, method, options)
-        options = object.send(:method, options) if options.is_a?(Symbol)
-        if options.respond_to?(:arity)          
-          options.call(*([cached_age, object, method][0,options.arity]))
-        else
-          cached_age > Time.now - options
-        end
+      ttl = process_options[:ttl]
+      self.class.cache_store.write(cache_key, value.to_yaml, :expires_in => ttl)
+      logger.info "cache_value: cached #{object.class.name}##{cached_method} for #{ttl}s (will save #{(time*1000).round(1)}ms)"
+
+      value
+    end
+
+    def process_options
+      opts = options
+      opts = object.send(:method, opts) if opts.is_a?(Symbol)
+      opts = opts.call(*([object, cached_method, arguments][0,opts.arity])) if opts.respond_to?(:arity)
+
+      if opts.respond_to?(:to_hash)
+        opts = opts.to_hash
+      else
+        opts = { :ttl => opts, :cache_key => nil }
       end
 
+      raise ConfigurationException.new('Options must resolve to a hash with a :ttl') unless opts[:ttl]
+
+      opts
     end
-  end
 
-  class ConfigurationException < StandardError
   end
+
+  class ConfigurationException < StandardError;  end
 end

data/lib/cache_value/util.rb

@@ -13,6 +13,10 @@ module CacheValue
       Digest::SHA1.hexdigest(stringify_value(values))
     end
     
+    def logger
+      ::RAILS_DEFAULT_LOGGER
+    end
+    
     protected
     def stringify_value(value)
       if value.respond_to?(:to_str)

data/lib/cache_value.rb

@@ -1,5 +1,4 @@
 require 'cache_value/cache_value'
 
-module CacheValue
-  ActiveRecord::Base.send(:extend, CacheValue::ClassMethods) if defined?(ActiveRecord::Base)
-end
+ActiveRecord::Base.send(:extend, CacheValue::ClassMethods) if defined?(ActiveRecord::Base)
+

data/test/cache_machine_test.rb

@@ -2,62 +2,55 @@ require 'test_helper'
 
 require 'cache_value/cache_machine'
 
+require 'logger'
 
 class CacheMachineTest < Test::Unit::TestCase
-
+  ::RAILS_DEFAULT_LOGGER = Logger.new('/dev/null')
+  
   def setup
-    @cm = CacheValue::CacheMachine
     @obj = mock
     @method = :some_method
     @value = 2
+    @arguments = [1,2]
+    @cm = CacheValue::CacheMachine.new(@obj, @method, 15, @arguments)
   end
 
-  context 'cache store' do
+  context 'at the class level' do
     should 'provide a cache store' do
-      ::RAILS_ROOT = '/tmp'
-      @cm.cache_store.should_not == nil
-    end
-
-    context 'default storage dir' do
-      should 'raise exception if RAILS_ENV is not set' do
-        assert_raise CacheValue::ConfigurationException do
-          @cm.default_storage_dir
-        end
-      end
-
-      should 'point to the tmp in RAILS_ROOT if available' do
-        ::RAILS_ROOT = '/tmp'
-        @cm.default_storage_dir.should == '/tmp/tmp/cache_value_caches'
-      end
-
-      
-    end
-
-    teardown do
-      Object.send(:remove_const, :RAILS_ROOT) if defined?(RAILS_ROOT)
+      CacheValue::CacheMachine.cache_store.should_not == nil
     end
     
+    should 'delegate the lookup call to an instance' do
+      CacheValue::CacheMachine.expects(:new).with(1,2,3,4).returns(@cm)
+      @cm.expects(:lookup)
+      CacheValue::CacheMachine.lookup(1,2,3,4)
+    end
   end
   
 
   context 'cache key' do
-    should 'raise exception if object does not respond_to cache_key' do
+    should 'raise exception if object does not respond_to cache_key and no cache key provided in the options' do
       assert_raise CacheValue::ConfigurationException do
-        @cm.cache_key(@obj, @method)
+        @cm.cache_key
       end
     end
+
+    should 'use the cache_key if provided in options' do
+      @cm.options = { :cache_key => 'a_key', :ttl => 1 }
+      @cm.cache_key.should =~ /a_key/
+    end
     
     context 'with an object that responds to cache_key' do
       setup do
         @obj.expects(:cache_key).returns('a/cache/key')
       end
       
-      should 'include the method name at the end' do
-        assert_match /_method$/, @cm.cache_key(@obj, :method)
+      should 'include the method name' do
+        assert_match /_some_method/, @cm.cache_key
       end
 
       should 'not have any slashes' do
-        assert_no_match %r{/}, @cm.cache_key(@obj, :method)
+        assert_no_match %r{/}, @cm.cache_key
       end
     end
 
@@ -66,9 +59,11 @@ class CacheMachineTest < Test::Unit::TestCase
         @obj.expects(:cache_key).returns('a/cache/key')
       end
 
-      should 'should include the hash in the key' do
+      should 'should include the argument hash in the key' do
         now = Time.now
-        assert_match /_method_#{@cm.send(:hex_digest, [1, 2, now])}$/, @cm.cache_key(@obj, :method, [1, 2, now])
+        args = [1, 2, now]
+        @cm.arguments = args
+        assert_match /_some_method_#{@cm.send(:hex_digest, args)}$/, @cm.cache_key
       end
 
     end
@@ -76,18 +71,18 @@ class CacheMachineTest < Test::Unit::TestCase
   
   context 'fetch_and_parse' do
     setup do
-      @cache_data = ['data', Time.now]
+      @cache_data = 'data'
       @cm.expects(:cache_key).returns('')
     end
 
-    should 'return the data and timestamp when found' do
-      @cm.cache_store.expects(:fetch).returns(@cache_data.to_yaml)
-      @cm.fetch_and_parse(@obj, @method).should == @cache_data
+    should 'return the data when found' do
+      @cm.class.cache_store.expects(:fetch).returns(@cache_data.to_yaml)
+      @cm.fetch_and_parse.should == @cache_data
     end
 
-    should 'return nils when data not found' do
-      @cm.cache_store.expects(:fetch).returns(nil)
-      @cm.fetch_and_parse(@obj, @method).should == [nil, nil]
+    should 'return nil when data not found' do
+      @cm.class.cache_store.expects(:fetch).returns(nil)
+      @cm.fetch_and_parse.should == nil
     end
   end
 
@@ -95,45 +90,51 @@ class CacheMachineTest < Test::Unit::TestCase
     setup do
       @obj.expects(:some_method_without_value_caching).returns(2)
       key = 'key'
-      @cm.expects(:cache_key).with(@obj, :some_method, nil).returns(key)
+      @cm.expects(:cache_key).returns(key)
       now = Time.now
       Time.stubs(:now).returns(now)
-      @cm.cache_store.expects(:write).with(key, [2, Time.now].to_yaml)
+      @cm.class.cache_store.expects(:write).with(key, 2.to_yaml, { :expires_in => 15 })
     end
     
     should 'return the data' do
-      @cm.call_and_store_value(@obj, :some_method).should == 2
+      @cm.call_and_store_value.should == 2
     end
 
   end
+  
+  context 'processing the options' do
 
-  context 'validity of stored value' do
-    
-    context 'checking by age in seconds' do
-      should 'be valid if the value is younger than the age limit' do
-        @cm.cached_value_is_still_valid?(@value, Time.now - 30, @obj, @method, 35).should == true
-      end
-
-      should 'not be valid if the value is older than the age limit' do
-        @cm.cached_value_is_still_valid?(@value, Time.now - 30, @obj, @method, 5).should == false
-      end
+    should 'return a hash if given a hash' do
+      @cm.options = { :ttl => 15 }
+      @cm.process_options.should == { :ttl => 15 }
     end
     
     context 'checking with block' do
       should 'pass the proper fields to the proc' do
+        now = Time.now
+        proc = lambda { |a,b|}
+        proc.expects(:call).with(@obj, @method).returns(1)
+        @cm.options = proc
+        
+        @cm.process_options
+      end
+      
+      should 'pass the arguments to the proc as well if the arity is high enough' do
         now = Time.now
         proc = lambda { |a,b,c|}
-        proc.expects(:call).with(now, @obj, @method)
-
-        @cm.cached_value_is_still_valid?(@value, now, @obj, @method, proc)
+        proc.expects(:call).with(@obj, @method, @arguments).returns(1)
+        @cm.options = proc
+        
+        @cm.process_options
       end
 
-      should 'only pass time if the proc only takes two args' do
+      should 'only pass the object if the proc only takes one arg' do
         now = Time.now
         proc = lambda { |a|}
-        proc.expects(:call).with(now)
-
-        @cm.cached_value_is_still_valid?(@value, now, @obj, @method, proc)
+        proc.expects(:call).with(@obj).returns({ :ttl => 1})
+        @cm.options = proc
+        
+        @cm.process_options
       end
     end
 
@@ -141,49 +142,56 @@ class CacheMachineTest < Test::Unit::TestCase
       setup do
         @object = Object.new
         def @object.the_method(a,b)
-          'blah'
+          {:ttl => 1}
         end
         
       end
 
       should 'call the method for the symbol on the object' do
-        @cm.cached_value_is_still_valid?(@value, Time.now, @object, @method, :the_method).should == 'blah'
+        @cm.options = :the_method
+        @cm.object = @object
+        @cm.process_options.should == { :ttl => 1 }
       end
      
     end
     
-    should 'raise exceptions if options is incorrect'
-
+    should 'raise exception if options do not resolve to a hash with :ttl' do
+      @cm.options = lambda { { }}
+      assert_raise CacheValue::ConfigurationException do
+        @cm.process_options
+      end
+    end
+    
   end
 
   context 'cache lookup' do
-    should 'call for the value (and return it) if nothing was cached' do 
-      @cm.expects(:fetch_and_parse).with(@obj, @method, nil).returns(nil, nil)
-      @cm.expects(:call_and_store_value).with(@obj, @method, nil).returns(@value)
-      @cm.lookup(@obj, @method, nil).should == @value
+    should 'call for the value (and return it) if nothing was cached' do
+      @cm.expects(:fetch_and_parse).returns(nil)
+      @cm.expects(:call_and_store_value).returns(@value)
+      @cm.lookup.should == @value
     end
 
-    should 'call for the value (and return it) if the value is no longer valid' do
-      now = Time.now
-      @cm.expects(:fetch_and_parse).with(@obj, @method, nil).returns([2, now])
-      @cm.expects(:cached_value_is_still_valid?).with(@value, now, @obj, @method, 2).returns(false)
-      @cm.expects(:call_and_store_value).with(@obj, @method, nil).returns(@value)
-      @cm.lookup(@obj, @method, 2).should == @value
-    end
-    
-    should 'not call and store if the cached value is valid' do
-      @cm.expects(:fetch_and_parse).with(@obj, @method, nil).returns([2, Time.now])
-      @cm.expects(:cached_value_is_still_valid?).returns(true)
+    should 'be able to cache a nil value' do
+      @cm.class.cache_store.expects(:fetch).returns(nil.to_yaml)
+      @cm.stubs(:cache_key).returns(nil)
       @cm.expects(:call_and_store_value).never
-      @cm.lookup(@obj, @method, 2).should == @value
+      @cm.lookup.should == nil
     end
     
-    should 'be able to cache a nil value' do
-            @cm.expects(:fetch_and_parse).with(@obj, @method, nil).returns([nil, Time.now])
-      @cm.expects(:cached_value_is_still_valid?).returns(true)
-      @cm.expects(:call_and_store_value).never
-      @cm.lookup(@obj, @method, 2).should == nil
+    context 'with a cached value' do
+      setup do
+        @cm.class.cache_store.expects(:fetch).returns(1.to_yaml)
+        @cm.stubs(:cache_key).returns('asf')
+      end
+
+      should 'not try to cache the value' do
+        @cm.expects(:call_and_store_value).never
+        @cm.lookup
+      end
+
+      should 'actually return the cached value' do
+        @cm.lookup.should == 1
+      end
     end
-      
   end
 end

data/test/util_test.rb

@@ -6,10 +6,10 @@ require 'cache_value/util'
 class UtilTest < Test::Unit::TestCase
   include CacheValue::Util
   
-  should 'be true' do
-    assert true
+  context 'hex_digest' do
+    should 'return the same digest for identical hashes' do 
+      hex_digest({ :ha => 'ha'}).should == hex_digest({ :ha => 'ha'})
+    end
   end
   
-  should 'have some tests here' 
-  
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: cache_value
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 4
+  version: 0.4.4
 platform: ruby
 authors: 
 - Tobias Crawley
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-07 00:00:00 -05:00
+date: 2010-06-10 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -51,18 +56,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Easy value caching