support_table_cache 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c7814572a411ad62d5077cf255ff24059d2ab9292be81ded041de7ecff8a6ac
-  data.tar.gz: 015ea25fb5083ce1a80579a143486bf44a091fa375bf0d122b0889763321852c
+  metadata.gz: d66ca180334bd4b561b514dab26606f7ddc0979136a3cbca0479982734ad5703
+  data.tar.gz: 0e156f0ea38520098710748d1e5ecad71df3aecdb0df4ff78f8be92d075dbd3f
 SHA512:
-  metadata.gz: c4a1f00fa0873f0e28501119c5b588a6df166f5f9bcee84fcaf3dc4ffe0985251a6d6e6ee24f00d2ee740bd02b1dfe74db425a7a8170d8d5ddd98fbed0c8ecde
-  data.tar.gz: 81de8cda7452731a341e82752f3a25ab793c1b15e518c41c78118348841b41f5f8c56af13304e2565e9bfeffc00210764bf0351e4920d56af0e4e49704fdfde7
+  metadata.gz: 1f3b29d73e1cb683689888513b87ae6ceff74c871744ebdb30bb271789b6c4942355c773de4fad80a0d5f4d65f35462b3d49043f7119858a725ce39243e74e47
+  data.tar.gz: 9a2b3e9d9a79f3b91178f1218668d4b6d388397e85e7863e4e4746a9e89d934c3e012a6d709099671073dd2e03035842d22fcb9e15c9b8ad3cf2062cc56074d3

data/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.1.0
+
+### Added
+- Added fetch_by and fetch_by! methods that can verify the result will be cacheable.
+- Allow configuring cache storage on a per class basis.
+- Allow disabling caching on per class basis.
+- Added optimized in-memory cache implementation.
+- Added support for caching belongs to assocations.
+- Added test mode to intialize new caches within a test block.
+
+### Changed
+- Changed fiber local variables used for disabling the cache to thread local variables.
+- Using find_by! on a relation will now use the cache.
+
+## 1.0.1
+
+### Added
+- Preserve scope on relations terminated with a `find_by`.
+
 ## 1.0.0
 
 ### Added

data/README.md

@@ -3,11 +3,11 @@
 [![Continuous Integration](https://github.com/bdurand/support_table_cache/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/support_table_cache/actions/workflows/continuous_integration.yml)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
-This gem adds caching for ActiveRecord support table models. These are models which have a unique key (i.e. a unique `name` attribute, etc.) and which have a limited number of entries (a few hundred at most). These are often models added do normalize the data structure.
+This gem adds caching for ActiveRecord support table models. These models have a unique key (i.e. a unique `name` attribute, etc.) and a limited number of entries (a few hundred at most). These are often models added to normalize the data structure and are also known as lookup tables.
 
-Rows from these kinds of tables are rarely inserted, updated, or deleted, but are queried very frequently. To take advantage of this behavior, this gem adds automatic caching for records when using the `find_by` method. This is most useful in situations where you have a unique key but need to get the database row for that key.
+Rows from these kinds of tables are rarely inserted, updated, or deleted, but are queried very frequently. To take advantage of this behavior, this gem adds automatic caching for records when using the `find_by` method and `belongs_to` associations.
 
-For instance, suppose you have a model `Status` that has a unique name attribute and you need to process a bunch of records from a data source that includes the status name. In order to do anything, you'll need to lookup each status by name to get the database id:
+For instance, suppose you have a model `Status` that has a unique name attribute and you need to process a lot of records from a data source that includes the status name. In order to do anything, you'll need to look up each status by name to get the database id:
 
 ```ruby
 params.each do |data|
@@ -16,11 +16,11 @@ params.each do |data|
 end
 ```
 
-With this gem, you can avoid the database query for the `find_by` call. You don't need to alter your code in any way other than to include `SupportTableCache` in your model and tell it which attributes comprise a unique key that can be used for caching.
+With this gem, you can avoid the database query associated with the `find_by` call. You don't need to alter your code in any way other than to include `SupportTableCache` in your model and telling it the attributes that comprise a unique key, which can be used for caching.
 
 ## Usage
 
-To use the gem, you need to include it in you models and then specify which attributes can be used for caching with the `cache_by` method. A caching attribute must be a unique key on the model. For a composite key, you can specify an array of attributes. If any of the attributes are case insensitive strings, you need to specify that as well.
+To use the gem, you need to include it in you models and then specify which attributes can be used for caching with the `cache_by` method. A caching attribute must be a unique key on the model. For a composite unique key, you can specify an array of attributes. If any of the attributes are case-insensitive strings, you need to specify that as well.
 
 ```ruby
   class MyModel < ApplicationRecord
@@ -36,14 +36,17 @@ To use the gem, you need to include it in you models and then specify which attr
   # Uses cache on a composite key
   MyModel.find_by(group: "first", name: "One")
 
-  # Does not use cache since value is not defined as a cacheable key
+  # Uses cache on a composite key with scoping
+  MyModel.where(group: "first").find_by(name: "One")
+
+  # Does not use cache because the value is not defined as a cacheable key
   MyModel.find_by(value: 1)
 
-  # Does not use caching since not using find_by
+  # Does not use caching because not using the find_by method
   MyModel.where(id: 1).first
 ```
 
-By default, records will be cleaned up from the cache only when they are modified. However, you can set a time to live on the model after which records will be removed from the cache.
+By default, records will be cleaned up from the cache only when they are modified. However, you can change this by setting a time to live on the model after which records will be removed from the cache.
 
 ```ruby
   class MyModel < ApplicationRecord
@@ -53,26 +56,89 @@ By default, records will be cleaned up from the cache only when they are modifie
   end
 ```
 
-If you are in a Rails application, the `Rails.cache` will be used by default to cache records. Otherwise, you need to set the `ActiveSupport::Cache::CacheStore`` to use.
+### Setting the Cache
+
+If you are in a Rails application, the `Rails.cache` will be used by default to cache records. Otherwise, you need to set the `ActiveSupport::Cache::CacheStore` instance to use.
 
 ```ruby
 SupportTableCache.cache = ActiveSupport::Cache::MemoryStore.new
 ```
 
-You can also disable caching behavior entirely if you want or just within a block. You may want to disable it entirely in test mode if it interferes with your tests.
+You can also set a cache per class. For instance, you can set an in-memory cache on models that are never changed to avoid a network round trip to the cache server. You can use the special value `:memory` to do this.
+
+```ruby
+  class MyModel < ApplicationRecord
+    include SupportTableCache
+
+    self.support_table_cache = :memory
+  end
+```
+
+Note that in-memory caches exist separately within each process and will not be cleared when records are changed in the database. The only way to refresh elements in an in-memory cache is to restart the process or set the `support_table_cache_ttl` value so that the entries will expire.
+
+### Disabling Caching
+
+You can disable the cache within a block either globally or only for a specific class. If the cache is disabled, then all queries will pass through to the database.
 
 ```ruby
 # Disable the cache globally
 SupportTableCache.disable
 
 SupportTableCache.enable do
-  # Re-enable the cache for the block
+  # Re-enable the cache within a block
   SupportTableCache.disable do
     # Disable it again
+    MySupportModel.enable_cache do
+      # Re-enable it only for the MySupportModel class
+    end
+  end
+end
+```
+
+### Caching Belongs to Associations
+
+You can also cache belongs to associations to cacheable models.
+
+To do this, you include the `SupportTableCache::Associations` module in your model and then call `cache_belongs_to` to specify which associations should be cached. You must define the association first with `belongs_to` before you can call `cache_belongs_to`. You can include `SupportTableCache::Associations` in `ApplicationRecord` if you want this behavior available to all of your models.
+
+The target class for the association must include the `SupportTableCache` module.
+
+```ruby
+class ParentModel <  ApplicationRecord
+  include SupportTableCache::Associations
+
+  belongs_to :my_model
+  cache_belongs_to :my_model
+end
+```
+
+You can include `SupportTableCache::Associations` in your `ApplicationRecord` class to make association caching available on all models.
+
+### Testing
+
+Caching may interfere with tests by allowing data created in one test to leak into subsequent tests. You can resolve this by wrapping your tests with the `SupportTableCache.testing!` method.
+
+```
+# Rspec
+RSpec.configure do |config|
+  config.around do |example|
+    SupportTableCache.testing! { example.run }
   end
 end
+
+# MiniTest (with the minitest-around gem)
+class MiniTest::Spec
+  around do |tests|
+    SupportTableCache.testing!(&tests)
+  end
+=end
+
 ```
 
+### Maintaining Data
+
+You can use the companion [support_table_data gem](https://github.com/bdurand/support_table_data) to provide functionality for loading static data into your support tables as well as adding helper functions to make looking up specific rows much easier.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -81,7 +147,7 @@ Add this line to your application's Gemfile:
 gem "support_table_cache"
 ```
 
-And then execute:
+Then execute:
 ```bash
 $ bundle
 ```

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/support_table_cache/associations.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SupportTableCache
+  # Extension to non-support table models for caching belongs_to associations to support tables.
+  module Associations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Specify that a belongs_to association should use the cache. This will override the reader method
+      # for the association so that it queries from the cache. The association must already be defined.
+      #
+      # If you need cached associations to be cleared when data changes, then the associated class will
+      # need to include SupportTableCache and cache by the primary key for the association.
+      #
+      # @param association_name [Symbol, String] The association name to cache.
+      # @return [void]
+      # @raise ArgumentError if the association is not defined or if it has a runtime scope.
+      def cache_belongs_to(association_name)
+        reflection = reflections[association_name.to_s]
+
+        unless reflection&.belongs_to?
+          raise ArgumentError.new("The belongs_to #{association_name} association is not defined")
+        end
+
+        if reflection.scopes.present?
+          raise ArgumentError.new("Cannot cache belongs_to #{association_name} association because it has a scope")
+        end
+
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{association_name}_with_cache
+            foreign_key = self.send(#{reflection.foreign_key.inspect})
+            return nil if foreign_key.nil?
+            key = [#{reflection.class_name.inspect}, {#{reflection.association_primary_key.inspect} => foreign_key}]
+            cache = #{reflection.class_name}.send(:current_support_table_cache)
+            ttl = #{reflection.class_name}.send(:support_table_cache_ttl)
+            if cache
+              cache.fetch(key, expires_in: ttl) do
+                #{association_name}_without_cache
+              end
+            else
+              #{association_name}_without_cache
+            end
+          end
+
+          alias_method :#{association_name}_without_cache, :#{association_name}
+          alias_method :#{association_name}, :#{association_name}_with_cache
+        RUBY
+      end
+    end
+  end
+end

data/lib/support_table_cache/find_by_override.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SupportTableCache
+  # @api private
+  module FindByOverride
+    # Override for the find_by method that looks in the cache first.
+    def find_by(*args)
+      cache = current_support_table_cache
+      return super if cache.nil?
+
+      cache_key = nil
+      attributes = (args.size == 1 && args.first.is_a?(Hash) ? args.first.stringify_keys : {})
+
+      if respond_to?(:scope_attributes) && scope_attributes.present?
+        attributes = scope_attributes.stringify_keys.merge(attributes)
+      end
+
+      if attributes.present?
+        support_table_cache_by_attributes.each do |attribute_names, case_sensitive, where|
+          where&.each do |name, value|
+            if attributes.include?(name) && attributes[name] == value
+              attributes.delete(name)
+            else
+              return super
+            end
+          end
+          cache_key = SupportTableCache.cache_key(self, attributes, attribute_names, case_sensitive)
+          break if cache_key
+        end
+      end
+
+      if cache_key
+        cache.fetch(cache_key, expires_in: support_table_cache_ttl) { super }
+      else
+        super
+      end
+    end
+
+    # Same as find_by, but performs a safety check to confirm the query will hit the cache.
+    #
+    # @param attributes [Hash] Attributes to find the record by.
+    # @raise ArgumentError if the query cannot use the cache.
+    def fetch_by(attributes)
+      find_by_attribute_names = support_table_find_by_attribute_names(attributes)
+      unless support_table_cache_by_attributes.any? { |attribute_names, _ci, _where| attribute_names == find_by_attribute_names }
+        raise ArgumentError.new("#{name} does not cache queries by #{find_by_attribute_names.to_sentence}")
+      end
+      find_by(attributes)
+    end
+
+    # Same as find_by!, but performs a safety check to confirm the query will hit the cache.
+    #
+    # @param attributes [Hash] Attributes to find the record by.
+    # @raise ArgumentError if the query cannot use the cache.
+    # @raise ActiveRecord::RecordNotFound if no record is found.
+    def fetch_by!(attributes)
+      value = fetch_by(attributes)
+      if value.nil?
+        raise ActiveRecord::RecordNotFound.new("Couldn't find #{name}", name)
+      end
+      value
+    end
+
+    private
+
+    def support_table_find_by_attribute_names(attributes)
+      attributes ||= {}
+      if respond_to?(:scope_attributes) && scope_attributes.present?
+        attributes = scope_attributes.merge(attributes)
+      end
+      attributes.keys.map(&:to_s).sort
+    end
+  end
+end

data/lib/support_table_cache/memory_cache.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SupportTableCache
+  # An optimized cache implementation that can be used when all records can easily fit
+  # in memory and are never changed. It is intended for use with small, static support
+  # tables only.
+  #
+  # This cache will not store nil values. This is to prevent the cache from filling up with
+  # cache misses because there is no purging mechanism.
+  class MemoryCache
+    def initialize
+      @cache = {}
+      @mutex = Mutex.new
+    end
+
+    def fetch(key, expires_in: nil)
+      serialized_value, expire_at = @cache[key]
+      if serialized_value.nil? || (expire_at && expire_at < Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        value = yield if block_given?
+        return nil if value.nil?
+        write(key, value, expires_in: expires_in)
+        serialized_value = Marshal.dump(value)
+      end
+      Marshal.load(serialized_value)
+    end
+
+    def read(key)
+      fetch(key)
+    end
+
+    def write(key, value, expires_in: nil)
+      return if value.nil?
+
+      if expires_in
+        expire_at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + expires_in
+      end
+
+      serialized_value = Marshal.dump(value)
+
+      @mutex.synchronize do
+        @cache[key] = [serialized_value, expire_at]
+      end
+    end
+
+    def delete(key)
+      @cache.delete(key)
+    end
+
+    def clear
+      @cache.clear
+    end
+  end
+end

data/lib/support_table_cache/relation_override.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module SupportTableCache
+  # @api private
+
+  module RelationOverride
+    # Override for the find_by method that looks in the cache first.
+    def find_by(*args)
+      return super unless klass.include?(SupportTableCache)
+
+      cache = klass.send(:current_support_table_cache)
+      return super if cache.nil?
+
+      cache_key = nil
+      attributes = (args.size == 1 && args.first.is_a?(Hash) ? args.first.stringify_keys : {})
+
+      # Apply any attributes from the current relation chain
+      if scope_attributes.present?
+        attributes = scope_attributes.stringify_keys.merge(attributes)
+      end
+
+      if attributes.present?
+        support_table_cache_by_attributes.each do |attribute_names, case_sensitive, where|
+          where&.each do |name, value|
+            if attributes.include?(name) && attributes[name] == value
+              attributes.delete(name)
+            else
+              return super
+            end
+          end
+          cache_key = SupportTableCache.cache_key(klass, attributes, attribute_names, case_sensitive)
+          break if cache_key
+        end
+      end
+
+      if cache_key
+        cache.fetch(cache_key, expires_in: support_table_cache_ttl) { super }
+      else
+        super
+      end
+    end
+
+    # Override for the find_by! method that looks in the cache first.
+    # @raise ActiveRecord::RecordNotFound if no record is found.
+    def find_by!(*args)
+      value = find_by(*args)
+      unless value
+        raise ActiveRecord::RecordNotFound.new("Couldn't find #{klass.name}", klass.name)
+      end
+      value
+    end
+
+    # Same as find_by, but performs a safety check to confirm the query will hit the cache.
+    #
+    # @param attributes [Hash] Attributes to find the record by.
+    # @raise ArgumentError if the query cannot use the cache.
+    def fetch_by(attributes)
+      find_by_attribute_names = support_table_find_by_attribute_names(attributes)
+      unless klass.support_table_cache_by_attributes.any? { |attribute_names, _ci| attribute_names == find_by_attribute_names }
+        raise ArgumentError.new("#{name} does not cache queries by #{find_by_attribute_names.to_sentence}")
+      end
+      find_by(attributes)
+    end
+
+    # Same as find_by!, but performs a safety check to confirm the query will hit the cache.
+    #
+    # @param attributes [Hash] Attributes to find the record by.
+    # @raise ArgumentError if the query cannot use the cache.
+    # @raise ActiveRecord::RecordNotFound if no record is found.
+    def fetch_by!(attributes)
+      value = fetch_by(attributes)
+      if value.nil?
+        raise ActiveRecord::RecordNotFound.new("Couldn't find #{klass.name}", klass.name)
+      end
+      value
+    end
+
+    private
+
+    def support_table_find_by_attribute_names(attributes)
+      attributes ||= {}
+      if scope_attributes.present?
+        attributes = scope_attributes.merge(attributes)
+      end
+      attributes.keys.map(&:to_s).sort
+    end
+  end
+end

data/lib/support_table_cache.rb

@@ -1,55 +1,166 @@
 # frozen_string_literal: true
 
-# This concern can be added to a model for a support table to add the ability to lookup
-# entries in these table using Rails.cache when calling find_by rather than hitting the
-# database every time.
+require_relative "support_table_cache/associations"
+require_relative "support_table_cache/find_by_override"
+require_relative "support_table_cache/relation_override"
+require_relative "support_table_cache/memory_cache"
+
+# This concern can be added to a model to add the ability to look up entries in the table
+# using Rails.cache when calling find_by rather than hitting the database every time.
 module SupportTableCache
   extend ActiveSupport::Concern
 
   included do
+    # @api private Used to store the list of attribute names used for caching.
     class_attribute :support_table_cache_by_attributes, instance_accessor: false
+
+    # Set the time to live in seconds for records in the cache.
     class_attribute :support_table_cache_ttl, instance_accessor: false
 
+    # @api private
+    class_attribute :support_table_cache_impl, instance_accessor: false
+
+    unless ActiveRecord::Relation.include?(RelationOverride)
+      ActiveRecord::Relation.prepend(RelationOverride)
+    end
+
     class << self
       prepend FindByOverride unless include?(FindByOverride)
       private :support_table_cache_by_attributes=
+      private :support_table_cache_impl
+      private :support_table_cache_impl=
     end
 
     after_commit :support_table_clear_cache_entries
   end
 
-  class_methods do
+  module ClassMethods
+    # Disable the caching behavior for this class within the block. The disabled setting
+    # for a class will always take precedence over the global setting.
+    #
+    # @param disabled [Boolean] Caching will be disabled if this is true and enabled if false.
+    # @yieldreturn The return value of the block.
+    def disable_cache(disabled = true, &block)
+      varname = "support_table_cache_disabled:#{name}"
+      save_val = Thread.current.thread_variable_get(varname)
+      begin
+        Thread.current.thread_variable_set(varname, !!disabled)
+      ensure
+        Thread.current.thread_variable_set(varname, save_val)
+      end
+    end
+
+    # Enable the caching behavior for this class within the block. The enabled setting
+    # for a class will always take precedence over the global setting.
+    #
+    # @return [void]
+    def enable_cache
+      disable_cache(false, &block)
+    end
+
+    # Load all records into the cache. You should only call this method on small tables with
+    # a few dozen rows at most because it will load each row one at a time.
+    #
+    # @return [void]
+    def load_cache
+      cache = current_support_table_cache
+      return super if cache.nil?
+
+      find_each do |record|
+        support_table_cache_by_attributes.each do |attribute_names, case_sensitive|
+          attributes = record.attributes.select { |name, value| attribute_names.include?(name) }
+          cache_key = SupportTableCache.cache_key(self, attributes, attribute_names, case_sensitive)
+          cache.fetch(cache_key, expires_in: support_table_cache_ttl) { record }
+        end
+      end
+    end
+
+    # Set a class-specific cache to use in lieu of the global cache.
+    #
+    # @param cache [ActiveSupport::Cache::Store, Symbol] The cache instance to use. You can also
+    #   specify the value :memory to use an optimized in-memory cache.
+    # @return [void]
+    def support_table_cache=(cache)
+      cache = MemoryCache.new if cache == :memory
+      self.support_table_cache_impl = cache
+    end
+
     protected
 
     # Specify which attributes can be used for looking up records in the cache. Each value must
     # define a unique key, Multiple unique keys can be specified.
+    #
     # If multiple attributes are used to make up a unique key, then they should be passed in as an array.
-    # @param attributes [String, Symbol, Array<String, Symbol>] Attributes that make up a unique key.
+    #
+    # If you need to remove caching setup in a superclass, you can pass in the value false to reset
+    # cache behavior on the class.
+    #
+    # @param attributes [String, Symbol, Array<String, Symbol>, FalseClass] Attributes that make up a unique key.
     # @param case_sensitive [Boolean] Indicate if strings should treated as case insensitive in the key.
-    def cache_by(attributes, case_sensitive: true)
+    # @param where [Hash] A hash representing a hard coded set of attributes that must match a query in order
+    #   to cache the result. If a model has a default scope, then this value should be set to match the
+    #   where clause in that scope.
+    # @return [void]
+    def cache_by(attributes, case_sensitive: true, where: nil)
+      if attributes == false
+        self.support_table_cache_by_attributes = []
+        return
+      end
+
       attributes = Array(attributes).map(&:to_s).sort.freeze
-      self.support_table_cache_by_attributes = (support_table_cache_by_attributes || []) + [[attributes, case_sensitive]]
+
+      if where
+        unless where.is_a?(Hash)
+          raise ArgumentError.new("where must be a Hash")
+        end
+        where = where.stringify_keys
+      end
+
+      self.support_table_cache_by_attributes ||= []
+      support_table_cache_by_attributes.delete_if { |data| data.first == attributes }
+      self.support_table_cache_by_attributes += [[attributes, case_sensitive, where]]
+    end
+
+    private
+
+    def support_table_cache_disabled?
+      current_block_value = Thread.current.thread_variable_get("support_table_cache_disabled:#{name}")
+      if current_block_value.nil?
+        SupportTableCache.disabled?
+      else
+        current_block_value
+      end
+    end
+
+    def current_support_table_cache
+      return nil? if support_table_cache_disabled?
+      SupportTableCache.testing_cache || support_table_cache_impl || SupportTableCache.cache
     end
   end
 
   class << self
-    # Disable the caching behavior. If a block is specified, then caching is only
-    # disabled for that block. If no block is specified, then caching is disabled
-    # globally.
-    # @param disabled [Boolean] Caching will be disabled if this is true, enabled if false.
+    # Disable the caching behavior for all classes. If a block is specified, then caching is only
+    # disabled for that block. If no block is specified, then caching is disabled globally.
+    #
+    # @param disabled [Boolean] Caching will be disabled if this is true and enabled if false.
+    # @yieldreturn The return value of the block.
     def disable(disabled = true, &block)
       if block
-        save_val = Thread.current[:support_table_cache_disabled]
+        save_val = Thread.current.thread_variable_get(:support_table_cache_disabled)
         begin
-          Thread.current[:support_table_cache_disabled] = !!disabled
+          Thread.current.thread_variable_set(:support_table_cache_disabled, !!disabled)
         ensure
-          Thread.current[:support_table_cache_disabled] = save_val
+          Thread.current.thread_variable_set(:support_table_cache_disabled, save_val)
         end
       else
         @disabled = !!disabled
       end
     end
 
+    # Enable the caching behavior for all classes. If a block is specified, then caching is only
+    # enabled for that block. If no block is specified, then caching is enabled globally.
+    #
+    # @yieldreturn The return value of the block.
     def enable(&block)
       disable(false, &block)
     end
@@ -57,7 +168,7 @@ module SupportTableCache
     # Return true if caching has been disabled.
     # @return [Boolean]
     def disabled?
-      block_value = Thread.current[:support_table_cache_disabled]
+      block_value = Thread.current.thread_variable_get(:support_table_cache_disabled)
       if block_value.nil?
         !!(defined?(@disabled) && @disabled)
       else
@@ -65,19 +176,63 @@ module SupportTableCache
       end
     end
 
-    attr_writer :cache
+    # Set the global cache to use.
+    # @param value [ActiveSupport::Cache::Store, Symbol] The cache instance to use. You can also
+    #   specify the value :memory to use an optimized in-memory cache.
+    # @return [void]
+    def cache=(value)
+      value = MemoryCache.new if value == :memory
+      @cache = value
+    end
 
+    # Get the global cache (will default to `Rails.cache` if running in a Rails environment).
+    #
+    # @return [ActiveSupport::Cache::Store]
     def cache
-      if defined?(@cache)
+      if testing_cache
+        testing_cache
+      elsif defined?(@cache)
         @cache
       elsif defined?(Rails.cache)
         Rails.cache
       end
     end
 
-    # Generate a consistent cache key for a set of attributes. Returns nil if the attributes
+    # Enter test mode for a block. New caches will be used within each test mode block. You
+    # can use this to wrap your test methods so that cached values from one test don't show up
+    # in subsequent tests.
+    #
+    # @return [void]
+    def testing!(&block)
+      save_val = Thread.current.thread_variable_get(:support_table_cache_test_cache)
+      if save_val.nil?
+        Thread.current.thread_variable_set(:support_table_cache_test_cache, MemoryCache.new)
+      end
+      begin
+        yield
+      ensure
+        Thread.current.thread_variable_set(:support_table_cache_test_cache, save_val)
+      end
+    end
+
+    # Get the current test mode cache. This will only return a value inside of a `testing!` block.
+    #
+    # @return [SupportTableCache::MemoryCache]
+    # @api private
+    def testing_cache
+      unless defined?(@cache) && @cache.nil?
+        Thread.current.thread_variable_get(:support_table_cache_test_cache)
+      end
+    end
+
+    # Generate a consistent cache key for a set of attributes. It will return nil if the attributes
     # are not cacheable.
-    # @param klass [Class] The class to
+    #
+    # @param klass [Class] The class that is being cached.
+    # @param attributes [Hash] The attributes used to find a record.
+    # @param key_attribute_names [Array] List of attributes that can be used as a key in the cache.
+    # @param case_sensitive [Boolean] Indicator if string values are case-sensitive in the cache key.
+    # @return [String]
     # @api private
     def cache_key(klass, attributes, key_attribute_names, case_sensitive)
       return nil if attributes.blank? || key_attribute_names.blank?
@@ -98,33 +253,15 @@ module SupportTableCache
     end
   end
 
-  module FindByOverride
-    # Override for the find_by method that looks in the cache first.
-    def find_by(*args)
-      return super if SupportTableCache.cache.nil? || SupportTableCache.disabled?
-
-      cache_key = nil
-      attributes = args.first if args.size == 1 && args.first.is_a?(Hash)
-      if attributes
-        support_table_cache_by_attributes.each do |attribute_names, case_sensitive|
-          cache_key = SupportTableCache.cache_key(self, attributes, attribute_names, case_sensitive)
-          break if cache_key
-        end
-      end
-
-      if cache_key
-        SupportTableCache.cache.fetch(cache_key, expires_in: support_table_cache_ttl) { super }
-      else
-        super
-      end
-    end
-  end
-
   # Remove the cache entry for this record.
+  #
   # @return [void]
   def uncache
     cache_by_attributes = self.class.support_table_cache_by_attributes
-    return if cache_by_attributes.blank? || SupportTableCache.cache.nil?
+    return if cache_by_attributes.blank?
+
+    cache = self.class.send(:current_support_table_cache)
+    return if cache.nil?
 
     cache_by_attributes.each do |attribute_names, case_sensitive|
       attributes = {}
@@ -132,7 +269,7 @@ module SupportTableCache
         attributes[name] = self[name]
       end
       cache_key = SupportTableCache.cache_key(self.class, attributes, attribute_names, case_sensitive)
-      SupportTableCache.cache.delete(cache_key)
+      cache.delete(cache_key)
     end
   end
 
@@ -143,7 +280,10 @@ module SupportTableCache
   # and after the change.
   def support_table_clear_cache_entries
     cache_by_attributes = self.class.support_table_cache_by_attributes
-    return if cache_by_attributes.blank? || SupportTableCache.cache.nil?
+    return if cache_by_attributes.blank?
+
+    cache = self.class.send(:current_support_table_cache)
+    return if cache.nil?
 
     cache_by_attributes.each do |attribute_names, case_sensitive|
       attributes_before = {} if saved_change_to_id.blank? || saved_change_to_id.first.present?
@@ -158,7 +298,7 @@ module SupportTableCache
       end
       [attributes_before, attributes_after].compact.uniq.each do |attributes|
         cache_key = SupportTableCache.cache_key(self.class, attributes, attribute_names, case_sensitive)
-        SupportTableCache.cache.delete(cache_key)
+        cache.delete(cache_key)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: support_table_cache
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,6 +50,10 @@ files:
 - README.md
 - VERSION
 - lib/support_table_cache.rb
+- lib/support_table_cache/associations.rb
+- lib/support_table_cache/find_by_override.rb
+- lib/support_table_cache/memory_cache.rb
+- lib/support_table_cache/relation_override.rb
 - support_table_cache.gemspec
 homepage: https://github.com/bdurand/support_table_cache
 licenses: