lru_redux 0.8.4 → 1.1.0

data/lib/lru_redux/{cache19.rb → cache_legacy.rb}

@@ -2,11 +2,6 @@
 #
 # This is an ultra efficient 1.9 freindly implementation
 class LruRedux::Cache
-  def initialize(max_size)
-    @max_size = max_size
-    @data = {}
-  end
-
   def max_size=(size)
     raise ArgumentError.new(:max_size) if @max_size < 1
     @max_size = size
@@ -30,26 +25,6 @@ class LruRedux::Cache
     end
   end
 
-  def fetch(key)
-    found = true
-    value = @data.delete(key){ found = false }
-    if found
-      @data[key] = value
-    else
-      yield if block_given?
-    end
-  end
-
-  def [](key)
-    found = true
-    value = @data.delete(key){ found = false }
-    if found
-      @data[key] = value
-    else
-      nil
-    end
-  end
-
   def []=(key,val)
     @data.delete(key)
     @data[key] = val
@@ -58,34 +33,6 @@ class LruRedux::Cache
     val
   end
 
-  def each
-    array = @data.to_a
-    array.reverse!.each do |pair|
-      yield pair
-    end
-  end
-
-  # used further up the chain, non thread safe each
-  alias_method :each_unsafe, :each
-
-  def to_a
-    array = @data.to_a
-    array.reverse!
-  end
-
-  def delete(k)
-    @data.delete(k)
-  end
-
-  def clear
-    @data.clear
-  end
-
-  def count
-    @data.size
-  end
-
-
   # for cache validation only, ensures all is sound
   def valid?
     true

data/lib/lru_redux/thread_safe_cache.rb

@@ -1,75 +1,3 @@
-require 'monitor'
-
 class LruRedux::ThreadSafeCache < LruRedux::Cache
-  include MonitorMixin
-
-  def initialize(max_size)
-    super(max_size)
-  end
-
-  def max_size=(size)
-    synchronize do
-      super(size)
-    end
-  end
-
-  def getset(key)
-    synchronize do
-      super(key)
-    end
-  end
-
-  def fetch(key)
-    synchronize do
-      super(key)
-    end
-  end
-
-  def [](key)
-    synchronize do
-      super(key)
-    end
-  end
-
-  def []=(key, value)
-    synchronize do
-      super(key, value)
-    end
-  end
-
-  def each
-    synchronize do
-      super
-    end
-  end
-
-  def to_a
-    synchronize do
-      super
-    end
-  end
-
-  def delete(key)
-    synchronize do
-      super(key)
-    end
-  end
-
-  def clear
-    synchronize do
-      super
-    end
-  end
-
-  def count
-    synchronize do
-      super
-    end
-  end
-
-  def valid?
-    synchronize do
-      super
-    end
-  end
+  include LruRedux::Util::SafeSync
 end

data/lib/lru_redux/ttl.rb

@@ -0,0 +1,4 @@
+require "lru_redux/util"
+
+require "lru_redux/ttl/cache"
+require "lru_redux/ttl/thread_safe_cache"

data/lib/lru_redux/ttl/cache.rb

@@ -0,0 +1,192 @@
+module LruRedux
+  module TTL
+    class Cache
+      attr_reader :max_size, :ttl
+
+      def initialize(*args)
+        max_size, ttl = args
+
+        ttl ||= :none
+
+        raise ArgumentError.new(:max_size) if
+            max_size < 1
+        raise ArgumentError.new(:ttl) unless
+            ttl == :none || ((ttl.is_a? Numeric) && ttl >= 0)
+
+        @max_size = max_size
+        @ttl = ttl
+        @data_lru = {}
+        @data_ttl = {}
+      end
+
+      def max_size=(max_size)
+        max_size ||= @max_size
+
+        raise ArgumentError.new(:max_size) if
+            max_size < 1
+
+        @max_size = max_size
+
+        resize
+      end
+
+      def ttl=(ttl)
+        ttl ||= @ttl
+
+        raise ArgumentError.new(:ttl) unless
+            ttl == :none || ((ttl.is_a? Numeric) && ttl >= 0)
+
+        @ttl = ttl
+
+        ttl_evict
+      end
+
+      def getset(key)
+        ttl_evict
+
+        found = true
+        value = @data_lru.delete(key){ found = false }
+        if found
+          @data_lru[key] = value
+        else
+          result = @data_lru[key] = yield
+          @data_ttl[key] = Time.now.to_f
+
+          if @data_lru.size > @max_size
+            key, _ = @data_lru.first
+
+            @data_ttl.delete(key)
+            @data_lru.delete(key)
+          end
+
+          result
+        end
+      end
+
+      def fetch(key)
+        ttl_evict
+
+        found = true
+        value = @data_lru.delete(key){ found = false }
+        if found
+          @data_lru[key] = value
+        else
+          yield if block_given?
+        end
+      end
+
+      def [](key)
+        ttl_evict
+
+        found = true
+        value = @data_lru.delete(key){ found = false }
+        if found
+          @data_lru[key] = value
+        else
+          nil
+        end
+      end
+
+      def []=(key, val)
+        ttl_evict
+
+        @data_lru.delete(key)
+        @data_ttl.delete(key)
+
+        @data_lru[key] = val
+        @data_ttl[key] = Time.now.to_f
+
+        if @data_lru.size > @max_size
+          key, _ = @data_lru.first
+
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+        end
+
+        val
+      end
+
+      def each
+        ttl_evict
+
+        array = @data_lru.to_a
+        array.reverse!.each do |pair|
+          yield pair
+        end
+      end
+
+      # used further up the chain, non thread safe each
+      alias_method :each_unsafe, :each
+
+      def to_a
+        ttl_evict
+
+        array = @data_lru.to_a
+        array.reverse!
+      end
+
+      def delete(key)
+        ttl_evict
+
+        @data_lru.delete(key)
+        @data_ttl.delete(key)
+      end
+
+      alias_method :evict, :delete
+
+      def key?(key)
+        ttl_evict
+
+        @data_lru.key?(key)
+      end
+
+      alias_method :has_key?, :key?
+
+      def clear
+        @data_lru.clear
+        @data_ttl.clear
+      end
+
+      def expire
+        ttl_evict
+      end
+
+      def count
+        @data_lru.size
+      end
+
+      protected
+
+      # for cache validation only, ensures all is sound
+      def valid?
+        @data_lru.size == @data_ttl.size
+      end
+
+      def ttl_evict
+        return if @ttl == :none
+
+        ttl_horizon = Time.now.to_f - @ttl
+        key, time = @data_ttl.first
+
+        until time.nil? || time > ttl_horizon
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+
+          key, time = @data_ttl.first
+        end
+      end
+
+      def resize
+        ttl_evict
+
+        while @data_lru.size > @max_size
+          key, _ = @data_lru.first
+
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+        end
+      end
+    end
+  end
+end
+

data/lib/lru_redux/ttl/thread_safe_cache.rb

@@ -0,0 +1,3 @@
+class LruRedux::TTL::ThreadSafeCache < LruRedux::TTL::Cache
+  include LruRedux::Util::SafeSync
+end

data/lib/lru_redux/util.rb

@@ -0,0 +1,4 @@
+require 'lru_redux/util/safe_sync'
+
+require 'lru_redux/util/safe_sync_jruby' if
+    RUBY_ENGINE == 'jruby' && JRUBY_VERSION < '9.0'

data/lib/lru_redux/util/safe_sync.rb

@@ -0,0 +1,103 @@
+require 'monitor'
+
+module LruRedux
+  module Util
+    module SafeSync
+      include MonitorMixin
+
+      def initialize(*args)
+        super(*args)
+      end
+
+      def max_size=(max_size)
+        synchronize do
+          super(max_size)
+        end
+      end
+
+      def ttl=(ttl)
+        synchronize do
+          super(ttl)
+        end
+      end
+
+      def getset(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def fetch(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def [](key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def []=(key, value)
+        synchronize do
+          super(key, value)
+        end
+      end
+
+      def each
+        synchronize do
+          super
+        end
+      end
+
+      def to_a
+        synchronize do
+          super
+        end
+      end
+
+      def delete(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def evict(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def key?(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def has_key?(key)
+        synchronize do
+          super(key)
+        end
+      end
+
+      def clear
+        synchronize do
+          super
+        end
+      end
+
+      def count
+        synchronize do
+          super
+        end
+      end
+
+      def valid?
+        synchronize do
+          super
+        end
+      end
+    end
+  end
+end