module Moneta::Defaults
Simple interface to key/value stores with Hash-like interface. @api public
Public Class Methods
# File lib/moneta/defaults.rb, line 50 def self.included(base) base.extend(ClassMethods) end
Public Instance Methods
Fetch value with key. Return nil if the key doesn’t exist
@param [Object] key @return [Object] value @api public
# File lib/moneta/defaults.rb, line 145 def [](key) load(key) end
Store value with key
@param [Object] key @param [Object] value @return value @api public
# File lib/moneta/defaults.rb, line 155 def []=(key, value) store(key, value) end
Explicitly close the store @return nil @api public
# File lib/moneta/defaults.rb, line 104 def close; end
Atomically sets a key to value if it’s not set.
@note Not every Moneta
store implements this method,
a NotImplementedError is raised if it is not supported.
@param [Object] key @param [Object] value @param [Hash] options @option options [Integer] :expires Update expiration time (See {Expires}) @option options [Boolean] :raw Raw access without value transformation (See {Transformer}) @option options [String] :prefix Prefix key (See {Transformer}) @return [Boolean] key was set @api public
# File lib/moneta/defaults.rb, line 189 def create(key, value, options = {}) raise NotImplementedError, 'create is not supported' end
Atomically decrement integer value with key
This is just syntactic sugar for calling increment
with a negative value.
This method also accepts negative amounts.
@param [Object] key @param [Integer] amount @param [Hash] options @option options [String] :prefix Prefix key (See {Transformer}) @option options Other options as defined by the adapters or middleware @return [Object] value from store @api public
# File lib/moneta/defaults.rb, line 97 def decrement(key, amount = 1, options = {}) increment(key, -amount, options) end
Calls block once for each key in store, passing the key as a parameter. If no block is given, an enumerator is returned instead.
@note Not every Moneta
store implements this method,
a NotImplementedError is raised if it is not supported.
@overload each_key
@return [Enumerator] An all-the-keys enumerator
@overload each_key
@yieldparam key [Object] Each key is yielded to the supplied block @return [self]
@api public
# File lib/moneta/defaults.rb, line 173 def each_key raise NotImplementedError, 'each_key is not supported' end
Returns features list
@return [Array<Symbol>] list of features
# File lib/moneta/defaults.rb, line 309 def features self.class.features end
Fetch a value with a key
@overload fetch(key, options = {}, &block)
retrieve a key. if the key is not available, execute the block and return its return value. @param [Object] key @param [Hash] options @option options [Integer] :expires Update expiration time (See {Expires}) @option options [Boolean] :raw Raw access without value transformation (See {Transformer}) @option options [String] :prefix Prefix key (See {Transformer}) @return [Object] value from store
@overload fetch(key, default, options = {})
retrieve a key. if the key is not available, return the default value. @param [Object] key @param [Object] default Default value @param [Hash] options @option options [Integer] :expires Update expiration time (See {Expires}) @option options [Boolean] :raw Raw access without value transformation (See {Transformer}) @option options [String] :prefix Prefix key (See {Transformer}) @return [Object] value from store
@api public
# File lib/moneta/defaults.rb, line 129 def fetch(key, default = nil, options = nil) if block_given? raise ArgumentError, 'Only one argument accepted if block is given' if options result = load(key, default || {}) result == nil ? yield(key) : result else result = load(key, options || {}) result == nil ? default : result end end
Behaves identically to {#values_at} except that it accepts an optional block. When supplied, the block will be called successively with each supplied key that is not present in the store. The return value of the block call will be used in place of nil in returned the array of values.
@note Some adapters may implement this method atomically. The default
implmentation uses {#values_at}.
@overload fetch_values
(*keys, **options)
@param (see #values_at) @option options (see #values_at) @return (see #values_at)
@overload fetch_values
(*keys, **options)
@param (see #values_at) @option options (see #values_at) @yieldparam key [Object] Each key that is not found in the store @yieldreturn [Object, nil] The value to substitute for the missing one @return [Array<Object, nil>] Array containing the values requested, or where keys are missing, the return values from the corresponding block calls
@api public
# File lib/moneta/defaults.rb, line 231 def fetch_values(*keys, **options) values = values_at(*keys, **options) return values unless block_given? keys.zip(values).map do |key, value| if value == nil yield key else value end end end
Atomically increment integer value with key
This method also accepts negative amounts.
@note Not every Moneta
store implements this method,
a NotImplementedError is raised if it is not supported.
@param [Object] key @param [Integer] amount @param [Hash] options @option options [String] :prefix Prefix key (See {Transformer}) @option options Other options as defined by the adapters or middleware @return [Object] value from store @api public
# File lib/moneta/defaults.rb, line 80 def increment(key, amount = 1, options = {}) raise NotImplementedError, 'increment is not supported' end
Exists the value with key
@param [Object] key @param [Hash] options @option options [Integer] :expires Update expiration time (See {Expires}) @option options [String] :prefix Prefix key (See {Transformer}) @option options Other options as defined by the adapters or middleware @return [Boolean] @api public
# File lib/moneta/defaults.rb, line 63 def key?(key, options = {}) load(key, options) != nil end
Stores the pairs in the key-value store, and returns itself. When a block is provided, it will be called before overwriting any existing values with the key, old value and supplied value, and the return value of the block will be used in place of the supplied value.
@note Some adapters may implement this method atomically, or in two passes
when a block is provided. The default implmentation uses {#key?}, {#load} and {#store}.
@overload merge!(pairs, options={})
@param [<(Object, Object)>] pairs A collection of key-value pairs to store @param [Hash] options @option options (see Proxy#store) @return [self]
@overload merge!(pairs, options={})
@param [<(Object, Object)>] pairs A collection of key-value pairs to store @param [Hash] options @option options (see Proxy#store) @yieldparam key [Object] A key that whose value is being overwritten @yieldparam old_value [Object] The existing value which is being overwritten @yieldparam new_value [Object] The value supplied in the method call @yieldreturn [Object] The value to use for overwriting @return [self]
@api public
# File lib/moneta/defaults.rb, line 290 def merge!(pairs, options = {}) pairs.each do |key, value| if block_given? existing = load(key, options) value = yield(key, existing, value) unless existing == nil end store(key, value, options) end self end
Returns a collection of key-value pairs corresponding to those supplied keys which are present in the key-value store, and their associated values. Only those keys present in the store will have pairs in the return value. The return value can be any enumerable object that yields pairs, so it could be a hash, but needn’t be.
@note The keys in the return value may be the same objects that were
supplied (i.e. {Object#equal?}), or may simply be equal (i.e. {Object#==}).
@note Some adapters may implement this method atomically. The default
implmentation uses {#values_at}.
@param (see values_at
) @option options (see values_at
) @return [<(Object, Object)>] A collection of key-value pairs @api public
# File lib/moneta/defaults.rb, line 260 def slice(*keys, **options) keys.zip(values_at(*keys, **options)).reject do |_, value| value == nil end end
Return true if adapter supports the given feature.
@return [Boolean]
# File lib/moneta/defaults.rb, line 316 def supports?(feature) features.include?(feature) end
(see merge!
)
# File lib/moneta/defaults.rb, line 302 def update(pairs, options = {}, &block) merge!(pairs, options, &block) end
Returns an array containing the values associated with the given keys, in the same order as the supplied keys. If a key is not present in the key-value-store, nil is returned in its place.
@note Some adapters may implement this method atomically, but the default
implementation simply makes repeated calls to {#load}.
@param keys [<Object>] The keys for the values to fetch @param options [Hash] @option options (see Proxy#load
) @return [Array<Object, nil>] Array containing the values requested, with
nil for missing values
@api public
# File lib/moneta/defaults.rb, line 206 def values_at(*keys, **options) keys.map { |key| load(key, options) } end