# File lib/object/cache.rb, line 95 def primary backend.is_a?(Hash) ? backend[:primary] : backend end
class Cache
Caching of objects in a Redis store
Constants
- VERSION
Attributes
Public Class Methods
# File lib/object/cache.rb, line 108 def build_key(key, key_prefix, proc) hash = Digest::SHA1.hexdigest([key, proc.source_location].flatten.join)[0..11] prefix = build_key_prefix(key_prefix, proc) [prefix, hash].compact.join('_') end
# File lib/object/cache.rb, line 115 def build_key_prefix(key_prefix, proc) case key_prefix when :method_name location = caller_locations.find { |l| proc.source_location.join == "#{l.path}#{l.lineno}" } location&.base_label when :class_name proc.binding.receiver.class.to_s else key_prefix end end
# File lib/object/cache.rb, line 82 def delete(key) return false unless include?(key) primary.del(key) true end
# File lib/object/cache.rb, line 76 def include?(key) replica.exists?(key) rescue false end
new
Finds the correct value (based on the provided key) in the cache store, or calls the original code, and stores the result in cache.
The TTL of the cached content is provided with the optional `ttl` named argument. If left blank, the `DEFAULT_TTL` ttl value will be used.
The caching key will be determined by creating a SHA digest of the original code's file location and line number within that file. This makes it easier to provide short caching keys like uid's, or ids, and still receive a unique caching key under which the data is stored.
The cache key can optionally be left blank. This should **only be done** if the provided data by the method will never changes based on some form of input.
For example: caching an `Item` should always be done by providing a unique item identifier as the caching key, otherwise the cache will return the same item every time, even if a different one is stored the second time.
good:
Cache.new { 'hello world' } # stored object is always the same Cache.new(item.id) { item } # stored item is namespaced using its id
bad:
Cache.new { item } # item is only stored once, and then always # retrieved, even if it is a different item
# File lib/object/cache.rb, line 47 def new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix, &block) return yield unless replica begin key = build_key(key, key_prefix, block) if (cached_value = replica.get(key)).nil? yield.tap do |value| begin update_cache(key, value, ttl: ttl) rescue TypeError # if `TypeError` is raised, the data could not be Marshal dumped. In that # case, delete anything left in the cache store, and get the data without # caching. # delete(key) end end else begin Marshal.load(cached_value) rescue delete(key) yield end end end end
# File lib/object/cache.rb, line 104 def replica replicas.sample end
# File lib/object/cache.rb, line 99 def replicas replicas = backend.is_a?(Hash) ? backend[:replicas] : backend replicas.respond_to?(:sample) ? replicas : [replicas] end
# File lib/object/cache.rb, line 89 def update_cache(key, value, ttl: default_ttl) return unless primary && (value = Marshal.dump(value)) ttl.to_i.zero? ? primary.set(key, value) : primary.setex(key, ttl.to_i, value) end