moneta 0.6.0 → 0.7.0

data/lib/moneta/adapters/tokyocabinet.rb

@@ -0,0 +1,41 @@
+require 'tokyocabinet'
+
+module Moneta
+  module Adapters
+    # TokyoCabinet backend
+    # @api public
+    class TokyoCabinet < Memory
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - Database file
+      # * :type - Database type (default :hdb, :bdb and :hdb possible)
+      def initialize(options = {})
+        file = options[:file]
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        if options[:type] == :bdb
+          @hash = ::TokyoCabinet::BDB.new
+          @hash.open(file, ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
+        else
+          @hash = ::TokyoCabinet::HDB.new
+          @hash.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
+        end or raise @hash.errmsg(@hash.ecode)
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        if value
+          @hash.delete(key)
+          value
+        end
+      end
+
+      def close
+        @hash.close
+        nil
+      end
+    end
+  end
+end

data/lib/moneta/adapters/yaml.rb

@@ -0,0 +1,15 @@
+require 'yaml/store'
+
+module Moneta
+  module Adapters
+    # YAML::Store backend
+    # @api public
+    class YAML < Moneta::Adapters::PStore
+      protected
+
+      def new_store(options)
+        ::YAML::Store.new(options[:file])
+      end
+    end
+  end
+end

data/lib/moneta/base.rb

@@ -0,0 +1,78 @@
+module Moneta
+  # Simple interface to key/value stores with Hash-like interface.
+  # @api public
+  class Base
+    include Mixins::WithOptions
+
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      load(key, options) != nil
+    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 = {})
+      raise NotImplementedError, 'increment is not supported'
+    end
+
+    # Explicitly close the store
+    # @api public
+    def close
+    end
+
+    # Fetch value with key
+    #
+    # This is a overloaded method:
+    #
+    # * fetch(key, options = {}, &block) retrieve a key. if the key is not available, execute the
+    #   block and return its return value.
+    #
+    # * fetch(key, value, options = {}) retrieve a key. if the key is not available, return the 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
+        load(key, default || {}) || yield(key)
+      else
+        load(key, options || {}) || default
+      end
+    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
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return value
+    # @api public
+    def []=(key, value)
+      store(key, value)
+    end
+  end
+end

data/lib/moneta/builder.rb

@@ -0,0 +1,39 @@
+module Moneta
+  # Builder implements the DSL to build a chain of store proxies
+  # @api private
+  class Builder
+    # @api private
+    def build
+      klass, options, block = @proxies.first
+      @proxies[1..-1].inject([klass.new(options, &block)]) do |stores, proxy|
+        klass, options, block = proxy
+        stores << klass.new(stores.last, options, &block)
+      end
+    end
+
+    def initialize(&block)
+      raise ArgumentError, 'No block given' unless block_given?
+      @proxies = []
+      instance_eval(&block)
+    end
+
+    # Add proxy to chain
+    #
+    # @param [Symbol or Class] proxy Name of proxy class or proxy class
+    # @param [Hash] options Options hash
+    def use(proxy, options = {}, &block)
+      proxy = Moneta.const_get(proxy) if Symbol === proxy
+      raise ArgumentError, 'You must give a Class or a Symbol' unless Class === proxy
+      @proxies.unshift [proxy, options, block]
+      nil
+    end
+
+    # Add adapter to chain
+    #
+    # @param [Symbol] name Name of adapter class
+    # @param [Hash] options Options hash
+    def adapter(name, options = {}, &block)
+      use(Adapters.const_get(name), options, &block)
+    end
+  end
+end

data/lib/moneta/cache.rb

@@ -0,0 +1,84 @@
+module Moneta
+  # Combines two stores. One is used as cache, the other as backend.
+  #
+  # @example Add cache to chain
+  #   Moneta.build do
+  #     use(:Cache) do
+  #      backend { adapter :File, :dir => 'data' }
+  #      cache { adapter :Memory }
+  #     end
+  #   end
+  #
+  # @api public
+  class Cache < Base
+    # @api private
+    class DSL
+      def initialize(options, &block)
+        @cache, @backend = options[:cache], options[:backend]
+        instance_eval(&block)
+      end
+
+      def backend(store = nil, &block)
+        raise 'Backend already set' if @backend
+        raise ArgumentError, 'Only argument or block allowed' if store && block
+        @backend = store || Moneta.build(&block)
+      end
+
+      def cache(store = nil, &block)
+        raise 'Cache already set' if @cache
+        raise ArgumentError, 'Only argument or block allowed' if store && block
+        @cache = store || Moneta.build(&block)
+      end
+
+      def result
+        [@cache, @backend]
+      end
+    end
+
+    attr_reader :cache, :backend
+
+    def initialize(options = {}, &block)
+      @cache, @backend = DSL.new(options, &block).result
+    end
+
+    def key?(key, options = {})
+      @cache.key?(key, options) || @backend.key?(key, options)
+    end
+
+    def load(key, options = {})
+      value = @cache.load(key, options)
+      unless value
+        value = @backend.load(key, options)
+        @cache.store(key, value, options) if value
+      end
+      value
+    end
+
+    def store(key, value, options = {})
+      @cache.store(key, value, options)
+      @backend.store(key, value, options)
+    end
+
+    def increment(key, amount = 1, options = {})
+      value = @backend.increment(key, amount, options)
+      @cache.store(key, value.to_s, options)
+      value
+    end
+
+    def delete(key, options = {})
+      @cache.delete(key, options)
+      @backend.delete(key, options)
+    end
+
+    def clear(options = {})
+      @cache.clear(options)
+      @backend.clear(options)
+      self
+    end
+
+    def close
+      @cache.close
+      @backend.close
+    end
+  end
+end

data/lib/moneta/expires.rb

@@ -0,0 +1,71 @@
+module Moneta
+  # Adds expiration support to the underlying store
+  #
+  # #store and #load support the :expires option to set/update
+  # the expiration time.
+  #
+  # @api public
+  class Expires < Proxy
+    # Constructor
+    #
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    #
+    # Options:
+    # * :expires - Default expiration time (default none)
+    def initialize(adapter, options = {})
+      super
+      @expires = options[:expires]
+    end
+
+    def key?(key, options = {})
+      load(key, options) != nil
+    end
+
+    def load(key, options = {})
+      if options.include?(:raw)
+        super
+      else
+        value = check_expired(key, super)
+        if value && options.include?(:expires)
+          store(key, value, options)
+        else
+          value
+        end
+      end
+    end
+
+    def store(key, value, options = {})
+      if options.include?(:raw)
+        super
+      else
+        if expires = (options.delete(:expires) || @expires)
+          super(key, [value, Time.now.to_i + expires], options)
+        else
+          super(key, [value], options)
+        end
+        value
+      end
+    end
+
+    def delete(key, options = {})
+      if options.include?(:raw)
+        super
+      else
+        check_expired(key, super, false)
+      end
+    end
+
+    protected
+
+    def check_expired(key, value, delete_expired = true)
+      value, expires = value
+      if expires && Time.now.to_i > expires
+        delete(key) if delete_expired
+        nil
+      else
+        value
+      end
+    end
+  end
+end

data/lib/moneta/lock.rb

@@ -0,0 +1,25 @@
+require 'thread'
+
+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
+    #
+    # Options:
+    # * :mutex - Mutex object (default Mutex.new)
+    def initialize(adapter, options = {})
+      super
+      @lock = options[:mutex] || Mutex.new
+    end
+
+    protected
+
+    def wrap(*args, &block)
+      @lock.synchronize(&block)
+    end
+  end
+end

data/lib/moneta/logger.rb

@@ -0,0 +1,61 @@
+module Moneta
+  # Logger proxy
+  # @api public
+  class Logger < Wrapper
+    # Standard formatter used by the logger
+    # @api public
+    class Format
+      def initialize(options)
+        @prefix = options[:prefix] || 'Moneta '
+        @out = options[:out] || STDOUT
+      end
+
+      def call(entry)
+        @out.write(format(entry))
+      end
+
+      protected
+
+      def format(entry)
+        args = entry[:args]
+        args.pop if Hash === args.last && args.last.empty?
+        args = args.map {|a| dump(a) }.join(', ')
+        if entry[:error]
+          "#{@prefix}#{entry[:method]}(#{args}) raised error: #{entry[:error].message}\n"
+        else
+          "#{@prefix}#{entry[:method]}(#{args}) -> #{dump entry[:return]}\n"
+        end
+      end
+
+      def dump(value)
+        value = value.inspect
+        value.size > 30 ? value[0..30] + '...' : value
+      end
+    end
+
+    # Constructor
+    #
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    #
+    # Options:
+    # * :logger - Callable logger object (default Moneta::Logger::Format)
+    # * :logprefix - Prefix string (default 'Moneta ')
+    # * :logout - Output (default STDOUT)
+    def initialize(adapter, options = {})
+      super
+      @logger = options[:logger] || Format.new(options)
+    end
+
+    protected
+
+    def wrap(method, *args)
+      ret = yield
+      @logger.call(:method => method, :args => args, :return => (method == :clear ? 'self' : ret))
+      ret
+    rescue Exception => error
+      @logger.call(:method => method, :args => args, :error => error)
+      raise
+    end
+  end
+end

data/lib/moneta/mixins.rb

@@ -0,0 +1,65 @@
+module Moneta
+  # @api private
+  module Mixins
+    module WithOptions
+      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
+
+      def prefix(prefix)
+        with(:prefix => prefix, :except => :clear)
+      end
+
+      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
+    end
+
+    module HashAdapter
+      def initialize(options = {})
+        @hash = {}
+      end
+
+      def key?(key, options = {})
+        @hash.has_key?(key)
+      end
+
+      def load(key, options = {})
+        @hash[key]
+      end
+
+      def store(key, value, options = {})
+        @hash[key] = value
+      end
+
+      def delete(key, options = {})
+        @hash.delete(key)
+      end
+
+      def clear(options = {})
+        @hash.clear
+        self
+      end
+    end
+  end
+end