Class: ActiveSupport::Cache::Store

Inherits:
Object
  • Object
show all
Defined in:
lib/active_support/cache.rb

Overview

An abstract cache store class. There are multiple cache store implementations, each having its own additional features. See the classes under the ActiveSupport::Cache module, e.g. ActiveSupport::Cache::MemCacheStore. MemCacheStore is currently the most popular cache store for large production websites.

ActiveSupport::Cache::Store is meant for caching strings. Some cache store implementations, like MemoryStore, are able to cache arbitrary Ruby objects, but don’t count on every cache store to be able to do that.

cache = ActiveSupport::Cache::MemoryStore.new

cache.read("city")   # => nil
cache.write("city", "Duckburgh")
cache.read("city")   # => "Duckburgh"

Direct Known Subclasses

FileStore, MemCacheStore, MemoryStore

Instance Method Summary collapse

Instance Method Details

#decrement(key, amount = 1) ⇒ Object 



202
203
204
205
206
207
208
209
 
# File 'lib/active_support/cache.rb', line 202

def decrement(key, amount = 1)
  log("decrementing", key, amount)
  if num = read(key)
    write(key, num - amount)
  else
    nil
  end
end

#delete(key, options = nil) ⇒ Object 



181
182
183
 
# File 'lib/active_support/cache.rb', line 181

def delete(key, options = nil)
  log("delete", key, options)
end

#delete_matched(matcher, options = nil) ⇒ Object 



185
186
187
 
# File 'lib/active_support/cache.rb', line 185

def delete_matched(matcher, options = nil)
  log("delete matched", matcher.inspect, options)
end

#exist?(key, options = nil) ⇒ Boolean

Returns:

  • (Boolean) 


189
190
191
 
# File 'lib/active_support/cache.rb', line 189

def exist?(key, options = nil)
  log("exist?", key, options)
end

#fetch(key, options = {}) ⇒ Object

Fetches data from the cache, using the given key. If there is data in the cache with the given key, then that data is returned.

If there is no such data in the cache (a cache miss occurred), then then nil will be returned. However, if a block has been passed, then that block will be run in the event of a cache miss. The return value of the block will be written to the cache under the given cache key, and that return value will be returned.

cache.write("today", "Monday")
cache.fetch("today")  # => "Monday"

cache.fetch("city")   # => nil
cache.fetch("city") do
  "Duckburgh"
end
cache.fetch("city")   # => "Duckburgh"

You may also specify additional options via the options argument. Setting :force => true will force a cache miss:

cache.write("today", "Monday")
cache.fetch("today", :force => true)  # => nil

Other options will be handled by the specific cache store implementation. Internally, #fetch calls #read, and calls #write on a cache miss. options will be passed to the #read and #write calls.

For example, MemCacheStore’s #write method supports the :expires_in option, which tells the memcached server to automatically expire the cache item after a certain period. We can use this option with #fetch too:

cache = ActiveSupport::Cache::MemCacheStore.new
cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
  "bar"
end
cache.fetch("foo")  # => "bar"
sleep(6)
cache.fetch("foo")  # => nil



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/active_support/cache.rb', line 128

def fetch(key, options = {})
  @logger_off = true
  if !options[:force] && value = read(key, options)
    @logger_off = false
    log("hit", key, options)
    value
  elsif block_given?
    @logger_off = false
    log("miss", key, options)

    value = nil
    seconds = Benchmark.realtime { value = yield }

    @logger_off = true
    write(key, value, options)
    @logger_off = false

    log("write (will save #{'%.2f' % (seconds * 1000)}ms)", key, nil)

    value
  end
end

#increment(key, amount = 1) ⇒ Object 



193
194
195
196
197
198
199
200
 
# File 'lib/active_support/cache.rb', line 193

def increment(key, amount = 1)
  log("incrementing", key, amount)
  if num = read(key)
    write(key, num + amount)
  else
    nil
  end
end

#read(key, options = nil) ⇒ Object

Fetches data from the cache, using the given key. If there is data in the cache with the given key, then that data is returned. Otherwise, nil is returned.

You may also specify additional options via the options argument. The specific cache store implementation will decide what to do with options.



158
159
160
 
# File 'lib/active_support/cache.rb', line 158

def read(key, options = nil)
  log("read", key, options)
end

#silence! ⇒ Object 



83
84
85
86
 
# File 'lib/active_support/cache.rb', line 83

def silence!
  @silence = true
  self
end

#write(key, value, options = nil) ⇒ Object

Writes the given value to the cache, with the given key.

You may also specify additional options via the options argument. The specific cache store implementation will decide what to do with options.

For example, MemCacheStore supports the :expires_in option, which tells the memcached server to automatically expire the cache item after a certain period:

cache = ActiveSupport::Cache::MemCacheStore.new
cache.write("foo", "bar", :expires_in => 5.seconds)
cache.read("foo")  # => "bar"
sleep(6)
cache.read("foo")  # => nil



177
178
179
 
# File 'lib/active_support/cache.rb', line 177

def write(key, value, options = nil)
  log("write", key, options)
end