Module: MoreCoreExtensions::CacheWithTimeout

Defined in:
lib/more_core_extensions/core_ext/module/cache_with_timeout.rb

Defined Under Namespace

Modules: ClassMethods

Instance Method Summary collapse

Instance Method Details

#cache_with_timeout(method, timeout = nil, &block) ⇒ Object

cache_with_timeout creates singleton methods that cache the

results of the given block, but only for a short amount of time.
If the method is called again after time has passed, then the
cache is cleared and the block is reevaluated.  Note that the
cache is only cleared on the next invocation after the time has
passed, so if the block retains references to large objects,
they will never be garbage collected if the method is never
called again.

The methods created are
- `method`
- `#{method}_clear_cache` - Will clear the cached value on demand
- `#{method}_cached?` - Says whether or not there is a value cached

Example:

class Foo
  cache_with_timeout(:expensive_operation) do
    sleep 100
    rand(100)
  end
end

Foo.expensive_operation # => 42
Foo.expensive_operation # => 42
# ... wait 5+ minutes ...
Foo.expensive_operation # => 18

Parameters:

  • method (String|Symbol) —

    The name of the method to create.

  • timeout (Integer) (defaults to: nil) —

    The number of seconds after which the cache is cleared (defaults to: 300 (5 minutes))

Raises:

  • (ArgumentError) 


39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/more_core_extensions/core_ext/module/cache_with_timeout.rb', line 39

def cache_with_timeout(method, timeout = nil, &block)
  raise "no block given" if block.nil?
  raise ArgumentError, "method must be a Symbol" unless method.respond_to?(:to_sym)

  key = "#{name}.#{method}".to_sym

  $cache_with_timeout_lock.synchronize(:EX) do
    $cache_with_timeout[key] = {}
  end

  define_singleton_method(method) do |*args|
    force_reload = args.first
    return $cache_with_timeout_lock.synchronize(:EX) do
      cache = $cache_with_timeout[key]

      old_timeout = cache[:timeout]
      cache.clear if force_reload || (old_timeout && Time.now.utc > old_timeout)
      break cache[:value] if cache.key?(:value)

      new_timeout = timeout || 300 # 5 minutes
      new_timeout = new_timeout.call if new_timeout.kind_of?(Proc)
      new_timeout = Time.now.utc + new_timeout
      new_value   = block.call

      cache[:timeout] = new_timeout
      cache[:value]   = new_value
    end
  end

  define_singleton_method("#{method}_clear_cache") do |*_args|
    $cache_with_timeout_lock.synchronize(:EX) do
      $cache_with_timeout[key].clear
    end
  end

  define_singleton_method("#{method}_cached?") do |*_args|
    $cache_with_timeout_lock.synchronize(:EX) do
      !$cache_with_timeout[key].empty?
    end
  end

  method.to_sym
end