Module: CachedRecord::Cache

Defined in:
lib/cached_record/cache.rb

Defined Under Namespace

Classes: Error

Class Method Summary collapse

Class Method Details

.cache ⇒ Object 



32
33
34
 
# File 'lib/cached_record/cache.rb', line 32

def self.cache
  @cache ||= {Dalli::Client => {}, Redis => {}}
end

.clear! ⇒ Object 



36
37
38
 
# File 'lib/cached_record/cache.rb', line 36

def self.clear!
  @cache = nil
end

.expire(instance) ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/cached_record/cache.rb', line 59

def self.expire(instance)
  klass = instance.class
  cache_key = klass.cache_key instance.id
  store(klass).delete cache_key
  cache[store(klass).class].delete cache_key if klass.as_cache[:memoize]
  nil
end

.get(klass, id) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/cached_record/cache.rb', line 40

def self.get(klass, id)
  retained(klass, id) || begin
    cache_string = store(klass).get(klass.cache_key(id)) || begin
      return unless (instance = yield if block_given?)
      set instance
    end
    json, epoch_time = split_cache_string(cache_string)
    memoized(klass, id, epoch_time) do
      klass.load_cache_json JSON.parse(json)
    end
  end
end

.memcached(options = nil) ⇒ Object 



14
15
16
17
18
19
20
21
22
 
# File 'lib/cached_record/cache.rb', line 14

def self.memcached(options = nil)
  if stores[:memcached].nil? || options
    options ||= {}
    host = options.delete(:host) || "localhost"
    port = options.delete(:port) || 11211
    stores[:memcached] = Dalli::Client.new "#{host}:#{port}", options
  end
  stores[:memcached]
end

.memoized(klass, id, epoch_time) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/cached_record/cache.rb', line 76

def self.memoized(klass, id, epoch_time)
  return yield unless klass.as_cache[:memoize]
  cache_hash, cache_key = cache[store(klass).class], klass.cache_key(id)
  cache_hit = klass.as_cache[:retain] ? {:cache_hit => (Time.now + klass.as_cache[:retain]).to_i} : {}

  if (cache_entry = cache_hash[cache_key]) && (epoch_time == cache_entry[:epoch_time])
    cache_entry.merge! cache_hit
    cache_entry[:instance]
  else
    yield.tap do |instance|
      cache_hash[cache_key] = {:instance => instance, :epoch_time => epoch_time}.merge(cache_hit) if instance
    end
  end
end

.redis(options = nil) ⇒ Object 



24
25
26
27
28
29
30
 
# File 'lib/cached_record/cache.rb', line 24

def self.redis(options = nil)
  if stores[:redis].nil? || options
    options ||= {}
    stores[:redis] = Redis.new options
  end
  stores[:redis]
end

.retained(klass, id) ⇒ Object 



67
68
69
70
71
72
73
74
 
# File 'lib/cached_record/cache.rb', line 67

def self.retained(klass, id)
  return unless klass.as_cache[:memoize] && klass.as_cache[:retain]
  cache_hash, cache_key = cache[store(klass).class], klass.cache_key(id)

  if (cache_entry = cache_hash[cache_key]) && (Time.now.to_i < cache_entry[:cache_hit])
    cache_entry[:instance]
  end
end

.set(instance) ⇒ Object 



53
54
55
56
57
 
# File 'lib/cached_record/cache.rb', line 53

def self.set(instance)
  "#{instance.to_cache_json}#{"@#{Time.now.to_i}" if instance.class.as_cache[:memoize]}".tap do |cache_string|
    store(instance.class).set instance.class.cache_key(instance.id), cache_string, instance.class.as_cache[:expire]
  end
end

.setup(store, options = {}) ⇒ Object 



8
9
10
11
12
 
# File 'lib/cached_record/cache.rb', line 8

def self.setup(store, options = {})
  if valid_store? store
    send store, options
  end
end