cache_keeper 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bef46cb308534d247ff50712366a7548864043aa0bf6cd4a75ccd2edeed1fee
-  data.tar.gz: 4c6375f02da64d4d60c38c6a7e2839c0e1d4084271011bc4a8fcd5d83a65caaa
+  metadata.gz: d50a51737d307549be39ed49fb7edcfe391a270c0b55d25b52e70092276c548c
+  data.tar.gz: 5f2d9f844f4eb18bd41eb27a51558d4dd4aec13672abaf13cdcf2598cdfe8263
 SHA512:
-  metadata.gz: 27a68b7c00a743092d3b6e317df3c38edae644be451c0760c186b66e648ecca7acccb5b4540369b3885f7e6a9fb9d5c5723e4fcd4f8877d6fc126d6b4853cc0a
-  data.tar.gz: 8a9fea0f3c9b654c530e6519bf6ccdbc0fabe7ff0ccd2e33d3efed9dc3272437135afe7ea07a98c86b9e927f01e3cb7c139d92a78828372354a6181ef25b057d
+  metadata.gz: '0519ed2a41f0c66ffcd0e8911f22d87f7e62b4b0fee2d3c1d1f9f9c567f9ebcebfa196b7253eb89b1534e04f5dbec873c94715ebc39fcb0e7836d4c5927b84d8'
+  data.tar.gz: 6b341290d842a7c6ec3c04170989428ea52bbfbd5a6f916a649aa0617326fb42766111f4dedbfcf714b86d403d26f3f5b57635c4cc3e9a34630ab130111da278

data/Gemfile

@@ -3,6 +3,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake"
+gem "byebug"
 
 gem "rails", ">= 6.1"
 gem "sqlite3"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cache_keeper (0.1.2)
+    cache_keeper (0.2.1)
       rails (>= 6.1.0)
 
 GEM
@@ -83,6 +83,7 @@ GEM
     base64 (0.1.1)
     bigdecimal (3.1.4)
     builder (3.2.4)
+    byebug (11.1.3)
     concurrent-ruby (1.2.2)
     connection_pool (2.4.1)
     crass (1.0.6)
@@ -188,6 +189,7 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  byebug
   cache_keeper!
   rails (>= 6.1)
   rake

data/README.md

@@ -3,7 +3,7 @@
   <br>
 </h1>
 
-<h3 align="center">Keep cached methods always fresh in your Rails application.</h3>
+<h3 align="center">Have your cached methods refreshed asynchronously and automatically.</h3>
 
 <p align="center">
   <img alt="Build" src="https://img.shields.io/github/actions/workflow/status/martinzamuner/cache_keeper/ci.yml?branch=main">
@@ -12,7 +12,7 @@
   <img alt="License" src="https://img.shields.io/github/license/martinzamuner/cache_keeper">
 </p>
 
-CacheKeeper allows you to mark any method to be kept fresh in your Rails cache. It uses ActiveJob to refresh the cache in the background.
+CacheKeeper is a Rails gem that allows you to mark any method to be kept fresh in your cache. It uses ActiveJob to refresh the cache in the background, either on demand or periodically.
 
 
 ## Installation
@@ -33,10 +33,22 @@ caches :slow_method, :really_slow_method, expires_in: 1.hour
 caches :incredibly_slow_method, expires_in: 2.hours, must_revalidate: true
 ```
 
-It is automatically available in your ActiveRecord models and in your controllers. You can also use it in any other class by including `CacheKeeper::Caching`.
+It's automatically available in your ActiveRecord models and in your controllers. You can also use it in any other class by including `CacheKeeper::Caching`.
 
 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.
 
+It's important to note that it will only work with methods that don't take any arguments.
+
+### Autorefresh
+
+You can tell CacheKeeper to automatically refresh the cache after a certain amount of time by setting the `autorefresh` option:
+
+```ruby
+caches :i_cant_even, expires_in: 2.hours, autorefresh: true
+```
+
+This works by running a job in cron mode that will periodically check for stale entries and enqueue a job to refresh them. You need to specify an adapter as explained in the configuration section below.
+
 
 ## Configuration
 
@@ -51,6 +63,15 @@ Rails.application.configure do
   # The queue to use for the refresh jobs.
   # Default: nil (uses the default queue)
   config.cache_keeper.queues.refresh = :low_priority
+
+  # The adapter to use for the autorefresh cron job.
+  # Options: :good_job
+  # Default: nil
+  config.cache_keeper.cron.adapter = :good_job
+
+  # The cron expression to use for the autorefresh cron job.
+  # Default: "*/15 * * * *" (every 15 minutes)
+  config.cache_keeper.cron.expression = "0 * * * *"
 end
 ```
 

data/app/jobs/cache_keeper/refresh_all_job.rb

@@ -0,0 +1,11 @@
+class CacheKeeper::RefreshAllJob < CacheKeeper::BaseJob
+  queue_as { CacheKeeper.configuration.queues[:refresh] }
+
+  def perform
+    CacheKeeper.manager.cached_methods.autorefreshed.each do |cached_method|
+      next unless cached_method.stale?
+
+      cached_method.refresh_later
+    end
+  end
+end

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

@@ -5,7 +5,9 @@ module CacheKeeper::CachedMethod::Refreshable
     end
   end
 
-  def refresh_later(instance)
+  def refresh_later(instance = nil)
+    instance ||= klass.new
+
     CacheKeeper::RefreshJob.perform_later self, instance
   end
 end

data/app/models/cache_keeper/cached_method.rb

@@ -13,6 +13,10 @@ class CacheKeeper::CachedMethod
     :"__#{method_name}__hooked__"
   end
 
+  def stale?
+    cache_entry.blank? || cache_entry.expired?
+  end
+
   def call(instance)
     if cache_entry.blank?
       refresh instance

data/cache_keeper.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.version  = CacheKeeper::VERSION
   s.authors  = ["Martin Zamuner"]
   s.email    = "martinzamuner@gmail.com"
-  s.summary  = "Keep a fresh copy of any method in your cache"
+  s.summary  = "Have your cached methods refreshed asynchronously and automatically"
   s.homepage = "https://github.com/martinzamuner/cache_keeper"
   s.license  = "MIT"
 

data/lib/cache_keeper/configuration.rb

@@ -2,15 +2,31 @@ module CacheKeeper
   class Configuration
     DEFAULT_MUST_REVALIDATE = false
     DEFAULT_QUEUES = {}
+    DEFAULT_CRON_EXPRESSION = "*/15 * * * *" # Every 15 minutes, every day
 
     def must_revalidate
-      return rails_config[:must_revalidate] unless rails_config[:must_revalidate].nil?
+      return rails_config.must_revalidate unless rails_config.must_revalidate.nil?
 
       DEFAULT_MUST_REVALIDATE
     end
 
     def queues
-      rails_config[:queues] || DEFAULT_QUEUES
+      rails_config.queues || DEFAULT_QUEUES
+    end
+
+    def cron_adapter
+      return if rails_config.cron.adapter.nil?
+
+      case rails_config.cron.adapter
+      when :good_job
+        CacheKeeper::Cron::GoodJobAdapter
+      else
+        raise "Unknown cron adapter: #{rails_config.cron.adapter}"
+      end
+    end
+
+    def cron_expression
+      rails_config.cron.expression || DEFAULT_CRON_EXPRESSION
     end
 
     private

data/lib/cache_keeper/cron/good_job_adapter.rb

@@ -0,0 +1,10 @@
+module CacheKeeper
+  class Cron::GoodJobAdapter
+    def self.setup
+      Rails.application.config.good_job.cron[:cache_keeper] = {
+        class: "CacheKeeper::RefreshAllJob",
+        cron: CacheKeeper.configuration.cron_expression
+      }
+    end
+  end
+end

data/lib/cache_keeper/cron.rb

@@ -0,0 +1,7 @@
+module CacheKeeper
+  module Cron
+    extend ActiveSupport::Autoload
+
+    autoload :GoodJobAdapter
+  end
+end

data/lib/cache_keeper/engine.rb

@@ -3,7 +3,8 @@ module CacheKeeper
     isolate_namespace CacheKeeper
 
     config.cache_keeper = ActiveSupport::OrderedOptions.new
-    config.cache_keeper.queues = ActiveSupport::InheritableOptions.new
+    config.cache_keeper.queues = ActiveSupport::OrderedOptions.new
+    config.cache_keeper.cron = ActiveSupport::OrderedOptions.new
 
     config.eager_load_namespaces << CacheKeeper
     config.autoload_once_paths = %W(
@@ -18,6 +19,12 @@ module CacheKeeper
       end
     end
 
+    initializer "cache_keeper.cron_adapter" do |app|
+      config.to_prepare do
+        CacheKeeper.configuration.cron_adapter&.setup
+      end
+    end
+
     initializer "cache_keeper.caching_methods" do |app|
       ActiveSupport.on_load :action_controller do
         ActionController::Base.send :include, CacheKeeper::Caching

data/lib/cache_keeper/manager.rb

@@ -3,32 +3,34 @@ module CacheKeeper
     attr_accessor :cached_methods
 
     def initialize
-      self.cached_methods = []
-    end
-
-    def find(klass, method_name)
-      cached_methods.find do |cached_method|
-        cached_method.klass == klass && cached_method.method_name == method_name
-      end
+      self.cached_methods = CacheKeeper::Store.new
     end
 
     def handled?(klass, method_name)
-      find(klass, method_name).present?
+      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|
+        if unsupported_options?(cached_method)
+          raise "You're trying to autorefresh an ActiveRecord model, which we don't currently support."
+        end
+
         cached_methods << cached_method
       end
     end
 
     def activate_if_handling(klass, method_name)
-      cached_method = find(klass, method_name) or return
+      cached_method = cached_methods.find_by(klass, method_name) or return
 
-      return unless requires_activation?(cached_method)
+      if requires_activation?(cached_method)
+        if unsupported_arity?(cached_method)
+          raise "You're trying to cache a method with parameters, which we don't currently support."
+        end
 
-      CacheKeeper::ReplaceMethod.replace(cached_method) do
-        cached_method.call(self)
+        CacheKeeper::ReplaceMethod.replace(cached_method) do
+          cached_method.call(self)
+        end
       end
     end
 
@@ -40,5 +42,17 @@ module CacheKeeper
 
       true
     end
+
+    def unsupported_options?(cached_method)
+      cached_method.klass < ActiveRecord::Base && cached_method.options[:autorefresh].present?
+    end
+
+    def unsupported_arity?(cached_method)
+      original_method =
+        cached_method.klass.instance_method(cached_method.method_name) ||
+        cached_method.klass.privateinstance_method(cached_method.method_name)
+
+      original_method.arity.nonzero?
+    end
   end
 end

data/lib/cache_keeper/store.rb

@@ -0,0 +1,15 @@
+module CacheKeeper
+  class Store < Array
+    def find_by(klass, method_name)
+      find do |cached_method|
+        cached_method.klass == klass && cached_method.method_name == method_name
+      end
+    end
+
+    def autorefreshed
+      select do |cached_method|
+        cached_method.options[:autorefresh].present?
+      end
+    end
+  end
+end

data/lib/cache_keeper/version.rb

@@ -1,3 +1,3 @@
 module CacheKeeper
-  VERSION = "0.1.2"
+  VERSION = "0.2.1"
 end

data/lib/cache_keeper.rb

@@ -7,6 +7,8 @@ module CacheKeeper
   autoload :Configuration
   autoload :Manager
   autoload :ReplaceMethod
+  autoload :Store
+  autoload :Cron
 
   mattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
 

data/test/dummy/app/models/recording.rb

@@ -10,4 +10,8 @@ class Recording < ApplicationRecord
   def another_method
     number
   end
+
+  def unsupported_method(parameter)
+    parameter * 2
+  end
 end

data/test/manager_test.rb

@@ -8,4 +8,21 @@ class CacheKeeper::ManagerTest < ActiveSupport::TestCase
     assert_equal 1, CacheKeeper.manager.cached_methods.count
     assert_equal :slow_method, CacheKeeper.manager.cached_methods.first.method_name
   end
+
+  test "doesn't allow to autorefresh ActiveRecord models" do
+    manager = CacheKeeper::Manager.new
+
+    assert_raises RuntimeError do
+      manager.handle Recording, :slow_method, autorefresh: true
+    end
+  end
+
+  test "doesn't allow to activate methods with parameters" do
+    manager = CacheKeeper::Manager.new
+    manager.handle Recording, :unsupported_method, {}
+
+    assert_raises RuntimeError do
+      manager.activate_if_handling Recording, :unsupported_method
+    end
+  end
 end

data/test/store_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class CacheKeeper::StoreTest < ActiveSupport::TestCase
+  test "#find_by returns only the one with the requested parameters" do
+    cached_method = CacheKeeper::CachedMethod.new(String, :slow_method, {})
+    autorefreshed_cached_method = CacheKeeper::CachedMethod.new(String, :really_slow_method, { autorefresh: true })
+    store = CacheKeeper::Store.new([cached_method, autorefreshed_cached_method])
+
+    assert_equal autorefreshed_cached_method, store.find_by(String, :really_slow_method)
+  end
+
+  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 })
+    store = CacheKeeper::Store.new([cached_method, autorefreshed_cached_method])
+
+    assert_equal [autorefreshed_cached_method], store.autorefreshed
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Martin Zamuner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-23 00:00:00.000000000 Z
+date: 2023-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -37,6 +37,7 @@ files:
 - MIT-LICENSE
 - README.md
 - app/jobs/cache_keeper/base_job.rb
+- app/jobs/cache_keeper/refresh_all_job.rb
 - app/jobs/cache_keeper/refresh_job.rb
 - app/models/cache_keeper/cached_method.rb
 - app/models/cache_keeper/cached_method/refreshable.rb
@@ -49,9 +50,12 @@ files:
 - lib/cache_keeper.rb
 - lib/cache_keeper/caching.rb
 - lib/cache_keeper/configuration.rb
+- lib/cache_keeper/cron.rb
+- lib/cache_keeper/cron/good_job_adapter.rb
 - lib/cache_keeper/engine.rb
 - lib/cache_keeper/manager.rb
 - lib/cache_keeper/replace_method.rb
+- lib/cache_keeper/store.rb
 - lib/cache_keeper/version.rb
 - test/cache_helper.rb
 - test/dummy/Rakefile
@@ -128,6 +132,7 @@ files:
 - test/models/cached_method_test.rb
 - test/serializers/cached_method_serializer_test.rb
 - test/serializers/whatever_serializer_test.rb
+- test/store_test.rb
 - test/test_helper.rb
 homepage: https://github.com/martinzamuner/cache_keeper
 licenses:
@@ -151,7 +156,7 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: Keep a fresh copy of any method in your cache
+summary: Have your cached methods refreshed asynchronously and automatically
 test_files:
 - test/cache_helper.rb
 - test/dummy/Rakefile
@@ -228,4 +233,5 @@ test_files:
 - test/models/cached_method_test.rb
 - test/serializers/cached_method_serializer_test.rb
 - test/serializers/whatever_serializer_test.rb
+- test/store_test.rb
 - test/test_helper.rb