moneta 1.4.1 → 1.5.1

data/lib/moneta/adapters/couch.rb

@@ -12,9 +12,7 @@ module Moneta
     #     db['key'] = {a: 1, b: 2}
     #
     # @api public
-    class Couch
-      include Defaults
-
+    class Couch < Adapter
       # @api private
       class HTTPError < StandardError
         attr_reader :status, :request_method, :key
@@ -28,10 +26,21 @@ module Moneta
         end
       end
 
-      attr_reader :backend
-
       supports :create, :each_key
 
+      config :value_field, default: 'value'
+      config :type_field, default: 'type'
+      config :login
+      config :password
+      config :adapter
+      config :skip_create_db
+
+      backend do |scheme: 'http', host: '127.0.0.1', port: 5984, db: 'moneta', adapter: nil, **options|
+        ::Faraday.new "#{scheme}://#{host}:#{port}/#{db}", options do |faraday|
+          faraday.adapter adapter if adapter
+        end
+      end
+
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Couch host
       # @option options [String] :port (5984) Couch port
@@ -46,26 +55,22 @@ module Moneta
       # @option options Other options passed to {Faraday::new} (unless
       #   :backend option is provided).
       def initialize(options = {})
-        @value_field = options.delete(:value_field) || 'value'
-        @type_field = options.delete(:type_field) || 'type'
-        login = options.delete(:login)
-        password = options.delete(:password)
-        @backend = options.delete(:backend) || begin
-          host = options.delete(:host) || '127.0.0.1'
-          port = options.delete(:port) || 5984
-          db = options.delete(:db) || 'moneta'
-          scheme = options.delete(:scheme) || 'http'
-          block = if faraday_adapter = options.delete(:adapter)
-                    proc { |faraday| faraday.adapter(faraday_adapter) }
-                  end
-          ::Faraday.new("#{scheme}://#{host}:#{port}/#{db}", options, &block)
+        super
+
+        if config.login && config.password
+          # Faraday 1.x had a `basic_auth` function
+          if backend.respond_to? :basic_auth
+            backend.basic_auth(config.login, config.password)
+          else
+            backend.request :authorization, :basic, config.login, config.password
+          end
         end
-        @backend.basic_auth(login, password) if login && password
+
         @rev_cache = Moneta.build do
           use :Lock
           adapter :LRUHash
         end
-        create_db
+        create_db unless config.skip_create_db
       end
 
       # (see Proxy#key?)
@@ -278,15 +283,15 @@ module Moneta
       end
 
       def doc_to_value(doc)
-        case doc[@type_field]
+        case doc[config.type_field]
         when 'Hash'
           doc = doc.dup
           doc.delete('_id')
           doc.delete('_rev')
-          doc.delete(@type_field)
+          doc.delete(config.type_field)
           doc
         else
-          doc[@value_field]
+          doc[config.value_field]
         end
       end
 
@@ -294,11 +299,11 @@ module Moneta
         doc =
           case value
           when Hash
-            value.merge(@type_field => 'Hash')
+            value.merge(config.type_field => 'Hash')
           when String
-            { @value_field => value, @type_field => 'String' }
+            { config.value_field => value, config.type_field => 'String' }
           when Float, Integer
-            { @value_field => value, @type_field => 'Number' }
+            { config.value_field => value, config.type_field => 'Number' }
           else
             raise ArgumentError, "Invalid value type: #{value.class}"
           end

data/lib/moneta/adapters/datamapper.rb

@@ -7,6 +7,7 @@ module Moneta
     # @api public
     class DataMapper
       include Defaults
+      include Config
       include NilValues
 
       supports :create
@@ -19,15 +20,18 @@ module Moneta
         self.raise_on_save_failure = true
       end
 
+      config :setup, required: true
+      config :repository, default: :moneta, coerce: :to_sym
+      config :table, default: :moneta, coerce: :to_sym
+
       # @param [Hash] options
       # @option options [String] :setup Datamapper setup string
       # @option options [String/Symbol] :repository (:moneta) Repository name
       # @option options [String/Symbol] :table (:moneta) Table name
       def initialize(options = {})
-        raise ArgumentError, 'Option :setup is required' unless options[:setup]
-        @repository = (options.delete(:repository) || :moneta).to_sym
-        Store.storage_names[@repository] = (options.delete(:table) || :moneta).to_s
-        ::DataMapper.setup(@repository, options[:setup])
+        configure(options)
+        Store.storage_names[config.repository] = config.table.to_s
+        ::DataMapper.setup(config.repository, config.setup)
         context { Store.auto_upgrade! }
       end
 
@@ -91,7 +95,7 @@ module Moneta
       private
 
       def context
-        ::DataMapper.repository(@repository) { yield }
+        ::DataMapper.repository(config.repository) { yield }
       end
     end
   end

data/lib/moneta/adapters/daybreak.rb

@@ -4,58 +4,52 @@ module Moneta
   module Adapters
     # Daybreak backend
     # @api public
-    class Daybreak
-      include Defaults
+    class Daybreak < Adapter
       include DBMAdapter
       include IncrementSupport
       include CreateSupport
       include EachKeySupport
 
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::Daybreak] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::Daybreak::DB.new(options[:file], serializer: ::Daybreak::Serializer::None)
-          end
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::Daybreak] :backend Use existing backend instance
+      backend { |file:| ::Daybreak::DB.new(file, serializer: ::Daybreak::Serializer::None) }
 
       # (see Proxy#load)
       def load(key, options = {})
-        @backend.load if options[:sync]
-        @backend[key]
+        backend.load if options[:sync]
+        backend[key]
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend[key] = value
-        @backend.flush if options[:sync]
+        backend[key] = value
+        backend.flush if options[:sync]
         value
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.lock { super }
+        backend.lock { super }
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @backend.lock { super }
+        backend.lock { super }
       end
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
         if block_given?
-          @backend.lock do
-            @backend.update(pairs.map do |key, new_value|
+          backend.lock do
+            backend.update(pairs.map do |key, new_value|
               new_value = yield(key, load(key), new_value) if key?(key)
               [key, new_value]
             end)
           end
         else
-          @backend.update(pairs)
+          backend.update(pairs)
         end
 
         self

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