object-cache 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3be3bd853f9ffd24ff89cff95d2762241021a1f
-  data.tar.gz: 48fc790b6f2a15b13d945a9fe6f0483355bc9995
+  metadata.gz: 1d2f1ec4b3467a87297e809f094d3f75461b3fa9
+  data.tar.gz: bf7eef92986a7ddb52c5f7ec2aa3110ddbaa791d
 SHA512:
-  metadata.gz: 6e1cd521b1b326ab8a381b71a0c39677fc37885dd0f714c8e8db010d7cc22dd5e88067827be3c4a863bda017f847ff63f77ab5814be6de0e20d527f986b4cf2e
-  data.tar.gz: 12f817db636a6d87ed92dbc80885d999f0b19b11b507aab5283fcf1ee7d9941495e430b0ff47571ab2601c559a5017703dde3de97f7d8666f04b6bf97dd4f4ae
+  metadata.gz: 323e1806f012635837d50ac2111d607232714308376d16e9ab32718cc2217fe760d745298b3e20165b1d3e70f339b90acca9aada9ec81cf44f5b75e971403006
+  data.tar.gz: 7b0cd11b83029e6e2b9701804a7426679e6002578777192916301c75af7faaf9780a61acd5ef8a32a8df52de45e977a5d86be1954f1a56dfdbd876bb7ea15dc7

data/.rubocop.yml

@@ -6,8 +6,5 @@ AllCops:
 Metrics/MethodLength:
   Max: 15
 
-Metrics/AbcSize:
-  Max: 16
-
 Metrics/LineLength:
   Max: 100

data/README.md

@@ -8,6 +8,7 @@ Easy caching of Ruby objects, using [Redis](http://redis.io) as a backend store.
   * [marshaling data](#marshaling-data)
   * [ttl](#ttl)
   * [namespaced keys](#namespaced-keys)
+  * [key prefixes](#key-prefixes)
   * [redis replicas](#redis-replicas)
   * [core extension](#core-extension)
 * [License](#license)
@@ -128,6 +129,58 @@ merged together with the file name and line number of the cache request, so you
 can re-use that same `email` namespace in different locations, without worrying
 about any naming collisions.
 
+#### key prefixes
+
+By default, the eventual key ending up in Redis is a 6-character long digest,
+based on the file name, line number, and optional key passed into the Cache
+object:
+
+```ruby
+Cache.new { 'hello world' }
+Cache.backend.keys # => ["22abcc"]
+```
+
+This makes working with keys quick and easy, without worying about conflicting
+keys.
+
+However, this does make it more difficult to selectively delete keys from the
+backend, if you want to purge the cache of specific keys, before their TTL
+expires.
+
+To support this use-case, you can use the `key_prefix` attribute:
+
+```ruby
+Cache.new(key_prefix: 'hello') { 'hello world' }
+Cache.backend.keys # => ["hello_22abcc"]
+```
+
+This allows you to selectively purge keys from Redis:
+
+```ruby
+Cache.backend.del('hello_')
+```
+
+You can also use the special value `:method_name` to dynamically set the key
+prefix based on where the cached object was created:
+
+```ruby
+Cache.new(key_prefix: :method_name) { 'hello world' }
+Cache.backend.keys # => ["test_key_prefix_method_name_22abcc"]
+```
+
+Or, use `:class_name` to group keys in the same class together:
+
+```ruby
+Cache.new(key_prefix: :class_name) { 'hello world' }
+Cache.backend.keys # => ["CacheTest_22abcc"]
+```
+
+You can also define these options globally:
+
+```ruby
+Cache.default_key_prefix = :method_name
+```
+
 #### redis replicas
 
 Before, we used the following setup to connect `Object::Cache` to a redis
@@ -137,7 +190,7 @@ backend:
 Cache.backend = Redis.new
 ```
 
-The Ruby Redis library has primary/replicas support [buit-in using Redis
+The Ruby Redis library has primary/replicas support [built-in using Redis
 Sentinel][sentinel].
 
 If however, you have your own setup, and want the writes and reads to be
@@ -151,7 +204,7 @@ Cache.backend = { primary: Redis.new, replicas: [Redis.new, Redis.new] }
 When writing the initial object to the backend, the `primary` Redis is used. On
 subsequent requests, a random replica is used to retrieve the stored value.
 
-The above example obiously only works if the replicas receive the written data
+The above example obviously only works if the replicas receive the written data
 from the primary instance.
 
 #### core extension
@@ -167,8 +220,8 @@ cache('hello', ttl: 60) { 'hello world' }
 Cache.new('hello', ttl: 60) { 'hello world' }
 ```
 
-Since the core extension adds the `cache` method to the `Object` class, you can
-also call this method directly on any instances inheriting from `Object`:
+You can also call this method directly on any instances inheriting from
+`Object`:
 
 ```ruby
 require 'object/cache/core_extension'

data/lib/object/cache.rb

@@ -10,6 +10,7 @@ class Cache
   class << self
     attr_accessor :backend
     attr_accessor :default_ttl
+    attr_accessor :default_key_prefix
 
     # new
     #
@@ -43,10 +44,10 @@ class Cache
     #   Cache.new { item } # item is only stored once, and then always
     #                      # retrieved, even if it is a different item
     #
-    def new(key = nil, ttl: default_ttl)
+    def new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix)
       return yield unless replica
 
-      key = Digest::SHA1.hexdigest([key, Proc.new.source_location].flatten.join)[0..5]
+      key = build_key(key, key_prefix, Proc.new)
 
       if (cached_value = replica.get(key)).nil?
         yield.tap { |value| update_cache(key, value, ttl: ttl) }
@@ -94,5 +95,24 @@ class Cache
     def replica
       replicas.sample
     end
+
+    def build_key(key, key_prefix, proc)
+      hash   = Digest::SHA1.hexdigest([key, proc.source_location].flatten.join)[0..5]
+      prefix = build_key_prefix(key_prefix, proc)
+
+      [prefix, hash].compact.join('_')
+    end
+
+    def build_key_prefix(key_prefix, proc)
+      case key_prefix
+      when :method_name
+        location = caller_locations.find { |l| "#{l.path}#{l.lineno}" == proc.source_location.join }
+        location&.base_label
+      when :class_name
+        proc.binding.receiver.class.to_s
+      else
+        key_prefix
+      end
+    end
   end
 end

data/lib/object/cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Cache
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/test/cache_test.rb

@@ -147,4 +147,40 @@ class CacheTest < Minitest::Test # rubocop:disable Metrics/ClassLength
     assert_equal 1, primary.keys.count
     assert_equal 0, replica.keys.count
   end
+
+  def test_default_key_prefix_custom
+    Cache.default_key_prefix = 'hello'
+
+    Cache.new { 'hello world' }
+    assert_match(/^hello/, redis.keys.first)
+  end
+
+  def test_default_key_prefix_method_name
+    Cache.default_key_prefix = :method_name
+
+    Cache.new { 'hello world' }
+    assert_match(/^test_default_key_prefix_method_name/, redis.keys.first)
+  end
+
+  def test_default_key_prefix_class_name
+    Cache.default_key_prefix = :class_name
+
+    Cache.new { 'hello world' }
+    assert_match(/^CacheTest/, redis.keys.first)
+  end
+
+  def test_key_prefix_custom
+    Cache.new(key_prefix: 'hello') { 'hello world' }
+    assert_match(/^hello/, redis.keys.first)
+  end
+
+  def test_key_prefix_method_name
+    Cache.new(key_prefix: :method_name) { 'hello world' }
+    assert_match(/^test_key_prefix_method_name/, redis.keys.first)
+  end
+
+  def test_key_prefix_class_name
+    Cache.new(key_prefix: :class_name) { 'hello world' }
+    assert_match(/^CacheTest/, redis.keys.first)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: object-cache
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jean