In Memory Cache for Ruby

This is a simple Ruby gem for in-memory caching.
Read this blog post
to understand what Zache is designed for.

First, install it:

gem install zache

Then, use it like this:

require 'zache'
zache = Zache.new
# Expires in 5 minutes
v = zache.get(:count, lifetime: 5 * 60) { expensive_calculation() }

If you omit the lifetime parameter, the key will never expire.

By default Zache is thread-safe. It locks the entire cache on each
get call. You can turn that off by using the sync argument:

zache = Zache.new(sync: false)
v = zache.get(:count) { expensive_calculation() }

You may use “dirty” mode, which will return an expired value while
calculation is in progress. For example, if you have a value in the cache that’s
expired, and you call get with a long-running block, the thread waits.
If another thread calls get again, that second thread won’t wait, but will
receive the expired value from the cache. This is a very convenient mode for situations
where absolute data accuracy is less important than performance:

zache = Zache.new(dirty: true)
# Or enable dirty mode for a specific get call
value = zache.get(:key, dirty: true) { expensive_calculation() }

The entire API is documented
here.
Here are some additional useful methods:

# Check if a key exists
zache.exists?(:key)
# Remove a key
zache.remove(:key)
# Remove all keys
zache.remove_all
# Remove keys that match a condition
zache.remove_by { |key| key.to_s.start_with?('temp_') }
# Clean up expired keys
zache.clean
# Check if cache is empty
zache.empty?

How to contribute

Read
these guidelines.
Make sure your build is green before you contribute
your pull request. You will need to have
Ruby 2.3+ and
Bundler installed. Then:

bundle update
bundle exec rake

If it’s clean and you don’t see any error messages, submit your pull request.