moneta 1.4.2 → 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
@@ -37,31 +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'
+        super
 
-        collection = options.delete(:collection) || 'moneta'
+        @database = backend.use(config.database)
+        @collection = @database[config.collection]
 
-        if options.key?(:db)
-          warn('Moneta::Adapters::Mongo - the :db option is deprecated and will be removed in a future version. Use :database instead')
-        end
-        database = options.delete(:database) || 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 = backend.use(database)
-        @collection = @backend[collection]
-        if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
-          @collection.indexes.create_one({ @expires_field => 1 }, expire_after: 0)
+        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
@@ -78,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)
@@ -105,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
@@ -113,9 +114,9 @@ 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
@@ -126,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
 
@@ -139,7 +140,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        @database.close
         nil
       end
 
@@ -152,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
@@ -198,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
 
@@ -217,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
@@ -253,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

data/lib/moneta/adapters/redis.rb

@@ -4,32 +4,28 @@ module Moneta
   module Adapters
     # Redis backend
     # @api public
-    class Redis
-      include Defaults
+    class Redis < Adapter
       include ExpiresSupport
 
       supports :create, :increment, :each_key
-      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)
-        @backend = options[:backend] || ::Redis.new(options)
-      end
+
+      # @!method initialize(options = {})
+      #   @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`
+      backend { |**options| ::Redis.new(options) }
 
       # (see Proxy#key?)
       #
       # This method considers false and 0 as "no-expire" and every positive
       # number as a time to live in seconds.
       def key?(key, options = {})
-        with_expiry_update(key, default: nil, **options) do
-          if @backend.respond_to?(:exists?)
-            @backend.exists?(key)
+        with_expiry_update(key, default: nil, **options) do |pipeline_handle|
+          if pipeline_handle.respond_to?(:exists?)
+            pipeline_handle.exists?(key)
           else
-            @backend.exists(key)
+            pipeline_handle.exists(key)
           end
         end
       end
@@ -44,8 +40,8 @@ module Moneta
 
       # (see Proxy#load)
       def load(key, options = {})
-        with_expiry_update(key, default: nil, **options) do
-          @backend.get(key)
+        with_expiry_update(key, default: nil, **options) do |pipeline_handle|
+          pipeline_handle.get(key)
         end
       end
 
@@ -63,17 +59,17 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         future = nil
-        @backend.pipelined do
-          future = @backend.get(key)
-          @backend.del(key)
+        @backend.pipelined do |pipeline|
+          future = pipeline.get(key)
+          pipeline.del(key)
         end
         future.value
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        with_expiry_update(key, **options) do
-          @backend.incrby(key, amount)
+        with_expiry_update(key, **options) do |pipeline_handle|
+          pipeline_handle.incrby(key, amount)
         end
       end
 
@@ -85,10 +81,10 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        expires = expires_value(options, @default_expires)
+        expires = expires_value(options, config.expires)
 
         if @backend.setnx(key, value)
-          update_expires(key, expires)
+          update_expires(@backend, key, expires)
           true
         else
           false
@@ -103,8 +99,8 @@ module Moneta
 
       # (see Defaults#values_at)
       def values_at(*keys, **options)
-        with_expiry_update(*keys, default: nil, **options) do
-          @backend.mget(*keys)
+        with_expiry_update(*keys, default: nil, **options) do |pipeline_handle|
+          pipeline_handle.mget(*keys)
         end
       end
 
@@ -130,8 +126,8 @@ module Moneta
           end
         end
 
-        with_expiry_update(*keys, **options) do
-          @backend.mset(*pairs.to_a.flatten(1))
+        with_expiry_update(*keys, **options) do |pipeline_handle|
+          pipeline_handle.mset(*pairs.to_a.flatten(1))
         end
 
         self
@@ -139,24 +135,33 @@ module Moneta
 
       protected
 
-      def update_expires(key, expires)
+      def update_expires(pipeline_handle, key, expires)
         case expires
         when false
-          @backend.persist(key)
+          pipeline_handle.persist(key)
         when Numeric
-          @backend.pexpire(key, (expires * 1000).to_i)
+          pipeline_handle.pexpire(key, (expires * 1000).to_i)
         end
       end
 
-      def with_expiry_update(*keys, default: @default_expires, **options)
+      def with_expiry_update(*keys, default: config.expires, **options)
         expires = expires_value(options, default)
         if expires == nil
-          yield
+          yield(@backend)
         else
           future = nil
-          @backend.multi do
-            future = yield
-            keys.each { |key| update_expires(key, expires) }
+          @backend.multi do |pipeline|
+            # as of redis 4.6 calling redis methods on the redis client itself
+            # is deprecated in favor of a pipeline handle provided by the
+            # +multi+ call. This will cause in error in redis >= 5.0.
+            #
+            # In order to continue supporting redis versions < 4.6, the following
+            # fallback has been introduced and can be removed once moneta
+            # no longer supports redis < 4.6.
+
+            pipeline_handle = pipeline || @backend
+            future = yield(pipeline_handle)
+            keys.each { |key| update_expires(pipeline_handle, key, expires) }
           end
           future.value
         end