class Cache

build_key(key, key_prefix, proc) click to toggle source

# 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

build_key_prefix(key_prefix, proc) click to toggle source

# 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

delete(key) click to toggle source

# File lib/object/cache.rb, line 82
def delete(key)
  return false unless include?(key)

  primary.del(key)
  true
end

include?(key) click to toggle source

# File lib/object/cache.rb, line 76
def include?(key)
  replica.exists?(key)
rescue
  false
end

new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix) { || ... } click to toggle source

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

primary() click to toggle source

# File lib/object/cache.rb, line 95
def primary
  backend.is_a?(Hash) ? backend[:primary] : backend
end

replica() click to toggle source

# File lib/object/cache.rb, line 104
def replica
  replicas.sample
end

replicas() click to toggle source

# File lib/object/cache.rb, line 99
def replicas
  replicas = backend.is_a?(Hash) ? backend[:replicas] : backend
  replicas.respond_to?(:sample) ? replicas : [replicas]
end

update_cache(key, value, ttl: default_ttl) click to toggle source

# 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

Constants

Attributes

Public Class Methods