moneta 1.1.1 → 1.4.1

data/lib/moneta/adapters/tokyotyrant.rb

@@ -48,7 +48,7 @@ module Moneta
       def load(key, options = {})
         value = @backend[key]
         # raise if there is an error and the error is not "no record"
-        error if value.nil? && @backend.ecode != ENOREC
+        error if value == nil && @backend.ecode != ENOREC
         value && unpack(value)
       end
 

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
@@ -79,5 +79,4 @@ Please check your Moneta builder block:
 }) if args != expected
     end
   end
-
 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_store ||=
-        begin
-          store = with(raw: true, only: [:load, :store, :create, :delete])
-          store.instance_variable_set(:@raw_store, 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
@@ -151,8 +101,7 @@ module Moneta
     # Explicitly close the store
     # @return nil
     # @api public
-    def close
-    end
+    def close; end
 
     # Fetch a value with a key
     #
@@ -338,7 +287,7 @@ module Moneta
     #   @yieldreturn [Object] The value to use for overwriting
     #   @return [self]
     # @api public
-    def merge!(pairs, options={})
+    def merge!(pairs, options = {})
       pairs.each do |key, value|
         if block_given?
           existing = load(key, options)
@@ -368,252 +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 = {})
-      value = Utils.to_int(load(key, options)) + 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
-
-    def self.included(base)
-      base.supports(:expires) if base.respond_to?(:supports)
-    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/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