cache_lib 0.0.1

data/lib/cache_lib/safe_sync.rb

@@ -0,0 +1,98 @@
+require 'monitor'
+
+module CacheLib
+  module SafeSync
+    include MonitorMixin
+
+    def initialize(*args)
+      super(*args)
+    end
+
+    def limit
+      synchronize do
+        super
+      end
+    end
+
+    def limit=(*args)
+      synchronize do
+        super(*args)
+      end
+    end
+
+    def get(key)
+      synchronize do
+        super(key)
+      end
+    end
+
+    def store(key, value)
+      synchronize do
+        super(key, value)
+      end
+    end
+
+    def lookup(key)
+      synchronize do
+        super(key)
+      end
+    end
+
+    def fetch(key)
+      synchronize do
+        super(key)
+      end
+    end
+
+    def evict(key)
+      synchronize do
+        super(key)
+      end
+    end
+
+    def clear
+      synchronize do
+        super
+      end
+    end
+
+    def each
+      synchronize do
+        super
+      end
+    end
+
+    def key?(key)
+      synchronize do
+        super(key)
+      end
+    end
+
+    def to_a
+      synchronize do
+        super
+      end
+    end
+
+    def size
+      synchronize do
+        super
+      end
+    end
+
+    def raw
+      synchronize do
+        super
+      end
+    end
+
+    def inspect
+      synchronize do
+        super
+      end
+    end
+
+    alias_method :[], :lookup
+    alias_method :[]=, :store
+  end
+end

data/lib/cache_lib/util_hash.rb

@@ -0,0 +1,29 @@
+module CacheLib
+  class UtilHash < Hash
+    def head
+      keys.last
+    end
+
+    def tail
+      first[0]
+    end
+
+    def set_head(key, value)
+      delete(key)
+      self[key] = value
+    end
+
+    def set_tail(key, value)
+      replace(Hash[key, value].merge(self))
+    end
+
+    def pop_tail
+      delete(tail)
+    end
+
+    def refresh(key)
+      value = delete(key)
+      self[key] = value
+    end
+  end
+end

data/lib/cache_lib/version.rb

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

data/lib/cache_lib.rb

@@ -0,0 +1,32 @@
+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/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_lirs_cache'
+require_relative 'cache_lib/version'
+
+module CacheLib
+  def self.create(type, *args)
+    case type
+    when :basic then BasicCache.new(*args)
+    when :fifo then FifoCache.new(*args)
+    when :lru then LruCache.new(*args)
+    when :lirs then LirsCache.new(*args)
+    else fail ArgumentError "Cache type not recognized: #{type}"
+    end
+  end
+
+  def self.safe_create(type, *args)
+    case type
+    when :basic then SafeBasicCache.new(*args)
+    when :fifo then SafeFifoCache.new(*args)
+    when :lru then SafeLruCache.new(*args)
+    when :lirs then SafeLirsCache.new(*args)
+    else fail ArgumentError "Cache type not recognized: #{type}"
+    end
+  end
+end

data/test/cache_lib/test_basic_cache.rb

@@ -0,0 +1,131 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+class TestBasicCache < MiniTest::Test
+  def setup
+    @cache = CacheLib.create :basic
+  end
+
+  def test_limit
+    assert_equal nil, @cache.limit
+  end
+
+  def test_set_limit
+    @cache.limit = 90
+
+    assert_equal nil, @cache.limit
+  end
+
+  def test_get
+    assert_equal 1, @cache.get(:a) { 1 }
+    assert_equal 1, @cache.get(:a) { 2 }
+    assert_equal 2, @cache.get(:b) { 2 }
+  end
+
+  def test_store
+    assert_equal 1, @cache.store(:a, 1)
+    assert_equal 2, @cache.store(:a, 2)
+    assert_equal 2, @cache.store(:b, 2)
+
+    assert_equal 3, @cache[:a] = 3
+    assert_equal 4, @cache[:b] = 4
+  end
+
+  def test_lookup
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal 1, @cache.lookup(:a)
+    assert_equal nil, @cache.lookup(:z)
+
+    assert_equal 2, @cache[:b]
+    assert_equal nil, @cache[:z]
+  end
+
+  def test_fetch
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal 1, @cache.fetch(:a)
+    assert_equal 2, @cache.fetch(:b) { 'b' }
+    assert_equal nil, @cache.fetch(:y)
+    assert_equal 26, @cache.fetch(:z) { 26 }
+
+    assert_equal 2, @cache[:b]
+    assert_equal nil, @cache[:z]
+  end
+
+  def test_evict
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal 1, @cache.evict(:a)
+    assert_equal nil, @cache.evict(:z)
+
+    assert_equal nil, @cache.lookup(:a)
+  end
+
+  def test_clear
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal(nil, @cache.clear)
+
+    assert_equal nil, @cache.lookup(:a)
+    assert_equal nil, @cache.lookup(:b)
+  end
+
+  def test_key?
+    @cache.store(:a, 1)
+
+    assert_equal true, @cache.key?(:a)
+    assert_equal false, @cache.key?(:z)
+  end
+
+  def test_to_a
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal [[:b, 2], [:a, 1]], @cache.to_a
+  end
+
+  def test_keys
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal [:b, :a], @cache.keys
+  end
+
+  def test_values
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal [2, 1], @cache.values
+  end
+
+  def test_size
+    @cache.store(:a, 1)
+
+    assert_equal 1, @cache.size
+
+    @cache.store(:b, 2)
+
+    assert_equal 2, @cache.size
+  end
+
+  def test_raw
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal({ a: 1, b: 2 }, @cache.raw[:cache])
+    assert_equal CacheLib::UtilHash, @cache.raw[:cache].class
+  end
+
+  def test_inspect
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    assert_equal "#{@cache.class} currently caching 2 items.",
+                 @cache.inspect
+  end
+end

data/test/cache_lib/test_cache_lib.rb

@@ -0,0 +1,38 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+class TestCacheLib < MiniTest::Test
+  def test_create
+    basic = CacheLib.create :basic
+    fifo = CacheLib.create :fifo, 1_000
+    lru = CacheLib.create :lru, 1_000
+    lirs = CacheLib.create :lirs, 950, 50
+
+    assert_equal basic.class, CacheLib::BasicCache
+    assert_equal fifo.class, CacheLib::FifoCache
+    assert_equal lru.class, CacheLib::LruCache
+    assert_equal lirs.class, CacheLib::LirsCache
+
+    assert_equal basic.limit, nil
+    assert_equal fifo.limit, 1_000
+    assert_equal lru.limit, 1_000
+    assert_equal lirs.limit, 1_000
+  end
+
+  def test_safe_create
+    basic = CacheLib.safe_create :basic
+    fifo = CacheLib.safe_create :fifo, 1_000
+    lru = CacheLib.safe_create :lru, 1_000
+    lirs = CacheLib.safe_create :lirs, 950, 50
+
+    assert_equal basic.class, CacheLib::SafeBasicCache
+    assert_equal fifo.class, CacheLib::SafeFifoCache
+    assert_equal lru.class, CacheLib::SafeLruCache
+    assert_equal lirs.class, CacheLib::SafeLirsCache
+
+    assert_equal basic.limit, nil
+    assert_equal fifo.limit, 1_000
+    assert_equal lru.limit, 1_000
+    assert_equal lirs.limit, 1_000
+  end
+end

data/test/cache_lib/test_fifo_cache.rb

@@ -0,0 +1,56 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_basic_cache'
+
+class TestFifoCache < TestBasicCache
+  def setup
+    @cache = CacheLib.create :fifo, 5
+  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} with a limit of 5 "\
+                 "currently caching 2 items.",
+                 @cache.inspect
+  end
+
+  def test_fifo_eviction
+    (1..6).each { |i| @cache.store(i, i) }
+
+    assert_equal 5, @cache.size
+    assert_equal({ 2 => 2, 3 => 3, 4 => 4, 5 => 5, 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
+end

data/test/cache_lib/test_lirs_cache.rb

@@ -0,0 +1,106 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_basic_cache'
+
+class TestLirsCache < TestBasicCache
+  def setup
+    @cache = CacheLib.create :lirs, 3, 2
+  end
+
+  def test_limit
+    assert_equal 5, @cache.limit
+  end
+
+  def test_set_limit
+    @cache.limit = 95, 5
+
+    assert_equal 100, @cache.limit
+  end
+
+  def test_inspect
+    @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.",
+                 @cache.inspect
+  end
+
+  def test_raw
+    @cache.store(:a, 1)
+    @cache.store(:b, 2)
+
+    raw_cache = @cache.raw
+
+    assert_equal({ a: 1, b: 2 }, raw_cache[:cache])
+    assert_equal({ a: nil, b: nil }, raw_cache[:stack])
+    assert_equal({}, raw_cache[:queue])
+
+    assert_equal CacheLib::UtilHash, raw_cache[:cache].class
+    assert_equal CacheLib::UtilHash, raw_cache[:stack].class
+    assert_equal CacheLib::UtilHash, raw_cache[:queue].class
+  end
+
+  def test_lirs_promotion
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.lookup(4)
+    @cache.lookup(1)
+
+    raw_cache = @cache.raw
+
+    assert_equal({ 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5 },
+                 raw_cache[:cache])
+    assert_equal({ 2 => nil, 3 => nil, 5 => nil, 4 => nil, 1 => nil },
+                 raw_cache[:stack])
+    assert_equal({ 5 => nil, 1 => nil }, raw_cache[:queue])
+  end
+
+  def test_lirs_eviction
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.lookup(4)
+    @cache.lookup(1)
+    @cache.store(6, 6)
+
+    raw_cache = @cache.raw
+
+    assert_equal 5, @cache.size
+    assert_equal({ 1 => 1, 2 => 2, 3 => 3, 4 => 4, 6 => 6 },
+                 raw_cache[:cache])
+    assert_equal({ 2 => nil, 3 => nil, 5 => nil,
+                   4 => nil, 1 => nil, 6 => nil },
+                 raw_cache[:stack])
+    assert_equal({ 1 => nil, 6 => nil }, raw_cache[:queue])
+  end
+
+  def test_upsize
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.limit = 5, 2
+    (6..8).each { |i| @cache.store(i, i) }
+
+    raw_cache = @cache.raw
+
+    assert_equal 7, @cache.size
+    assert_equal({ 1 => 1, 2 => 2, 3 => 3, 4 => 4,
+                   5 => 5, 7 => 7, 8 => 8 },
+                 raw_cache[:cache])
+    assert_equal({ 1 => nil, 2 => nil, 3 => nil, 4 => nil,
+                   5 => nil, 6 => nil, 7 => nil, 8 => nil },
+                 raw_cache[:stack])
+    assert_equal({ 7 => nil, 8 => nil }, raw_cache[:queue])
+  end
+
+  def test_downsize
+    (1..5).each { |i| @cache.store(i, i) }
+    @cache.limit = 2, 1
+
+    raw_cache = @cache.raw
+
+    assert_equal 3, @cache.size
+    assert_equal({ 1 => 1, 2 => 2, 3 => 3 }, raw_cache[:cache])
+    assert_equal({ 2 => nil, 3 => nil, 4 => nil, 5 => nil },
+                 raw_cache[:stack])
+    assert_equal({ 1 => nil }, raw_cache[:queue])
+  end
+end

data/test/cache_lib/test_lru_cache.rb

@@ -0,0 +1,68 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_basic_cache'
+
+class TestLruCache < TestBasicCache
+  def setup
+    @cache = CacheLib.create :lru, 5
+  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} with a limit of 5 "\
+                 "currently caching 2 items.",
+                 @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
+end

data/test/cache_lib/test_safe_basic_cache.rb

@@ -0,0 +1,10 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_basic_cache'
+
+class TestSafeBasicCache < TestBasicCache
+  def setup
+    @cache = CacheLib.safe_create :basic
+  end
+end

data/test/cache_lib/test_safe_fifo_cache.rb

@@ -0,0 +1,10 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_fifo_cache'
+
+class TestSafeFifoCache < TestFifoCache
+  def setup
+    @cache = CacheLib.safe_create :fifo, 5
+  end
+end

data/test/cache_lib/test_safe_lirs_cache.rb

@@ -0,0 +1,10 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_lirs_cache'
+
+class TestSafeLirsCache < TestLirsCache
+  def setup
+    @cache = CacheLib.safe_create :lirs, 3, 2
+  end
+end

data/test/cache_lib/test_safe_lru_cache.rb

@@ -0,0 +1,10 @@
+require 'cache_lib'
+require 'minitest/autorun'
+
+require_relative 'test_lru_cache'
+
+class TestSafeLruCache < TestLruCache
+  def setup
+    @cache = CacheLib.safe_create :lru, 5
+  end
+end