any_cache 0.0.0 → 0.1.0

data/lib/any_cache/adapters/active_support_file_store/persist.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportFileStore::Persist < ActiveSupportNaiveStore::Persist
+    # @since 0.1.0
+    include ActiveSupportFileStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore < ActiveSupportNaiveStore
+    require_relative 'active_support_memory_store/fetching'
+    require_relative 'active_support_memory_store/operation'
+    require_relative 'active_support_memory_store/increment'
+    require_relative 'active_support_memory_store/decrement'
+    require_relative 'active_support_memory_store/expire'
+    require_relative 'active_support_memory_store/persist'
+
+    class << self
+      # @param driver [Object]
+      # @return [Boolean]
+      #
+      # @api private
+      # @since 0.1.0
+      def supported_driver?(driver)
+        defined?(::ActiveSupport::Cache::MemoryStore) &&
+        driver.is_a?(::ActiveSupport::Cache::MemoryStore)
+      end
+    end
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/decrement.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore::Decrement < ActiveSupportNaiveStore::Decrement
+    # @since 0.1.0
+    include ActiveSupportMemoryStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/expire.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore::Expire < ActiveSupportNaiveStore::Expire
+    # @since 0.1.0
+    include ActiveSupportMemoryStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/fetching.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class AnyCache::Adapters::ActiveSupportMemoryStore
+  # @api private
+  # @since 0.1.0
+  module Fetching
+    # @param key [String]
+    # @return [NilClass, ActiveSupport::Cache::Entry]
+    #
+    # @api private
+    # @since 0.1.0
+    def fetch_entry(key)
+      driver.instance_eval { read_entry(key, {}) }
+    end
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/increment.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore::Increment < ActiveSupportNaiveStore::Increment
+    # @since 0.1.0
+    include ActiveSupportMemoryStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/operation.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore::Operation < ActiveSupportNaiveStore::Operation
+    # @since 0.1.0
+    include ActiveSupportMemoryStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_memory_store/persist.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportMemoryStore::Persist < ActiveSupportNaiveStore::Persist
+    # @since 0.1.0
+    include ActiveSupportMemoryStore::Fetching
+  end
+end

data/lib/any_cache/adapters/active_support_naive_store.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module AnyCache::Adapters
+  # @api private
+  # @since 0.1.0
+  class ActiveSupportNaiveStore < Delegator
+    require_relative 'active_support_naive_store/operation'
+    require_relative 'active_support_naive_store/increment'
+    require_relative 'active_support_naive_store/decrement'
+    require_relative 'active_support_naive_store/expire'
+    require_relative 'active_support_naive_store/persist'
+
+    # @param driver [Object]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def initialize(driver)
+      super
+      @lock = Concurrent::ReentrantReadWriteLock.new
+      @incr_operation = self.class::Increment.new(driver)
+      @decr_operation = self.class::Decrement.new(driver)
+      @expr_operation = self.class::Expire.new(driver)
+      @pers_operation = self.class::Persist.new(driver)
+    end
+
+    # @param key [String]
+    # @param options [Hash]
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.1.0
+    def read(key, **options)
+      lock.with_read_lock { super }
+    end
+
+    # @param key [String]
+    # @param options [Hash]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def delete(key, **options)
+      lock.with_write_lock { super }
+    end
+
+    # @param options [Hash]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def clear(**options)
+      lock.with_write_lock { super }
+    end
+
+    # @param key [String]
+    # @param value [Object]
+    # @param options [Hash]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def write(key, value, **options)
+      lock.with_write_lock do
+        expires_in = options.fetch(:expires_in, self.class::Operation::NO_EXPIRATION_TTL)
+
+        super(key, value, expires_in: expires_in)
+      end
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @option expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def increment(key, amount = self.class::Increment::DEFAULT_AMOUNT, **options)
+      lock.with_write_lock do
+        expires_in = options.fetch(:expires_in, self.class::Operation::NO_EXPIRATION_TTL)
+
+        incr_operation.call(key, amount, expires_in: expires_in)
+      end
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @option expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def decrement(key, amount = self.class::Decrement::DEFAULT_AMOUNT, **options)
+      lock.with_write_lock do
+        expires_in = options.fetch(:expires_in, self.class::Operation::NO_EXPIRATION_TTL)
+
+        decr_operation.call(key, amount, expires_in: expires_in)
+      end
+    end
+
+    # @param key [String]
+    # @option expires_in [NilClass, Integer]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def expire(key, expires_in: self.class::Operation::DEAD_TTL)
+      lock.with_write_lock { expr_operation.call(key, expires_in: expires_in) }
+    end
+
+    # @param key [String]
+    # @param options [Hash]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def persist(key, **options)
+      lock.with_write_lock { pers_operation.call(key) }
+    end
+
+    private
+
+    # @return [Concurrent::ReentrantReadWriteLock]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :lock
+
+    # @return [Operation::Increment]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :incr_operation
+
+    # @return [Operation::Decrement]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :decr_operation
+
+    # @return [Operation::Expire]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :expr_operation
+
+    # @return [Operation::Persist]
+    attr_reader :pers_operation
+  end
+end

data/lib/any_cache/adapters/active_support_naive_store/decrement.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class AnyCache::Adapters::ActiveSupportNaiveStore
+  # @api private
+  # @since 0.1.0
+  class Decrement < Operation
+    # @return [Integer]
+    #
+    # @api private
+    # @since 0.1.0
+    DEFAULT_AMOUNT = 1
+
+    # @since 0.1.0
+    def_delegators :driver, :decrement
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @option expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(key, amount = DEFAULT_AMOUNT, expires_in: NO_EXPIRATION_TTL)
+      expires_in ? decr_and_expire(key, amount, expires_in) : decr_existing(key, amount)
+    end
+
+    private
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @param expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def decr_and_expire(key, amount, expires_in)
+      new_amount = decrement(key, amount, expires_in: expires_in)
+      new_amount || decr_non_existing(key, amount, expires_in)
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def decr_existing(key, amount)
+      new_amount = begin
+        entry = fetch_entry(key)
+        decrement(key, amount, expires_in: calc_entry_expiration(entry)) if entry
+      end
+
+      new_amount || decr_non_existing(key, amount)
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @param expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def decr_non_existing(key, amount, expires_in = NO_EXPIRATION_TTL)
+      amount = -amount
+      (expires_in ? write(key, amount, expires_in: expires_in) : write(key, amount)) && amount
+    end
+
+    # @!method fetch_entry(key)
+    #   @param key [String]
+    #   @return [NilClass, ActiveSupport::Cache::Entry]
+  end
+end

data/lib/any_cache/adapters/active_support_naive_store/expire.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class AnyCache::Adapters::ActiveSupportNaiveStore
+  # @api private
+  # @since 0.1.0
+  class Expire < Operation
+    # @param key [String]
+    # @option expires_in [Integer, NilClass]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(key, expires_in: DEAD_TTL)
+      fetch_entry(key).tap do |entry|
+        next unless entry
+        is_alive = expires_in.positive?
+        is_alive ? write(key, entry.value, expires_in: expires_in) : delete(key)
+      end
+    end
+
+    # @!method fetch_entry(key)
+    #   @param key [String]
+    #   @return [NilClass, ActiveSupport::Cache::Entry]
+  end
+end

data/lib/any_cache/adapters/active_support_naive_store/increment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class AnyCache::Adapters::ActiveSupportNaiveStore
+  # @api private
+  # @since 0.1.0
+  class Increment < Operation
+    # @return [Integer]
+    #
+    # @api private
+    # @since 0.1.0
+    DEFAULT_AMOUNT = 1
+
+    # @since 0.1.0
+    def_delegators :driver, :increment
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @option expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def call(key, amount = DEFAULT_AMOUNT, expires_in: NO_EXPIRATION_TTL)
+      expires_in ? incr_and_expire(key, amount, expires_in) : incr_existing(key, amount)
+    end
+
+    private
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @param expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def incr_and_expire(key, amount, expires_in)
+      new_amount = increment(key, amount, expires_in: expires_in)
+      new_amount || incr_non_existing(key, amount, expires_in)
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def incr_existing(key, amount)
+      new_amount = begin
+        entry = fetch_entry(key)
+        increment(key, amount, expires_in: calc_entry_expiration(entry)) if entry
+      end
+
+      new_amount || incr_non_existing(key, amount)
+    end
+
+    # @param key [String]
+    # @param amount [Integer, Float]
+    # @param expires_in [NilClass, Integer]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def incr_non_existing(key, amount, expires_in = NO_EXPIRATION_TTL)
+      (expires_in ? write(key, amount, expires_in: expires_in) : write(key, amount)) && amount
+    end
+
+    # @!method fetch_entry(key)
+    #   @param key [String]
+    #   @return [NilClass, ActiveSupport::Cache::Entry]
+  end
+end

data/lib/any_cache/adapters/active_support_naive_store/operation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class AnyCache::Adapters::ActiveSupportNaiveStore
+  # @api private
+  # @since 0.1.0
+  class Operation
+    # @since 0.1.0
+    extend Forwardable
+
+    # @return [NilClass]
+    #
+    # @api private
+    # @since 0.1.0
+    NO_EXPIRATION_TTL = nil
+
+    # @return [Integer]
+    #
+    # @api private
+    # @since 0.1.0
+    DEAD_TTL = 0
+
+    # @since 0.1.0
+    def_delegators :driver, :read, :write, :delete
+
+    # @param driver [Object]
+    # @return [void]
+    #
+    # @api private
+    # @since 0.1.0
+    def initialize(driver)
+      @driver = driver
+    end
+
+    private
+
+    # @return [Object]
+    #
+    # @api private
+    # @since 0.1.0
+    attr_reader :driver
+
+    # @option as_integer [Boolean]
+    # @return [Integer, Float]
+    #
+    # @api private
+    # @since 0.1.0
+    def calc_epoch_time(as_integer: false)
+      as_integer ? Time.now.to_i : Time.now.to_f
+    end
+
+    # @param [ActiveSupport::Cache::Entry]
+    # @return [NilClass, Integer]
+    #
+    # @api private
+    # @since 0.1.0
+    def calc_entry_expiration(entry)
+      entry.expires_at ? (entry.expires_at - calc_epoch_time) : NO_EXPIRATION_TTL
+    end
+
+    # @!method fetch_entry(key)
+    #   @param key [String]
+    #   @return [NilClass, ActiveSupport::Cache::Entry]
+  end
+end