moneta 1.4.0 → 1.5.0

data/lib/moneta/adapters/cassandra.rb

@@ -4,14 +4,34 @@ module Moneta
   module Adapters
     # Cassandra backend
     # @api public
-    class Cassandra
-      include Defaults
+    class Cassandra < Adapter
       include ExpiresSupport
 
-      attr_reader :backend
-
       supports :each_key
 
+      config :table, default: 'moneta'
+      config :key_column, default: 'key'
+      config :value_column, default: 'value'
+      config :updated_column, default: 'updated_at'
+      config :expired_column, default: 'expired'
+      config :read_consistency, default: :all
+      config :write_consistency, default: :all
+
+      backend do |keyspace: 'moneta', cluster: nil, create_keyspace: nil, **options|
+        cluster ||= ::Cassandra.cluster(options).tap do |own_cluster|
+          @own_cluster = own_cluster
+        end
+
+        begin
+          cluster.connect(keyspace)
+        rescue ::Cassandra::Errors::InvalidError
+          backend = cluster.connect
+          create_keyspace(backend, keyspace, create_keyspace)
+          backend.execute("USE " + keyspace)
+          backend
+        end
+      end
+
       # @param [Hash] options
       # @option options [String] :keyspace ('moneta') Cassandra keyspace
       # @option options [String] :table ('moneta') Cassandra table
@@ -35,39 +55,17 @@ module Moneta
       #   keyspace does not already exist.
       # @option options [::Cassandra::Cluster] :cluster Existing cluster to use
       # @option options [::Cassandra::Session] :backend Existing session to use
-      # @option options Other options passed to `Cassandra#new`
+      # @option options Other options passed to `Cassandra#cluster`
       def initialize(options = {})
-        self.default_expires = options.delete(:expires)
-        keyspace = options.delete(:keyspace) || 'moneta'
-
-        @table = (options.delete(:column_family) || 'moneta').to_sym
-        @key_column = options.delete(:key_column) || 'key'
-        @value_column = options.delete(:value_column) || 'value'
-        @updated_column = options.delete(:updated_column) || 'updated_at'
-        @expired_column = options.delete(:expired_column) || 'expired'
-        @read_consistency = options.delete(:read_consistency) || :all
-        @write_consistency = options.delete(:write_consistency) || :all
-        @create_keyspace = options.delete(:create_keyspace)
-
-        unless @backend = options.delete(:backend)
-          cluster = options.delete(:cluster) || (@own_cluster = ::Cassandra.cluster(options))
-          begin
-            @backend = cluster.connect(keyspace)
-          rescue ::Cassandra::Errors::InvalidError
-            @backend = cluster.connect
-            create_keyspace(keyspace)
-            @backend.execute("USE " + keyspace)
-            @backend
-          end
-        end
-
-        @backend.execute <<-CQL
-          CREATE TABLE IF NOT EXISTS #{@table} (
-            #{@key_column} blob,
-            #{@value_column} blob,
-            #{@updated_column} timeuuid,
-            #{@expired_column} boolean,
-            PRIMARY KEY (#{@key_column}, #{@updated_column})
+        super
+
+        backend.execute <<-CQL
+          CREATE TABLE IF NOT EXISTS #{config.table} (
+            #{config.key_column} blob,
+            #{config.value_column} blob,
+            #{config.updated_column} timeuuid,
+            #{config.expired_column} boolean,
+            PRIMARY KEY (#{config.key_column}, #{config.updated_column})
           )
         CQL
 
@@ -82,18 +80,18 @@ module Moneta
           # whole column, when we want to update the expiry we load the value
           # and then re-set it in order to update the TTL.
           return false unless
-            row = @backend.execute(@load, options.merge(consistency: rc, arguments: [key])).first and
-              row[@expired_column] != nil
-          @backend.execute(@update_expires,
-                           options.merge(consistency: wc,
-                                         arguments: [(expires || 0).to_i,
-                                                     timestamp,
-                                                     row[@value_column],
-                                                     key,
-                                                     row[@updated_column]]))
+            row = backend.execute(@load, options.merge(consistency: rc, arguments: [key])).first and
+              row[config.expired_column] != nil
+          backend.execute(@update_expires,
+                          options.merge(consistency: wc,
+                                        arguments: [(expires || 0).to_i,
+                                                    timestamp,
+                                                    row[config.value_column],
+                                                    key,
+                                                    row[config.updated_column]]))
           true
-        elsif row = @backend.execute(@key, options.merge(consistency: rc, arguments: [key])).first
-          row[@expired_column] != nil
+        elsif row = backend.execute(@key, options.merge(consistency: rc, arguments: [key])).first
+          row[config.expired_column] != nil
         else
           false
         end
@@ -102,17 +100,17 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         rc, wc = consistency(options)
-        if row = @backend.execute(@load, options.merge(consistency: rc, arguments: [key])).first and row[@expired_column] != nil
+        if row = backend.execute(@load, options.merge(consistency: rc, arguments: [key])).first and row[config.expired_column] != nil
           if (expires = expires_value(options, nil)) != nil
-            @backend.execute(@update_expires,
-                             options.merge(consistency: wc,
-                                           arguments: [(expires || 0).to_i,
-                                                       timestamp,
-                                                       row[@value_column],
-                                                       key,
-                                                       row[@updated_column]]))
+            backend.execute(@update_expires,
+                            options.merge(consistency: wc,
+                                          arguments: [(expires || 0).to_i,
+                                                      timestamp,
+                                                      row[config.value_column],
+                                                      key,
+                                                      row[config.updated_column]]))
           end
-          row[@value_column]
+          row[config.value_column]
         end
       end
 
@@ -121,33 +119,33 @@ module Moneta
         _, wc = consistency(options)
         expires = expires_value(options)
         t = timestamp
-        batch = @backend.batch do |batch|
+        batch = backend.batch do |batch|
           batch.add(@store_delete, arguments: [t, key])
           batch.add(@store, arguments: [key, value, (expires || 0).to_i, t + 1])
         end
-        @backend.execute(batch, options.merge(consistency: wc))
+        backend.execute(batch, options.merge(consistency: wc))
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
         rc, wc = consistency(options)
-        result = @backend.execute(@delete_value, options.merge(consistency: rc, arguments: [key]))
-        if row = result.first and row[@expired_column] != nil
-          @backend.execute(@delete, options.merge(consistency: wc, arguments: [timestamp, key, row[@updated_column]]))
-          row[@value_column]
+        result = backend.execute(@delete_value, options.merge(consistency: rc, arguments: [key]))
+        if row = result.first and row[config.expired_column] != nil
+          backend.execute(@delete, options.merge(consistency: wc, arguments: [timestamp, key, row[config.updated_column]]))
+          row[config.value_column]
         end
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.execute(@clear)
+        backend.execute(@clear)
         self
       end
 
       # (see Proxy#close)
       def close
-        @backend.close_async
+        backend.close_async
         @backend = nil
         if @own_cluster
           @own_cluster.close_async
@@ -160,11 +158,11 @@ module Moneta
       def each_key
         rc, = consistency
         return enum_for(:each_key) unless block_given?
-        result = @backend.execute(@each_key, consistency: rc, page_size: 100)
+        result = backend.execute(@each_key, consistency: rc, page_size: 100)
         loop do
           result.each do |row|
-            next if row[@expired_column] == nil
-            yield row[@key_column]
+            next if row[config.expired_column] == nil
+            yield row[config.key_column]
           end
 
           break if result.last_page?
@@ -176,27 +174,27 @@ module Moneta
       # (see Proxy#slice)
       def slice(*keys, **options)
         rc, wc = consistency(options)
-        result = @backend.execute(@slice, options.merge(consistency: rc, arguments: [keys]))
+        result = backend.execute(@slice, options.merge(consistency: rc, arguments: [keys]))
         expires = expires_value(options, nil)
         updated = [] if expires != nil
         pairs = result.map do |row|
-          next if row[@expired_column] == nil
+          next if row[config.expired_column] == nil
           if expires != nil
-            updated << [row[@key_column], row[@value_column], row[@updated_column]]
+            updated << [row[config.key_column], row[config.value_column], row[config.updated_column]]
           end
-          [row[@key_column], row[@value_column]]
+          [row[config.key_column], row[config.value_column]]
         end.compact
 
         if expires != nil && !updated.empty?
           ttl = (expires || 0).to_i
           t = timestamp
-          batch = @backend.batch do |batch|
+          batch = backend.batch do |batch|
             updated.each do |key, value, updated|
               batch.add(@update_expires, arguments: [ttl, t, value, key, updated])
             end
           end
 
-          @backend.execute(batch, options.merge(consistency: wc))
+          backend.execute(batch, options.merge(consistency: wc))
         end
 
         pairs
@@ -240,13 +238,13 @@ module Moneta
         _rc, wc = consistency(options)
         expires = expires_value(options)
         t = timestamp
-        batch = @backend.batch do |batch|
+        batch = backend.batch do |batch|
           batch.add(@merge_delete, arguments: [t, keys])
           pairs.each do |key, value|
             batch.add(@store, arguments: [key, value, (expires || 0).to_i, t + 1])
           end
         end
-        @backend.execute(batch, options.merge(consistency: wc))
+        backend.execute(batch, options.merge(consistency: wc))
 
         self
       end
@@ -257,7 +255,7 @@ module Moneta
         (Time.now.to_r * 1_000_000).to_i
       end
 
-      def create_keyspace(keyspace)
+      def create_keyspace(backend, keyspace, create_keyspace)
         options = {
           replication: {
             class: 'SimpleStrategy',
@@ -265,13 +263,13 @@ module Moneta
           }
         }
 
-        case @create_keyspace
+        case create_keyspace
         when Proc
-          return @create_keyspace.call(keyspace)
+          return create_keyspace.call(keyspace)
         when false
           return
         when Hash
-          options.merge!(@create_keyspace)
+          options.merge!(create_keyspace)
         end
 
         # This is a bit hacky, but works.  Options in Cassandra look like JSON,
@@ -281,7 +279,7 @@ module Moneta
           key.to_s + ' = ' + MultiJson.dump(value).tr(?", ?')
         end.join(' AND ')
 
-        @backend.execute "CREATE KEYSPACE IF NOT EXISTS %<keyspace>s WITH %<options>s" % {
+        backend.execute "CREATE KEYSPACE IF NOT EXISTS %<keyspace>s WITH %<options>s" % {
           keyspace: keyspace,
           options: option_str
         }
@@ -291,65 +289,65 @@ module Moneta
       end
 
       def prepare_statements
-        @key = @backend.prepare(<<-CQL)
-          SELECT #{@updated_column}, #{@expired_column}
-          FROM #{@table} WHERE #{@key_column} = ?
+        @key = backend.prepare(<<-CQL)
+          SELECT #{config.updated_column}, #{config.expired_column}
+          FROM #{config.table} WHERE #{config.key_column} = ?
           LIMIT 1
         CQL
-        @store_delete = @backend.prepare(<<-CQL)
-          DELETE FROM #{@table}
+        @store_delete = backend.prepare(<<-CQL)
+          DELETE FROM #{config.table}
           USING TIMESTAMP ?
-          WHERE #{@key_column} = ?
+          WHERE #{config.key_column} = ?
         CQL
-        @store = @backend.prepare(<<-CQL)
-          INSERT INTO #{@table} (#{@key_column}, #{@value_column}, #{@updated_column}, #{@expired_column})
+        @store = backend.prepare(<<-CQL)
+          INSERT INTO #{config.table} (#{config.key_column}, #{config.value_column}, #{config.updated_column}, #{config.expired_column})
           VALUES (?, ?, now(), false)
           USING TTL ? AND TIMESTAMP ?
         CQL
-        @load = @backend.prepare(<<-CQL)
-          SELECT #{@value_column}, #{@updated_column}, #{@expired_column}
-          FROM #{@table}
-          WHERE #{@key_column} = ?
+        @load = backend.prepare(<<-CQL)
+          SELECT #{config.value_column}, #{config.updated_column}, #{config.expired_column}
+          FROM #{config.table}
+          WHERE #{config.key_column} = ?
           LIMIT 1
         CQL
-        @update_expires = @backend.prepare(<<-CQL)
-          UPDATE #{@table}
+        @update_expires = backend.prepare(<<-CQL)
+          UPDATE #{config.table}
           USING TTL ? AND TIMESTAMP ?
-          SET #{@value_column} = ?, #{@expired_column} = false
-          WHERE #{@key_column} = ? AND #{@updated_column} = ?
+          SET #{config.value_column} = ?, #{config.expired_column} = false
+          WHERE #{config.key_column} = ? AND #{config.updated_column} = ?
         CQL
-        @clear = @backend.prepare("TRUNCATE #{@table}")
-        @delete_value = @backend.prepare(<<-CQL)
-          SELECT #{@value_column}, #{@updated_column}, #{@expired_column}
-          FROM #{@table}
-          WHERE #{@key_column} = ?
+        @clear = backend.prepare("TRUNCATE #{config.table}")
+        @delete_value = backend.prepare(<<-CQL)
+          SELECT #{config.value_column}, #{config.updated_column}, #{config.expired_column}
+          FROM #{config.table}
+          WHERE #{config.key_column} = ?
           LIMIT 1
         CQL
-        @delete = @backend.prepare(<<-CQL, idempotent: true)
-          DELETE FROM #{@table}
+        @delete = backend.prepare(<<-CQL, idempotent: true)
+          DELETE FROM #{config.table}
           USING TIMESTAMP ?
-          WHERE #{@key_column} = ? AND #{@updated_column} = ?
+          WHERE #{config.key_column} = ? AND #{config.updated_column} = ?
         CQL
-        @each_key = @backend.prepare(<<-CQL)
-          SELECT #{@key_column}, #{@expired_column}
-          FROM #{@table}
+        @each_key = backend.prepare(<<-CQL)
+          SELECT #{config.key_column}, #{config.expired_column}
+          FROM #{config.table}
         CQL
-        @slice = @backend.prepare(<<-CQL)
-          SELECT #{@key_column}, #{@value_column}, #{@updated_column}, #{@expired_column}
-          FROM #{@table}
-          WHERE #{@key_column} IN ?
+        @slice = backend.prepare(<<-CQL)
+          SELECT #{config.key_column}, #{config.value_column}, #{config.updated_column}, #{config.expired_column}
+          FROM #{config.table}
+          WHERE #{config.key_column} IN ?
         CQL
-        @merge_delete = @backend.prepare(<<-CQL)
-          DELETE FROM #{@table}
+        @merge_delete = backend.prepare(<<-CQL)
+          DELETE FROM #{config.table}
           USING TIMESTAMP ?
-          WHERE #{@key_column} IN ?
+          WHERE #{config.key_column} IN ?
         CQL
       end
 
       def consistency(options = {})
         [
-          options[:read_consistency] || @read_consistency,
-          options[:write_consistency] || @write_consistency
+          options[:read_consistency] || config.read_consistency,
+          options[:write_consistency] || config.write_consistency
         ]
       end
     end

data/lib/moneta/adapters/client.rb

@@ -4,20 +4,19 @@ module Moneta
   module Adapters
     # Moneta client backend
     # @api public
-    class Client
-      include Defaults
-
-      # @param [Hash] options
-      # @option options [Integer] :port (9000) TCP port
-      # @option options [String] :host ('127.0.0.1') Hostname
-      # @option options [String] :socket Unix socket file name as alternative to `:port` and `:host`
-      def initialize(options = {})
-        @socket =
-          if options[:socket]
-            UNIXSocket.open(options[:socket])
-          else
-            TCPSocket.open(options[:host] || '127.0.0.1', options[:port] || 9000)
-          end
+    class Client < Adapter
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [TCPSocket | UNIXSocket] :backend an open socket to use
+      #   @option options [Integer] :port (9000) TCP port
+      #   @option options [String] :host ('127.0.0.1') Hostname
+      #   @option options [String] :socket Unix socket file name as alternative to `:port` and `:host`
+      backend do |socket: nil, host: '127.0.0.1', port: 9000|
+        if socket
+          UNIXSocket.open(socket)
+        else
+          TCPSocket.open(host, port)
+        end
       end
 
       # (see Proxy#key?)
@@ -66,7 +65,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @socket.close
+        backend.close
         nil
       end
 
@@ -114,19 +113,19 @@ module Moneta
 
       def write(*args)
         s = Marshal.dump(args)
-        @socket.write([s.bytesize].pack('N') << s)
+        backend.write([s.bytesize].pack('N') << s)
       end
 
       # JRuby doesn't support socket#recv with flags
       if defined?(JRUBY_VERSION)
         def read(bytes)
-          received = @socket.read(bytes)
+          received = backend.read(bytes)
           raise EOFError, "Server closed socket" unless received && received.bytesize == bytes
           received
         end
       else
         def read(bytes)
-          received = @socket.recv(bytes, Socket::MSG_WAITALL)
+          received = backend.recv(bytes, Socket::MSG_WAITALL)
           raise EOFError, "Server closed socket" unless received && received.bytesize == bytes
           received
         end

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