class ActiveSupport::Cache::MonetaStore

@api public

Public Class Methods

new(options = nil) click to toggle source
Calls superclass method
# File lib/active_support/cache/moneta_store.rb, line 5
def initialize(options = nil)
  raise ArgumentError, 'Option :store is required' unless @store = options.delete(:store)
  @store = ::Moneta.new(@store, expires: true) if Symbol === @store
  super(options)
  extend Strategy::LocalCache
end

Public Instance Methods

clear(options = nil) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 26
def clear(options = nil)
  options = merged_options(options)
  instrument(:clear, nil, nil) do
    @store.clear(moneta_options(options))
  end
end
decrement(key, amount = 1, options = nil) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 19
def decrement(key, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:decrement, key, amount: amount) do
    @store.increment(normalize_key(key, options), -amount, moneta_options(options))
  end
end
exist?(name, options = {}) click to toggle source

This prevents underlying Moneta transformers from erroring on raw values

Calls superclass method
# File lib/active_support/cache/moneta_store.rb, line 34
def exist?(name, options = {})
  super
rescue
  super(name, options.merge(raw: true))
end
fetch_multi(*names) { |name| ... } click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 45
def fetch_multi(*names)
  raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." \
    unless block_given?

  options = names.extract_options!
  options = merged_options(options)

  instrument :read_multi, names, options do |payload|
    read_multi_entries(names, options).tap do |results|
      payload[:hits] = results.keys
      payload[:super_operation] = :fetch_multi

      writes = {}

      (names - results.keys).each do |name|
        results[name] = writes[name] = yield(name)
      end

      write_multi writes, options
    end
  end
end
increment(key, amount = 1, options = nil) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 12
def increment(key, amount = 1, options = nil)
  options = merged_options(options)
  instrument(:increment, key, amount: amount) do
    @store.increment(normalize_key(key, options), amount, moneta_options(options))
  end
end
read_multi(*names) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 68
def read_multi(*names)
  options = names.extract_options!
  options = merged_options(options)

  instrument :read_multi, names, options do |payload|
    read_multi_entries(names, options).tap do |results|
      payload[:hits] = results.keys
    end
  end
end
write_multi(hash, options = nil) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 79
def write_multi(hash, options = nil)
  options = merged_options(options)

  instrument :write_multi, hash, options do
    entries = hash.each_with_object({}) do |(name, value), memo|
      memo[normalize_key(name, options)] = \
        Entry.new(value, options.merge(version: normalize_version(name, options)))
    end

    write_multi_entries entries, options
  end
end

Protected Instance Methods

delete_entry(key, **options) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 114
def delete_entry(key, **options)
  @store.delete(key, moneta_options(options))
  true
end
make_entry(value) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 95
def make_entry(value)
  case value
  when ActiveSupport::Cache::Entry, nil
    value
  else
    ActiveSupport::Cache::Entry.new(value)
  end
end
read_entry(key, **options) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 104
def read_entry(key, **options)
  make_entry(@store.load(key, moneta_options(options, false)))
end
read_multi_entries(names, **options) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 119
def read_multi_entries(names, **options)
  keys = names.map { |name| normalize_key(name, options) }
  entries = @store
    .values_at(*keys, **moneta_options(options, false))
    .map(&method(:make_entry))

  delete_options = moneta_options(options)
  names.zip(keys, entries).map do |name, key, entry|
    next if entry == nil
    @store.delete(key, delete_options) if entry.expired?
    next if entry.expired? || entry.mismatched?(normalize_version(name, options))

    [name, entry.value]
  end.compact.to_h
end
write_entry(key, entry, **options) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 108
def write_entry(key, entry, **options)
  value = options[:raw] ? entry.value.to_s : entry
  @store.store(key, value, moneta_options(options))
  true
end
write_multi_entries(hash, **options) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 135
def write_multi_entries(hash, **options)
  pairs = if options[:raw]
            hash.transform_values { |entry| entry.value.to_s }
          else
            hash
          end

  @store.merge!(pairs, moneta_options(options))
  hash
end

Private Instance Methods

moneta_options(options, include_expires = true) click to toggle source
# File lib/active_support/cache/moneta_store.rb, line 173
def moneta_options(options, include_expires = true)
  new_options = options ? options.dup : {}
  if new_options.include?(:expires_in) and include_expires
    new_options[:expires] = new_options.delete(:expires_in).to_r
  end
  new_options
end