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"
Methods
Attributes
[R] logger_off
[R] silence
Public Instance methods
decrement(key, amount = 1)

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 225
225:       def decrement(key, amount = 1)
226:         log("decrementing", key, amount)
227:         if num = read(key)
228:           write(key, num - amount)
229:         else
230:           nil
231:         end
232:       end
delete(key, options = nil)

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 204
204:       def delete(key, options = nil)
205:         log("delete", key, options)
206:       end
delete_matched(matcher, options = nil)

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 208
208:       def delete_matched(matcher, options = nil)
209:         log("delete matched", matcher.inspect, options)
210:       end
exist?(key, options = nil)

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 212
212:       def exist?(key, options = nil)
213:         log("exist?", key, options)
214:       end
fetch(key, options = {}) {|| ...}

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

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 151
151:       def fetch(key, options = {})
152:         @logger_off = true
153:         if !options[:force] && value = read(key, options)
154:           @logger_off = false
155:           log("hit", key, options)
156:           value
157:         elsif block_given?
158:           @logger_off = false
159:           log("miss", key, options)
160: 
161:           value = nil
162:           ms = Benchmark.ms { value = yield }
163: 
164:           @logger_off = true
165:           write(key, value, options)
166:           @logger_off = false
167: 
168:           log('write (will save %.2fms)' % ms, key, nil)
169: 
170:           value
171:         end
172:       end
increment(key, amount = 1)

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 216
216:       def increment(key, amount = 1)
217:         log("incrementing", key, amount)
218:         if num = read(key)
219:           write(key, num + amount)
220:         else
221:           nil
222:         end
223:       end
mute() {|| ...}

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 104
104:       def mute
105:         previous_silence, @silence = defined?(@silence) && @silence, true
106:         yield
107:       ensure
108:         @silence = previous_silence
109:       end
read(key, options = nil)

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.

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 181
181:       def read(key, options = nil)
182:         log("read", key, options)
183:       end
silence!()

[ show source ]

    # File activesupport/lib/active_support/cache.rb, line 96
96:       def silence!
97:         @silence = true
98:         self
99:       end
write(key, value, options = nil)

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

[ show source ]

     # File activesupport/lib/active_support/cache.rb, line 200
200:       def write(key, value, options = nil)
201:         log("write", key, options)
202:       end