Stop polluting Cacheable namespace with interceptor constants

Previously, each class that included Cacheable created a constant
on the Cacheable module (e.g. Cacheable::MyClassCacher) via
const_set. This polluted the namespace and leaked memory for
anonymous classes. Re-including Cacheable used remove_const which
left ghost modules in the MRO.

Now interceptor modules are stored as instance variables on the
including class (@_cacheable_interceptor). The module gets a
descriptive to_s/inspect for debugging without creating constants.

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

Author: agrberg

lib/cacheable.rb

@@ -36,8 +36,10 @@ def self.included(base)
     base.extend(Cacheable::MethodGenerator)
 
     interceptor_name = base.send(:method_interceptor_module_name)
-    remove_const(interceptor_name) if const_defined?(interceptor_name)
-
-    base.prepend const_set(interceptor_name, Module.new)
+    interceptor = Module.new
+    interceptor.define_singleton_method(:to_s) { interceptor_name }
+    interceptor.define_singleton_method(:inspect) { interceptor_name }
+    base.instance_variable_set(:@_cacheable_interceptor, interceptor)
+    base.prepend interceptor
   end
 end

lib/cacheable/method_generator.rb

@@ -22,7 +22,7 @@ def create_cacheable_methods(original_method_name, opts = {})
 
       unless_proc = opts[:unless].is_a?(Symbol) ? opts[:unless].to_proc : opts[:unless]
 
-      const_get(method_interceptor_module_name).class_eval do
+      @_cacheable_interceptor.class_eval do
         define_method(method_names[:key_format_method_name]) do |*args, **kwargs|
           key_format_proc.call(self, original_method_name, args, **kwargs)
         end

spec/cacheable/cacheable_spec.rb

@@ -89,22 +89,17 @@
     end
 
     it 'uses the class name to define an interceptor module' do
-      # This is done specifically this way to be compatible w/ RSpec best practices
-      # Once Cacheable is included in a class, it uses the name of the class to define the
-      # interceptor module. However, it is considered bad practice to create constants in RSpec
-      # so they're typically made with `stub_const`. We need to include Cacheable after the
-      # anonymous class has been created and assigned to the stubbed constant for this order to work.
       stub_const('RealClassName', Class.new)
-      class_name = RealClassName.include(described_class)
+      RealClassName.include(described_class)
 
-      expect(class_name.ancestors.map(&:to_s)).to include("Cacheable::#{class_name}Cacher")
+      expect(RealClassName.ancestors.map(&:to_s)).to include('RealClassNameCacher')
     end
 
     it 'uses the class address to define an interceptor module for anonymous classes' do
       custom_class = Class.new { include Cacheable }
       class_name = custom_class.to_s.tr('#:<>', '')
 
-      expect(custom_class.ancestors.map(&:to_s)).to include("Cacheable::#{class_name}Cacher")
+      expect(custom_class.ancestors.map(&:to_s)).to include("#{class_name}Cacher")
     end
 
     context 'when the method name has special characters' do
@@ -126,7 +121,7 @@
         stub_const('Outer::Inner', Class.new)
         Outer::Inner.include(described_class)
 
-        expect(Outer::Inner.ancestors.map(&:to_s)).to include('Cacheable::OuterInnerCacher')
+        expect(Outer::Inner.ancestors.map(&:to_s)).to include('OuterInnerCacher')
       end
     end
   end