cache_keeper 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c55e34ac5e0676e81456a04f7edae71cf0c79c6cd5be9e135c56561f6439be
-  data.tar.gz: 6f9d9bc0bd404cd350f1cf7ff48b8c59bbff60dbeeda754c052ca22457720b8a
+  metadata.gz: edca690bc194349e3a062521687f2e91fc91415f66e7f0e976293a0e7470f8a8
+  data.tar.gz: 78e3725f253be829e474602792fb3316889ffd8d6485bff0b1a6baae2525d0d7
 SHA512:
-  metadata.gz: 1eec12fc16cf629cbe1b3502918b67d6d420bb812c1ed88088a809b07faf31ec981dfddb0d094507f0cd9522238134b1bc60ff011f0d99a12339144a5ba0a3d2
-  data.tar.gz: 6a93852da524a5e478166bc24d0bee53973a3343a8b55c2574ed67259f3e5ffc7f927b31bd35e257fe0107073e69fc32a99e608614b07ab736fa103e8ce33adc
+  metadata.gz: 03a22be5703c831beeb55f3a30e3f2a7534afdccf581cbb16e0f556eedc9b518c279267a4e2db06d8dfb9bcfe255f70f68313e9118b53f5522059168a75ecd70
+  data.tar.gz: 5cc2b635e0766a2b4dc269cf59aef03c27f19fb1ba516771885df0157835057f1479816f0110d1fbfffb3794d9510e567386e7320864c48505cff3af40058cc2

data/README.md

@@ -29,19 +29,19 @@ bundle add cache_keeper
 CacheKeeper provides a `caches` method that will cache the result of the methods you give it:
 
 ```ruby
-class Recording < ApplicationRecord
-  caches :slow_method, :really_slow_method, expires_in: 1.hour, must_revalidate: true
-  caches :incredibly_slow_method, expires_in: 2.hours, key: -> { "custom-key/#{id}" }
+class AlienAnecdoteAmplifier < ApplicationRecord
+  caches :amplify, :enhance_hilarity, expires_in: 1.hour
+  caches :generate_anecdotal_tales, expires_in: 2.hours, must_revalidate: true
 
-  def slow_method
+  def amplify
     ...
   end
 
-  def really_slow_method
+  def enhance_hilarity
     ...
   end
 
-  def incredibly_slow_method
+  def generate_anecdotal_tales
     ...
   end
 end
@@ -51,28 +51,64 @@ It's automatically available in your ActiveRecord models and in your controllers
 
 By default, it will immediately run the method call if it hasn't been cached before. The next time it is called, it will return the cached value if it hasn't expired yet. If it has expired, it will enqueue a job to refresh the cache in the background and return the stale value in the meantime. You can avoid returning stale values by setting `must_revalidate: true` in the options.
 
-CacheKeeper will compose cache keys from the name of the method and the instance's `cache_key` if it's defined or the name of the class otherwise. You can pass a `key` option to customize the cache key if you need it. It accepts [the same values](https://guides.rubyonrails.org/caching_with_rails.html#cache-keys) as `Rails.cache.fetch`, as well as procs or lambdas in case you need access to the instance.
-
 It's important to note that it will only work with methods that don't take any arguments.
 
+### Cache key
+
+CacheKeeper will compose cache keys from the name of the method and the instance's `cache_key` if it's defined or the name of the class otherwise. You can pass a `key` option to customize the cache key if you need it. It accepts [the same values](https://guides.rubyonrails.org/caching_with_rails.html#cache-keys) as `Rails.cache.fetch`, as well as procs or lambdas in case you need access to the instance:
+
+```ruby
+class NebulaNoodleTwister
+  caches :twist_noodles, :dish_of_the_day, key: ->(method_name) { [:recoding, id, method_name] }
+  caches :synchronize_taste_buds, key: -> { [:recoding, id, :synchronize_taste_buds] }
+  caches :space_soup_simulation, key: :space_soup_simulation
+end
+```
+
 ### Serialization
 
 CacheKeeper needs to pass the instance on which the cached method is called along to the refresh job. As any other job argument, ActiveJob requires it to be serializable. ActiveRecord instances are serializable by default, but controllers, POROs and other classes are not. CacheKeeper provides a `serializer` option that will work in most cases:
 
 ```ruby
-class Example
-  # Generate a new instance using an empty initializer (Example.new)
+class QuantumQuackerator
+  # Generate a new instance using an empty initializer (QuantumQuackerator.new)
   # Useful for controllers and for POROs with no arguments
-  caches :slow_method, serializer: :new_instance
+  caches :quackify_particles, serializer: :new_instance
 
   # Replicate the old instance using Marshal.dump and Marshal.load
   # Useful in most other cases, but make sure the dump is not too big
-  caches :slow_method, serializer: :marshal
+  caches :quackify_particles, serializer: :marshal
 end
 ```
 
 If those options don't work for you, you can always [write custom serializers](https://guides.rubyonrails.org/active_job_basics.html#serializers) for your classes.
 
+### Autorefresh
+
+CacheKeeper can automatically refresh your cached methods so that they are always warm. You need to pass a block to the `caches` method that will be called periodically. It will receive a `cached_method` object that you can use to `autorefresh` the cache for a specific instance:
+
+```ruby
+class LaughInducingLuminator < ApplicationRecord
+  caches :generate_chuckles, expires_in: 1.day do |cached_method|
+    find_each do { |luminator| cached_method.autorefresh luminator }
+  end
+end
+```
+
+The last step is to register the `CacheKeeper::AutorefreshJob` in whatever system you use to run jobs periodically. For example, if you use [GoodJob](https://github.com/bensheldon/good_job) you would do something like this:
+
+```ruby
+Rails.application.configure do
+  config.good_job.enable_cron = true
+  config.good_job.cron = {
+    cache_keeper: {
+      cron: "*/15 * * * *", # every 15 minutes, every day
+      class: "CacheKeeper::AutorefreshJob"
+    }
+  }
+end
+```
+
 
 ## Configuration
 

data/app/jobs/cache_keeper/autorefresh_job.rb

@@ -0,0 +1,9 @@
+class CacheKeeper::AutorefreshJob < CacheKeeper::BaseJob
+  queue_as { CacheKeeper.configuration.queues[:refresh] }
+
+  def perform
+    CacheKeeper.manager.cached_methods.autorefreshed.each do |cached_method|
+      cached_method.autorefresh_block.call
+    end
+  end
+end

data/app/models/cache_keeper/cached_method/refreshable.rb

@@ -8,4 +8,10 @@ module CacheKeeper::CachedMethod::Refreshable
   def refresh_later(target)
     CacheKeeper::RefreshJob.perform_later self, target
   end
+
+  def autorefresh(target)
+    return unless stale?(target)
+
+    refresh_later target
+  end
 end

data/app/models/cache_keeper/cached_method.rb

@@ -2,18 +2,23 @@ class CacheKeeper::CachedMethod
   include Refreshable
   include SerializableTarget
 
-  attr_accessor :klass, :method_name, :options
+  attr_accessor :klass, :method_name, :options, :autorefresh_block
 
-  def initialize(klass, method_name, options = {})
+  def initialize(klass, method_name, options = {}, &block)
     self.klass = klass
     self.method_name = method_name
     self.options = options.with_indifferent_access
+    self.autorefresh_block = block
   end
 
   def alias_for_original_method
     :"__#{method_name}__hooked__"
   end
 
+  def stale?(target)
+    cache_entry(target).blank? || cache_entry(target).expired?
+  end
+
   def call(target)
     cache_entry = cache_entry(target)
 
@@ -39,8 +44,14 @@ class CacheKeeper::CachedMethod
   end
 
   def cache_key(target)
-    if options[:key].present?
-      options[:key].is_a?(Proc) ? target.instance_exec(&options[:key]) : options[:key]
+    if options[:key].is_a?(Proc)
+      if options[:key].arity == 1
+        target.instance_exec(method_name, &options[:key])
+      else
+        target.instance_exec(&options[:key])
+      end
+    elsif options[:key].present?
+      options[:key]
     else
       target.respond_to?(:cache_key) ? ["CacheKeeper", target, method_name] : ["CacheKeeper", klass, method_name]
     end

data/lib/cache_keeper/caching.rb

@@ -3,9 +3,9 @@ module CacheKeeper
     extend ActiveSupport::Concern
 
     included do
-      def self.caches(*method_names, **options)
+      def self.caches(*method_names, **options, &block)
         method_names.each do |method_name|
-          CacheKeeper.manager.handle self, method_name, options
+          CacheKeeper.manager.handle self, method_name, options, &block
 
           # If the method is already defined, we need to hook it
           method_added method_name

data/lib/cache_keeper/manager.rb

@@ -10,8 +10,8 @@ module CacheKeeper
       cached_methods.find_by(klass, method_name).present?
     end
 
-    def handle(klass, method_name, options)
-      CacheKeeper::CachedMethod.new(klass, method_name, options).tap do |cached_method|
+    def handle(klass, method_name, options, &block)
+      CacheKeeper::CachedMethod.new(klass, method_name, options, &block).tap do |cached_method|
         if unsupported_options?(cached_method)
           raise "You're trying to autorefresh an ActiveRecord model, which we don't currently support."
         end

data/lib/cache_keeper/store.rb

@@ -8,7 +8,7 @@ module CacheKeeper
 
     def autorefreshed
       select do |cached_method|
-        cached_method.options[:autorefresh].present?
+        cached_method.autorefresh_block.present?
       end
     end
   end

data/lib/cache_keeper/version.rb

@@ -1,3 +1,3 @@
 module CacheKeeper
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/test/models/cached_method/refreshable_test.rb

@@ -11,4 +11,27 @@ class CacheKeeper::CachedMethod::RefreshableTest < ActiveSupport::TestCase
       cached_method.refresh_later recording
     end
   end
+
+  test "#autorefresh enqueues a refresh job if it's stale" do
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = CacheKeeper.manager.cached_methods.first
+
+      assert_enqueued_with(job: CacheKeeper::RefreshJob) do
+        cached_method.autorefresh recording
+      end
+    end
+  end
+
+  test "#autorefresh doesn't enqueue a refresh job if it's fresh" do
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = CacheKeeper.manager.cached_methods.first
+      cached_method.call(recording)
+
+      assert_no_enqueued_jobs do
+        cached_method.autorefresh recording
+      end
+    end
+  end
 end

data/test/models/cached_method_test.rb

@@ -2,14 +2,84 @@ require "test_helper"
 
 class CacheKeeper::CachedMethodTest < ActiveSupport::TestCase
   test "#call caches the result of the original method" do
-    recording = Recording.create(number: 5)
-    cached_method = manager.handle(Recording, :another_method, expires_in: 1.hour)
-    manager.activate_if_handling(Recording, :another_method)
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = manager.handle(Recording, :another_method, expires_in: 1.hour)
+      manager.activate_if_handling(Recording, :another_method)
 
-    result = cached_method.call(recording)
+      result = cached_method.call(recording)
 
-    assert_equal 5, result
-    assert cache_has_key? "CacheKeeper/recordings/#{recording.id}/another_method"
+      assert_equal 5, result
+      assert cache_has_key? "CacheKeeper/recordings/#{recording.id}/another_method"
+    end
+  end
+
+  test "#stale? is true for cold caches" do
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = manager.handle(Recording, :another_method, expires_in: 1.hour)
+
+      assert cached_method.stale?(recording)
+    end
+  end
+
+  test "#stale? is true for expired caches" do
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = manager.handle(Recording, :another_method, expires_in: 0.01.seconds)
+      manager.activate_if_handling(Recording, :another_method)
+      cached_method.call(recording)
+
+      sleep 0.01
+
+      assert cached_method.stale?(recording)
+    end
+  end
+
+  test "#stale? is false for fresh caches" do
+    with_clean_caching do
+      recording = Recording.create(number: 5)
+      cached_method = manager.handle(Recording, :another_method, expires_in: 1.hour)
+      manager.activate_if_handling(Recording, :another_method)
+      cached_method.call(recording)
+
+      assert_not cached_method.stale?(recording)
+    end
+  end
+
+  test ":key option accepts arrays" do
+    cached_method = manager.handle(Recording, :another_method, key: ["QuantumQuackerator", "quackify_particles"])
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal ["QuantumQuackerator", "quackify_particles"], cache_key
+  end
+
+  test ":key option accepts procs with no arguments" do
+    cached_method = manager.handle(Recording, :another_method, key: proc { 123 })
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal 123, cache_key
+  end
+
+  test ":key option accepts procs with an argument" do
+    cached_method = manager.handle(Recording, :another_method, key: proc { |method_name| [method_name, 123] })
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal [:another_method, 123], cache_key
+  end
+
+  test ":key option accepts lambdas with no arguments" do
+    cached_method = manager.handle(Recording, :another_method, key: -> { 123 })
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal 123, cache_key
+  end
+
+  test ":key option accepts lambdas with an argument" do
+    cached_method = manager.handle(Recording, :another_method, key: ->(method_name) { [method_name, 123] })
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal [:another_method, 123], cache_key
   end
 
   private

data/test/store_test.rb

@@ -11,7 +11,7 @@ class CacheKeeper::StoreTest < ActiveSupport::TestCase
 
   test "#autorefreshed returns only the ones with the correct option" do
     cached_method = CacheKeeper::CachedMethod.new(String, :slow_method, {})
-    autorefreshed_cached_method = CacheKeeper::CachedMethod.new(String, :really_slow_method, { autorefresh: true })
+    autorefreshed_cached_method = CacheKeeper::CachedMethod.new(String, :really_slow_method, {}, &proc {})
     store = CacheKeeper::Store.new([cached_method, autorefreshed_cached_method])
 
     assert_equal [autorefreshed_cached_method], store.autorefreshed

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Martin Zamuner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-25 00:00:00.000000000 Z
+date: 2023-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -36,6 +36,7 @@ files:
 - Gemfile
 - MIT-LICENSE
 - README.md
+- app/jobs/cache_keeper/autorefresh_job.rb
 - app/jobs/cache_keeper/base_job.rb
 - app/jobs/cache_keeper/refresh_job.rb
 - app/models/cache_keeper/cached_method.rb