moneta 1.4.2 → 1.5.0

data/lib/moneta/adapters/dbm.rb

@@ -4,23 +4,17 @@ module Moneta
   module Adapters
     # DBM backend (Berkeley DB)
     # @api public
-    class DBM
-      include Defaults
+    class DBM < Adapter
       include DBMAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::DBM] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::DBM.new(options[:file])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::DBM] :backend Use existing backend instance
+      backend { |file:| ::DBM.new(file) }
     end
   end
 end

data/lib/moneta/adapters/file.rb

@@ -7,14 +7,18 @@ module Moneta
     # @api public
     class File
       include Defaults
+      include Config
+
       supports :create, :increment, :each_key
 
+      config :dir, required: true
+
       # @param [Hash] options
       # @option options [String] :dir Directory where files will be stored
       def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless @dir = options[:dir]
-        FileUtils.mkpath(@dir)
-        raise "#{@dir} is not a directory" unless ::File.directory?(@dir)
+        configure(options)
+        FileUtils.mkpath(config.dir)
+        raise "#{config.dir} is not a directory" unless ::File.directory?(config.dir)
       end
 
       # (see Proxy#key?)
@@ -24,12 +28,16 @@ module Moneta
 
       # (see Proxy#each_key)
       def each_key(&block)
-        entries = ::Dir.entries(@dir).reject { |k| ::File.directory?(::File.join(@dir, k)) }
-
-        return enum_for(:each_key) { ::Dir.entries(@dir).length - 2 } unless block_given?
+        entries = ::Dir.entries(config.dir).reject do |k|
+          ::File.directory?(::File.join(config.dir, k))
+        end
 
-        entries.each { |k| yield(k) }
-        self
+        if block_given?
+          entries.each { |k| yield(k) }
+          self
+        else
+          enum_for(:each_key) { ::Dir.entries(config.dir).length - 2 }
+        end
       end
 
       # (see Proxy#load)
@@ -41,7 +49,7 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        temp_file = ::File.join(@dir, "value-#{$PROCESS_ID}-#{Thread.current.object_id}")
+        temp_file = ::File.join(config.dir, "value-#{$PROCESS_ID}-#{Thread.current.object_id}")
         path = store_path(key)
         FileUtils.mkpath(::File.dirname(path))
         ::File.open(temp_file, 'wb') { |f| f.write(value) }
@@ -63,9 +71,9 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        temp_dir = "#{@dir}-#{$PROCESS_ID}-#{Thread.current.object_id}"
-        ::File.rename(@dir, temp_dir)
-        FileUtils.mkpath(@dir)
+        temp_dir = "#{config.dir}-#{$PROCESS_ID}-#{Thread.current.object_id}"
+        ::File.rename(config.dir, temp_dir)
+        FileUtils.mkpath(config.dir)
         self
       rescue Errno::ENOENT
         self
@@ -120,7 +128,7 @@ module Moneta
       protected
 
       def store_path(key)
-        ::File.join(@dir, key)
+        ::File.join(config.dir, key)
       end
     end
   end

data/lib/moneta/adapters/fog.rb

@@ -4,19 +4,18 @@ module Moneta
   module Adapters
     # Fog backend (Cloud storage services)
     # @api public
-    class Fog
-      include Defaults
+    class Fog < Adapter
+      config :dir, required: true
 
-      attr_reader :backend
+      backend { |**options| ::Fog::Storage.new(options) }
 
       # @param [Hash] options
       # @option options [String] :dir Fog directory
       # @option options [::Fog::Storage] :backend Use existing backend instance
       # @option options Other options passed to `Fog::Storage#new`
       def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-        @backend = options[:backend] || ::Fog::Storage.new(options)
-        @directory = @backend.directories.get(dir) || @backend.directories.create(key: dir)
+        super
+        @directory = backend.directories.get(config.dir) || backend.directories.create(key: config.dir)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/gdbm.rb

@@ -4,23 +4,17 @@ module Moneta
   module Adapters
     # GDBM backend
     # @api public
-    class GDBM
-      include Defaults
+    class GDBM < Adapter
       include DBMAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::GDBM] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::GDBM.new(options[:file])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::GDBM] :backend Use existing backend instance
+      backend { |file:| ::GDBM.new(file) }
     end
   end
 end

data/lib/moneta/adapters/hbase.rb

@@ -4,10 +4,12 @@ module Moneta
   module Adapters
     # HBase thrift backend
     # @api public
-    class HBase
-      include Defaults
+    class HBase < Adapter
+      config :column, 'value'
+      config :table, 'moneta'
+      config :column_family, 'moneta'
 
-      attr_reader :backend
+      backend { |host: '127.0.0.1', port: 9090| HBaseRb::Client.new(host, port) }
 
       # TODO: Add create support using checkAndPut if added to thrift api
       # https://issues.apache.org/jira/browse/HBASE-3307
@@ -22,14 +24,10 @@ module Moneta
       # @option options [String] :column ('value') Column
       # @option options [::HBaseRb::Client] :backend Use existing backend instance
       def initialize(options = {})
-        options[:column] ||= 'value'
-        options[:table] ||= 'moneta'
-        cf = (options[:column_family] || 'moneta')
-        @column = "#{cf}:#{options[:column]}"
-        @backend = options[:backend] ||
-          HBaseRb::Client.new(options[:host] || '127.0.0.1', options[:port] || '9090')
-        @backend.create_table(options[:table], cf) unless @backend.has_table?(options[:table])
-        @table = @backend.get_table(options[:table])
+        super
+        @column = [config.column_family, config.column].join(':')
+        backend.create_table(config.table, config.column_family) unless backend.has_table?(config.table)
+        @table = backend.get_table(config.table)
       end
 
       # (see Proxy#key?)
@@ -75,7 +73,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 

data/lib/moneta/adapters/kyotocabinet.rb

@@ -4,58 +4,53 @@ module Moneta
   module Adapters
     # KyotoCabinet backend
     # @api public
-    class KyotoCabinet
-      include Defaults
+    class KyotoCabinet < Adapter
       include HashAdapter
 
       supports :each_key, :increment, :create
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::KyotoCabinet::DB] :backend Use existing backend instance
-      def initialize(options = {})
-        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
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::KyotoCabinet::DB] :backend Use existing backend instance
+      backend do |file:|
+        backend = ::KyotoCabinet::DB.new
+        raise backend.error.to_s unless backend.open(file, ::KyotoCabinet::DB::OWRITER | ::KyotoCabinet::DB::OCREATE)
+        backend
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.check(key) >= 0
+        backend.check(key) >= 0
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @backend.seize(key)
+        backend.seize(key)
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @backend.add(key, value)
+        backend.add(key, value)
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Proxy#each_key)
       def each_key
-        return enum_for(:each_key) { @backend.count } unless block_given?
-        @backend.each_key { |arr| yield arr[0] }
+        return enum_for(:each_key) { backend.count } unless block_given?
+        backend.each_key { |arr| yield arr[0] }
         self
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         ret = nil
-        success = @backend.accept(key) do |_, value|
+        success = backend.accept(key) do |_, value|
           ret =
             if value
               Integer(value) + amount
@@ -65,13 +60,13 @@ module Moneta
           ret.to_s
         end
 
-        raise @backend.error unless success
+        raise backend.error unless success
         ret
       end
 
       # (see Proxy#slice)
       def slice(*keys, atomic: true, **options)
-        @backend.get_bulk(keys, atomic)
+        backend.get_bulk(keys, atomic)
       end
 
       # (see Proxy#values_at)
@@ -87,7 +82,7 @@ module Moneta
 
         success =
           if block_given?
-            @backend.transaction(hard) do
+            backend.transaction(hard) do
               existing = slice(*pairs.map { |k, _| k }, **options)
               pairs = pairs.map do |key, new_value|
                 if existing.key?(key)
@@ -96,13 +91,13 @@ module Moneta
                   [key, new_value]
                 end
               end
-              @backend.set_bulk(pairs.to_h, atomic) >= 0
+              backend.set_bulk(pairs.to_h, atomic) >= 0
             end
           else
-            @backend.set_bulk(pairs.to_h, atomic) >= 0
+            backend.set_bulk(pairs.to_h, atomic) >= 0
           end
 
-        raise @backend.error unless success
+        raise backend.error unless success
         self
       end
     end

data/lib/moneta/adapters/leveldb.rb

@@ -4,59 +4,53 @@ module Moneta
   module Adapters
     # LevelDB backend
     # @api public
-    class LevelDB
-      include Defaults
+    class LevelDB < Adapter
       include HashAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @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 = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :dir is required' unless options[:dir]
-            ::LevelDB::DB.new(options[:dir])
-          end
-      end
+      # @!method initialize(options = {})
+      #   @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
+      backend { |dir:| ::LevelDB::DB.new(dir) }
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.includes?(key)
+        backend.includes?(key)
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.each { |k,| delete(k, options) }
+        backend.each { |k,| delete(k, options) }
         self
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        backend.close
         nil
       end
 
       # (see Proxy#each_key)
       def each_key
-        return enum_for(:each_key) { @backend.size } unless block_given?
-        @backend.each { |key, _| yield key }
+        return enum_for(:each_key) { backend.size } unless block_given?
+        backend.each { |key, _| yield key }
         self
       end
 
       # (see Proxy#values_at)
       def values_at(*keys, **options)
         ret = nil
-        @backend.batch { ret = super }
+        backend.batch { ret = super }
         ret
       end
 
       # (see Proxy#merge!)
       def merge!(*keys, **options)
-        @backend.batch { super }
+        backend.batch { super }
         self
       end
     end

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