cache_keeper 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc9efe0608912e0c97f6f89659ad73e64588e33eb384701afe0c52afb981c568
-  data.tar.gz: 22b645e8a15de837f4d72de70bc64a1d966c9ce96f9ada07a6fb2f7ba6a0d32f
+  metadata.gz: edca690bc194349e3a062521687f2e91fc91415f66e7f0e976293a0e7470f8a8
+  data.tar.gz: 78e3725f253be829e474602792fb3316889ffd8d6485bff0b1a6baae2525d0d7
 SHA512:
-  metadata.gz: e60f463b994d17a08f047cd00cd7ef7114940cf5458a6c42d25efacf1968d93a01b2b9cbd6c1bad23252a9b357f88cae5909b291b24756a566ebe95efb0cf578
-  data.tar.gz: 25e87146ea75af98f0112aa8ba6acb730d6314962357589e4b8c0a540a728e9e59c2ebecb4764612f1eba375a6ad45069686ad5e3934bec05cbe31781522eee6
+  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
-  caches :incredibly_slow_method, expires_in: 2.hours, must_revalidate: true
+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
@@ -62,8 +62,6 @@ 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
 ```
 
@@ -75,16 +73,42 @@ CacheKeeper needs to pass the instance on which the cached method is called alon
 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)
 

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.1"
+  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,21 +2,56 @@ 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", "dimensional_duckling"])
+    cached_method = manager.handle(Recording, :another_method, key: ["QuantumQuackerator", "quackify_particles"])
     cache_key = cached_method.send :cache_key, Recording.new
 
-    assert_equal ["QuantumQuackerator", "dimensional_duckling"], cache_key
+    assert_equal ["QuantumQuackerator", "quackify_particles"], cache_key
   end
 
   test ":key option accepts procs with no arguments" do

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Martin Zamuner
@@ -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