Support per-class cache adapter configuration

Previously all classes shared a single global Cacheable.cache_adapter.
Now each class that includes Cacheable can set its own adapter via
MyClass.cache_adapter=, falling back to the global adapter when
not configured.

Changes:
- Extend including classes with CacheAdapter
- CacheAdapter#cache_adapter falls back to Cacheable.cache_adapter
  when no class-level adapter is set
- Generated methods resolve adapter from the class instead of
  referencing Cacheable directly

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: agrberg

README.md

@@ -254,6 +254,26 @@ If your cache backend supports options, you can pass them as the `cache_options:
 cacheable :with_options, cache_options: {expires_in: 3_600}
 ```
 
+### Per-Class Cache Adapter
+
+By default, all classes use the global adapter set via `Cacheable.cache_adapter`. If you need a specific class to use a different cache backend, you can set one directly on the class:
+
+```ruby
+class FrequentlyAccessedModel
+  include Cacheable
+
+  self.cache_adapter = MyFasterCache.new
+
+  cacheable :expensive_lookup
+
+  def expensive_lookup
+    # ...
+  end
+end
+```
+
+The class-level adapter takes precedence over the global adapter. Classes without their own adapter fall back to `Cacheable.cache_adapter` as usual.
+
 ### Flexible Options
 
 You can use the same options with multiple cache methods or limit them only to specific methods:

lib/cacheable.rb

@@ -32,6 +32,7 @@ module Cacheable
   extend CacheAdapter
 
   def self.included(base)
+    base.extend(Cacheable::CacheAdapter)
     base.extend(Cacheable::MethodGenerator)
 
     interceptor_name = base.send(:method_interceptor_module_name)

lib/cacheable/cache_adapter.rb

@@ -7,11 +7,11 @@ module CacheAdapter
 
     def self.extended(base)
       base.instance_variable_set(:@_cache_adapter, nil)
-      base.cache_adapter = DEFAULT_ADAPTER
+      base.cache_adapter = DEFAULT_ADAPTER if base == Cacheable
     end
 
     def cache_adapter
-      @_cache_adapter
+      @_cache_adapter || (self == Cacheable ? nil : Cacheable.cache_adapter)
     end
 
     def cache_adapter=(name_or_adapter)

lib/cacheable/method_generator.rb

@@ -15,7 +15,7 @@ def method_interceptor_module_name
       "#{class_name}Cacher"
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def create_cacheable_methods(original_method_name, opts = {})
       method_names = create_method_names(original_method_name)
       key_format_proc = opts[:key_format] || default_key_format
@@ -28,15 +28,17 @@ def create_cacheable_methods(original_method_name, opts = {})
         end
 
         define_method(method_names[:clear_cache_method_name]) do |*args, **kwargs|
-          Cacheable.cache_adapter.delete(__send__(method_names[:key_format_method_name], *args, **kwargs))
+          adapter = (is_a?(Module) ? singleton_class : self.class).cache_adapter
+          adapter.delete(__send__(method_names[:key_format_method_name], *args, **kwargs))
         end
 
         define_method(method_names[:without_cache_method_name]) do |*args, **kwargs, &block|
           method(original_method_name).super_method.call(*args, **kwargs, &block)
         end
 
         define_method(method_names[:with_cache_method_name]) do |*args, **kwargs, &block|
-          Cacheable.cache_adapter.fetch(__send__(method_names[:key_format_method_name], *args, **kwargs), opts[:cache_options]) do # rubocop:disable Lint/UselessDefaultValueArgument -- not Hash#fetch; second arg is cache options (e.g. expires_in) passed to the adapter
+          adapter = (is_a?(Module) ? singleton_class : self.class).cache_adapter
+          adapter.fetch(__send__(method_names[:key_format_method_name], *args, **kwargs), opts[:cache_options]) do # rubocop:disable Lint/UselessDefaultValueArgument -- not Hash#fetch; second arg is cache options (e.g. expires_in) passed to the adapter
             __send__(method_names[:without_cache_method_name], *args, **kwargs, &block)
           end
         end
@@ -50,7 +52,7 @@ def create_cacheable_methods(original_method_name, opts = {})
         end
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     def default_key_format
       warned = false

spec/cacheable/cacheable_spec.rb

@@ -558,6 +558,37 @@ def cache_control_method
     end
   end
 
+  describe 'per-class cache adapter' do
+    it 'falls back to the global adapter by default' do
+      expect(cacheable_class.cache_adapter).to eq(described_class.cache_adapter)
+    end
+
+    it 'allows setting a class-specific adapter' do
+      class_adapter = Cacheable::CacheAdapters::MemoryAdapter.new
+      cacheable_class.cache_adapter = class_adapter
+
+      expect(cacheable_class.cache_adapter).to eq(class_adapter)
+      expect(cacheable_class.cache_adapter).not_to eq(described_class.cache_adapter)
+    end
+
+    it 'uses the class adapter for caching when set' do
+      class_adapter = Cacheable::CacheAdapters::MemoryAdapter.new
+      cacheable_class.cache_adapter = class_adapter
+
+      cacheable_object.send(cacheable_method)
+      expect(class_adapter.exist?([cacheable_method])).to be true
+      expect(described_class.cache_adapter.exist?([cacheable_method])).to be false
+    end
+
+    it 'does not affect other classes' do
+      other_class = Class.new.tap { |klass| klass.class_exec(&class_definition) }
+      class_adapter = Cacheable::CacheAdapters::MemoryAdapter.new
+      cacheable_class.cache_adapter = class_adapter
+
+      expect(other_class.cache_adapter).to eq(described_class.cache_adapter)
+    end
+  end
+
   it 'passes `cache_options` to the cache client' do
     cache_options = {expires_in: 3_600}
     cache_method_with_cache_options = :cache_method_with_cache_options