moneta 0.7.9 → 0.7.10

data/lib/moneta/adapters/kyotocabinet.rb

@@ -7,31 +7,36 @@ module Moneta
     class KyotoCabinet < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::KyotoCabinet::DB] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::KyotoCabinet::DB.new
-        raise @hash.error.to_s unless @hash.open(options[:file],
-                                                 ::KyotoCabinet::DB::OWRITER | ::KyotoCabinet::DB::OCREATE)
+        if options[:backend]
+          @backend = options[:backend]
+        else
+          raise ArgumentError, 'Option :file is required' unless options[:file]
+          @backend = ::KyotoCabinet::DB.new
+          raise @backend.error.to_s unless @backend.open(options[:file],
+                                                         ::KyotoCabinet::DB::OWRITER | ::KyotoCabinet::DB::OCREATE)
+        end
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @hash.check(key) >= 0
+        @backend.check(key) >= 0
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @hash.seize(key)
+        @backend.seize(key)
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @hash.add(key, value)
+        @backend.add(key, value)
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/leveldb.rb

@@ -8,25 +8,29 @@ module Moneta
       # @param [Hash] options
       # @option options [String] :dir - Database path
       # @option options All other options passed to `LevelDB::DB#new`
+      # @option options [::LevelDB::DB] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless options[:dir]
-        @hash = ::LevelDB::DB.new(options[:dir])
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :dir is required' unless options[:dir]
+            ::LevelDB::DB.new(options[:dir])
+          end
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @hash.includes?(key)
+        @backend.includes?(key)
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @hash.each {|k,v| delete(k, options) }
+        @backend.each {|k,v| delete(k, options) }
         self
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/localmemcache.rb

@@ -10,15 +10,19 @@ module Moneta
 
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::LocalMemCache] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::LocalMemCache.new(:filename => options[:file])
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::LocalMemCache.new(:filename => options[:file])
+          end
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
-        @hash.delete(key)
+        @backend.delete(key)
         value
       end
     end

data/lib/moneta/adapters/memcached/dalli.rb

@@ -9,37 +9,42 @@ module Moneta
       include ExpiresSupport
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :server ('127.0.0.1:11211') Memcached server
       # @option options [Integer] :expires Default expiration time
+      # @option options [::Dalli::Client] :backend Use existing backend instance
       # @option options Other options passed to `Dalli::Client#new`
       def initialize(options = {})
         self.default_expires = options.delete(:expires)
-        server = options.delete(:server) || '127.0.0.1:11211'
-        @cache = ::Dalli::Client.new(server, options)
+        @backend = options[:backend] ||
+          begin
+            server = options.delete(:server) || '127.0.0.1:11211'
+            ::Dalli::Client.new(server, options)
+          end
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @cache.get(key)
+        value = @backend.get(key)
         if value
           expires = expires_value(options, nil)
-          @cache.set(key, value, expires || nil, :raw => true) if expires != nil
+          @backend.set(key, value, expires || nil, :raw => true) if expires != nil
           value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @cache.set(key, value, expires_value(options) || nil, :raw => true)
+        @backend.set(key, value, expires_value(options) || nil, :raw => true)
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        value = @cache.get(key)
-        @cache.delete(key)
+        value = @backend.get(key)
+        @backend.delete(key)
         value
       end
 
@@ -48,7 +53,7 @@ module Moneta
         # FIXME: There is a Dalli bug, load(key) returns a wrong value after increment
         # therefore we set default = nil and create the counter manually
 	# See https://github.com/mperham/dalli/issues/309
-        result = amount >= 0 ? @cache.incr(key, amount, nil, nil) : @cache.decr(key, -amount, nil, nil)
+        result = amount >= 0 ? @backend.incr(key, amount, nil, nil) : @backend.decr(key, -amount, nil, nil)
         if result
           result
         elsif create(key, amount.to_s, options)
@@ -60,18 +65,18 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @cache.flush_all
+        @backend.flush_all
         self
       end
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @cache.add(key, value, expires_value(options) || nil, :raw => true)
+        @backend.add(key, value, expires_value(options) || nil, :raw => true)
       end
 
       # (see Proxy#close)
       def close
-        @cache.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/memcached/native.rb

@@ -9,28 +9,33 @@ module Moneta
       include ExpiresSupport
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :server ('127.0.0.1:11211') Memcached server
       # @option options [String] :namespace Key namespace
       # @option options [Integer] :expires (604800) Default expiration time
+      # @option options [::Memcached] :backend Use existing backend instance
       # @option options Other options passed to `Memcached#new`
       def initialize(options = {})
         server = options.delete(:server) || '127.0.0.1:11211'
         self.default_expires = options.delete(:expires)
-        options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
-        # We don't want a limitation on the key charset. Therefore we use the binary protocol.
-        # It is also faster.
-        options[:binary_protocol] = true unless options.include?(:binary_protocol)
-        @cache = ::Memcached.new(server, options)
+        @backend = options[:backend] ||
+          begin
+            options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
+            # We don't want a limitation on the key charset. Therefore we use the binary protocol.
+            # It is also faster.
+            options[:binary_protocol] = true unless options.include?(:binary_protocol)
+            ::Memcached.new(server, options)
+          end
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @cache.get(key, false)
+        value = @backend.get(key, false)
         if value
           expires = expires_value(options, nil)
-          @cache.set(key, value, expires || 0, false) if expires != nil
+          @backend.set(key, value, expires || 0, false) if expires != nil
           value
         end
       rescue ::Memcached::NotFound
@@ -39,14 +44,14 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         # TTL must be Fixnum
-        @cache.set(key, value, expires_value(options) || 0, false)
+        @backend.set(key, value, expires_value(options) || 0, false)
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        value = @cache.get(key, false)
-        @cache.delete(key)
+        value = @backend.get(key, false)
+        @backend.delete(key)
         value
       rescue ::Memcached::NotFound
       end
@@ -54,13 +59,13 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         result = if amount >= 0
-          @cache.increment(key, amount)
+          @backend.increment(key, amount)
         else
-          @cache.decrement(key, -amount)
+          @backend.decrement(key, -amount)
         end
         # HACK: Throw error if applied to invalid value
 	# see https://github.com/evan/memcached/issues/110
-        Utils.to_int((@cache.get(key, false) rescue nil)) if result == 0
+        Utils.to_int((@backend.get(key, false) rescue nil)) if result == 0
         result
       rescue ::Memcached::NotFound => ex
         retry unless create(key, amount.to_s, options)
@@ -69,7 +74,7 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @cache.add(key, value, expires_value(options) || 0, false)
+        @backend.add(key, value, expires_value(options) || 0, false)
         true
       rescue ::Memcached::ConnectionDataExists
         false
@@ -77,7 +82,7 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @cache.flush
+        @backend.flush
         self
       end
     end

data/lib/moneta/adapters/memory.rb

@@ -9,8 +9,9 @@ module Moneta
       include CreateSupport
 
       # @param [Hash] options Options hash
+      # @option options [Hash] :backend Use existing backend instance
       def initialize(options = {})
-        @hash = {}
+        @backend = options[:backend] || {}
       end
     end
   end

data/lib/moneta/adapters/mongo.rb

@@ -13,6 +13,7 @@ module Moneta
       include ExpiresSupport
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :collection ('moneta') MongoDB collection name
@@ -22,19 +23,23 @@ module Moneta
       # @option options [Integer] :port (MongoDB default port) MongoDB server port
       # @option options [String] :db ('moneta') MongoDB database
       # @option options [Integer] :expires Default expiration time
+      # @option options [::Mongo::MongoClient] :backend Use existing backend instance
       def initialize(options = {})
         self.default_expires = options.delete(:expires)
         collection = options.delete(:collection) || 'moneta'
-        host = options.delete(:host) || '127.0.0.1'
-        port = options.delete(:port) || ::Mongo::MongoClient::DEFAULT_PORT
         db = options.delete(:db) || 'moneta'
-        user = options.delete(:user)
-        password = options.delete(:password)
-        client = ::Mongo::MongoClient.new(host, port, options)
-        db = client.db(db)
+        @backend = options[:backend] ||
+          begin
+            host = options.delete(:host) || '127.0.0.1'
+            port = options.delete(:port) || ::Mongo::MongoClient::DEFAULT_PORT
+            user = options.delete(:user)
+            password = options.delete(:password)
+            ::Mongo::MongoClient.new(host, port, options)
+          end
+        db = @backend.db(db)
         db.authenticate(user, password, true) if user && password
         @collection = db.collection(collection)
-        if client.server_version >= '2.2'
+        if @backend.server_version >= '2.2'
           @collection.ensure_index([['expiresAt', ::Mongo::ASCENDING]], :expireAfterSeconds => 0)
         else
           warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
@@ -105,7 +110,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @collection.db.connection.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/pstore.rb

@@ -8,51 +8,56 @@ module Moneta
       include Defaults
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :file PStore file
+      # @option options [::PStore] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        FileUtils.mkpath(::File.dirname(options[:file]))
-        @pstore = new_store(options)
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            FileUtils.mkpath(::File.dirname(options[:file]))
+            new_store(options)
+          end
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @pstore.transaction(true) { @pstore.root?(key) }
+        @backend.transaction(true) { @backend.root?(key) }
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        @pstore.transaction(true) { @pstore[key] }
+        @backend.transaction(true) { @backend[key] }
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @pstore.transaction { @pstore[key] = value }
+        @backend.transaction { @backend[key] = value }
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @pstore.transaction { @pstore.delete(key) }
+        @backend.transaction { @backend.delete(key) }
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @pstore.transaction do
-          value = Utils.to_int(@pstore[key]) + amount
-          @pstore[key] = value.to_s
+        @backend.transaction do
+          value = Utils.to_int(@backend[key]) + amount
+          @backend[key] = value.to_s
           value
         end
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @pstore.transaction do
-          if @pstore.root?(key)
+        @backend.transaction do
+          if @backend.root?(key)
             false
           else
-            @pstore[key] = value
+            @backend[key] = value
             true
           end
         end
@@ -60,9 +65,9 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @pstore.transaction do
-          @pstore.roots.each do |key|
-            @pstore.delete(key)
+        @backend.transaction do
+          @backend.roots.each do |key|
+            @backend.delete(key)
           end
         end
         self
@@ -70,12 +75,10 @@ module Moneta
 
       protected
 
-      if RUBY_VERSION > '1.9'
-        def new_store(options)
+      def new_store(options)
+        if RUBY_VERSION > '1.9'
           ::PStore.new(options[:file], options[:threadsafe])
-        end
-      else
-        def new_store(options)
+        else
           ::PStore.new(options[:file])
         end
       end

data/lib/moneta/adapters/redis.rb

@@ -9,13 +9,15 @@ module Moneta
       include ExpiresSupport
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [Integer] :expires Default expiration time
+      # @option options [::Redis] :backend Use existing backend instance
       # @option options Other options passed to `Redis#new`
       def initialize(options = {})
         self.default_expires = options.delete(:expires)
-        @redis = ::Redis.new(options)
+        @backend = options[:backend] || ::Redis.new(options)
       end
 
       # (see Proxy#key?)
@@ -23,7 +25,7 @@ module Moneta
       # This method considers false and 0 as "no-expire" and every positive
       # number as a time to live in seconds.
       def key?(key, options = {})
-        if @redis.exists(key)
+        if @backend.exists(key)
           update_expires(key, options, nil)
           true
         else
@@ -33,7 +35,7 @@ module Moneta
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @redis.get(key)
+        value = @backend.get(key)
         update_expires(key, options, nil)
         value
       end
@@ -41,9 +43,9 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         if expires = expires_value(options)
-          @redis.setex(key, expires, value)
+          @backend.setex(key, expires, value)
         else
-          @redis.set(key, value)
+          @backend.set(key, value)
         end
         value
       end
@@ -51,25 +53,25 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         if value = load(key, options)
-          @redis.del(key)
+          @backend.del(key)
           value
         end
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @redis.incrby(key, amount)
+        @backend.incrby(key, amount)
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @redis.flushdb
+        @backend.flushdb
         self
       end
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        if @redis.setnx(key, value)
+        if @backend.setnx(key, value)
           update_expires(key, options)
           true
         else
@@ -79,7 +81,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @redis.quit
+        @backend.quit
         nil
       end
 
@@ -88,9 +90,9 @@ module Moneta
       def update_expires(key, options, default = @default_expires)
         case expires = expires_value(options, default)
         when false
-          @redis.persist(key)
+          @backend.persist(key)
         when Numeric
-          @redis.expire(key, expires)
+          @backend.expire(key, expires)
         end
       end
     end