moneta 1.4.1 → 1.5.1

data/lib/moneta/adapters/lmdb.rb

@@ -5,28 +5,25 @@ module Moneta
   module Adapters
     # LMDB backend
     # @api public
-    class LMDB
-      include Defaults
-
+    class LMDB < Adapter
       supports :create, :increment, :each_key
-      attr_reader :backend, :db
 
       PUT_FLAGS = %i[nooverwrite nodupdata current append appenddup].freeze
 
+      config :db, default: 'moneta'
+
+      backend do |dir:, **options|
+        FileUtils.mkpath(dir)
+        ::LMDB.new(dir, options)
+      end
+
       # @param [Hash] options
       # @option options [String] :dir Environment directory
       # @option options [::LMDB::Environment] :backend Use existing backend instance
-      # @option options [String or nil] :db Database name
-      def initialize(options)
-        db = options.delete(:db)
-        @backend = options.delete(:backend) ||
-          begin
-            raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-            FileUtils.mkpath(dir)
-            ::LMDB.new(dir, options)
-          end
-
-        @db = @backend.database(db, create: true)
+      # @option options [String or nil] :db ('moneta') Database name
+      def initialize(options = {})
+        super
+        @db = backend.database(config.db, create: true)
       end
 
       # (see Proxy#key?)
@@ -47,7 +44,7 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @backend.transaction do
+        backend.transaction do
           if value = @db.get(key)
             @db.delete(key)
             value
@@ -63,7 +60,7 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction do
+        backend.transaction do
           value = Integer(@db.get(key) || 0) + amount
           @db.put(key, value.to_s, Utils.only(options, *PUT_FLAGS))
           value
@@ -72,7 +69,7 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @backend.transaction do
+        backend.transaction do
           if @db.get(key)
             false
           else
@@ -84,7 +81,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
@@ -103,17 +100,17 @@ module Moneta
 
       # (see Proxy#values_at)
       def values_at(*keys, **options)
-        @backend.transaction { super }
+        backend.transaction { super }
       end
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        @backend.transaction { super }
+        backend.transaction { super }
       end
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
-        @backend.transaction { super }
+        backend.transaction { super }
       end
     end
   end

data/lib/moneta/adapters/localmemcache.rb

@@ -4,25 +4,19 @@ module Moneta
   module Adapters
     # LocalMemCache backend
     # @api public
-    class LocalMemCache
-      include Defaults
+    class LocalMemCache < Adapter
       include HashAdapter
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::LocalMemCache] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::LocalMemCache.new(filename: options[:file])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::LocalMemCache] :backend Use existing backend instance
+      backend { |file:| ::LocalMemCache.new(filename: file) }
 
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
-        @backend.delete(key)
+        backend.delete(key)
         value
       end
     end

data/lib/moneta/adapters/lruhash.rb

@@ -6,70 +6,70 @@ module Moneta
     # both memory usage and hash size.
     #
     # @api public
-    class LRUHash
-      include Defaults
+    class LRUHash < Adapter
       include IncrementSupport
       include CreateSupport
 
-      DEFAULT_MAX_SIZE = 1024000
-      DEFAULT_MAX_COUNT = 10240
+      config :max_size, default: 1024000
+      config(:max_value) { |max_size:, max_value:, **| [max_value, max_size].compact.min }
+      config :max_count, default: 10240
 
       supports :each_key
 
+      backend { {} }
+
       # @param [Hash] options
       # @option options [Integer] :max_size (1024000) Maximum byte size of all values, nil disables the limit
       # @option options [Integer] :max_value (options[:max_size]) Maximum byte size of one value, nil disables the limit
       # @option options [Integer] :max_count (10240) Maximum number of values, nil disables the limit
       def initialize(options = {})
-        @max_size = options.fetch(:max_size) { DEFAULT_MAX_SIZE }
-        @max_count = options.fetch(:max_count) { DEFAULT_MAX_COUNT }
-        @max_value = [options[:max_value], @max_size].compact.min
+        super
         clear
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.key?(key)
+        backend.key?(key)
       end
 
       # (see Proxy#each_key)
       def each_key(&block)
-        return enum_for(:each_key) { @backend.length } unless block_given?
+        return enum_for(:each_key) { backend.length } unless block_given?
 
         # The backend needs to be duplicated because reading mutates this
         # store.
-        @backend.dup.each_key { |k| yield(k) }
+        backend.dup.each_key { |k| yield(k) }
         self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        if value = @backend.delete(key)
-          @backend[key] = value
+        if value = backend.delete(key)
+          backend[key] = value
           value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        if @max_value && value.bytesize > @max_value
+        if config.max_value && value.bytesize > config.max_value
           delete(key)
         else
-          if @max_size
-            if old_value = @backend.delete(key)
+          if config.max_size
+            if old_value = backend.delete(key)
               @size -= old_value.bytesize
             end
             @size += value.bytesize
           end
-          @backend[key] = value
-          drop while @max_size && @size > @max_size || @max_count && @backend.size > @max_count
+          backend[key] = value
+          drop while config.max_size && @size > config.max_size || config.max_count && backend.size > config.max_count
         end
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        if value = @backend.delete(key) and @max_size
+        if value = backend.delete(key) and config.max_size
           @size -= value.bytesize
         end
         value
@@ -77,7 +77,7 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend = {}
+        backend.clear
         @size = 0
         self
       end
@@ -87,7 +87,7 @@ module Moneta
       # @param [Hash] options Options to merge
       # @return [(Object, String), nil] The dropped pair, if any
       def drop(options = {})
-        if key = @backend.keys.first
+        if key = backend.keys.first
           [key, delete(key)]
         end
       end

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