cache_keeper 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c55e34ac5e0676e81456a04f7edae71cf0c79c6cd5be9e135c56561f6439be
-  data.tar.gz: 6f9d9bc0bd404cd350f1cf7ff48b8c59bbff60dbeeda754c052ca22457720b8a
+  metadata.gz: bc9efe0608912e0c97f6f89659ad73e64588e33eb384701afe0c52afb981c568
+  data.tar.gz: 22b645e8a15de837f4d72de70bc64a1d966c9ce96f9ada07a6fb2f7ba6a0d32f
 SHA512:
-  metadata.gz: 1eec12fc16cf629cbe1b3502918b67d6d420bb812c1ed88088a809b07faf31ec981dfddb0d094507f0cd9522238134b1bc60ff011f0d99a12339144a5ba0a3d2
-  data.tar.gz: 6a93852da524a5e478166bc24d0bee53973a3343a8b55c2574ed67259f3e5ffc7f927b31bd35e257fe0107073e69fc32a99e608614b07ab736fa103e8ce33adc
+  metadata.gz: e60f463b994d17a08f047cd00cd7ef7114940cf5458a6c42d25efacf1968d93a01b2b9cbd6c1bad23252a9b357f88cae5909b291b24756a566ebe95efb0cf578
+  data.tar.gz: 25e87146ea75af98f0112aa8ba6acb730d6314962357589e4b8c0a540a728e9e59c2ebecb4764612f1eba375a6ad45069686ad5e3934bec05cbe31781522eee6

data/README.md

@@ -30,8 +30,8 @@ CacheKeeper provides a `caches` method that will cache the result of the methods
 
 ```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}" }
+  caches :slow_method, :really_slow_method, expires_in: 1.hour
+  caches :incredibly_slow_method, expires_in: 2.hours, must_revalidate: true
 
   def slow_method
     ...
@@ -51,17 +51,29 @@ 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
 

data/app/models/cache_keeper/cached_method.rb

@@ -39,8 +39,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/version.rb

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

data/test/models/cached_method_test.rb

@@ -12,6 +12,41 @@ class CacheKeeper::CachedMethodTest < ActiveSupport::TestCase
     assert cache_has_key? "CacheKeeper/recordings/#{recording.id}/another_method"
   end
 
+  test ":key option accepts arrays" do
+    cached_method = manager.handle(Recording, :another_method, key: ["QuantumQuackerator", "dimensional_duckling"])
+    cache_key = cached_method.send :cache_key, Recording.new
+
+    assert_equal ["QuantumQuackerator", "dimensional_duckling"], 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
 
   def manager

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 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