timeout_cache 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://www.rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+(MIT License)
+
+Copyright (c) 2012 Adam Prescott
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# TimeoutCache
+
+A `TimeoutCache` is a simple cache where objects are stored with a fixed expiration time. It is useful when you want to keep an object around for a sufficiently long period of time, but want them to disappear after, say, 5 seconds, or on the first day of next month.
+
+# How do I use this thing?
+
+A `TimeoutCache` is easy to use.
+
+```ruby
+cache = TimeoutCache.new
+cache[:foo] = :bar
+cache[:foo] #=> bar
+
+# wait some time (by default, 60 seconds)
+
+cache[:foo] #=> nil
+```
+
+By default, retrievals return `nil` 60 seconds after they're put into the cache. You can control the length of time by using `#set` with the `:time` option:
+
+```ruby
+cache.set(:a, :b, :time => 5)
+cache[:a] #=> :b
+sleep 5
+cache[:a] #=> nil
+```
+
+You can also use an instance of `Time`:
+
+```ruby
+cache.set(:x, :y, :time => Time.now + 50)
+```
+
+If you want to change the default expiration time, do so when you make a new instance of `TimeoutCache` by passing the length of time in seconds.
+
+```ruby
+cache = TimeoutCache.new(10 * 60 * 60) # 10 hours
+```
+
+Unless an object is added to the cache using the `:time` option, the default is used. This default length of time is 60 seconds.
+
+# Entry deletion and pruning
+
+Expired entries are deleted lazily. If an entry is added with an expire time of 15 seconds and nothing touches the cache, the entry will still be in the cache after 20 seconds. Expired entries are deleted only when a call to `#[]` (or, equivalently, `#get`) finds an expired entry. At that point, `#prune` is called.
+
+If you want to manually prune the cache, you may do so by calling `#prune`.
+
+# Documentation
+
+There's not much to the code, but it's all commented and you can generate documentation with `rake docs`.
+
+# Tests
+
+You can run the tests with `rake test`.
+
+# License / Copyright
+
+Copyright (c) 2012 Adam Prescott, released under the MIT license. See the LICENSE file for details.
+
+# Contributing
+
+The official repository is on GitHub at [aprescott/timeout_cache](https://github.com/aprescott/timeout_cache). Issues should be opened there, as well as pull requests. Submissions should be on a separate feature branch:
+
+* Fork and clone
+* Create a feature branch
+* Add code and tests
+* Run all the tests
+* Push you branch to your GitHub repository
+* Send a pull request
+
+Your contribution will be assumed to also be licensed under the MIT license.

data/lib/timeout_cache.rb

@@ -0,0 +1,151 @@
+# Copyright (c) 2012 Adam Prescott, licensed under the MIT license. See LICENSE.
+
+#
+# TimeoutCache is a simple key-value store where entries expire after a certain
+# time. It implements parts of the Hash interface.
+#
+#     cache = TimeoutCache.new
+#     cache[:foo] = :bar
+#     cache[:foo] #=> bar
+#
+#     # wait some time (by default, 60 seconds)
+#
+#     cache[:foo] #=> nil
+#
+class TimeoutCache
+  VERSION = "0.0.1"
+  
+  # Wraps an object by attaching a time to it.
+  class TimedObject # :nodoc:
+    attr_reader :value, :expires_at
+    
+    def initialize(value, time)
+      @value = value
+      @expires_at = time
+    end
+    
+    # Returns true if the object has expired.
+    # Returns false if the object has not yet expired.
+    def expired?
+      @expires_at <= Time.now
+    end
+  end
+  
+  # The default number of seconds an object stays alive.
+  DEFAULT_TIMEOUT = 60
+  
+  attr_reader :timeout
+  
+  # Creates a new TimeoutCache.
+  #
+  # If <tt>timeout</tt> is specified, the default survival time for
+  # a cache entry is <tt>timeout</tt> in seconds.
+  #
+  # If no default value is used, then DEFAULT_TIMEOUT is the default
+  # time-to-expire in seconds.
+  def initialize(timeout = DEFAULT_TIMEOUT)
+    raise ArgumentError.new("Timeout must be > 0") unless timeout > 0
+    
+    @timeout = timeout
+    
+    # we can use this for look-ups in O(1), instead of only find-min in O(1)
+    @store = {}
+  end
+  
+  # Returns the number of items in the cache.
+  def size
+    @store.size
+  end
+  alias_method :length, :size
+  
+  # Returns the value for the given key. If there is no such key in the cache,
+  # then this returns nil. If the value has an expire time earlier than or equal
+  # to the current time, this returns nil.
+  #
+  # As an implementation detail, this method calls #prune whenever it finds
+  # an element that has expired.
+  def [](key)
+    val = @store[key]
+    
+    if val
+      if val.expired?
+        prune
+        nil
+      else
+        val.value
+      end
+    else
+      nil
+    end
+  end
+  alias_method :get, :[]
+  
+  # Returns the expire time of the value for the given key.
+  def expire_time(key)
+    @store[key].expires_at
+  end
+  
+  # Stores an object in the cache with an expire time DEFAULT_TIMEOUT
+  # seconds from now.
+  def []=(key, value)
+    v = TimedObject.new(value, Time.now + timeout)
+    @store[key] = v
+  end
+  
+  # Stores an object in the cache. options is a hash with symbol keys:
+  #
+  # :time:: can be either an Integer representing the number of seconds the object should be alive
+  #         or a Time object representing a fixed time.
+  #
+  # If time is not specified in the hash, the default timeout length is used.
+  #
+  # If the object would expire immediately, returns nil, otherwise returns the object stored.
+  def set(key, value, options = {})
+    time = options[:time] || timeout
+    
+    time = case time
+           when Integer
+             Time.now + time
+           when Time
+             time
+           end
+    
+    return nil if time <= Time.now
+    
+    v = TimedObject.new(value, time)
+    @store[key] = v
+    
+    value
+  end
+  
+  # Returns true if the cache is empty, otherwise false.
+  def empty?
+    @store.empty?
+  end
+  
+  # Deletes the key-value pair for the given key.
+  #
+  # Returns nil if there is no such key, otherwise returns the deleted value.
+  def delete(key)
+    v = @store.delete(key)
+    v ? v.value : v
+  end
+  
+  # Removes any expired entries from the cache.
+  #
+  # If nothing was removed, returns nil, otherwise returns
+  # the number of elements removed.
+  def prune
+    return nil if empty?
+    
+    count = 0
+    
+    @store.delete_if { |k, v| v.expired? && count += 1 }
+    
+    count == 0 ? nil : count
+  end
+  
+  def inspect
+    %Q{#<#{self.class} #{@store.inspect}>}
+  end
+end

data/lib/timeout_cache.rb~

@@ -0,0 +1,151 @@
+# Copyright (c) 2012 Adam Prescott, licensed under the MIT license. See LICENSE.
+
+#
+# TimeoutCache is a simple key-value store where entries expire after a certain
+# time. It implements parts of the Hash interface.
+#
+#     cache = TimeoutCache.new
+#     cache[:foo] = :bar
+#     cache[:foo] #=> bar
+#
+#     # wait some time (by default, 60 seconds)
+#
+#     cache[:foo] #=> nil
+#
+class TimeoutCache
+  VERSION = "0.0.1"
+  
+  # Wraps an object by attaching a time to it.
+  class TimedObject #:nodoc:
+    attr_reader :value, :expires_at
+    
+    def initialize(value, time)
+      @value = value
+      @expires_at = time
+    end
+    
+    # Returns true if the object has expired.
+    # Returns false if the object has not yet expired.
+    def expired?
+      @expires_at <= Time.now
+    end
+  end
+  
+  # The default number of seconds an object stays alive.
+  DEFAULT_TIMEOUT = 60
+  
+  attr_reader :timeout
+  
+  # Creates a new TimeoutCache.
+  #
+  # If <tt>timeout</tt> is specified, the default survival time for
+  # a cache entry is <tt>timeout</tt> in seconds.
+  #
+  # If no default value is used, then DEFAULT_TIMEOUT is the default
+  # time-to-expire in seconds.
+  def initialize(timeout = DEFAULT_TIMEOUT)
+    raise ArgumentError.new("Timeout must be > 0") unless timeout > 0
+    
+    @timeout = timeout
+    
+    # we can use this for look-ups in O(1), instead of only find-min in O(1)
+    @store = {}
+  end
+  
+  # Returns the number of items in the cache.
+  def size
+    @store.size
+  end
+  alias_method :length, :size
+  
+  # Returns the value for the given key. If there is no such key in the cache,
+  # then this returns nil. If the value has an expire time earlier than or equal
+  # to the current time, this returns nil.
+  #
+  # As an implementation detail, this method calls #prune whenever it finds
+  # an element that has expired.
+  def [](key)
+    val = @store[key]
+    
+    if val
+      if val.expired?
+        prune
+        nil
+      else
+        val.value
+      end
+    else
+      nil
+    end
+  end
+  alias_method :get, :[]
+  
+  # Returns the expire time of the value for the given key.
+  def expire_time(key)
+    @store[key].expires_at
+  end
+  
+  # Stores an object in the cache with an expire time DEFAULT_TIMEOUT
+  # seconds from now.
+  def []=(key, value)
+    v = TimedObject.new(value, Time.now + timeout)
+    @store[key] = v
+  end
+  
+  # Stores an object in the cache. options is a hash with symbol keys:
+  #
+  # :time:: can be either an Integer representing the number of seconds the object should be alive
+  #         or a Time object representing a fixed time.
+  #
+  # If time is not specified in the hash, the default timeout length is used.
+  #
+  # If the object would expire immediately, returns nil, otherwise returns the object stored.
+  def set(key, value, options = {})
+    time = options[:time] || timeout
+    
+    time = case time
+           when Integer
+             Time.now + time
+           when Time
+             time
+           end
+    
+    return nil if time <= Time.now
+    
+    v = TimedObject.new(value, time)
+    @store[key] = v
+    
+    value
+  end
+  
+  # Returns true if the cache is empty, otherwise false.
+  def empty?
+    @store.empty?
+  end
+  
+  # Deletes the key-value pair for the given key.
+  #
+  # Returns nil if there is no such key, otherwise returns the deleted value.
+  def delete(key)
+    v = @store.delete(key)
+    v ? v.value : v
+  end
+  
+  # Removes any expired entries from the cache.
+  #
+  # If nothing was removed, returns nil, otherwise returns
+  # the number of elements removed.
+  def prune
+    return nil if empty?
+    
+    count = 0
+    
+    @store.delete_if { |k, v| v.expired? && count += 1 }
+    
+    count == 0 ? nil : count
+  end
+  
+  def inspect
+    %Q{#<#{self.class} #{@store.inspect}>}
+  end
+end

data/rakefile

@@ -0,0 +1,26 @@
+require "rake"
+require "rdoc/task"
+require "rspec/core/rake_task"
+
+$:.unshift(File.expand_path("lib", __FILE__))
+require "timeout_cache"
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.rspec_opts = "-I test --color --format nested"
+  t.pattern = "test/**/*_spec.rb"
+  t.verbose = false
+  t.fail_on_error = true
+end
+
+task :doc => [:docs]
+
+Rake::RDocTask.new(:docs) do |rd|
+  #rd.main = "docs/README.md"
+  rd.main = "" # I'm broken, fix me
+  rd.rdoc_dir = "docs"
+  rd.title = "TimeoutCache #{TimeoutCache::VERSION}"
+  rd.options << '--line-numbers' << '--inline-source'
+  rd.rdoc_files.include("README.md", "lib")
+end
+
+task :default => :test

data/test/timeout_cache_spec.rb

@@ -0,0 +1,167 @@
+require "timeout_cache"
+require "rspec"
+
+describe TimeoutCache do
+  it "uses the global default timeout with no time specified" do
+    subject.timeout.should == TimeoutCache::DEFAULT_TIMEOUT
+  end
+  
+  it "uses a specified timeout if one is given" do
+    TimeoutCache.new(50).timeout.should == 50
+  end
+  
+  it "cannot be instantiated with a global timeout <= 0" do
+    [0, -1, -5].each do |i|
+      expect { TimeoutCache.new(i) }.to raise_error(ArgumentError)
+    end
+    
+    expect { TimeoutCache.new(1) }.to_not raise_error
+  end
+  
+  describe "#set" do
+    it "sets the given key-value pair" do
+      subject.set(:a, 1)
+      subject.get(:a).should == 1
+    end
+    
+    it "sets the given key-value pair with a timeout" do
+      t = Time.now + 10
+      subject.set(:a, 1, :time => t)
+      subject.expire_time(:a).should == t
+    end
+    
+    # here be dragons. if it takes too long to execute these
+    # commands, the times won't match, so this test isn't deterministic
+    it "sets a default timeout time with no time value specified" do
+      t = Time.now + subject.timeout
+      subject.set(:a, 1)
+      subject.expire_time(:a).should_not be_nil
+      subject.expire_time(:a).to_i.should == t.to_i
+    end
+    
+    it "doesn't set a value if the timeout time is <= now" do
+      subject.set(:a, 1, :time => Time.now)
+      subject.get(:a).should be_nil
+    end
+    
+    it "can have a negative time value" do
+      expect { subject.set(:a, 1, :time => -1) }.to_not raise_error
+      subject.get(:a).should be_nil
+    end
+  end
+  
+  describe "#get" do
+    it "returns nil if there is no matching key" do
+      subject.get(:no_such_key).should be_nil
+    end
+    
+    it "returns nil if the object has expired" do
+      subject.set(:a, 1, :time => 1)
+      subject.get(:a).should == 1
+      sleep 2
+      subject.get(:a).should be_nil
+    end
+  end
+  
+  describe "#prune" do
+    it "erases expired entries" do
+      subject.set(:a, 1, :time => 1)
+      subject.get(:a).should == 1
+      sleep 2
+      subject.prune
+      subject.get(:a).should be_nil
+    end
+    
+    it "returns nil if nothing was pruned" do
+      subject.prune.should be_nil
+    end
+  end
+  
+  describe "#delete" do
+    it "deletes entries from the cache" do
+      subject[0] = 1
+      subject.delete(0)
+      subject[0].should be_nil
+    end
+    
+    it "returns nil if nothing was deleted" do
+      subject[:no_such_key].should be_nil
+      
+      subject[0] = 1
+      subject.delete(0)
+      subject.delete(0).should be_nil
+    end
+    
+    it "returns the value deleted if the key is deleted" do
+      subject[0] = 1
+      subject.delete(0).should == 1
+    end
+  end
+  
+  describe "#size" do
+    it "returns the number of entries in the cache" do
+        subject.size.should == 0
+        subject[:a] = :b
+        subject.size.should == 1
+        (1..10).each { |n| subject[n] = n }
+        subject.size.should == 11
+    end
+    
+    it "is 0 if the cache is empty" do
+        subject.empty?.should be_true
+        subject.size.should == 0
+    end
+    
+    it "is non-zero if the cache is empty" do
+        subject[:a] = 1
+        subject.size.should_not == 0
+    end
+  end
+  
+  describe "pruning" do
+    it "happens when calling #get(key) when get(key) is expired" do
+      subject.set(:a, 1, :time => 2)
+      subject.set(:b, 1, :time => 2)
+      sleep 3
+      subject.size.should == 2
+      subject.get(:a)
+      subject.size.should == 0
+    end
+
+    it "does not happen when calling #get(key) when get(key) is not expired" do
+      subject.set(:a, 1, :time => 200)
+      subject.set(:b, 1, :time => 2)
+      sleep 3
+      subject.size.should == 2
+      subject.get(:a)
+      subject.size.should == 2
+    end
+  end
+  
+  describe "#empty?" do
+    it "is true if the cache is empty" do
+      subject.empty?.should be_true
+    end
+    
+    it "is false if the cache is not empty" do
+      subject.set(:a, 1)
+      subject.empty?.should be_false
+    end
+  end
+end
+
+describe TimeoutCache::TimedObject do
+  describe "#expired?" do
+    it "returns true for expire time > now" do
+      TimeoutCache::TimedObject.new(:value, Time.now + 50)
+    end
+    
+    it "returns false for expire time < now" do
+      TimeoutCache::TimedObject.new(:value, Time.now - 50)
+    end
+    
+    it "returns false for expire time = now" do
+      TimeoutCache::TimedObject.new(:value, Time.now)
+    end
+  end
+end

data/test/timeout_cache_spec.rb~

@@ -0,0 +1,163 @@
+require "timeout_cache"
+require "rspec"
+
+describe TimeoutCache do
+  it "uses the global default timeout with no time specified" do
+    subject.timeout.should == TimeoutCache::DEFAULT_TIMEOUT
+  end
+  
+  it "uses a specified timeout if one is given" do
+    TimeoutCache.new(50).timeout.should == 50
+  end
+  
+  it "cannot be instantiated with a global timeout <= 0" do
+    [0, -1, -5].each do |i|
+      expect { TimeoutCache.new(i) }.to raise_error(ArgumentError)
+    end
+    
+    expect { TimeoutCache.new(1) }.to_not raise_error
+  end
+  
+  describe "#set" do
+    it "sets the given key-value pair" do
+      subject.set(:a, 1)
+      subject.get(:a).should == 1
+    end
+    
+    it "sets the given key-value pair with a timeout" do
+      t = Time.now + 10
+      subject.set(:a, 1, :time => t)
+      subject.expire_time(:a).should == t
+    end
+    
+    # here be dragons. if it takes too long to execute these
+    # commands, the times won't match, so this test isn't deterministic
+    it "sets a default timeout time with no time value specified" do
+      t = Time.now + subject.timeout
+      subject.set(:a, 1)
+      subject.expire_time(:a).should_not be_nil
+      subject.expire_time(:a).to_i.should == t.to_i
+    end
+    
+    it "doesn't set a value if the timeout time is <= now" do
+      subject.set(:a, 1, :time => Time.now)
+      subject.get(:a).should be_nil
+    end
+    
+    it "can have a negative time value" do
+      expect { subject.set(:a, 1, :time => -1) }.to_not raise_error
+      subject.get(:a).should be_nil
+    end
+  end
+  
+  describe "#get" do
+    it "returns nil if there is no matching key" do
+      subject.get(:no_such_key).should be_nil
+    end
+    
+    it "returns nil if the object has expired" do
+      subject.set(:a, 1, :time => 1)
+      subject.get(:a).should == 1
+      sleep 2
+      subject.get(:a).should be_nil
+    end
+  end
+  
+  describe "#prune" do
+    it "erases expired entries" do
+      subject.set(:a, 1, :time => 1)
+      subject.get(:a).should == 1
+      sleep 2
+      subject.prune
+      subject.get(:a).should be_nil
+    end
+    
+    it "returns nil if nothing was pruned" do
+      subject.prune.should be_nil
+    end
+  end
+  
+  describe "#delete" do
+    it "deletes entries from the cache" do
+      subject[0] = 1
+      subject.delete(0)
+      subject[0].should be_nil
+    end
+    
+    it "returns nil if nothing was deleted" do
+      subject[:no_such_key].should be_nil
+    end
+    
+    it "returns the value deleted if the key is deleted" do
+      subject[0] = 1
+      subject.delete(0).should == 1
+    end
+  end
+  
+  describe "#size" do
+    it "returns the number of entries in the cache" do
+        subject.size.should == 0
+        subject[:a] = :b
+        subject.size.should == 1
+        (1..10).each { |n| subject[n] = n }
+        subject.size.should == 11
+    end
+    
+    it "is 0 if the cache is empty" do
+        subject.empty?.should be_true
+        subject.size.should == 0
+    end
+    
+    it "is non-zero if the cache is empty" do
+        subject[:a] = 1
+        subject.size.should_not == 0
+    end
+  end
+  
+  describe "pruning" do
+    it "happens when calling #get(key) when get(key) is expired" do
+      subject.set(:a, 1, :time => 2)
+      subject.set(:b, 1, :time => 2)
+      sleep 3
+      subject.size.should == 2
+      subject.get(:a)
+      subject.size.should == 0
+    end
+
+    it "does not happen when calling #get(key) when get(key) is not expired" do
+      subject.set(:a, 1, :time => 200)
+      subject.set(:b, 1, :time => 2)
+      sleep 3
+      subject.size.should == 2
+      subject.get(:a)
+      subject.size.should == 2
+    end
+  end
+  
+  describe "#empty?" do
+    it "is true if the cache is empty" do
+      subject.empty?.should be_true
+    end
+    
+    it "is false if the cache is not empty" do
+      subject.set(:a, 1)
+      subject.empty?.should be_false
+    end
+  end
+end
+
+describe TimeoutCache::TimedObject do
+  describe "#expired?" do
+    it "returns true for expire time > now" do
+      TimeoutCache::TimedObject.new(:value, Time.now + 50)
+    end
+    
+    it "returns false for expire time < now" do
+      TimeoutCache::TimedObject.new(:value, Time.now - 50)
+    end
+    
+    it "returns false for expire time = now" do
+      TimeoutCache::TimedObject.new(:value, Time.now)
+    end
+  end
+end

data/timeout_cache.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "timeout_cache"
+
+Gem::Specification.new do |s|
+  s.name         = "timeout_cache"
+  s.version      = TimeoutCache::VERSION
+  s.authors      = ["Adam Prescott"]
+  s.email        = ["adam@aprescott.com"]
+  s.homepage     = "https://github.com/aprescott/timeout_cache"
+  s.summary      = "Simple time-based cache."
+  s.description  = "Simple time-based cache."
+  s.files        = Dir["{lib/**/*,test/**/*}"] + %w[timeout_cache.gemspec .gemtest LICENSE Gemfile rakefile README.md]
+  s.require_path = "lib"
+  s.test_files   = Dir["test/*"]
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: timeout_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Prescott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple time-based cache.
+email:
+- adam@aprescott.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/timeout_cache.rb~
+- lib/timeout_cache.rb
+- test/timeout_cache_spec.rb
+- test/timeout_cache_spec.rb~
+- timeout_cache.gemspec
+- .gemtest
+- LICENSE
+- Gemfile
+- rakefile
+- README.md
+homepage: https://github.com/aprescott/timeout_cache
+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: Simple time-based cache.
+test_files:
+- test/timeout_cache_spec.rb
+- test/timeout_cache_spec.rb~