moneta 1.0.0 → 1.5.1

data/lib/moneta/enumerable.rb

@@ -0,0 +1,38 @@
+module Moneta
+  # Adds the Ruby {Enumerable} API to the store.  The underlying store must
+  # support `:each_key`.
+  #
+  # @example Adding to a builder
+  #   Moneta.build do
+  #     # It should be the top middleware
+  #     use :Enumerable
+  #     adapter :DBM
+  #   end
+  #
+  # @api public
+  class Enumerable < Proxy
+    include ::Enumerable
+
+    def initialize(adapter, options = {})
+      raise "Adapter must support :each_key" unless adapter.supports? :each_key
+      super
+    end
+
+    # Enumerate over all pairs in the store
+    #
+    # @overload each
+    #   @return [Enumerator]
+    #
+    # @overload each
+    #   @yieldparam pair [Array<(Object, Object)>] Each pair is yielded
+    #   @return [self]
+    #
+    def each
+      return enum_for(:each) unless block_given?
+      each_key { |key| yield key, load(key) }
+      self
+    end
+
+    alias each_pair each
+  end
+end

data/lib/moneta/expires.rb

@@ -14,21 +14,20 @@ module Moneta
     def initialize(adapter, options = {})
       raise 'Store already supports feature :expires' if adapter.supports?(:expires)
       super
-      self.default_expires = options[:expires]
     end
 
     # (see Proxy#key?)
     def key?(key, options = {})
       # Transformer might raise exception
       load_entry(key, options) != nil
-    rescue Exception
+    rescue
       super(key, Utils.without(options, :expires))
     end
 
     # (see Proxy#load)
     def load(key, options = {})
       return super if options.include?(:raw)
-      value, expires = load_entry(key, options)
+      value, = load_entry(key, options)
       value
     end
 
@@ -44,7 +43,7 @@ module Moneta
     def delete(key, options = {})
       return super if options.include?(:raw)
       value, expires = super
-      value if !expires || Time.now.to_i <= expires
+      value if !expires || Time.now <= Time.at(expires)
     end
 
     # (see Proxy#store)
@@ -54,34 +53,136 @@ module Moneta
       @adapter.create(key, new_entry(value, expires), Utils.without(options, :expires))
     end
 
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+      with_updates(options) do |updates|
+        keys.zip(@adapter.values_at(*keys, **options)).map do |key, entry|
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          next if entry == nil
+          value, = entry
+          value
+        end
+      end
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+      substituted = {}
+      block = if block_given?
+                lambda do |key|
+                  substituted[key] = true
+                  yield key
+                end
+              end
+
+      with_updates(options) do |updates|
+        keys.zip(@adapter.fetch_values(*keys, **options, &block)).map do |key, entry|
+          next entry if substituted[key]
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          if entry == nil
+            value = if block_given?
+                      yield key
+                    end
+          else
+            value, = entry
+          end
+          value
+        end
+      end
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      return super if options.include?(:raw)
+      new_expires = expires_at(options, nil)
+      options = Utils.without(options, :expires)
+
+      with_updates(options) do |updates|
+        @adapter.slice(*keys, **options).map do |key, entry|
+          entry = invalidate_entry(key, entry, new_expires) do |new_entry|
+            updates[key] = new_entry
+          end
+          next if entry == nil
+          value, = entry
+          [key, value]
+        end.reject(&:nil?)
+      end
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options = {})
+      expires = expires_at(options)
+      options = Utils.without(options, :expires)
+
+      block = if block_given?
+                lambda do |key, old_entry, entry|
+                  old_entry = invalidate_entry(key, old_entry)
+                  if old_entry == nil
+                    entry # behave as if no replace is happening
+                  else
+                    old_value, = old_entry
+                    new_value, = entry
+                    new_entry(yield(key, old_value, new_value), expires)
+                  end
+                end
+              end
+
+      entry_pairs = pairs.map do |key, value|
+        [key, new_entry(value, expires)]
+      end
+      @adapter.merge!(entry_pairs, options, &block)
+      self
+    end
+
     private
 
     def load_entry(key, options)
       new_expires = expires_at(options, nil)
       options = Utils.without(options, :expires)
       entry = @adapter.load(key, options)
+      invalidate_entry(key, entry, new_expires) do |new_entry|
+        @adapter.store(key, new_entry, options)
+      end
+    end
+
+    def invalidate_entry(key, entry, new_expires = nil)
       if entry != nil
         value, expires = entry
-        if expires && Time.now.to_i > expires
+        if expires && Time.now > Time.at(expires)
           delete(key)
-          nil
+          entry = nil
         elsif new_expires != nil
-          @adapter.store(key, new_entry(value, new_expires), options)
-          entry
-        else
-          entry
+          yield new_entry(value, new_expires) if block_given?
         end
       end
+      entry
     end
 
     def new_entry(value, expires)
       if expires
-        [value, expires.to_i]
+        [value, expires.to_r]
       elsif Array === value || value == nil
         [value]
       else
         value
       end
     end
+
+    def with_updates(options)
+      updates = {}
+      yield(updates).tap do
+        @adapter.merge!(updates, options) unless updates.empty?
+      end
+    end
   end
 end

data/lib/moneta/expires_support.rb

@@ -0,0 +1,59 @@
+module Moneta
+  # This mixin handles the calculation of expiration times.
+  #
+  #
+  module ExpiresSupport
+    protected
+
+    # Calculates the time when something will expire.
+    #
+    # This method considers false and 0 as "no-expire" and every positive
+    # number as a time to live in seconds.
+    #
+    # @param [Hash] options Options hash
+    # @option options [0,false,nil,Numeric] :expires expires value given by user
+    # @param [0,false,nil,Numeric] default default expiration time
+    #
+    # @return [false] if it should not expire
+    # @return [Time] the time when something should expire
+    # @return [nil] if it is not known
+    def expires_at(options, default = config.expires)
+      value = expires_value(options, default)
+      Numeric === value ? Time.now + value : value
+    end
+
+    # Calculates the number of seconds something should last.
+    #
+    # This method considers false and 0 as "no-expire" and every positive
+    # number as a time to live in seconds.
+    #
+    # @param [Hash] options Options hash
+    # @option options [0,false,nil,Numeric] :expires expires value given by user
+    # @param [0,false,nil,Numeric] default default expiration time
+    #
+    # @return [false] if it should not expire
+    # @return [Numeric] seconds until expiration
+    # @return [nil] if it is not known
+    def expires_value(options, default = config.expires)
+      case value = options[:expires]
+      when 0, false
+        false
+      when nil
+        default ? default.to_r : nil
+      when Numeric
+        value = value.to_r
+        raise ArgumentError, ":expires must be a positive value, got #{value}" if value < 0
+        value
+      else
+        raise ArgumentError, ":expires must be Numeric or false, got #{value.inspect}"
+      end
+    end
+
+    class << self
+      def included(base)
+        base.supports(:expires) if base.respond_to?(:supports)
+        base.config :expires
+      end
+    end
+  end
+end

data/lib/moneta/fallback.rb

@@ -0,0 +1,84 @@
+module Moneta
+  # Provides a fallback to a second store when an exception is raised
+  #
+  # @example Basic usage - catches any {IOError} and falls back to {Moneta::Adapters:Null}
+  #   Moneta.build do
+  #     use :Fallback
+  #     adapter :Client
+  #   end
+  #
+  # @example Specifying an exception to rescue
+  #   Moneta.build do
+  #     use :Fallback, rescue: Redis::CannotConnectError
+  #     adapter :Redis
+  #   end
+  #
+  # @example Specifying a different fallback
+  #   Moneta.build do
+  #     use :Fallback do
+  #       # This is a new builder context
+  #       adapter :Memory
+  #     end
+  #     adapter :File, dir: 'cache'
+  #   end
+  #
+  # @api public
+  class Fallback < Wrapper
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    # @option options [Moneta store] :fallback (:Null store) The store to fall
+    #   back on
+    # @option options [Class|Array<Class>] :rescue ([IOError]) The list
+    #   of exceptions that should be rescued
+    # @yieldreturn [Moneta store] Moneta store built using the builder API
+    def initialize(adapter, options = {}, &block)
+      super
+
+      @fallback =
+        if block_given?
+          ::Moneta.build(&block)
+        elsif options.key?(:fallback)
+          options.delete(:fallback)
+        else
+          ::Moneta::Adapters::Null.new
+        end
+
+      @rescue =
+        case options[:rescue]
+        when nil
+          [::IOError]
+        when Array
+          options[:rescue]
+        else
+          [options[:rescue]]
+        end
+    end
+
+    protected
+
+    def wrap(name, *args, &block)
+      yield
+    rescue => e
+      raise unless @rescue.any? { |rescuable| rescuable === e }
+      fallback(name, *args, &block)
+    end
+
+    def fallback(name, *args, &block)
+      result =
+        case name
+        when :values_at, :fetch_values, :slice
+          keys, options = args
+          @fallback.public_send(name, *keys, **options, &block)
+        else
+          @fallback.public_send(name, *args, &block)
+        end
+
+      # Don't expose the fallback class to the caller
+      if result == @fallback
+        self
+      else
+        result
+      end
+    end
+  end
+end

data/lib/moneta/hash_adapter.rb

@@ -0,0 +1,68 @@
+module Moneta
+  # @api private
+  module HashAdapter
+    attr_reader :backend
+
+    # (see Proxy#key?)
+    def key?(key, options = {})
+      @backend.has_key?(key)
+    end
+
+    # (see Proxy#load)
+    def load(key, options = {})
+      @backend[key]
+    end
+
+    # (see Proxy#store)
+    def store(key, value, options = {})
+      @backend[key] = value
+    end
+
+    # (see Proxy#delete)
+    def delete(key, options = {})
+      @backend.delete(key)
+    end
+
+    # (see Proxy#clear)
+    def clear(options = {})
+      @backend.clear
+      self
+    end
+
+    # (see Defaults#values_at)
+    def values_at(*keys, **options)
+      return super unless @backend.respond_to? :values_at
+      @backend.values_at(*keys)
+    end
+
+    # (see Defaults#fetch_values)
+    def fetch_values(*keys, **options, &defaults)
+      return super unless @backend.respond_to? :fetch_values
+      defaults ||= {} # prevents KeyError
+      @backend.fetch_values(*keys, &defaults)
+    end
+
+    # (see Defaults#slice)
+    def slice(*keys, **options)
+      return super unless @backend.respond_to? :slice
+      @backend.slice(*keys)
+    end
+
+    # (see Defaults#merge!)
+    def merge!(pairs, options = {}, &block)
+      return super unless method = [:merge!, :update].find do |method|
+        @backend.respond_to? method
+      end
+
+      hash = Hash === pairs ? pairs : Hash[pairs.to_a]
+      case method
+      when :merge!
+        @backend.merge!(hash, &block)
+      when :update
+        @backend.update(hash, &block)
+      end
+
+      self
+    end
+  end
+end

data/lib/moneta/increment_support.rb

@@ -0,0 +1,16 @@
+module Moneta
+  # @api private
+  module IncrementSupport
+    # (see Defaults#increment)
+    def increment(key, amount = 1, options = {})
+      existing = load(key, options)
+      value = (existing == nil ? 0 : Integer(existing)) + amount
+      store(key, value.to_s, options)
+      value
+    end
+
+    def self.included(base)
+      base.supports(:increment) if base.respond_to?(:supports)
+    end
+  end
+end

data/lib/moneta/lock.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require 'set'
 
 module Moneta
   # Locks the underlying stores with a Mutex
@@ -14,8 +14,32 @@ module Moneta
 
     protected
 
-    def wrap(*args, &block)
+    def wrap(name, *args, &block)
+      self.locks ||= Set.new
+      if locked?
+        yield
+      else
+        lock!(&block)
+      end
+    end
+
+    def locks=(locks)
+      Thread.current.thread_variable_set('Moneta::Lock', locks)
+    end
+
+    def locks
+      Thread.current.thread_variable_get('Moneta::Lock')
+    end
+
+    def lock!(&block)
+      locks << @lock
       @lock.synchronize(&block)
+    ensure
+      locks.delete @lock
+    end
+
+    def locked?
+      locks.include? @lock
     end
   end
 end

data/lib/moneta/logger.rb

@@ -29,7 +29,7 @@ module Moneta
       def format(entry)
         args = entry[:args]
         args.pop if Hash === args.last && args.last.empty?
-        args = args.map {|a| dump(a) }.join(', ')
+        args = args.map { |a| dump(a) }.join(', ')
         if entry[:error]
           "#{@prefix}#{entry[:method]}(#{args}) raised error: #{entry[:error].message}\n"
         else
@@ -66,7 +66,7 @@ module Moneta
       ret = yield
       @logger.log(method: method, args: args, return: (method == :clear ? 'self' : ret))
       ret
-    rescue Exception => error
+    rescue => error
       @logger.log(method: method, args: args, error: error)
       raise
     end

data/lib/moneta/nil_values.rb

@@ -0,0 +1,35 @@
+module Moneta
+  # This contains overrides of methods in Defaults where additional nil
+  # checks are required, because nil values are possible in the store.
+  # @api private
+  module NilValues
+    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 && !key?(key)
+          yield key
+        else
+          value
+        end
+      end
+    end
+
+    def slice(*keys, **options)
+      keys.zip(values_at(*keys, **options)).reject do |key, value|
+        value == nil && !key?(key)
+      end
+    end
+
+    def merge!(pairs, options = {})
+      pairs.each do |key, value|
+        if block_given? && key?(key, options)
+          existing = load(key, options)
+          value = yield(key, existing, value)
+        end
+        store(key, value, options)
+      end
+      self
+    end
+  end
+end

data/lib/moneta/option_support.rb

@@ -0,0 +1,51 @@
+module Moneta
+  # @api private
+  module OptionSupport
+    # Return Moneta store with default options or additional proxies
+    #
+    # @param [Hash] options Options to merge
+    # @return [Moneta store]
+    #
+    # @api public
+    def with(options = nil, &block)
+      adapter = self
+      if block
+        builder = Builder.new(&block)
+        builder.adapter(adapter)
+        adapter = builder.build.last
+      end
+      options ? OptionMerger.new(adapter, options) : adapter
+    end
+
+    # Return Moneta store with default option raw: true
+    #
+    # @return [OptionMerger]
+    # @api public
+    def raw
+      @raw ||=
+        begin
+          store = with(raw: true, only: [:load, :store, :create, :delete])
+          store.instance_variable_set(:@raw, store)
+          store
+        end
+    end
+
+    # Return Moneta store with default prefix option
+    #
+    # @param [String] prefix Key prefix
+    # @return [OptionMerger]
+    # @api public
+    def prefix(prefix)
+      with(prefix: prefix, except: :clear)
+    end
+
+    # Return Moneta store with default expiration time
+    #
+    # @param [Integer] expires Default expiration time
+    # @return [OptionMerger]
+    # @api public
+    def expires(expires)
+      with(expires: expires, only: [:store, :create, :increment])
+    end
+  end
+end

data/lib/moneta/optionmerger.rb

@@ -40,4 +40,3 @@ module Moneta
     end
   end
 end
-