sin_lru_redux 2.0.0

data/bench/bench_ttl.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'benchmark'
+require 'fast_cache'
+
+Bundler.require
+
+# FastCache
+fast_cache = FastCache::Cache.new(1_000, 5 * 60)
+
+# LruRedux
+redux_ttl = LruRedux::TTL::Cache.new(1_000, 5 * 60)
+redux_ttl_thread_safe = LruRedux::TTL::ThreadSafeCache.new(1_000, 5 * 60)
+redux_ttl_disabled = LruRedux::TTL::Cache.new(1_000, :none)
+
+puts '** TTL Benchmarks **'
+
+Benchmark.bmbm do |bm|
+  bm.report 'FastCache' do
+    1_000_000.times { fast_cache.fetch(rand(2_000)) { :value } } # rubocop:disable Style/RedundantFetchBlock
+  end
+
+  bm.report 'LruRedux::TTL::Cache' do
+    1_000_000.times { redux_ttl.getset(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruRedux::TTL::ThreadSafeCache' do
+    1_000_000.times { redux_ttl_thread_safe.getset(rand(2_000)) { :value } }
+  end
+
+  bm.report 'LruRedux::TTL::Cache (TTL disabled)' do
+    1_000_000.times { redux_ttl_disabled.getset(rand(2_000)) { :value } }
+  end
+end

data/lib/lru_redux/cache.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+class LruRedux::Cache
+  def initialize(*args)
+    max_size, ignore_nil, _ = args
+
+    ignore_nil ||= false
+
+    raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
+    raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+
+    @max_size = max_size
+    @ignore_nil = ignore_nil
+    @data = {}
+  end
+
+  def max_size=(max_size)
+    max_size ||= @max_size
+
+    raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
+
+    @max_size = max_size
+
+    @data.shift while @data.size > @max_size
+  end
+
+  def ttl=(_)
+    nil
+  end
+
+  def ignore_nil=(ignore_nil)
+    ignore_nil ||= @ignore_nil
+    raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+
+    @ignore_nil = ignore_nil
+  end
+
+  def getset(key)
+    found = true
+    value = @data.delete(key) { found = false }
+    if found
+      @data[key] = value
+    else
+      result = @data[key] = yield
+      @data.shift if @data.length > @max_size
+      result
+    end
+  end
+
+  def fetch(key)
+    found = true
+    value = @data.delete(key) { found = false }
+    if found
+      @data[key] = value
+    else
+      yield if block_given? # rubocop:disable Style/IfInsideElse
+    end
+  end
+
+  def [](key)
+    found = true
+    value = @data.delete(key) { found = false }
+    @data[key] = value if found
+  end
+
+  def []=(key, val)
+    @data.delete(key)
+    @data[key] = val
+    @data.shift if @data.length > @max_size
+    val # rubocop:disable Lint/Void
+  end
+
+  def each(&block)
+    array = @data.to_a
+    array.reverse!.each(&block)
+  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 values
+    vals = @data.values
+    vals.reverse!
+  end
+
+  def delete(key)
+    @data.delete(key)
+  end
+
+  alias_method :evict, :delete
+
+  def key?(key)
+    @data.key?(key)
+  end
+
+  alias_method :has_key?, :key?
+
+  def clear
+    @data.clear
+  end
+
+  def count
+    @data.size
+  end
+
+  protected
+
+  def valid_max_size?(max_size)
+    return true if max_size.is_a?(Integer) && max_size >= 1
+
+    false
+  end
+
+  def valid_ignore_nil?(ignore_nil)
+    return true if [true, false].include?(ignore_nil)
+
+    false
+  end
+
+  # for cache validation only, ensures all is sound
+  def valid?
+    true
+  end
+end

data/lib/lru_redux/thread_safe_cache.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class LruRedux::ThreadSafeCache < LruRedux::Cache
+  include LruRedux::Util::SafeSync
+end

data/lib/lru_redux/ttl/cache.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module LruRedux
+  module TTL
+    class Cache
+      attr_reader :max_size, :ttl, :ignore_nil
+
+      def initialize(*args)
+        max_size, ttl, ignore_nil = args
+
+        ttl ||= :none
+        ignore_nil ||= false
+
+        raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
+        raise ArgumentError.new(:ttl) unless valid_ttl?(ttl)
+        raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+
+        @max_size = max_size
+        @ttl = ttl
+        @ignore_nil = ignore_nil
+        @data_lru = {}
+        @data_ttl = {}
+      end
+
+      def max_size=(max_size)
+        max_size ||= @max_size
+
+        raise ArgumentError.new(:max_size) unless valid_max_size?(max_size)
+
+        @max_size = max_size
+
+        resize
+      end
+
+      def ttl=(ttl)
+        ttl ||= @ttl
+        raise ArgumentError.new(:ttl) unless valid_ttl?(ttl)
+
+        @ttl = ttl
+
+        ttl_evict
+      end
+
+      def ignore_nil=(ignore_nil)
+        ignore_nil ||= @ignore_nil
+        raise ArgumentError.new(:ignore_nil) unless valid_ignore_nil?(ignore_nil)
+
+        @ignore_nil = ignore_nil
+      end
+
+      def getset(key)
+        ttl_evict
+
+        found = true
+        value = @data_lru.delete(key) { found = false }
+        if found
+          @data_lru[key] = value
+        else
+          result = yield
+
+          if !result.nil? || !@ignore_nil
+            @data_lru[key] = result
+            @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
+          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? # rubocop:disable Style/IfInsideElse
+        end
+      end
+
+      def [](key)
+        ttl_evict
+
+        found = true
+        value = @data_lru.delete(key) { found = false }
+        @data_lru[key] = value if found
+      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 # rubocop:disable Lint/Void
+      end
+
+      def each(&block)
+        ttl_evict
+
+        array = @data_lru.to_a
+        array.reverse!.each(&block)
+      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 values
+        ttl_evict
+
+        vals = @data_lru.values
+        vals.reverse!
+      end
+
+      def delete(key)
+        ttl_evict
+
+        @data_ttl.delete(key)
+        @data_lru.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_ttl.clear
+        @data_lru.clear
+      end
+
+      def expire
+        ttl_evict
+      end
+
+      def count
+        @data_lru.size
+      end
+
+      protected
+
+      def valid_max_size?(max_size)
+        return true if max_size.is_a?(Integer) && max_size >= 1
+
+        false
+      end
+
+      def valid_ttl?(ttl)
+        return true if ttl == :none
+        return true if ttl.is_a?(Numeric) && ttl >= 0
+
+        false
+      end
+
+      def valid_ignore_nil?(ignore_nil)
+        return true if [true, false].include?(ignore_nil)
+
+        false
+      end
+
+      # 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,5 @@
+# frozen_string_literal: true
+
+class LruRedux::TTL::ThreadSafeCache < LruRedux::TTL::Cache
+  include LruRedux::Util::SafeSync
+end

data/lib/lru_redux/ttl.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'lru_redux/util'
+require 'lru_redux/ttl/cache'
+require 'lru_redux/ttl/thread_safe_cache'

data/lib/lru_redux/util/safe_sync.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+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 ignore_nil=(ignore_nil)
+        synchronize do
+          super(ignore_nil)
+        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 values
+        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) # rubocop:disable Naming/PredicateName
+        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

data/lib/lru_redux/util.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'lru_redux/util/safe_sync'

data/lib/lru_redux/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LruRedux
+  VERSION = '2.0.0'
+end

data/lib/lru_redux.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'lru_redux/util'
+require 'lru_redux/cache'
+require 'lru_redux/thread_safe_cache'
+require 'lru_redux/ttl'
+require 'lru_redux/version'

data/sin_lru_redux.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lru_redux/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'sin_lru_redux'
+  spec.version = LruRedux::VERSION
+  spec.description = 'An efficient implementation of an lru cache'
+  spec.summary = 'An efficient implementation of an lru cache'
+  spec.authors = ['Masahiro']
+  spec.email = ['watanabe@cadenza-tech.com']
+  spec.license = 'MIT'
+
+  github_root_uri = 'https://github.com/cadenza-tech/sin_lru_redux'
+  spec.homepage = "#{github_root_uri}/tree/#{spec.version}/#{spec.name}"
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => "#{github_root_uri}/blob/#{spec.version}#changelog",
+    'bug_tracker_uri' => "#{github_root_uri}/issues",
+    'documentation_uri' => "https://rubydoc.info/gems/#{spec.name}/#{spec.version}",
+    'rubygems_mfa_required' => 'true'
+  }
+
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+end

data/test/cache_test.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'lru_redux'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+class CacheTest < Minitest::Test
+  def setup
+    @c = LruRedux::Cache.new(3)
+  end
+
+  def teardown
+    assert @c.send(:valid?) # rubocop:disable Minitest/AssertionInLifecycleHook
+  end
+
+  def test_drops_old
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c[:d] = 4
+
+    assert_equal [[:d, 4], [:c, 3], [:b, 2]], @c.to_a
+    assert_nil @c[:a]
+  end
+
+  def test_fetch
+    @c[:a] = nil
+    @c[:b] = 2
+
+    assert_nil @c.fetch(:a) { 1 } # rubocop:disable Style/RedundantFetchBlock
+    assert_equal 3, @c.fetch(:c) { 3 } # rubocop:disable Style/RedundantFetchBlock
+    assert_equal [[:a, nil], [:b, 2]], @c.to_a
+  end
+
+  def test_getset # rubocop:disable Minitest/MultipleAssertions
+    assert_equal 1, @c.getset(:a) { 1 }
+    @c.getset(:b) { 2 }
+
+    assert_equal 1, @c.getset(:a) { 11 }
+    @c.getset(:c) { 3 }
+
+    assert_equal 4, @c.getset(:d) { 4 }
+    assert_equal [[:d, 4], [:c, 3], [:a, 1]], @c.to_a
+  end
+
+  def test_pushes_lru_to_back
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+
+    @c[:a]
+    @c[:d] = 4
+
+    assert_equal [[:d, 4], [:a, 1], [:c, 3]], @c.to_a
+    assert_nil @c[:b]
+  end
+
+  def test_delete # rubocop:disable Minitest/MultipleAssertions
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c.delete(:a)
+
+    assert_equal [[:c, 3], [:b, 2]], @c.to_a
+    assert_nil @c[:a]
+
+    # Regression test for a bug in the legacy delete method
+    @c.delete(:b)
+    @c[:d] = 4
+    @c[:e] = 5
+    @c[:f] = 6
+
+    assert_equal [[:f, 6], [:e, 5], [:d, 4]], @c.to_a
+    assert_nil @c[:b]
+  end
+
+  def test_key?
+    @c[:a] = 1
+    @c[:b] = 2
+
+    assert @c.key?(:a)
+    refute @c.key?(:c)
+  end
+
+  def test_update
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c[:a] = 99
+
+    assert_equal [[:a, 99], [:c, 3], [:b, 2]], @c.to_a
+  end
+
+  def test_clear
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+
+    @c.clear
+
+    assert_empty @c.to_a
+  end
+
+  def test_grow
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c.max_size = 4
+    @c[:d] = 4
+
+    assert_equal [[:d, 4], [:c, 3], [:b, 2], [:a, 1]], @c.to_a
+  end
+
+  def test_shrink
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c.max_size = 1
+
+    assert_equal [[:c, 3]], @c.to_a
+  end
+
+  def test_each
+    @c.max_size = 2
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+
+    pairs = []
+    @c.each do |pair| # rubocop:disable Style/MapIntoArray
+      pairs << pair
+    end
+
+    assert_equal [[:c, 3], [:b, 2]], pairs
+  end
+
+  def test_values
+    @c[:a] = 1
+    @c[:b] = 2
+    @c[:c] = 3
+    @c[:d] = 4
+
+    assert_equal [4, 3, 2], @c.values
+    assert_nil @c[:a]
+  end
+end