timedcache 0.3 → 0.4.0

data/Rakefile

@@ -1,16 +1,31 @@
-# -*- ruby -*-
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
 
 require 'rubygems'
-require 'hoe'
-require './lib/timedcache.rb'
-
-Hoe.new('timedcache', TimedCache::VERSION) do |p|
-  p.rubyforge_name = 'timedcache'
-  p.author = 'Nicholas Dainty'
-  p.email = 'nick@npad.co.uk'
-  p.summary = 'A very simple time-based object cache.'
-  p.description = p.paragraphs_of('README.txt', 3..4).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-  p.remote_rdoc_dir = '' # Place RDocs on project home page.
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+# ============================================================================
+
+# If you're using this file as a template to set up a new gem, this constant
+# is the only thing you should need to change in the Rakefile:
+GEM_NAME = 'timedcache'
+
+# ============================================================================
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+# ============================================================================
+# = Gem package and release stuff.
+# ============================================================================
+
+spec = eval(File.read(File.join(File.dirname(__FILE__), "#{GEM_NAME}.gemspec")))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
 end
+
+# ============================================================================
+
+task :default => [:test]

data/lib/timedcache.rb

@@ -2,59 +2,58 @@ require "pstore"
 require "monitor"
 
 # == TimedCache
-# 
+#
 # TimedCache implements a cache in which you can place objects
 # and specify a timeout value.
-# 
+#
 # If you attempt to retrieve the object within the specified timeout
 # period, the object will be returned. If the timeout period has elapsed,
 # the TimedCache will return nil.
-# 
+#
 # e.g.:
 #   cache = TimedCache.new
 #   cache.put :my_object_key, "Expensive data", 10 # => "Expensive data"
-#   
+#
 #   cache.get :my_object_key # => "Expensive data"
 #   cache[:my_object_key]    # => "Expensive data"
-# 
+#
 # ... 10 seconds later:
 #   cache.get :my_object_key # => nil
-# 
+#
 # === Default timeout
-# 
+#
 # When creating a new TimedCache, a default timeout value can be set. This value
 # will be used for each object added to the cache, unless a different timeout value
 # is specifically set for that object.
-# 
+#
 # e.g.:
-# 
+#
 #   cache = TimedCache.new(:default_timeout => 120)
 #   cache.default_timeout # => 120
-# 
+#
 # === File-based cache
-# 
-# By default, TimedCache will use an in-memory store. A file-based store (using the 
+#
+# By default, TimedCache will use an in-memory store. A file-based store (using the
 # PStore library) can also be used.
-# 
+#
 # e.g.:
-# 
+#
 #   TimedCache.new(:type => :file, :filename => "my_cache.db")
-# 
-# The file-based cache makes it possible to easily share a cache between several ruby 
-# processes. However when using the cache in this way, you will probably want to update the 
-# cache by passing a block to the TimedCache#get method (see below for details).
-# 
+#
+# The file-based cache makes it possible to easily share a cache between several ruby
+# processes.
+#
 # Note that objects that cannot be marshalled (e.g. a Proc) can't be stored using the file-based cache.
 class TimedCache
   VERSION = "0.3"
-  
+
   attr_reader :default_timeout
-  
+
   # Create a new TimedCache. Available options are:
   # <tt>type</tt>:: <tt>:memory</tt> or <tt>:file</tt> (defaults to <tt>:memory</tt>).
   # <tt>default_timeout</tt>:: Timeout to use if none is specified when adding an object to the cache.
   # <tt>filename</tt>:: Must be specified when using the <tt>:file</tt> type store.
-  # 
+  #
   # e.g.:
   #   TimedCache.new(:type => :file, :filename => "cache.db")
   def initialize(opts = {})
@@ -63,66 +62,73 @@ class TimedCache
     @store = new_store(opts)
     @store.extend(MonitorMixin)
   end
-  
+
   # Add an object to the cache. e.g.:
   #   cache.put(:session_id, 12345)
-  # 
-  # The third parameter is an optional timeout value. If not specified, the 
+  #
+  # The third parameter is an optional timeout value. If not specified, the
   # <tt>:default_timeout</tt> for this TimedCache will be used instead.
   def put(key, value, timeout = @default_timeout)
     @store.synchronize do
       @store.put(key, value, timeout) unless value.nil?
     end
   end
-  
+  alias :set :put
+
+  # Remove an object from the cache. e.g.:
+  #   cache.del(:session_id)
+  def delete(key)
+    @store.delete(key)
+  end
+  alias :del :delete
+
   # Retrieve the object which the given +key+. If the object has expired or
   # is not present, +nil+ is returned.
-  # 
+  #
   # Optionally, a block can be given. The result of evaluating the block will
   # be substituted as the cache value, if the cache has expired.
-  # 
+  #
   # e.g.:
-  # 
+  #
   #   cache.get("slow_database_query") do
   #     MyDatabase.query("SELECT * FROM bigtable...")
   #   end
-  # 
-  # The block syntax can also be used with the in-memory cache.
+  #
   def get(key, &block)
     @store.synchronize do
       @store.get(key, &block)
     end
   end
-  
+
   # Add to the cache using a hash-like syntax. e.g.:
   #   cache[:name] = "Nick"
-  # 
+  #
   # Note that adding to the cache this way does not allow you to specify timeout values
   # on a per-object basis.
   def []=(key, value)
     put(key, value)
   end
-  
+
   # Fetch objects using the hash syntax. e.g.:
   #   cache[:name] # => "Nick"
   def [](key)
     get(key)
   end
-  
+
   protected
-  
+
   def new_store(options) #:nodoc:
     self.class.const_get(options[:type].to_s.capitalize + "Store").new(self, options)
   end
-  
+
   class Store #:nodoc:
     def initialize(timed_cache, options)
       @timed_cache = timed_cache
       @options     = options
     end
-    
+
     protected
-    
+
     def generic_get(key, timeout, callback, fetch_key = lambda {|k| @cache[key]})
       if object_store = fetch_key.call(key)
         if object_store.expired?
@@ -139,40 +145,44 @@ class TimedCache
         run_callback_and_add_to_cache(key, object_store, callback, timeout)
       end
     end
-    
+
     def run_callback_and_add_to_cache(key, object_store, callback, timeout)
       object_store.no_expiry! if object_store
-      
+
       begin
         result = callback.call
       rescue
         object_store.reset_expiry! if object_store
         raise
       end
-      
+
       @timed_cache.put(key, result, timeout)
       result
     end
   end
-  
+
   class MemoryStore < Store #:nodoc:
     def initialize(*args)
       super(*args)
       @cache = Hash.new
     end
-    
+
     def put(key, value, timeout)
       @cache[key] = ObjectContainer.new(value, timeout)
       # Return just the given value, so that references to the
       # ObjectStore instance can't be held outside this TimedCache:
       value
     end
-    
+
     def get(key, timeout = @timed_cache.default_timeout, &block)
       generic_get(key, timeout, block)
     end
+
+    def delete(key)
+      @cache.delete(key)
+    end
   end
-  
+
   class FileStore < Store #:nodoc:
     def initialize(*args)
       super(*args)
@@ -182,15 +192,15 @@ class TimedCache
       end
       @cache = PStore.new(filename)
     end
-    
+
     def put(key, value, timeout)
       @cache.transaction { @cache[key] = ObjectContainer.new(value, timeout) }
-      
+
       # Return just the given value, so that references to the
       # ObjectStore instance can't be held outside this TimedCache:
       value
     end
-    
+
     def get(key, timeout = @timed_cache.default_timeout, &block)
       if block
         generic_get(key, timeout, block, lambda {|k| @cache.transaction { @cache[key] } })
@@ -198,18 +208,22 @@ class TimedCache
         @cache.transaction { generic_get(key, timeout, block) }
       end
     end
+
+    def delete(key)
+      @cache.transaction { @cache.delete(key) }
+    end
   end
-  
+
   class ObjectContainer #:nodoc:
     attr_accessor :object
-    
+
     def initialize(object, timeout)
       @created_at = Time.now.utc
       @timeout    = timeout
       @object     = object
       @frozen     = false
     end
-    
+
     def expired?
       if @frozen
         false
@@ -217,11 +231,11 @@ class TimedCache
         (Time.now.utc - @timeout) > @created_at
       end
     end
-    
+
     def no_expiry!
       @frozen = true
     end
-    
+
     def reset_expiry!
       @frozen = false
     end

data/lib/timedcache/version.rb

@@ -0,0 +1,3 @@
+class TimedCache
+  VERSION = "0.4.0"
+end

data/misc/thread_test.rb

@@ -1,7 +1,7 @@
-require File.join(File.dirname(__FILE__), "../lib/timedcache")
+require File.expand_path('../lib/timedcache', File.dirname(__FILE__))
 
-# This script will almost certainly raise an exception if 
-# thread safety is not implemented.
+# This script will almost certainly raise an exception if the cache is not
+# thread safe.
 
 db = File.join(File.dirname(__FILE__), "thread_test.db")
 

data/test/test_timed_cache.rb

@@ -0,0 +1,115 @@
+require 'test/unit'
+require 'timedcache'
+
+class TimedCacheTest < Test::Unit::TestCase
+  def setup
+    @filename     = File.join(File.dirname(__FILE__), "specs.db")
+    @memory_cache = TimedCache.new
+    @file_cache   = TimedCache.new(:type => :file, :filename => @filename)
+    @caches       = [@memory_cache, @file_cache]
+  end
+
+  def teardown
+    File.delete(@filename) if File.exist?(@filename)
+  end
+
+  def test_can_add_an_object_to_the_cache_specifying_a_timeout_value
+    @caches.each do |cache|
+      assert_equal("This needs caching", cache.put(:myobject, "This needs caching", 10))
+    end
+  end
+
+  def test_can_add_an_object_to_the_cache_specifying_a_timeout_value_using_the_set_method
+    @caches.each do |cache|
+      assert_equal("This needs caching", cache.set(:myobject, "This needs caching", 10))
+    end
+  end
+
+  def test_can_remove_objects_from_the_cache
+    @caches.each do |cache|
+      cache.put(:myobject, "This needs caching", 10)
+      assert_equal("This needs caching", cache.get(:myobject))
+      cache.del(:myobject)
+      assert_nil(cache.get(:myobject))
+    end
+  end
+
+  def test_cache_should_hold_seperate_values_for_each_key
+    @caches.each do |cache|
+      assert_equal("This needs caching", cache.put(:myobject, "This needs caching", 10))
+      assert_equal("...and this too", cache.put(:my_other_object, "...and this too", 10))
+      assert_equal("This needs caching", cache.get(:myobject))
+      assert_equal("...and this too", cache.get(:my_other_object))
+    end
+  end
+
+  def test_string_and_symbol_keys_are_not_treated_as_equivalent
+    @caches.each do |cache|
+      cache[:symbolkey]  = "Referenced by symbol"
+      cache["stringkey"] = "Referenced by string"
+
+      assert_equal("Referenced by symbol", cache[:symbolkey])
+      assert_nil(cache["symbolkey"])
+
+      assert_equal("Referenced by string", cache["stringkey"])
+      assert_nil(cache[:stringkey])
+    end
+  end
+
+  def test_after_the_specified_timeout_value_has_elapsed_nil_should_be_returned
+    @caches.each do |cache|
+      assert_equal("This needs caching", cache.put(:myobject, "This needs caching", 0))
+      assert_nil(cache.get(:myobject))
+    end
+  end
+
+  def test_if_no_object_matching_the_given_key_is_found_nil_should_be_returned
+    @caches.each do |cache|
+      assert_nil(cache.get(:my_nonexistant_object))
+    end
+  end
+
+  def test_should_be_able_to_use_an_array_as_a_cache_key
+    @caches.each do |cache|
+      assert_equal("Array", cache.put([123,234], "Array"))
+      assert_equal("Array", cache.get([123,234]))
+    end
+  end
+
+  def test_passing_a_block_to_the_get_method_should_substitute_result_of_block_as_value_for_given_key
+    @caches.each do |cache|
+      cache.put("block_test", 1984, 0)
+      assert_equal(2001, cache.get("block_test") { 2001 })
+      assert_equal(2001, cache.get("block_test"))
+    end
+  end
+
+  def test_passing_block_to_get_should_add_result_of_callback_when_there_is_no_existing_value
+    @caches.each do |cache|
+      assert_equal(nil, cache.get("new_key_with_block"))
+      assert_equal("Nicholas", cache.get("new_key_with_block") { "Nicholas" })
+    end
+  end
+
+  def test_is_able_to_specify_default_timeout_when_creating_an_instance
+    cache = TimedCache.new(:default_timeout => 20)
+    assert_equal(20, cache.default_timeout)
+  end
+
+  def test_if_no_default_timeout_is_set_60_seconds_should_be_used
+    cache = TimedCache.new
+    assert_equal(60, cache.default_timeout)
+  end
+
+  def test_timeout_specified_when_putting_a_new_object_into_the_cache_should_override_default_timeout
+    cache = TimedCache.new(:default_timeout => 20)
+    assert_equal(20, cache.default_timeout)
+    cache.put("alternative_timeout", "2 minutes", 120)
+
+    timeout = cache.instance_variable_get(:@store).
+      instance_variable_get(:@cache)["alternative_timeout"].
+      instance_variable_get(:@timeout)
+
+    assert_equal(120, timeout)
+  end
+end

data/timedcache.gemspec

@@ -0,0 +1,15 @@
+require 'timedcache/version'
+
+Gem::Specification.new do |s|
+  s.name = "timedcache"
+  s.version = TimedCache::VERSION
+  s.summary = %q{TimedCache implements a cache in which you can place objects and specify a timeout value.}
+  s.description = %q{TimedCache implements a cache in which you can place objects and specify a timeout value.  If you attempt to retrieve the object within the specified timeout, the object will be returned. If the timeout period has elapsed, the TimedCache will return nil.}
+  s.files = Dir['**/*']
+  s.authors = ["Nicholas Dainty"]
+  s.email = "nick@npad.co.uk"
+  s.homepage = "http://timedcache.rubyforge.org/"
+  s.has_rdoc = true
+  s.rdoc_options = ["--charset=UTF-8", "--line-numbers", "--inline-source"]
+  s.required_ruby_version = '>= 1.8.6'
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: timedcache
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Nicholas Dainty
@@ -9,64 +15,66 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-28 23:00:00 +00:00
+date: 2011-03-24 00:00:00 +00:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.8.2
-    version: 
-description: TimedCache implements a cache in which you can place objects and specify a timeout value.  If you attempt to retrieve the object within the specified timeout period, the object will be returned. If the timeout period has elapsed, the TimedCache will return nil.
+dependencies: []
+
+description: TimedCache implements a cache in which you can place objects and specify a timeout value.  If you attempt to retrieve the object within the specified timeout, the object will be returned. If the timeout period has elapsed, the TimedCache will return nil.
 email: nick@npad.co.uk
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
+extra_rdoc_files: []
+
 files: 
 - History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
 - lib/timed_cache.rb
+- lib/timedcache/version.rb
 - lib/timedcache.rb
+- Manifest.txt
 - misc/thread_test.rb
-- spec/timed_cache_spec.rb
+- Rakefile
+- README.txt
+- test/test_timed_cache.rb
+- timedcache.gemspec
 has_rdoc: true
-homepage: 
+homepage: http://timedcache.rubyforge.org/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
-- --main
-- README.txt
+- --charset=UTF-8
+- --line-numbers
+- --inline-source
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: timedcache
-rubygems_version: 1.3.1
+rubyforge_project: 
+rubygems_version: 1.5.3
 signing_key: 
-specification_version: 2
-summary: A very simple time-based object cache.
+specification_version: 3
+summary: TimedCache implements a cache in which you can place objects and specify a timeout value.
 test_files: []
 

data/spec/timed_cache_spec.rb

@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), "../lib/timedcache")
-
-$filename = File.join(File.dirname(__FILE__), "specs.db")
-
-describe "Adding and retrieving objects from the cache" do
-  before(:each) do
-    @memory_cache = TimedCache.new
-    @file_cache   = TimedCache.new(:type => :file, :filename => $filename)
-    @caches       = [@memory_cache, @file_cache]
-  end
-  
-  after do
-    File.delete($filename)
-  end
-  
-  it "Can add an object to the cache, specifying a timeout value" do
-    @caches.each do |cache|
-      cache.put(:myobject, "This needs caching", 10).should == "This needs caching"
-    end
-  end
-    
-  it "Cache should hold seperate values for each key" do
-    @caches.each do |cache|    
-      cache.put(:myobject, "This needs caching", 10).should == "This needs caching"
-      cache.put(:my_other_object, "...and this too", 10).should == "...and this too"
-      cache.get(:myobject).should == "This needs caching"
-      cache.get(:my_other_object).should == "...and this too"
-    end
-  end
-  
-  it "String and symbol keys are not treated as equivalent" do
-    @caches.each do |cache|
-      cache[:symbolkey]  = "Referenced by symbol"
-      cache["stringkey"] = "Referenced by string"
-      
-      cache[:symbolkey].should == "Referenced by symbol"
-      cache["symbolkey"].should == nil
-      
-      cache["stringkey"].should == "Referenced by string"
-      cache[:stringkey].should == nil
-    end
-  end
-  
-  it "After the specified timeout value has elapsed, nil should be returned" do
-    @caches.each do |cache|    
-      cache.put(:myobject, "This needs caching", 0).should == "This needs caching"
-      cache.get(:myobject).should == nil
-    end
-  end
-  
-  it "If no object matching the given key is found, nil should be returned" do
-    @caches.each do |cache|
-      cache.get(:my_nonexistant_object).should == nil
-    end
-  end
-  
-  it "Should be able to use an array as a cache key" do
-    @caches.each do |cache|
-      cache.put([123,234], "Array").should == "Array"
-      cache.get([123,234]).should == "Array"
-    end
-  end
-  
-  it "Passing a block to the TimedCache#get method should substitute the " +
-     "result of the block as the value for the given key" do
-    @caches.each do |cache|
-      cache.put("block_test", 1984, 0)
-      cache.get("block_test") { 2001 }.should == 2001
-      cache.get("block_test").should == 2001
-    end
-  end
-  
-  it "Passing a block to TimedCache#get should add the result of the callback " + 
-     "when there is no existing value for the key given" do
-    @caches.each do |cache|
-      cache.get("new_key_with_block").should == nil
-      cache.get("new_key_with_block") { "Nicholas" }.should == "Nicholas"
-    end
-  end
-end
-
-describe "Specifying a default timeout" do
-  it "Should be able to it a default timeout when creating a TimedCache" do
-    cache = TimedCache.new(:default_timeout => 20)
-    cache.should be_kind_of(TimedCache)
-    cache.default_timeout.should == 20
-  end
-  
-  it "If no default timeout is set, 60 seconds should be used" do
-    cache = TimedCache.new
-    cache.should be_kind_of(TimedCache)
-    cache.default_timeout.should == 60
-  end
-  
-  it "Timeout specified when putting a new object into the cache should override default timeout" do
-    cache = TimedCache.new(:default_timeout => 20)
-    cache.default_timeout.should == 20
-    cache.put("alternative_timeout", "2 minutes", 120)
-    cache.instance_variable_get(:@store).instance_variable_get(:@cache)["alternative_timeout"].
-    instance_variable_get(:@timeout).should == 120
-  end
-end