moneta 1.2.0 → 1.4.2

data/lib/moneta/builder.rb

@@ -17,12 +17,12 @@ module Moneta
       adapter = @proxies.first
       if Array === adapter
         klass, options, block = adapter
-        adapter = new_proxy(klass, options, &block)
+        adapter = new_proxy(klass, options.dup, &block)
         check_arity(klass, adapter, 1)
       end
       @proxies[1..-1].inject([adapter]) do |result, proxy|
         klass, options, block = proxy
-        proxy = new_proxy(klass, result.last, options, &block)
+        proxy = new_proxy(klass, result.last, options.dup, &block)
         check_arity(klass, proxy, 2)
         result << proxy
       end

data/lib/moneta/create_support.rb

@@ -0,0 +1,21 @@
+module Moneta
+  # Implements simple create using key? and store.
+  #
+  # This is sufficient for non-shared stores or if atomicity is not required.
+  # @api private
+  module CreateSupport
+    # (see Defaults#create)
+    def create(key, value, options = {})
+      if key? key
+        false
+      else
+        store(key, value, options)
+        true
+      end
+    end
+
+    def self.included(base)
+      base.supports(:create) if base.respond_to?(:supports)
+    end
+  end
+end

data/lib/moneta/dbm_adapter.rb

@@ -0,0 +1,31 @@
+module Moneta
+  # This is for adapters that conform to the DBM interface
+  # @api private
+  module DBMAdapter
+    include HashAdapter
+
+    # (see Proxy#close)
+    def close
+      @backend.close
+      nil
+    end
+
+    # (see Proxy#merge!)
+    def merge!(pairs, options = {})
+      hash =
+        if block_given?
+          keys = pairs.map { |k, _| k }
+          old_pairs = Hash[slice(*keys)]
+          Hash[pairs.map do |key, new_value|
+            new_value = yield(key, old_pairs[key], new_value) if old_pairs.key?(key)
+            [key, new_value]
+          end.to_a]
+        else
+          Hash === pairs ? pairs : Hash[pairs.to_a]
+        end
+
+      @backend.update(hash)
+      self
+    end
+  end
+end

data/lib/moneta/{mixins.rb → defaults.rb}

@@ -1,58 +1,8 @@
 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
-
   # Simple interface to key/value stores with Hash-like interface.
   # @api public
   module Defaults
-    include OptionSupport
+    include ::Moneta::OptionSupport
 
     # @api private
     module ClassMethods
@@ -367,255 +317,4 @@ module Moneta
       features.include?(feature)
     end
   end
-
-  # 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
-
-  # @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
-
-  # This provides an each_key implementation that works in most cases.
-  # @api private
-  module EachKeySupport
-    def each_key
-      return enum_for(:each_key) unless block_given?
-
-      if @backend.respond_to?(:each_key)
-        @backend.each_key { |key| yield key }
-      elsif @backend.respond_to?(:keys)
-        if keys = @backend.keys
-          keys.each { |key| yield key }
-        end
-      elsif @backend.respond_to?(:each)
-        @backend.each { |key, _| yield key }
-      else
-        raise ::NotImplementedError, "No enumerable found on backend"
-      end
-
-      self
-    end
-
-    def self.included(base)
-      base.supports(:each_key) if base.respond_to?(:supports)
-    end
-  end
-
-  # Implements simple create using key? and store.
-  #
-  # This is sufficient for non-shared stores or if atomicity is not required.
-  # @api private
-  module CreateSupport
-    # (see Defaults#create)
-    def create(key, value, options = {})
-      if key? key
-        false
-      else
-        store(key, value, options)
-        true
-      end
-    end
-
-    def self.included(base)
-      base.supports(:create) if base.respond_to?(:supports)
-    end
-  end
-
-  # @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
-
-  # This is for adapters that conform to the DBM interface
-  # @api private
-  module DBMAdapter
-    include HashAdapter
-
-    # (see Proxy#close)
-    def close
-      @backend.close
-      nil
-    end
-
-    # (see Proxy#merge!)
-    def merge!(pairs, options = {})
-      hash =
-        if block_given?
-          keys = pairs.map { |k, _| k }
-          old_pairs = Hash[slice(*keys)]
-          Hash[pairs.map do |key, new_value|
-            new_value = yield(key, old_pairs[key], new_value) if old_pairs.key?(key)
-            [key, new_value]
-          end.to_a]
-        else
-          Hash === pairs ? pairs : Hash[pairs.to_a]
-        end
-
-      @backend.update(hash)
-      self
-    end
-  end
-
-  # This mixin handles the calculation of expiration times.
-  #
-  #
-  module ExpiresSupport
-    attr_accessor :default_expires
-
-    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 = @default_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 = @default_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)
-      end
-    end
-  end
 end

data/lib/moneta/each_key_support.rb

@@ -0,0 +1,27 @@
+module Moneta
+  # This provides an each_key implementation that works in most cases.
+  # @api private
+  module EachKeySupport
+    def each_key
+      return enum_for(:each_key) unless block_given?
+
+      if @backend.respond_to?(:each_key)
+        @backend.each_key { |key| yield key }
+      elsif @backend.respond_to?(:keys)
+        if keys = @backend.keys
+          keys.each { |key| yield key }
+        end
+      elsif @backend.respond_to?(:each)
+        @backend.each { |key, _| yield key }
+      else
+        raise ::NotImplementedError, "No enumerable found on backend"
+      end
+
+      self
+    end
+
+    def self.included(base)
+      base.supports(:each_key) if base.respond_to?(:supports)
+    end
+  end
+end

data/lib/moneta/expires_support.rb

@@ -0,0 +1,60 @@
+module Moneta
+  # This mixin handles the calculation of expiration times.
+  #
+  #
+  module ExpiresSupport
+    attr_accessor :default_expires
+
+    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 = @default_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 = @default_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)
+      end
+    end
+  end
+end