Class: Cache

Inherits:
Object show all
Defined in:
lib/object/cache.rb,
lib/object/cache/version.rb

Overview

Caching of objects in a Redis store

Constant Summary collapse

VERSION = 
'0.0.5'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.backend ⇒ Object

Returns the value of attribute backend.



11
12
13
 
# File 'lib/object/cache.rb', line 11

def backend
  @backend
end

.default_key_prefix ⇒ Object

Returns the value of attribute default_key_prefix.



13
14
15
 
# File 'lib/object/cache.rb', line 13

def default_key_prefix
  @default_key_prefix
end

.default_ttl ⇒ Object

Returns the value of attribute default_ttl.



12
13
14
 
# File 'lib/object/cache.rb', line 12

def default_ttl
  @default_ttl
end

Class Method Details

.build_key(key, key_prefix, proc) ⇒ Object 



100
101
102
103
104
105
 
# File 'lib/object/cache.rb', line 100

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

.build_key_prefix(key_prefix, proc) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/object/cache.rb', line 107

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 && location.base_label
  when :class_name
    proc.binding.receiver.class.to_s
  else
    key_prefix
  end
end

.delete(key) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/object/cache.rb', line 74

def delete(key)
  return false unless include?(key)

  primary.del(key)
  true
end

.include?(key) ⇒ Boolean

Returns:

  • (Boolean) 


68
69
70
71
72
 
# File 'lib/object/cache.rb', line 68

def include?(key)
  replica.exists(key)
rescue
  false
end

.new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix) ⇒ Object

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



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/object/cache.rb', line 47

def new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix)
  return yield unless replica

  key = build_key(key, key_prefix, Proc.new)

  if (cached_value = replica.get(key)).nil?
    yield.tap { |value| update_cache(key, value, ttl: ttl) }
  else
    Marshal.load(cached_value)
  end
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)
  yield
rescue
  yield
end

.primary ⇒ Object 



87
88
89
 
# File 'lib/object/cache.rb', line 87

def primary
  backend.is_a?(Hash) ? backend[:primary] : backend
end

.replica ⇒ Object 



96
97
98
 
# File 'lib/object/cache.rb', line 96

def replica
  replicas.sample
end

.replicas ⇒ Object 



91
92
93
94
 
# File 'lib/object/cache.rb', line 91

def replicas
  replicas = backend.is_a?(Hash) ? backend[:replicas] : backend
  replicas.respond_to?(:sample) ? replicas : [replicas]
end

.update_cache(key, value, ttl: default_ttl) ⇒ Object 



81
82
83
84
85
 
# File 'lib/object/cache.rb', line 81

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