Module: SupportTableCache

Extended by:
ActiveSupport::Concern
Defined in:
lib/support_table_cache.rb,
lib/support_table_cache/associations.rb,
lib/support_table_cache/memory_cache.rb,
lib/support_table_cache/find_by_override.rb,
lib/support_table_cache/relation_override.rb

Overview

This concern can be added to a model to add the ability to look up entries in the table using Rails.cache when calling find_by rather than hitting the database every time.

Defined Under Namespace

Modules: Associations, ClassMethods, FindByOverride, RelationOverride Classes: MemoryCache

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.cache ⇒ ActiveSupport::Cache::Store

Get the global cache (will default to Rails.cache if running in a Rails environment).

Returns:

  • (ActiveSupport::Cache::Store) 


191
192
193
194
195
196
197
198
199
 
# File 'lib/support_table_cache.rb', line 191

def cache
  if testing_cache
    testing_cache
  elsif defined?(@cache)
    @cache
  elsif defined?(Rails.cache)
    Rails.cache
  end
end

.cache=(value) ⇒ void

This method returns an undefined value.

Set the global cache to use.

Parameters:

  • value (ActiveSupport::Cache::Store, Symbol) —

    The cache instance to use. You can also specify the value :memory to use an optimized in-memory cache.



183
184
185
186
 
# File 'lib/support_table_cache.rb', line 183

def cache=(value)
  value = MemoryCache.new if value == :memory
  @cache = value
end

.cache_key(klass, attributes, key_attribute_names, case_sensitive) ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Generate a consistent cache key for a set of attributes. It will return nil if the attributes are not cacheable.

Parameters:

  • klass (Class) —

    The class that is being cached.

  • attributes (Hash) —

    The attributes used to find a record.

  • key_attribute_names (Array) —

    List of attributes that can be used as a key in the cache.

  • case_sensitive (Boolean) —

    Indicator if string values are case-sensitive in the cache key.

Returns:

  • (String) 


237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/support_table_cache.rb', line 237

def cache_key(klass, attributes, key_attribute_names, case_sensitive)
  return nil if attributes.blank? || key_attribute_names.blank?

  sorted_names = attributes.keys.map(&:to_s).sort
  return nil unless sorted_names == key_attribute_names

  sorted_attributes = {}
  sorted_names.each do |attribute_name|
    value = (attributes[attribute_name] || attributes[attribute_name.to_sym])
    if !case_sensitive && (value.is_a?(String) || value.is_a?(Symbol))
      value = value.to_s.downcase
    end
    sorted_attributes[attribute_name] = value
  end

  [klass.name, sorted_attributes]
end

.disable(disabled = true, &block) ⇒ Object

Disable the caching behavior for all classes. If a block is specified, then caching is only disabled for that block. If no block is specified, then caching is disabled globally.

Parameters:

  • disabled (Boolean) (defaults to: true) —

    Caching will be disabled if this is true and enabled if false.

Yield Returns:

  • The return value of the block.



147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/support_table_cache.rb', line 147

def disable(disabled = true, &block)
  if block
    save_val = Thread.current.thread_variable_get(:support_table_cache_disabled)
    begin
      Thread.current.thread_variable_set(:support_table_cache_disabled, !!disabled)
    ensure
      Thread.current.thread_variable_set(:support_table_cache_disabled, save_val)
    end
  else
    @disabled = !!disabled
  end
end

.disabled? ⇒ Boolean

Return true if caching has been disabled.

Returns:

  • (Boolean) 


170
171
172
173
174
175
176
177
 
# File 'lib/support_table_cache.rb', line 170

def disabled?
  block_value = Thread.current.thread_variable_get(:support_table_cache_disabled)
  if block_value.nil?
    !!(defined?(@disabled) && @disabled)
  else
    block_value
  end
end

.enable(&block) ⇒ Object

Enable the caching behavior for all classes. If a block is specified, then caching is only enabled for that block. If no block is specified, then caching is enabled globally.

Yield Returns:

  • The return value of the block.



164
165
166
 
# File 'lib/support_table_cache.rb', line 164

def enable(&block)
  disable(false, &block)
end

.testing!(&block) ⇒ void

This method returns an undefined value.

Enter test mode for a block. New caches will be used within each test mode block. You can use this to wrap your test methods so that cached values from one test don’t show up in subsequent tests.



206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/support_table_cache.rb', line 206

def testing!(&block)
  save_val = Thread.current.thread_variable_get(:support_table_cache_test_cache)
  if save_val.nil?
    Thread.current.thread_variable_set(:support_table_cache_test_cache, MemoryCache.new)
  end
  begin
    yield
  ensure
    Thread.current.thread_variable_set(:support_table_cache_test_cache, save_val)
  end
end

.testing_cache ⇒ SupportTableCache::MemoryCache

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Get the current test mode cache. This will only return a value inside of a testing! block.

Returns:



222
223
224
225
226
 
# File 'lib/support_table_cache.rb', line 222

def testing_cache
  unless defined?(@cache) && @cache.nil?
    Thread.current.thread_variable_get(:support_table_cache_test_cache)
  end
end

Instance Method Details

#uncache ⇒ void

This method returns an undefined value.

Remove the cache entry for this record.



259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'lib/support_table_cache.rb', line 259

def uncache
  cache_by_attributes = self.class.support_table_cache_by_attributes
  return if cache_by_attributes.blank?

  cache = self.class.send(:current_support_table_cache)
  return if cache.nil?

  cache_by_attributes.each do |attribute_names, case_sensitive|
    attributes = {}
    attribute_names.each do |name|
      attributes[name] = self[name]
    end
    cache_key = SupportTableCache.cache_key(self.class, attributes, attribute_names, case_sensitive)
    cache.delete(cache_key)
  end
end