Parent

Class/Module Index [+]

Quicksearch

ActiveSupport::Cache::Store

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"

Attributes

logger_off[R]
logger_off?[R]
silence[R]
silence?[R]

Public Instance Methods

decrement(key, amount = 1) click to toggle source
# File lib/active_support/cache.rb, line 225
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) click to toggle source
# File lib/active_support/cache.rb, line 204
def delete(key, options = nil)
  log("delete", key, options)
end
delete_matched(matcher, options = nil) click to toggle source
# File lib/active_support/cache.rb, line 208
def delete_matched(matcher, options = nil)
  log("delete matched", matcher.inspect, options)
end
exist?(key, options = nil) click to toggle source
# File lib/active_support/cache.rb, line 212
def exist?(key, options = nil)
  log("exist?", key, options)
end
fetch(key, options = {}) click to toggle source

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
# File lib/active_support/cache.rb, line 151
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
    ms = Benchmark.ms { value = yield }

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

    log('write (will save %.2fms)' % ms, key, nil)

    value
  end
end
increment(key, amount = 1) click to toggle source
# File lib/active_support/cache.rb, line 216
def increment(key, amount = 1)
  log("incrementing", key, amount)
  if num = read(key)
    write(key, num + amount)
  else
    nil
  end
end
mute() click to toggle source
# File lib/active_support/cache.rb, line 104
def mute
  previous_silence, @silence = defined?(@silence) && @silence, true
  yield
ensure
  @silence = previous_silence
end
read(key, options = nil) click to toggle source

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.

# File lib/active_support/cache.rb, line 181
def read(key, options = nil)
  log("read", key, options)
end
silence!() click to toggle source
# File lib/active_support/cache.rb, line 96
def silence!
  @silence = true
  self
end
write(key, value, options = nil) click to toggle source

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
# File lib/active_support/cache.rb, line 200
def write(key, value, options = nil)
  log("write", key, options)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.