moneta 0.7.1 → 0.7.2

data/lib/moneta/expires.rb

@@ -6,8 +6,6 @@ module Moneta
   #
   # @api public
   class Expires < Proxy
-    # Constructor
-    #
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
     # @option options [String] :expires Default expiration time
@@ -17,7 +15,11 @@ module Moneta
     end
 
     def key?(key, options = {})
+      # Transformer might raise exception
       load_entry(key, options) != nil
+    rescue Exception
+      options.include?(:expires) && (options = options.dup; options.delete(:expires))
+      super(key, options)
     end
 
     def load(key, options = {})
@@ -28,10 +30,13 @@ module Moneta
 
     def store(key, value, options = {})
       return super if options.include?(:raw)
-      if expires = (options.delete(:expires) || @expires)
+      expires = options.include?(:expires) && (options = options.dup; options.delete(:expires))
+      if expires ||= @expires
         super(key, [value, Time.now.to_i + expires], options)
-      else
+      elsif Array === value || value == nil
         super(key, [value], options)
+      else
+        super(key, value, options)
       end
       value
     end
@@ -45,8 +50,9 @@ module Moneta
     private
 
     def load_entry(key, options)
-      new_expires = options.delete(:expires)
-      if entry = @adapter.load(key, options)
+      new_expires = options.include?(:expires) && (options = options.dup; options.delete(:expires))
+      entry = @adapter.load(key, options)
+      if entry != nil
         value, expires = entry
         if expires && Time.now.to_i > expires
           delete(key)

data/lib/moneta/lock.rb

@@ -4,8 +4,6 @@ module Moneta
   # Locks the underlying stores with a Mutex
   # @api public
   class Lock < Wrapper
-    # Constructor
-    #
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
     # @option options [String] :mutex (Mutex.new) Mutex object

data/lib/moneta/logger.rb

@@ -33,8 +33,6 @@ module Moneta
       end
     end
 
-    # Constructor
-    #
     # @param [Moneta store] adapter The underlying store
     # @param [Hash] options
     # @option options [Object] :logger (Moneta::Logger::Format) Callable logger object

data/lib/moneta/mixins.rb

@@ -1,65 +1,193 @@
 module Moneta
   # @api private
-  module Mixins
-    module WithOptions
-      def with(options)
-        OptionMerger.new(self, options)
-      end
+  module OptionSupport
+    # @api public
+    def with(options)
+      OptionMerger.new(self, options)
+    end
 
-      def raw
-        @raw_store ||=
-          begin
-            store = with(:raw => true, :only => [:load, :store, :delete])
-            store.instance_variable_set(:@raw_store, store)
-            store
-          end
-      end
+    # @api public
+    def raw
+      @raw_store ||=
+        begin
+          store = with(:raw => true, :only => [:load, :store, :delete])
+          store.instance_variable_set(:@raw_store, store)
+          store
+        end
+    end
 
-      def prefix(prefix)
-        with(:prefix => prefix, :except => :clear)
-      end
+    # @api public
+    def prefix(prefix)
+      with(:prefix => prefix, :except => :clear)
+    end
 
-      def expires(expires)
-        with(:expires => expires, :only => [:store, :increment])
-      end
+    # @api public
+    def expires(expires)
+      with(:expires => expires, :only => [:store, :increment])
     end
+  end
 
-    module IncrementSupport
-      def increment(key, amount = 1, options = {})
-        value = load(key, options)
-        intvalue = value.to_i
-        raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
-        intvalue += amount
-        store(key, intvalue.to_s, options)
-        intvalue
-      end
+  # Simple interface to key/value stores with Hash-like interface.
+  # @api public
+  module Defaults
+    include OptionSupport
+
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      load(key, options) != nil
     end
 
-    module HashAdapter
-      def initialize(options = {})
-        @hash = {}
-      end
+    # Atomically increment integer value with key
+    #
+    # Not every Moneta store implements this method,
+    # a NotImplementedError if it is not supported.
+    #
+    # This method also accepts negative amounts.
+    #
+    # @param [Object] key
+    # @param [Integer] amount
+    # @param [Hash] options
+    # @return [Object] value from store
+    # @api public
+    def increment(key, amount = 1, options = {})
+      raise NotImplementedError, 'increment is not supported'
+    end
 
-      def key?(key, options = {})
-        @hash.has_key?(key)
-      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
+    # @return [Object] value from store
+    # @api public
+    def decrement(key, amount = 1, options = {})
+      increment(key, -amount, options)
+    end
 
-      def load(key, options = {})
-        @hash[key]
-      end
+    # Explicitly close the store
+    # @return nil
+    # @api public
+    def close
+    end
 
-      def store(key, value, options = {})
-        @hash[key] = value
+    # 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
+    #   @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
+    #   @return [Object] value from store
+    #
+    # @api public
+    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
 
-      def delete(key, options = {})
-        @hash.delete(key)
-      end
+    # Fetch value with key. Return nil if the key doesn't exist
+    #
+    # @param [Object] key
+    # @return [Object] value
+    # @api public
+    def [](key)
+      load(key)
+    end
 
-      def clear(options = {})
-        @hash.clear
-        self
-      end
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return value
+    # @api public
+    def []=(key, value)
+      store(key, value)
+    end
+  end
+
+  # @api private
+  module IncrementSupport
+    # (see Defaults#increment)
+    # @api public
+    def increment(key, amount = 1, options = {})
+      value = load(key, options)
+      intvalue = value.to_i
+      raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
+      intvalue += amount
+      store(key, intvalue.to_s, options)
+      intvalue
+    end
+  end
+
+  # @api private
+  module HashAdapter
+    # (see Proxy#key?)
+    def key?(key, options = {})
+      @hash.has_key?(key)
+    end
+
+    # (see Proxy#load)
+    def load(key, options = {})
+      @hash[key]
+    end
+
+    # (see Proxy#store)
+    def store(key, value, options = {})
+      @hash[key] = value
+    end
+
+    # (see Proxy#delete)
+    def delete(key, options = {})
+      @hash.delete(key)
+    end
+
+    # (see Proxy#clear)
+    def clear(options = {})
+      @hash.clear
+      self
+    end
+  end
+
+  # @api private
+  module Net
+    DEFAULT_PORT = 9000
+
+    class Error < RuntimeError; end
+
+    def pack(o)
+      s = Marshal.dump(o)
+      [s.bytesize].pack('N') << s
+    end
+
+    def read(io)
+      size = io.read(4).unpack('N').first
+      Marshal.load(io.read(size))
+    end
+
+    def write(io, o)
+      io.write(pack(o))
     end
   end
 end

data/lib/moneta/optionmerger.rb

@@ -29,6 +29,8 @@ module Moneta
       end
     end
 
+    protected
+
     def wrap(method, *args)
       options = args.last
       options.merge!(@default_options[method]) if Hash === options && @default_options.include?(method)

data/lib/moneta/proxy.rb

@@ -1,27 +1,32 @@
 module Moneta
   # Proxy base class
   # @api public
-  class Proxy < Base
+  class Proxy
+    include Defaults
+
     attr_reader :adapter
 
-    # Constructor
-    #
     # @param [Moneta store] adapter underlying adapter
     # @param [Hash] options
     def initialize(adapter, options = {})
       @adapter = adapter
     end
 
-    # Exists the value with key
-    #
-    # @param [Object] key
-    # @return [Boolean]
-    # @param [Hash] options
-    # @api public
+    # (see Defaults#key?)
     def key?(key, options = {})
       @adapter.key?(key, options)
     end
 
+    # (see Defaults#increment)
+    def increment(key, amount = 1, options = {})
+      @adapter.increment(key, amount, options)
+    end
+
+    # (see Defaults#close)
+    def close
+      @adapter.close
+    end
+
     # Fetch value with key. Return nil if the key doesn't exist
     #
     # @param [Object] key
@@ -53,20 +58,6 @@ module Moneta
       @adapter.delete(key, options)
     end
 
-    # Atomically increment integer value with key
-    #
-    # Not every Moneta store implements this method,
-    # a NotImplementedError if it is not supported.
-    #
-    # @param [Object] key
-    # @param [Integer] amount
-    # @param [Hash] options
-    # @return [Object] value from store
-    # @api public
-    def increment(key, amount = 1, options = {})
-      @adapter.increment(key, amount, options)
-    end
-
     # Clear all keys in this store
     #
     # @param [Hash] options
@@ -76,12 +67,5 @@ module Moneta
       @adapter.clear(options)
       self
     end
-
-    # Close this store
-    # @return nil
-    # @api public
-    def close
-      @adapter.close
-    end
   end
 end

data/lib/moneta/server.rb

@@ -4,8 +4,6 @@ module Moneta
   # Moneta server
   # @api public
   class Server
-    # Constructor
-    #
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :file Alternative Unix socket file name

data/lib/moneta/shared.rb

@@ -11,8 +11,6 @@ module Moneta
   #
   # @api public
   class Shared < Wrapper
-    # Constructor
-    #
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :host Server hostname
@@ -34,7 +32,7 @@ module Moneta
       end
     end
 
-    private
+    protected
 
     def wrap(*args)
       @adapter ||= Adapters::Client.new(@options)

data/lib/moneta/stack.rb

@@ -12,7 +12,9 @@ module Moneta
   #   end
   #
   # @api public
-  class Stack < Base
+  class Stack
+    include Defaults
+
     # @api private
     class DSL
       attr_reader :stack
@@ -22,6 +24,7 @@ module Moneta
         instance_eval(&block)
       end
 
+      # @api public
       def add(store = nil, &block)
         raise ArgumentError, 'Only argument or block allowed' if store && block
         @stack << (store || Moneta.build(&block))
@@ -35,23 +38,34 @@ module Moneta
       @stack = DSL.new(options, &block).stack
     end
 
+    # (see Proxy#key?)
     def key?(key, options = {})
-      @stack.any? {|s| s.key?(key) }
+      @stack.any? {|s| s.key?(key, options) }
     end
 
+    # (see Proxy#load)
     def load(key, options = {})
       @stack.each do |s|
         value = s.load(key, options)
-        return value if value
+        return value if value != nil
       end
       nil
     end
 
+    # (see Proxy#store)
     def store(key, value, options = {})
       @stack.each {|s| s.store(key, value, options) }
       value
     end
 
+    # (see Proxy#increment)
+    def increment(key, amount = 1, options = {})
+      last = nil
+      @stack.each {|s| last = s.increment(key, amount, options) }
+      last
+    end
+
+    # (see Proxy#delete)
     def delete(key, options = {})
       @stack.inject(nil) do |value, s|
         v = s.delete(key, options)
@@ -59,17 +73,13 @@ module Moneta
       end
     end
 
-    def increment(key, amount = 1, options = {})
-      last = nil
-      @stack.each {|s| last = s.increment(key, amount, options) }
-      last
-    end
-
+    # (see Proxy#clear)
     def clear(options = {})
-      @stack.each {|s| s.clear }
+      @stack.each {|s| s.clear(options) }
       self
     end
 
+    # (see Proxy#close)
     def close
       @stack.each {|s| s.close }
       nil