cache_lib 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49951bebe666d8d905c8cb74e5b1324f95f460da
-  data.tar.gz: eb58345e35655ea65121a69d22f6d936c9eae506
+  metadata.gz: 04ef9e417311a3650f36194439a2a1a131a15079
+  data.tar.gz: dc0a81c4f79f2cd9da54ab117b304cf0a07fb549
 SHA512:
-  metadata.gz: 51a1d55a39dbacf762ab5b1b58275de0018fb968d7b200e7dbddbed4f159e1f3691ebd96232999a484fcffc355f9703922f3bc3f43017dd66076a0ce5c48bd28
-  data.tar.gz: f38f39b35db8a674c052184ba4ee32e8b7c640d06f56574ef5d528f9c4e1356ae38610949b4329d55cf48cc370b00e5007296aeab4826f3df09a1d4ba6a45607
+  metadata.gz: 44933670c7e8e9e1d56c99b3fe9b97268f6c2ce70f3bb463ad97d4fa8cf4e0e6d6858d33fa2c7bc04301a52a63e42a074255bb4be1dcb02605d869d40fe93002
+  data.tar.gz: 10b126320be7b1ff1f6da63c57a16d7c3c3b225810faec6ed59557a83c2d083dea87b94d0b82a84cb3bdf492c875d6c7a5965cf762a2ca590733d3d8989a8111

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+### 0.1.0
+This release does not have any breaking API changes.
+NEW: TtlCache added, a simple extension of the LRU cache with a cache level ttl eviction strategy.
+NEW: #delete and #expire method added to all caches.
+FIX: Infinite loop bug LirsCache fixed.
+
+### 0.0.1
+Initial release implementing Basic, FIFO, LRU and LIRS caches.

data/NOTICE.md

@@ -0,0 +1,31 @@
+## Credits
+### LruRedux
+::LirsCache and ::SafeLirsCache started as a feature fork of LruRedux 0.8.1.
+
+##### Homepage:
+https://github.com/SamSaffron/lru_redux/
+##### License:
+```
+Copyright (c) 2013 Sam Saffron
+
+MIT License
+
+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

@@ -1,8 +1,8 @@
 # CacheLib
-#### A Ruby caching library implementing Basic, FIFO, LRU and LIRS caches.
+#### A Ruby caching library implementing Basic, FIFO, LRU, TTL and LIRS caches.
 
 ##### CacheLib is young library and breaking api changes are still possible.  Please read the release notes before upgrading.
-CacheLib currently implements basic, FIFO, LRU and LIRS caches along with offering thread safe implementations of each.  Originally a LIRS cache feature fork of [LruRedux](https://github.com/SamSaffron/lru_redux), CacheLib was built to provide a clean base for implementing the LIRS cache in Ruby, along with offering user friendly api.
+CacheLib currently implements basic, FIFO, LRU and LIRS caches along with offering thread safe implementations of each.  Originally a LIRS cache feature fork of [LruRedux](https://github.com/SamSaffron/lru_redux), CacheLib was built to provide a clean base for implementing the LIRS cache in Ruby, along with offering a user friendly api.
 
 ##### Basic:
 The basic cache is the simplest cache available and forms the base for the others.  It does NOT have an eviction strategy and will store however much it is given.
@@ -13,8 +13,11 @@ The FIFO cache adds to the basic cache with a simple First In First Our eviction
 ##### LRU:
 The LRU cache further adds to the previous caches with a Least Recently Used eviction strategy.  The primary difference between FIFO and LRU is that LRU will refresh currently cached items if they are requested again.
 
+##### TTL:
+The TTL cache is an extension of the LRU cache, adding a TTL eviction strategy that takes precedence over LRU eviction.
+
 ##### LIRS:
-The LIRS cache implements the Low Inter-Reference Recency Set Replacement Policy developed by Song Jiang and Xiaodong Zhang.  Please reference the [original paper](http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.116.2184) for more information.
+The LIRS cache implements the Low Inter-Reference Recency Set eviction policy.  LIRS improves performance over LRU by taking into account the recency and reuse of an item in eviction selection. Please reference the [original paper](http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.116.2184) for more information.
 
 ##### CacheLib is Ruby >= 1.9.3 only.
 If you are looking for a LRU cache that supports an earlier version or just want an alternative LRU cache, please take a look at [LruRedux](https://github.com/SamSaffron/lru_redux).
@@ -33,8 +36,14 @@ cache = CacheLib.create :fifo, 100
 # LRU with a limit of 100
 cache = CacheLib.create :lru, 100
 
+# TTL with a limit of 100 and a ttl of 5 minutes.
+cache = CacheLib.create :ttl, 100, 5 * 60
+
 # LIRS with a cache limit of 100, made up of a S limit of 95 and a Q limit of 5.
 cache = CacheLib.create :lirs, 95, 5
+
+# Threadsafe versions of every cache can be made by using CacheLib.safe_create
+cache = CacheLib.safe_create :lirs, 95, 5
 ```
 
 ### Using the cache
@@ -42,7 +51,9 @@ cache = CacheLib.create :lirs, 95, 5
 # Cache methods remain the same across all variations
 cache = CacheLib.create :lru, 100
 
-# .get is the primary method for accessing the cache.  It requires a key and block that will generate the value that is stored if the key is not cached.
+# .get is the primary method for accessing the cache.
+# It requires a key and block that will generate the value that is stored
+# if the key is not cached.
 cache.get(:a) { 'Apple' }
 # => 'Apple'
 cache.get(:b) { 'Beethoven' }
@@ -50,7 +61,8 @@ cache.get(:b) { 'Beethoven' }
 cache.get(:a) { 'Apricot' }
 # => 'Apple'
 
-# .store takes a key and value and implements the functionality of Hash#store. Will refresh the key in LRU and LIRS caches.
+# .store takes a key and value and implements the functionality of Hash#store.
+# Will refresh the key in LRU and LIRS caches.
 cache.store(:c, 'Chopin')
 # => 'Chopin'
 cache.store(:a, 'Mozart')
@@ -70,18 +82,24 @@ cache.lookup(:t)
 cache[:a]
 # => 'Mozart'
 
-# .fetch is similar to .lookup, but takes an optional block that will execute if the key is not cached.
+# .fetch is similar to .lookup,
+# but takes an optional block that will execute if the key is not cached.
 cache.fetch(:c)
 # => 'Chopin'
 cache.fetch(:r) { 21 * 2 }
 # => 42
 
-# .evict takes a key and will remove the key from the cache and return the associated value.  Returns nil is the key is not cached.
+# .evict takes a key and will remove the key from the cache and return the associated value.
+# Returns nil is the key is not cached.
 cache.evict(:d)
 # => 'Denmark'
 cache.evict(:r)
 # => nil
 
+# .delete is equivalent to .evict
+cache.delete(:x)
+# => nil
+
 # .each takes each key value pair and applies the given block to them.
 cache.each { |_, value| puts value }
 # => 'Chopin'
@@ -94,7 +112,9 @@ cache.key?(:a)
 cache.key?(:g)
 # => false
 
-# .to_a returns an array of arrays of key value pairs that are cached.  Basic, FIFO and LIRS are insertion ordered while LRU is recency ordered, starting with newest.
+# .to_a returns an array of arrays of key value pairs that are cached.
+# Basic, FIFO and LIRS are insertion ordered while LRU and TTL are recency ordered,
+# starting with the newest.
 cache.to_a
 # => [[:c, 'Chopin'], [:a, 'Mozart'], [:b, 'Beethoven']]
 
@@ -110,13 +130,44 @@ cache.values
 cache.size
 # => 3
 
+# .limit returns the current cache limit.
+cache.limit
+# => 100
+
+# The limit can be changed with .limit=.
+cache.limit = 125
+# => 125
+
 # .clear removes all items from the cache.
 cache.clear
 # => nil
+
+# The LIRS and TTL caches have additional options for .limit=.
+lirs = CacheLib.create :lirs, 95, 5
+ttl = CacheLib.create :ttl, 100, 5 * 60
+
+# LIRS require both the Stack limit and Queue limit be given,
+# and their sum is the cache limit.
+lirs.limit = 120, 5
+# => [120, 5]
+lirs.limit
+# => 125
+
+# TTL can have a new limit and ttl set at the same time.
+ttl.limit = 125, 10 * 60
+# => [125, 600]
+
+# Or just the limit
+ttl.limit = 150
+
+# Or just the ttl
+ttl.limit = nil, 6 * 60
 ```
 
-## Copyright
+## Credits and Notices
+See [NOTICE.md](NOTICE.md) for details.
 
+## Copyright
 Copyright (c) 2015 Kaijah Hougham
 
 See [LICENSE.txt](LICENSE.txt) for details.

data/cache_lib.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.name          = 'cache_lib'
   gem.version       = CacheLib::VERSION
   gem.summary       = 'A Ruby Caching Library'
-  gem.description   = 'A Ruby caching library implementing Basic, FIFO, LRU and LIRS caching strategies.'
+  gem.description   = 'A Ruby caching library implementing Basic, FIFO, LRU, TTL and LIRS caches.'
   gem.license       = 'MIT'
   gem.authors       = 'Kaijah Hougham'
   gem.email         = 'github@seberius.com'
@@ -21,5 +21,6 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'bundler', '~> 1.7'
   gem.add_development_dependency 'rake', '~> 10'
-  gem.add_development_dependency 'minitest', '~> 5.0'
+  gem.add_development_dependency 'minitest', '~> 5.5'
+  gem.add_development_dependency 'timecop', '~> 0.7'
 end

data/lib/cache_lib.rb

@@ -2,10 +2,12 @@ require_relative 'cache_lib/util_hash'
 require_relative 'cache_lib/basic_cache'
 require_relative 'cache_lib/fifo_cache'
 require_relative 'cache_lib/lru_cache'
+require_relative 'cache_lib/ttl_cache'
 require_relative 'cache_lib/lirs_cache'
 require_relative 'cache_lib/safe_basic_cache'
 require_relative 'cache_lib/safe_fifo_cache'
 require_relative 'cache_lib/safe_lru_cache'
+require_relative 'cache_lib/safe_ttl_cache'
 require_relative 'cache_lib/safe_lirs_cache'
 require_relative 'cache_lib/version'
 
@@ -15,6 +17,7 @@ module CacheLib
     when :basic then BasicCache.new(*args)
     when :fifo then FifoCache.new(*args)
     when :lru then LruCache.new(*args)
+    when :ttl then TtlCache.new(*args)
     when :lirs then LirsCache.new(*args)
     else fail ArgumentError "Cache type not recognized: #{type}"
     end
@@ -25,6 +28,7 @@ module CacheLib
     when :basic then SafeBasicCache.new(*args)
     when :fifo then SafeFifoCache.new(*args)
     when :lru then SafeLruCache.new(*args)
+    when :ttl then SafeTtlCache.new(*args)
     when :lirs then SafeLirsCache.new(*args)
     else fail ArgumentError "Cache type not recognized: #{type}"
     end

data/lib/cache_lib/basic_cache.rb

@@ -21,9 +21,10 @@ module CacheLib
     end
 
     def get(key)
-      value = hit(key)
+      has_key = true
+      value = @cache.fetch(key) { has_key = false }
 
-      if value
+      if has_key
         value
       else
         miss(key, yield)
@@ -58,6 +59,10 @@ module CacheLib
       nil
     end
 
+    def expire
+      nil
+    end
+
     def each
       @cache.each do |pair|
         yield pair
@@ -90,11 +95,14 @@ module CacheLib
     end
 
     def inspect
-      "#{self.class} currently caching #{@cache.size} items."
+      "#{self.class}, "\
+      "Limit: #{@limit}, "\
+      "Size: #{@cache.size}"
     end
 
     alias_method :[], :lookup
     alias_method :[]=, :store
+    alias_method :delete, :evict
 
     protected
 

data/lib/cache_lib/fifo_cache.rb

@@ -3,7 +3,7 @@ module CacheLib
     def initialize(*args)
       limit, _ = args
 
-      fail ArgumentError "Cache Limit must be 1 or greater: #{limit}" if
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
           limit.nil? || limit < 1
 
       @limit = limit
@@ -13,7 +13,10 @@ module CacheLib
 
     def limit=(args)
       limit, _ = args
-      fail ArgumentError "Cache Limit must be 1 or greater: #{limit}" if
+
+      limit ||= @limit
+
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
           limit.nil? || limit < 1
 
       @limit = limit
@@ -21,18 +24,14 @@ module CacheLib
       resize
     end
 
-    def inspect
-      "#{self.class} with a limit of #{@limit} "\
-      "currently caching #{@cache.size} items."
-    end
-
     alias_method :[], :lookup
     alias_method :[]=, :store
+    alias_method :delete, :evict
 
     protected
 
     def resize
-      @cache.delete(@cache.tail) while @cache.size > @limit
+      @cache.pop_tail while @cache.size > @limit
     end
 
     def miss(key, value)

data/lib/cache_lib/lirs_cache.rb

@@ -3,9 +3,9 @@ module CacheLib
     def initialize(*args)
       s_limit, q_limit = args
 
-      fail ArgumentError 'S Limit must be 1 or greater.' if
+      fail ArgumentError, 'S Limit must be 1 or greater.' if
           s_limit.nil? || s_limit < 1
-      fail ArgumentError 'Q Limit must be 1 or greater.' if
+      fail ArgumentError, 'Q Limit must be 1 or greater.' if
           q_limit.nil? || q_limit < 1
 
       @s_limit = s_limit
@@ -32,9 +32,9 @@ module CacheLib
     def limit=(args)
       s_limit, q_limit = args
 
-      fail ArgumentError 'S Limit must be 1 or greater.' if
+      fail ArgumentError, 'S Limit must be 1 or greater.' if
           s_limit.nil? || s_limit < 1
-      fail ArgumentError 'Q Limit must be 1 or greater.' if
+      fail ArgumentError, 'Q Limit must be 1 or greater.' if
           q_limit.nil? || q_limit < 1
 
       @s_limit = s_limit
@@ -106,47 +106,50 @@ module CacheLib
     end
 
     def inspect
-      "#{self.class} with a limit of #{@limit}, "\
-      "s_limit of #{@s_limit} and q_limit of #{@q_limit} "\
-      "currently caching #{@cache.size} items."
+      "#{self.class}, "\
+      "Limit: #{@limit}, "\
+      "Stack Limit: #{@s_limit}, "\
+      "Queue Limit: #{@q_limit}, "\
+      "Size: #{@cache.size}"
     end
 
     alias_method :[], :lookup
     alias_method :[]=, :store
+    alias_method :delete, :evict
 
     protected
 
     def trim_stack
-      s_tail = @stack.tail
-      while @queue.key?(s_tail) || !@cache.key?(s_tail)
-        @stack.delete(s_tail)
-        s_tail = @stack.tail
+      key, _ = @stack.tail
+      while key && (@queue.key?(key) || !@cache.key?(key))
+        @stack.delete(key)
+        key, _ = @stack.tail
       end
     end
 
     def promote_hir
-      key = @queue.head
+      key = @queue.head_key
 
       @stack.set_tail(key, nil) unless @stack.key?(key)
       @queue.delete(key)
     end
 
     def pop_tail
-      key = @queue.tail
+      key, _ = @queue.tail
 
       @queue.delete(key)
       @cache.delete(key)
     end
 
     def pop_stack
-      key = @stack.tail
+      key, _ = @stack.tail
 
       @cache.delete(key)
       trim_stack
     end
 
     def demote_lir
-      key = @stack.tail
+      key, _ = @stack.tail
 
       @stack.delete(key)
       @queue.set_head(key, nil)
@@ -154,11 +157,7 @@ module CacheLib
     end
 
     def resize
-      s_size = 0
-
-      @stack.each do |key, _|
-        s_size += 1 if @cache.key?(key) && !@queue.key?(key)
-      end
+      s_size = @stack.count { |key, _| @cache.key?(key) && !@queue.key?(key) }
 
       promote_hir while (s_size < @s_limit && @queue.size > 0) && s_size += 1
       pop_tail while @queue.size > 0 && @cache.size > @limit
@@ -176,7 +175,7 @@ module CacheLib
 
           demote_lir
         else
-          s_tail_key = @stack.tail
+          s_tail_key, _ = @stack.tail
           @stack.refresh(key)
 
           trim_stack if s_tail_key == key

data/lib/cache_lib/lru_cache.rb

@@ -3,7 +3,7 @@ module CacheLib
     def initialize(*args)
       limit, _ = args
 
-      fail ArgumentError "Cache Limit must be 1 or greater: #{limit}" if
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
           limit.nil? || limit < 1
 
       @limit = limit
@@ -14,7 +14,9 @@ module CacheLib
     def limit=(args)
       limit, _ = args
 
-      fail ArgumentError "Cache Limit must be 1 or greater: #{limit}" if
+      limit ||= @limit
+
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
           limit.nil? || limit < 1
 
       @limit = limit
@@ -53,13 +55,9 @@ module CacheLib
       end
     end
 
-    def inspect
-      "#{self.class} with a limit of #{@limit} "\
-      "currently caching #{@cache.size} items."
-    end
-
     alias_method :[], :lookup
     alias_method :[]=, :store
+    alias_method :delete, :evict
 
     protected
 

data/lib/cache_lib/safe_sync.rb

@@ -56,6 +56,12 @@ module CacheLib
       end
     end
 
+    def expire
+      synchronize do
+        super
+      end
+    end
+
     def each
       synchronize do
         super
@@ -94,5 +100,6 @@ module CacheLib
 
     alias_method :[], :lookup
     alias_method :[]=, :store
+    alias_method :delete, :evict
   end
 end

data/lib/cache_lib/safe_ttl_cache.rb

@@ -0,0 +1,7 @@
+require_relative 'safe_sync'
+
+module CacheLib
+  class SafeTtlCache < TtlCache
+    include SafeSync
+  end
+end

data/lib/cache_lib/ttl_cache.rb

@@ -0,0 +1,150 @@
+module CacheLib
+  class TtlCache < BasicCache
+    def initialize(*args)
+      limit, ttl = args
+
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
+          limit.nil? || limit < 1
+      fail ArgumentError, "TTL must be :none, 0 or greater: #{ttl}" unless
+          ttl == :none || ((ttl.is_a? Numeric) && ttl >= 0)
+
+      @limit = limit
+      @ttl = ttl
+
+      @cache = UtilHash.new
+      @queue = UtilHash.new
+    end
+
+    def initialize_copy(source)
+      source_raw = source.raw
+
+      @limit = source_raw[:limit]
+
+      @cache = source_raw[:cache]
+      @queue = source_raw[:queue]
+    end
+
+    def limit=(args)
+      limit, ttl = args
+
+      limit ||= @limit
+      ttl ||= @ttl
+
+      fail ArgumentError, "Cache Limit must be 1 or greater: #{limit}" if
+          limit.nil? || limit < 1
+      fail ArgumentError, "TTL must be :none, 0 or greater: #{ttl}" unless
+          ttl == :none || ((ttl.is_a? Numeric) && ttl >= 0)
+
+      @limit = limit
+      @ttl = ttl
+
+      resize
+    end
+
+    def get(key)
+      if hit?(key)
+        hit(key)
+      else
+        miss(key, yield)
+      end
+    end
+
+    def store(key, value)
+      ttl_evict
+
+      @cache.delete(key)
+      @queue.delete(key)
+
+      miss(key, value)
+    end
+
+    def lookup(key)
+      hit(key) if hit?(key)
+    end
+
+    def fetch(key)
+      if hit?(key)
+        hit(key)
+      else
+        yield if block_given?
+      end
+    end
+
+    def evict(key)
+      @queue.delete(key)
+      @cache.delete(key)
+    end
+
+    def expire
+      ttl_evict
+    end
+
+    def raw
+      { limit: @limit,
+        cache: @cache.clone,
+        queue: @queue.clone }
+    end
+
+    def inspect
+      "#{self.class}, "\
+      "Limit: #{@limit}, "\
+      "TTL: #{@ttl}, "\
+      "Size: #{@cache.size}"
+    end
+
+    alias_method :[], :lookup
+    alias_method :[]=, :store
+    alias_method :delete, :evict
+
+    protected
+
+    def ttl_evict
+      return if @ttl == :none
+
+      ttl_horizon = Time.now - @ttl
+      key, time = @queue.tail
+
+      until time.nil? || time > ttl_horizon
+        @queue.delete(key)
+        @cache.delete(key)
+
+        key, time = @queue.tail
+      end
+    end
+
+    def resize
+      ttl_evict
+
+      while @cache.size > @limit
+        key, _ = @cache.tail
+
+        @queue.delete(key)
+        @cache.delete(key)
+      end
+    end
+
+    def hit?(key)
+      ttl_evict
+
+      @cache.key?(key)
+    end
+
+    def hit(key)
+      @cache.refresh(key)
+    end
+
+    def miss(key, value)
+      @cache[key] = value
+      @queue[key] = Time.now
+
+      while @cache.size > @limit
+        key, _ = @cache.tail
+
+        @queue.delete(key)
+        @cache.delete(key)
+      end
+
+      value
+    end
+  end
+end

data/lib/cache_lib/util_hash.rb

@@ -1,11 +1,11 @@
 module CacheLib
   class UtilHash < Hash
-    def head
+    def head_key
       keys.last
     end
 
     def tail
-      first[0]
+      first
     end
 
     def set_head(key, value)
@@ -18,7 +18,7 @@ module CacheLib
     end
 
     def pop_tail
-      delete(tail)
+      delete(first[0])
     end
 
     def refresh(key)

data/lib/cache_lib/version.rb

@@ -1,3 +1,3 @@
 module CacheLib
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/test/cache_lib/test_basic_cache.rb

@@ -1,5 +1,5 @@
 require 'cache_lib'
-require 'minitest/autorun'
+require 'minitest'
 
 class TestBasicCache < MiniTest::Test
   def setup
@@ -63,6 +63,11 @@ class TestBasicCache < MiniTest::Test
     assert_equal nil, @cache.evict(:z)
 
     assert_equal nil, @cache.lookup(:a)
+
+    assert_equal 2, @cache.delete(:b)
+    assert_equal nil, @cache.delete(:z)
+
+    assert_equal nil, @cache.lookup(:b)
   end
 
   def test_clear
@@ -125,7 +130,7 @@ class TestBasicCache < MiniTest::Test
     @cache.store(:a, 1)
     @cache.store(:b, 2)
 
-    assert_equal "#{@cache.class} currently caching 2 items.",
+    assert_equal "#{@cache.class}, Limit: , Size: 2",
                  @cache.inspect
   end
 end

data/test/cache_lib/test_fifo_cache.rb

@@ -1,6 +1,3 @@
-require 'cache_lib'
-require 'minitest/autorun'
-
 require_relative 'test_basic_cache'
 
 class TestFifoCache < TestBasicCache
@@ -22,8 +19,7 @@ class TestFifoCache < TestBasicCache
     @cache.store(:a, 1)
     @cache.store(:b, 2)
 
-    assert_equal "#{@cache.class} with a limit of 5 "\
-                 "currently caching 2 items.",
+    assert_equal "#{@cache.class}, Limit: 5, Size: 2",
                  @cache.inspect
   end
 

data/test/cache_lib/test_lirs_cache.rb

@@ -1,6 +1,3 @@
-require 'cache_lib'
-require 'minitest/autorun'
-
 require_relative 'test_basic_cache'
 
 class TestLirsCache < TestBasicCache
@@ -22,9 +19,8 @@ class TestLirsCache < TestBasicCache
     @cache.store(:a, 1)
     @cache.store(:b, 2)
 
-    assert_equal "#{@cache.class} with a limit of 5, "\
-                 "s_limit of 3 and q_limit of 2 "\
-                 "currently caching 2 items.",
+    assert_equal "#{@cache.class}, Limit: 5, Stack Limit: 3, "\
+                 'Queue Limit: 2, Size: 2',
                  @cache.inspect
   end
 

data/test/cache_lib/test_lru_cache.rb

@@ -1,6 +1,3 @@
-require 'cache_lib'
-require 'minitest/autorun'
-
 require_relative 'test_basic_cache'
 
 class TestLruCache < TestBasicCache
@@ -22,8 +19,7 @@ class TestLruCache < TestBasicCache
     @cache.store(:a, 1)
     @cache.store(:b, 2)
 
-    assert_equal "#{@cache.class} with a limit of 5 "\
-                 "currently caching 2 items.",
+    assert_equal "#{@cache.class}, Limit: 5, Size: 2",
                  @cache.inspect
   end
 

data/test/cache_lib/test_safe_ttl_cache.rb

@@ -0,0 +1,14 @@
+require 'timecop'
+
+require_relative 'test_ttl_cache'
+
+class TestSafeTtlCache < TestTtlCache
+  def setup
+    Timecop.freeze(Time.now)
+    @cache = CacheLib.safe_create :ttl, 5, 5 * 60
+  end
+
+  def teardown
+    Timecop.return
+  end
+end

data/test/cache_lib/test_ttl_cache.rb

@@ -0,0 +1,143 @@
+require 'timecop'
+
+require_relative 'test_basic_cache'
+
+class TestTtlCache < TestBasicCache
+  def setup
+    Timecop.freeze(Time.now)
+    @cache = CacheLib.create :ttl, 5, 5 * 60
+  end
+
+  def teardown
+    Timecop.return
+  end
+
+  def test_limit
+    assert_equal 5, @cache.limit
+  end
+
+  def test_set_limit
+    @cache.limit = 90
+
+    assert_equal 90, @cache.limit
+  end
+
+  def test_inspect
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal "#{@cache.class}, Limit: 5, TTL: 300, Size: 2",
+                 @cache.inspect
+  end
+
+  def test_lru_promotion
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.lookup(3)
+    @cache.lookup(1)
+
+    assert_equal({ 2 => 2, 4 => 4, 5 => 5, 3 => 3, 1 => 1 },
+                 @cache.raw[:cache])
+  end
+
+  def test_lru_eviction
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.lookup(3)
+    @cache.lookup(1)
+    @cache.store(6, 6)
+
+    assert_equal 5, @cache.size
+    assert_equal({ 4 => 4, 5 => 5, 3 => 3, 1 => 1, 6 => 6 },
+                 @cache.raw[:cache])
+  end
+
+  def test_upsize
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.limit = 7
+    (6..8).each { |i| @cache.store(i, i) }
+
+    assert_equal 7, @cache.size
+    assert_equal({ 2 => 2, 3 => 3, 4 => 4, 5 => 5,
+                   6 => 6, 7 => 7, 8 => 8 },
+                 @cache.raw[:cache])
+  end
+
+  def test_downsize
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.limit = 3
+
+    assert_equal 3, @cache.size
+    assert_equal({ 3 => 3, 4 => 4, 5 => 5 }, @cache.raw[:cache])
+  end
+
+  # TTL tests using Timecop
+  def test_ttl_eviction_on_access
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    Timecop.freeze(Time.now + 330)
+
+    @cache.store(:c, 3)
+
+    assert_equal({ :c => 3 }, @cache.raw[:cache])
+  end
+
+  def test_ttl_eviction_on_expire
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    Timecop.freeze(Time.now + 330)
+
+    @cache.expire
+
+    assert_equal({}, @cache.raw[:cache])
+  end
+
+  def test_ttl_eviction_on_new_limit
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    Timecop.freeze(Time.now + 330)
+
+    @cache.limit = 10
+
+    assert_equal({}, @cache.raw[:cache])
+  end
+
+  def test_ttl_eviction_on_new_ttl
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    Timecop.freeze(Time.now + 330)
+
+    @cache.limit = nil, 10 * 60
+
+    assert_equal({ :a => 1, :b => 2 }, @cache.raw[:cache])
+
+    @cache.limit = nil, 2 * 60
+
+    assert_equal({}, @cache.raw[:cache])
+  end
+
+  def test_ttl_precedence_over_lru
+    @cache.store(:a, 1)
+
+    Timecop.freeze(Time.now + 60)
+
+    @cache.store(:b, 2)
+    @cache.store(:c, 3)
+    @cache.store(:d, 4)
+    @cache.store(:e, 5)
+
+    @cache.lookup(:a)
+
+    assert_equal [[:a, 1], [:e, 5], [:d, 4], [:c, 3], [:b, 2]],
+                 @cache.to_a
+
+    Timecop.freeze(Time.now + 270)
+
+    @cache.store(:f, 6)
+
+    assert_equal [[:f, 6], [:e, 5], [:d, 4], [:c, 3], [:b, 2]],
+                 @cache.to_a
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_lib
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Kaijah Hougham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,23 +44,38 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-description: A Ruby caching library implementing Basic, FIFO, LRU and LIRS caching
-  strategies.
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: A Ruby caching library implementing Basic, FIFO, LRU, TTL and LIRS caches.
 email: github@seberius.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
+- NOTICE.md
 - README.md
 - Rakefile
 - cache_lib.gemspec
@@ -74,6 +89,8 @@ files:
 - lib/cache_lib/safe_lirs_cache.rb
 - lib/cache_lib/safe_lru_cache.rb
 - lib/cache_lib/safe_sync.rb
+- lib/cache_lib/safe_ttl_cache.rb
+- lib/cache_lib/ttl_cache.rb
 - lib/cache_lib/util_hash.rb
 - lib/cache_lib/version.rb
 - test/cache_lib/test_basic_cache.rb
@@ -85,6 +102,8 @@ files:
 - test/cache_lib/test_safe_fifo_cache.rb
 - test/cache_lib/test_safe_lirs_cache.rb
 - test/cache_lib/test_safe_lru_cache.rb
+- test/cache_lib/test_safe_ttl_cache.rb
+- test/cache_lib/test_ttl_cache.rb
 homepage: https://github.com/seberius/cache_lib
 licenses:
 - MIT
@@ -105,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A Ruby Caching Library
@@ -119,3 +138,5 @@ test_files:
 - test/cache_lib/test_safe_fifo_cache.rb
 - test/cache_lib/test_safe_lirs_cache.rb
 - test/cache_lib/test_safe_lru_cache.rb
+- test/cache_lib/test_safe_ttl_cache.rb
+- test/cache_lib/test_ttl_cache.rb