moneta 1.4.0 → 1.5.0

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

@@ -4,47 +4,39 @@ module Moneta
   module Adapters
     # Memcached backend (using gem dalli)
     # @api public
-    class MemcachedDalli
-      include Defaults
+    class MemcachedDalli < Adapter
       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)
-        @backend = options[:backend] ||
-          begin
-            server = options.delete(:server) || '127.0.0.1:11211'
-            ::Dalli::Client.new(server, options)
-          end
-      end
+
+      # @!method initialize(options = {})
+      #   @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`
+      backend { |server: '127.0.0.1:11211', **options| ::Dalli::Client.new(server, options) }
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @backend.get(key)
+        value = backend.get(key)
         if value
           expires = expires_value(options, nil)
-          @backend.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 = {})
-        @backend.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 = @backend.get(key)
-        @backend.delete(key)
+        value = backend.get(key)
+        backend.delete(key)
         value
       end
 
@@ -52,9 +44,9 @@ module Moneta
       def increment(key, amount = 1, options = {})
         result =
           if amount >= 0
-            @backend.incr(key, amount, expires_value(options) || nil)
+            backend.incr(key, amount, expires_value(options) || nil)
           else
-            @backend.decr(key, -amount, expires_value(options) || nil)
+            backend.decr(key, -amount, expires_value(options) || nil)
           end
         if result
           result
@@ -67,32 +59,32 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.flush_all
+        backend.flush_all
         self
       end
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        !!@backend.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
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Defaults#slice)
       def slice(*keys, **options)
-        @backend.get_multi(keys).tap do |pairs|
+        backend.get_multi(keys).tap do |pairs|
           next if pairs.empty?
           expires = expires_value(options, nil)
           next if expires == nil
           expires = expires.to_i if Numeric === expires
           expires ||= 0
-          @backend.multi do
+          backend.multi do
             pairs.each do |key, value|
-              @backend.set(key, value, expires, false)
+              backend.set(key, value, expires, false)
             end
           end
         end
@@ -112,7 +104,7 @@ module Moneta
 
         if block_given?
           keys = pairs.map { |key, _| key }.to_a
-          old_pairs = @backend.get_multi(keys)
+          old_pairs = backend.get_multi(keys)
           pairs = pairs.map do |key, new_value|
             if old_pairs.key? key
               new_value = yield(key, old_pairs[key], new_value)
@@ -121,9 +113,9 @@ module Moneta
           end
         end
 
-        @backend.multi do
+        backend.multi do
           pairs.each do |key, value|
-            @backend.set(key, value, expires, raw: true)
+            backend.set(key, value, expires, raw: true)
           end
         end
 

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

@@ -4,30 +4,24 @@ module Moneta
   module Adapters
     # Memcached backend (using gem memcached)
     # @api public
-    class MemcachedNative
-      include Defaults
+    class MemcachedNative < Adapter
       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)
-        @backend = options[:backend] ||
-          begin
-            options[: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
+      # @!method initialize(options = {})
+      #   @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`
+      backend do |server: '127.0.0.1:11211', namespace: nil, **options|
+        options[:prefix_key] = namespace if 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
 
       # (see Proxy#load)

data/lib/moneta/adapters/memory.rb

@@ -2,19 +2,17 @@ module Moneta
   module Adapters
     # Memory backend using a hash to store the entries
     # @api public
-    class Memory
-      include Defaults
+    class Memory < Adapter
       include NilValues
       include HashAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options Options hash
-      # @option options [Hash] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] || {}
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options Options hash
+      #   @option options [Hash] :backend Use existing backend instance
+      backend { {} }
     end
   end
 end

data/lib/moneta/adapters/mongo.rb

@@ -14,14 +14,33 @@ module Moneta
     #     db['key'] = {a: 1, b: 2}
     #
     # @api public
-    class Mongo
-      include Defaults
+    class Mongo < Adapter
       include ExpiresSupport
 
       supports :each_key, :create, :increment
-      attr_reader :backend
 
-      DEFAULT_PORT = 27017
+      config :collection, default: 'moneta'
+
+      config :db
+      config :database, default: 'moneta' do |database:, db:, **|
+        if db
+          warn('Moneta::Adapters::Mongo - the :db option is deprecated and will be removed in a future version. Use :database instead')
+          db
+        else
+          database
+        end
+      end
+
+      config :expires_field, default: 'expiresAt'
+      config :value_field, default: 'value'
+      config :type_field, default: 'type'
+
+      backend do |host: '127.0.0.1', port: 27017, **options|
+        options[:logger] ||= ::Logger.new(STDERR).tap do |logger|
+          logger.level = ::Logger::ERROR
+        end
+        ::Mongo::Client.new(["#{host}:#{port}"], options)
+      end
 
       # @param [Hash] options
       # @option options [String] :collection ('moneta') MongoDB collection name
@@ -29,7 +48,7 @@ module Moneta
       # @option options [String] :user Username used to authenticate
       # @option options [String] :password Password used to authenticate
       # @option options [Integer] :port (MongoDB default port) MongoDB server port
-      # @option options [String] :db ('moneta') MongoDB database
+      # @option options [String] :database ('moneta') MongoDB database
       # @option options [Integer] :expires Default expiration time
       # @option options [String] :expires_field ('expiresAt') Document field to store expiration time
       # @option options [String] :value_field ('value') Document field to store value
@@ -37,26 +56,13 @@ module Moneta
       # @option options [::Mongo::Client] :backend Use existing backend instance
       # @option options Other options passed to `Mongo::MongoClient#new`
       def initialize(options = {})
-        self.default_expires = options.delete(:expires)
-        @expires_field = options.delete(:expires_field) || 'expiresAt'
-        @value_field = options.delete(:value_field) || 'value'
-        @type_field = options.delete(:type_field) || 'type'
-
-        collection = options.delete(:collection) || 'moneta'
-        db = options.delete(:db) || 'moneta'
-        @backend = options[:backend] ||
-          begin
-            host = options.delete(:host) || '127.0.0.1'
-            port = options.delete(:port) || DEFAULT_PORT
-            options[:logger] ||= ::Logger.new(STDERR).tap do |logger|
-              logger.level = ::Logger::ERROR
-            end
-            ::Mongo::Client.new(["#{host}:#{port}"], options)
-          end
-        @backend.use(db)
-        @collection = @backend[collection]
-        if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
-          @collection.indexes.create_one({ @expires_field => 1 }, expire_after: 0)
+        super
+
+        @database = backend.use(config.database)
+        @collection = @database[config.collection]
+
+        if @database.command(buildinfo: 1).documents.first['version'] >= '2.2'
+          @collection.indexes.create_one({ config.expires_field => 1 }, expire_after: 0)
         else
           warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
         end
@@ -73,7 +79,7 @@ module Moneta
 
         if doc
           update_expiry(options, nil) do |expires|
-            view.update_one(:$set => { @expires_field => expires })
+            view.update_one(:$set => { config.expires_field => expires })
           end
 
           doc_to_value(doc)
@@ -100,7 +106,7 @@ module Moneta
       def delete(key, options = {})
         key = to_binary(key)
         if doc = @collection.find(_id: key).find_one_and_delete and
-            !doc[@expires_field] || doc[@expires_field] >= Time.now
+            !doc[config.expires_field] || doc[config.expires_field] >= Time.now
           doc_to_value(doc)
         end
       end
@@ -108,9 +114,12 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @collection.find_one_and_update({ :$and => [{ _id: to_binary(key) }, not_expired] },
-                                        { :$inc => { @value_field => amount } },
+                                        { :$inc => { config.value_field => amount } },
                                         return_document: :after,
-                                        upsert: true)[@value_field]
+                                        upsert: true)[config.value_field]
+      rescue ::Mongo::Error::OperationFailure
+        tries ||= 0
+        (tries += 1) < 3 ? retry : raise
       end
 
       # (see Proxy#create)
@@ -118,8 +127,8 @@ module Moneta
         key = to_binary(key)
         @collection.insert_one(value_to_doc(key, value, options))
         true
-      rescue ::Mongo::Error::OperationFailure => ex
-        raise unless ex.message =~ /^E11000 / # duplicate key error
+      rescue ::Mongo::Error::OperationFailure => error
+        raise unless error.code == 11000 # duplicate key error
         false
       end
 
@@ -131,7 +140,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        @database.close
         nil
       end
 
@@ -144,7 +153,7 @@ module Moneta
         pairs = view.map { |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }
 
         update_expiry(options, nil) do |expires|
-          view.update_many(:$set => { @expires_field => expires })
+          view.update_many(:$set => { config.expires_field => expires })
         end
 
         pairs
@@ -190,18 +199,18 @@ module Moneta
       private
 
       def doc_to_value(doc)
-        case doc[@type_field]
+        case doc[config.type_field]
         when 'Hash'
           doc = doc.dup
           doc.delete('_id')
-          doc.delete(@type_field)
-          doc.delete(@expires_field)
+          doc.delete(config.type_field)
+          doc.delete(config.expires_field)
           doc
         when 'Number'
-          doc[@value_field]
+          doc[config.value_field]
         else
           # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
-          from_binary(doc[@value_field])
+          from_binary(doc[config.value_field])
         end
       end
 
@@ -209,22 +218,22 @@ module Moneta
         case value
         when Hash
           value.merge('_id' => key,
-                      @type_field => 'Hash',
-                      # @expires_field must be a Time object (BSON date datatype)
-                      @expires_field => expires_at(options) || nil)
+                      config.type_field => 'Hash',
+                      # expires_field must be a Time object (BSON date datatype)
+                      config.expires_field => expires_at(options) || nil)
         when Float, Integer
           { '_id' => key,
-            @type_field => 'Number',
-            @value_field => value,
-            # @expires_field must be a Time object (BSON date datatype)
-            @expires_field => expires_at(options) || nil }
+            config.type_field => 'Number',
+            config.value_field => value,
+            # expires_field must be a Time object (BSON date datatype)
+            config.expires_field => expires_at(options) || nil }
         when String
           intvalue = value.to_i
           { '_id' => key,
-            @type_field => 'String',
-            @value_field => intvalue.to_s == value ? intvalue : to_binary(value),
+            config.type_field => 'String',
+            config.value_field => intvalue.to_s == value ? intvalue : to_binary(value),
             # @expires_field must be a Time object (BSON date datatype)
-            @expires_field => expires_at(options) || nil }
+            config.expires_field => expires_at(options) || nil }
         else
           raise ArgumentError, "Invalid value type: #{value.class}"
         end
@@ -245,8 +254,8 @@ module Moneta
       def not_expired
         {
           :$or => [
-            { @expires_field => nil },
-            { @expires_field => { :$gte => Time.now } }
+            { config.expires_field => nil },
+            { config.expires_field => { :$gte => Time.now } }
           ]
         }
       end

data/lib/moneta/adapters/pstore.rb

@@ -5,63 +5,61 @@ module Moneta
   module Adapters
     # PStore backend
     # @api public
-    class PStore
-      include Defaults
+    class PStore < Adapter
       include NilValues
 
       supports :create, :increment, :each_key
-      attr_reader :backend
+
+      backend do |file:, threadsafe: false|
+        FileUtils.mkpath(::File.dirname(file))
+        ::PStore.new(file, threadsafe)
+      end
 
       # @param [Hash] options
       # @option options [String] :file PStore file
+      # @option options [Boolean] :threadsafe Makes the PStore thread-safe
       # @option options [::PStore] :backend Use existing backend instance
       def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            FileUtils.mkpath(::File.dirname(options[:file]))
-            new_store(options)
-          end
-
+        super
         @id = "Moneta::Adapters::PStore(#{object_id})"
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        transaction(true) { @backend.root?(key) }
+        transaction(true) { backend.root?(key) }
       end
 
       # (see Proxy#each_key)
       def each_key(&block)
-        return enum_for(:each_key) { transaction(true) { @backend.roots.size } } unless block_given?
+        return enum_for(:each_key) { transaction(true) { backend.roots.size } } unless block_given?
 
         transaction(true) do
-          @backend.roots.each { |k| yield(k) }
+          backend.roots.each { |k| yield(k) }
         end
         self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        transaction(true) { @backend[key] }
+        transaction(true) { backend[key] }
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        transaction { @backend[key] = value }
+        transaction { backend[key] = value }
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        transaction { @backend.delete(key) }
+        transaction { backend.delete(key) }
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         transaction do
-          existing = @backend[key]
+          existing = backend[key]
           value = (existing == nil ? 0 : Integer(existing)) + amount
-          @backend[key] = value.to_s
+          backend[key] = value.to_s
           value
         end
       end
@@ -69,10 +67,10 @@ module Moneta
       # (see Proxy#create)
       def create(key, value, options = {})
         transaction do
-          if @backend.root?(key)
+          if backend.root?(key)
             false
           else
-            @backend[key] = value
+            backend[key] = value
             true
           end
         end
@@ -81,8 +79,8 @@ module Moneta
       # (see Proxy#clear)
       def clear(options = {})
         transaction do
-          @backend.roots.each do |key|
-            @backend.delete(key)
+          backend.roots.each do |key|
+            backend.delete(key)
           end
         end
         self
@@ -109,10 +107,6 @@ module Moneta
 
       class TransactionError < StandardError; end
 
-      def new_store(options)
-        ::PStore.new(options[:file], options[:threadsafe])
-      end
-
       def transaction(read_only = false)
         case Thread.current[@id]
         when read_only, false
@@ -122,7 +116,7 @@ module Moneta
         else
           begin
             Thread.current[@id] = read_only
-            @backend.transaction(read_only) { yield }
+            backend.transaction(read_only) { yield }
           ensure
             Thread.current[@id] = nil
           end