cache_keeper 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d50a51737d307549be39ed49fb7edcfe391a270c0b55d25b52e70092276c548c
-  data.tar.gz: 5f2d9f844f4eb18bd41eb27a51558d4dd4aec13672abaf13cdcf2598cdfe8263
+  metadata.gz: 167f1cc0d9fdfca15b5882a90dde733b9d74b65f3adfad47f71ef34606b6e9d0
+  data.tar.gz: 278285596e0e0bdcbab9a687c07244c0c2f57d19e588b275ccb3e3281a8f3f78
 SHA512:
-  metadata.gz: '0519ed2a41f0c66ffcd0e8911f22d87f7e62b4b0fee2d3c1d1f9f9c567f9ebcebfa196b7253eb89b1534e04f5dbec873c94715ebc39fcb0e7836d4c5927b84d8'
-  data.tar.gz: 6b341290d842a7c6ec3c04170989428ea52bbfbd5a6f916a649aa0617326fb42766111f4dedbfcf714b86d403d26f3f5b57635c4cc3e9a34630ab130111da278
+  metadata.gz: 62d8e87244040101cb4f345c1e11a6b857c23bd7d7074877e0358d18e44c8acf7b76182ce0a922fa2998699ea74ede71484430c4f701cd12978710e7420b3022
+  data.tar.gz: 72a3207e7df9c92dcaf5764ba3055bed5cba3e943c406f824e6087d741c245301b7b11f05c00091cd8c77ed6a5739e31a843134f08d6856f9d677ee54a2f645d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cache_keeper (0.2.1)
+    cache_keeper (0.3.0)
       rails (>= 6.1.0)
 
 GEM

data/README.md

@@ -39,15 +39,23 @@ By default, it will immediately run the method call if it hasn't been cached bef
 
 It's important to note that it will only work with methods that don't take any arguments.
 
-### Autorefresh
+### Serialization
 
-You can tell CacheKeeper to automatically refresh the cache after a certain amount of time by setting the `autorefresh` option:
+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
-caches :i_cant_even, expires_in: 2.hours, autorefresh: true
+class Example
+  # Generate a new instance using an empty initializer (Example.new)
+  # Useful for controllers and for POROs with no arguments
+  caches :slow_method, 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
+end
 ```
 
-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.
+If those options don't work for you, you can always [write custom serializer](https://guides.rubyonrails.org/active_job_basics.html#serializers) for your classes.
 
 
 ## Configuration
@@ -63,15 +71,6 @@ 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/base_job.rb

@@ -3,14 +3,18 @@ class CacheKeeper::BaseJob < ActiveJob::Base
 
   private
 
-  # Monkey patch ActiveJob::Core#serialize_arguments to use CacheKeeper::WhateverSerializer
-  # in case there's no serializer for the argument. I'm doing it this way because I don't
+  # Monkey patch ActiveJob::Core#serialize_arguments to use our custom serializers
+  # in case the `serializer` option is present. I'm doing it this way because I don't
   # want to register the serializer as it would affect the whole application.
   def serialize_arguments(arguments)
     arguments.map do |argument|
       ActiveJob::Arguments.send :serialize_argument, argument
-    rescue ActiveJob::SerializationError
-      CacheKeeper::WhateverSerializer.serialize argument
+    rescue ActiveJob::SerializationError => e
+      if arguments.first.serialize_target?
+        arguments.first.serialize_target argument
+      else
+        raise e
+      end
     end
   end
 end

data/app/jobs/cache_keeper/refresh_job.rb

@@ -1,7 +1,7 @@
 class CacheKeeper::RefreshJob < CacheKeeper::BaseJob
   queue_as { CacheKeeper.configuration.queues[:refresh] }
 
-  def perform(cached_method, instance)
-    cached_method.refresh instance
+  def perform(cached_method, target)
+    cached_method.refresh target
   end
 end

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

@@ -1,13 +1,11 @@
 module CacheKeeper::CachedMethod::Refreshable
-  def refresh(instance)
+  def refresh(target)
     Rails.cache.fetch(cache_key, expires_in: expires_in) do
-      instance.send alias_for_original_method
+      target.send alias_for_original_method
     end
   end
 
-  def refresh_later(instance = nil)
-    instance ||= klass.new
-
-    CacheKeeper::RefreshJob.perform_later self, instance
+  def refresh_later(target)
+    CacheKeeper::RefreshJob.perform_later self, target
   end
 end

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

@@ -0,0 +1,18 @@
+module CacheKeeper::CachedMethod::SerializableTarget
+  def serialize_target?
+    options[:serializer].present?
+  end
+
+  def serialize_target(target)
+    case options[:serializer]
+    when :new_instance
+      CacheKeeper::NewInstanceSerializer.serialize target
+    when :marshal
+      CacheKeeper::MarshalSerializer.serialize target
+    else
+      raise "Unknown serializer: #{options[:serializer]}"
+    end
+  rescue StandardError => e
+    raise "Error serializing target using #{options[:serializer]}: #{e}"
+  end
+end

data/app/models/cache_keeper/cached_method.rb

@@ -1,5 +1,6 @@
 class CacheKeeper::CachedMethod
   include Refreshable
+  include SerializableTarget
 
   attr_accessor :klass, :method_name, :options
 
@@ -17,14 +18,14 @@ class CacheKeeper::CachedMethod
     cache_entry.blank? || cache_entry.expired?
   end
 
-  def call(instance)
+  def call(target)
     if cache_entry.blank?
-      refresh instance
+      refresh target
     elsif cache_entry.expired?
       if must_revalidate?
-        refresh instance
+        refresh target
       else
-        refresh_later instance
+        refresh_later target
 
         cache_entry.value
       end

data/app/serializers/cache_keeper/marshal_serializer.rb

@@ -0,0 +1,9 @@
+class CacheKeeper::MarshalSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(target)
+    super("dump" => Marshal.dump(target).force_encoding("ISO-8859-1").encode("UTF-8"))
+  end
+
+  def deserialize(json)
+    Marshal.load(json["dump"].encode("ISO-8859-1").force_encoding("ASCII-8BIT"))
+  end
+end

data/app/serializers/cache_keeper/new_instance_serializer.rb

@@ -0,0 +1,9 @@
+class CacheKeeper::NewInstanceSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(target)
+    super("klass" => target.class.to_s)
+  end
+
+  def deserialize(json)
+    json["klass"].constantize.new
+  end
+end

data/lib/cache_keeper/configuration.rb

@@ -2,7 +2,6 @@ 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?
@@ -14,21 +13,6 @@ module CacheKeeper
       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
 
     def rails_config

data/lib/cache_keeper/engine.rb

@@ -2,16 +2,10 @@ module CacheKeeper
   class Engine < ::Rails::Engine
     isolate_namespace CacheKeeper
 
+    config.eager_load_namespaces << CacheKeeper
+
     config.cache_keeper = ActiveSupport::OrderedOptions.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(
-      #{root}/app/jobs
-      #{root}/app/models
-      #{root}/app/serializers
-    )
 
     initializer "cache_keeper.active_job_serializer" do |app|
       config.to_prepare do
@@ -19,12 +13,6 @@ 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

@@ -29,7 +29,7 @@ module CacheKeeper
         end
 
         CacheKeeper::ReplaceMethod.replace(cached_method) do
-          cached_method.call(self)
+          instance_variable_get(:"@#{method_name}") || instance_variable_set(:"@#{method_name}", cached_method.call(self))
         end
       end
     end

data/lib/cache_keeper/version.rb

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

data/lib/cache_keeper.rb

@@ -8,7 +8,6 @@ module CacheKeeper
   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

@@ -2,8 +2,6 @@ class Recording < ApplicationRecord
   caches :slow_method, expires_in: 1.hour
 
   def slow_method
-    sleep 2
-
     42
   end
 

data/test/engine_test.rb

@@ -5,7 +5,11 @@ class CacheKeeper::EngineTest < ActiveSupport::TestCase
     assert_includes Rails.application.config.active_job.custom_serializers, CacheKeeper::CachedMethodSerializer
   end
 
-  test "doesn't register the ActiveJob serializer for whatever" do
-    assert_not_includes Rails.application.config.active_job.custom_serializers, CacheKeeper::WhateverSerializer
+  test "doesn't register the ActiveJob new_instance serializer" do
+    assert_not_includes Rails.application.config.active_job.custom_serializers, CacheKeeper::NewInstanceSerializer
+  end
+
+  test "doesn't register the ActiveJob marshal serializer" do
+    assert_not_includes Rails.application.config.active_job.custom_serializers, CacheKeeper::MarshalSerializer
   end
 end

data/test/jobs/refresh_job_test.rb

@@ -0,0 +1,14 @@
+require "test_helper"
+
+class CacheKeeper::RefreshJobTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  test "calls #refresh" do
+    recording = Recording.create(number: 5)
+    cached_method = CacheKeeper.manager.cached_methods.first
+
+    assert_performed_with(queue: :default) do
+      CacheKeeper::RefreshJob.perform_later cached_method, recording
+    end
+  end
+end

data/test/models/cached_method/refreshable_test.rb

@@ -0,0 +1,14 @@
+require "test_helper"
+
+class CacheKeeper::CachedMethod::RefreshableTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  test "#refresh_later enqueues a refresh job" do
+    recording = Recording.create(number: 5)
+    cached_method = CacheKeeper.manager.cached_methods.first
+
+    assert_enqueued_with(job: CacheKeeper::RefreshJob, queue: :default) do
+      cached_method.refresh_later recording
+    end
+  end
+end

data/test/models/cached_method/serializable_target_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+class CacheKeeper::CachedMethod::SerializableTargetTest < ActiveSupport::TestCase
+  test "#serialize_target doesn't allow unknown serializers" do
+    recording = Recording.new(number: 5)
+    cached_method = CacheKeeper::CachedMethod.new(Recording, :another_method, serializer: :unknown_serializer)
+
+    error = assert_raises RuntimeError do
+      cached_method.serialize_target(recording)
+    end
+
+    assert_includes error.message, "Unknown serializer: unknown_serializer"
+  end
+
+  test "#serialize_target raises an error if unable to serialize" do
+    cached_method = CacheKeeper::CachedMethod.new(Recording, :another_method, serializer: :marshal)
+
+    error = assert_raises RuntimeError do
+      cached_method.serialize_target(Proc.new {})
+    end
+
+    assert_includes error.message, "Error serializing target using marshal:"
+  end
+end

data/test/serializers/marshal_serializer_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+class CacheKeeper::MarshalSerializerTest < ActiveSupport::TestCase
+  test "serializes the marshal dump" do
+    target = Recording.new
+    serialized = serializer.serialize(target)
+
+    assert_equal serialized["dump"], Marshal.dump(target).force_encoding("ISO-8859-1").encode("UTF-8")
+  end
+
+  test "deserializes the marshal dump" do
+    target = Recording.new
+    serialized = serializer.serialize(target)
+    deserialized = serializer.deserialize(serialized)
+
+    assert_equal Recording, deserialized.class
+  end
+
+  private
+
+  def serializer
+    CacheKeeper::MarshalSerializer
+  end
+end

data/test/serializers/{whatever_serializer_test.rb → new_instance_serializer_test.rb}

@@ -1,10 +1,6 @@
 require "test_helper"
 
-class CacheKeeper::WhateverSerializerTest < ActiveSupport::TestCase
-  test "serializes whatever" do
-    assert serializer.serialize?(RecordingsController.new)
-  end
-
+class CacheKeeper::NewInstanceSerializerTest < ActiveSupport::TestCase
   test "serializes the class name" do
     serialized = serializer.serialize(RecordingsController.new)
 
@@ -21,6 +17,6 @@ class CacheKeeper::WhateverSerializerTest < ActiveSupport::TestCase
   private
 
   def serializer
-    CacheKeeper::WhateverSerializer
+    CacheKeeper::NewInstanceSerializer
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Martin Zamuner
@@ -37,12 +37,13 @@ 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
+- app/models/cache_keeper/cached_method/serializable_target.rb
 - app/serializers/cache_keeper/cached_method_serializer.rb
-- app/serializers/cache_keeper/whatever_serializer.rb
+- app/serializers/cache_keeper/marshal_serializer.rb
+- app/serializers/cache_keeper/new_instance_serializer.rb
 - bin/rails
 - bin/release
 - bin/test
@@ -50,8 +51,6 @@ 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
@@ -128,10 +127,14 @@ files:
 - test/dummy/test/test_helper.rb
 - test/dummy/vendor/.keep
 - test/engine_test.rb
+- test/jobs/refresh_job_test.rb
 - test/manager_test.rb
+- test/models/cached_method/refreshable_test.rb
+- test/models/cached_method/serializable_target_test.rb
 - test/models/cached_method_test.rb
 - test/serializers/cached_method_serializer_test.rb
-- test/serializers/whatever_serializer_test.rb
+- test/serializers/marshal_serializer_test.rb
+- test/serializers/new_instance_serializer_test.rb
 - test/store_test.rb
 - test/test_helper.rb
 homepage: https://github.com/martinzamuner/cache_keeper
@@ -229,9 +232,13 @@ test_files:
 - test/dummy/test/test_helper.rb
 - test/dummy/vendor/.keep
 - test/engine_test.rb
+- test/jobs/refresh_job_test.rb
 - test/manager_test.rb
+- test/models/cached_method/refreshable_test.rb
+- test/models/cached_method/serializable_target_test.rb
 - test/models/cached_method_test.rb
 - test/serializers/cached_method_serializer_test.rb
-- test/serializers/whatever_serializer_test.rb
+- test/serializers/marshal_serializer_test.rb
+- test/serializers/new_instance_serializer_test.rb
 - test/store_test.rb
 - test/test_helper.rb

data/app/jobs/cache_keeper/refresh_all_job.rb

@@ -1,11 +0,0 @@
-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/serializers/cache_keeper/whatever_serializer.rb

@@ -1,15 +0,0 @@
-class CacheKeeper::WhateverSerializer < ActiveJob::Serializers::ObjectSerializer
-  def serialize?(argument)
-    true
-  end
-
-  def serialize(whatever)
-    super(
-      "klass" => whatever.class.to_s
-    )
-  end
-
-  def deserialize(hash)
-    hash["klass"].constantize.new
-  end
-end

data/lib/cache_keeper/cron/good_job_adapter.rb

@@ -1,10 +0,0 @@
-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

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