class Moneta::Adapters::Memcached

Memcached backend (using gem dalli) @api public

Public Instance Methods

clear(options = {}) click to toggle source

(see Proxy#clear)

# File lib/moneta/adapters/memcached/dalli.rb, line 61
def clear(options = {})
  backend.flush_all
  self
end
close() click to toggle source

(see Proxy#close)

# File lib/moneta/adapters/memcached/dalli.rb, line 72
def close
  backend.close
  nil
end
create(key, value, options = {}) click to toggle source

(see Defaults#create)

# File lib/moneta/adapters/memcached/dalli.rb, line 67
def create(key, value, options = {})
  !!backend.add(key, value, expires_value(options) || nil, raw: true)
end
delete(key, options = {}) click to toggle source

(see Proxy#delete)

# File lib/moneta/adapters/memcached/dalli.rb, line 37
def delete(key, options = {})
  value = backend.get(key)
  backend.delete(key)
  value
end
increment(key, amount = 1, options = {}) click to toggle source

(see Proxy#increment)

# File lib/moneta/adapters/memcached/dalli.rb, line 44
def increment(key, amount = 1, options = {})
  result =
    if amount >= 0
      backend.incr(key, amount, expires_value(options) || nil)
    else
      backend.decr(key, -amount, expires_value(options) || nil)
    end
  if result
    result
  elsif create(key, amount.to_s, options)
    amount
  else
    increment(key, amount, options)
  end
end
load(key, options = {}) click to toggle source

(see Proxy#load)

# File lib/moneta/adapters/memcached/dalli.rb, line 21
def load(key, options = {})
  value = backend.get(key)
  if value
    expires = expires_value(options, nil)
    backend.set(key, value, expires || nil, raw: true) if expires != nil
    value
  end
end
merge!(pairs, options = {}) { |key, old_pairs, new_value| ... } click to toggle source

(see Defaults#merge!)

# File lib/moneta/adapters/memcached/dalli.rb, line 100
def merge!(pairs, options = {})
  expires = expires_value(options)
  expires = expires.to_i if Numeric === expires
  expires ||= nil

  if block_given?
    keys = pairs.map { |key, _| key }.to_a
    old_pairs = backend.get_multi(keys)
    pairs = pairs.map do |key, new_value|
      if old_pairs.key? key
        new_value = yield(key, old_pairs[key], new_value)
      end
      [key, new_value]
    end
  end

  backend.multi do
    pairs.each do |key, value|
      backend.set(key, value, expires, raw: true)
    end
  end

  self
end
slice(*keys, **options) click to toggle source

(see Defaults#slice)

# File lib/moneta/adapters/memcached/dalli.rb, line 78
def slice(*keys, **options)
  backend.get_multi(keys).tap do |pairs|
    next if pairs.empty?
    expires = expires_value(options, nil)
    next if expires == nil
    expires = expires.to_i if Numeric === expires
    expires ||= 0
    backend.multi do
      pairs.each do |key, value|
        backend.set(key, value, expires, false)
      end
    end
  end
end
store(key, value, options = {}) click to toggle source

(see Proxy#store)

# File lib/moneta/adapters/memcached/dalli.rb, line 31
def store(key, value, options = {})
  backend.set(key, value, expires_value(options) || nil, raw: true)
  value
end
values_at(*keys, **options) click to toggle source

(see Defaults#values_at)

# File lib/moneta/adapters/memcached/dalli.rb, line 94
def values_at(*keys, **options)
  pairs = slice(*keys, **options)
  keys.map { |key| pairs.delete(key) }
end