moneta 1.1.1 → 1.2.0

data/README.md

@@ -1,6 +1,9 @@
 # Moneta: A unified interface for key/value stores
 
-[![Gem Version](https://badge.fury.io/rb/moneta.svg)](http://rubygems.org/gems/moneta) [![Build Status](https://secure.travis-ci.org/moneta-rb/moneta.svg?branch=master)](http://travis-ci.org/moneta-rb/moneta) [![Code Climate](https://codeclimate.com/github/moneta-rb/moneta.svg)](https://codeclimate.com/github/moneta-rb/moneta) [![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=min4d&url=https://github.com/moneta-rb/moneta&title=Moneta&language=&tags=github&category=software)
+[![Gem Version](https://badge.fury.io/rb/moneta.svg)](http://rubygems.org/gems/moneta)
+[![Build Status](https://secure.travis-ci.org/moneta-rb/moneta.svg?branch=master)](http://travis-ci.org/moneta-rb/moneta)
+[![Code Climate](https://codeclimate.com/github/moneta-rb/moneta.svg)](https://codeclimate.com/github/moneta-rb/moneta)
+[![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=min4d&url=https://github.com/moneta-rb/moneta&title=Moneta&language=&tags=github&category=software)
 
 Moneta provides a standard interface for interacting with various kinds of key/value stores. Moneta supports the well-known
 NoSQL and document based stores.
@@ -75,6 +78,9 @@ store.close
 * API documentation:
     * Latest Gem: <http://rubydoc.info/gems/moneta/frames>
     * GitHub master: <http://rubydoc.info/github/moneta-rb/moneta/master/frames>
+* Changelog: <https://github.com/moneta-rb/moneta/blob/master/CHANGES>
+
+In case you are wondering, Moneta uses [Semantic Versioning](https://semver.org/) since v1.0.0.
 
 ------
 
@@ -164,7 +170,7 @@ __NOTE:__ <a name="backend-matrix"></a>The backend matrix is much more readable
 
 <tr><td>DBM</td><td>-</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://www.ruby-doc.org/stdlib/libdoc/dbm/rdoc/DBM.html">Berkeley DB using DBM interface or NDBM (Depends on Ruby environment)</a></td></tr>
 
-<tr><td>GDBM</td><td>-</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://www.ruby-doc.org/stdlib/libdoc/gdbm/rdoc/GDBM.html">GDBM</a> database</td></tr>
+<tr><td>GDBM</td><td>ffi-gdbm on JRuby</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://www.ruby-doc.org/stdlib/libdoc/gdbm/rdoc/GDBM.html">GDBM</a> database</td></tr>
 
 <tr><td>LevelDB</td><td>leveldb</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#F44">✗</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td style="text-align:center;background:#5F5">✓</td><td><a href="http://code.google.com/p/leveldb/">LevelDB</a> database</td></tr>
 
@@ -235,17 +241,37 @@ __NOTE:__ <a name="backend-matrix"></a>The backend matrix is much more readable
 In addition it supports proxies (Similar to [Rack middlewares](http://rack.github.com/)) which
 add additional features to storage backends:
 
-* `Moneta::Proxy` and `Moneta::Wrapper` proxy base classes
-* `Moneta::Expires` to add expiration support to stores which don't support it natively. Add it in the builder using `use :Expires`.
-* `Moneta::Stack` to stack multiple stores (Read returns result from first where the key is found, writes go to all stores). Add it in the builder using `use(:Stack) {}`.
-* `Moneta::Transformer` transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...). Add it in the builder using `use :Transformer`.
-* `Moneta::Cache` combine two stores, one as backend and one as cache (e.g. `Moneta::Adapters::File` + `Moneta::Adapters::LRUHash`). Add it in the builder using `use(:Cache) {}`.
-* `Moneta::Lock` to make store thread safe. Add it in the builder using `use :Lock`.
-* `Moneta::Pool` to create a pool of stores as a means of making the store thread safe. Add it in the builder using `use(:Pool) {}`.
-* `Moneta::Logger` to log database accesses. Add it in the builder using `use :Logger`.
-* `Moneta::Shared` to share a store between multiple processes. Add it in the builder using `use(:Shared) {}`.
-* `Moneta::WeakIncrement` and `Moneta::WeakCreate` to add `#create` and `#increment` support without atomicity (weak) to stores which don't support it.
-* `Moneta::WeakEachKey` to add key traversal to stores that don't support it, with the important caveat that only those keys previously seen by this proxy will be traversed.
+* `Moneta::Proxy` and `Moneta::Wrapper` are the proxy base classes.
+* `Moneta::Cache` combine two stores, one as backend and one as cache (e.g.
+  `Moneta::Adapters::File` + `Moneta::Adapters::LRUHash`). Add it in the
+  builder using `use(:Cache) {}`.
+* `Moneta::Expires` to add expiration support to stores which don't support it
+  natively. Add it in the builder using `use :Expires`.
+* `Moneta::Fallback` use a store as a fallback when exceptions occur (by default the
+  `:Null` adapter is used so that an error results in a no-op). Add it to the
+  builder using `use(:Fallback, rescue: IOError)`
+* `Moneta::Lock` to make store thread safe. Add it in the builder using `use
+  :Lock`.
+* `Moneta::Logger` to log database accesses. Add it in the builder using `use
+  :Logger`.
+* `Moneta::Pool` to create a pool of stores as a means of making the store
+  thread safe. Add it in the builder using `use(:Pool, min: 2, max: 4, ttl: 60,
+  timeout: 5) {}`.
+* `Moneta::Shared` to share a store between multiple processes. Add it in the
+  builder using `use(:Shared) {}`.
+* `Moneta::Stack` to stack multiple stores (Read returns result from first
+  where the key is found, writes go to all stores). Add it in the builder using
+  `use(:Stack) {}`.
+* `Moneta::Transformer` transforms keys and values (Marshal, YAML, JSON,
+  Base64, MD5, ...). Add it in the builder using `use :Transformer`.
+* `Moneta::WeakIncrement` and `Moneta::WeakCreate` to add `#create` and
+  `#increment` support without atomicity (weak) to stores which don't support
+  it.
+* `Moneta::WeakEachKey` to add key traversal to stores that don't support it,
+  with the important caveat that only those keys previously seen by this proxy
+  will be traversed.
+
+Check the YARD documentation for more information and examples.
 
 ### Serializers and compressors (`Moneta::Transformer`)
 
@@ -887,7 +913,7 @@ Person.adapter :memory, Moneta.new(:Redis)
 
 ## Testing and Benchmarks
 
-Testing is done using [Travis-CI](http://travis-ci.org/moneta-rb/moneta). Currently we support Ruby >= 1.9.3.
+Testing is done using [Travis-CI](http://travis-ci.org/moneta-rb/moneta). Currently we support MRI Ruby >= 2.2.2 and JRuby 9.2.x.
 
 Benchmarks for each store are done on [Travis-CI](http://travis-ci.org/moneta-rb/moneta) for each build. Take a look there
 to compare the speed of the different key value stores for different key/value sizes and size distributions.

data/feature_matrix.yaml

@@ -82,6 +82,7 @@ backends:
     description: "[Berkeley DB using DBM interface or NDBM (Depends on Ruby environment)](http://www.ruby-doc.org/stdlib/libdoc/dbm/rdoc/DBM.html)"
   - adapter: GDBM
     platforms: [ MRI, JRuby ]
+    gems: ffi-gdbm on JRuby
     features: [ increment, create, each_key, bulk_read, bulk_write ]
     description: "[GDBM](http://www.ruby-doc.org/stdlib/libdoc/gdbm/rdoc/GDBM.html) database"
   - adapter: LevelDB

data/lib/action_dispatch/middleware/session/moneta_store.rb

@@ -3,6 +3,7 @@ require 'action_dispatch/middleware/session/abstract_store'
 
 module ActionDispatch
   module Session
+    # A Rails cache backed by any Moneta store
     class MonetaStore < Rack::Session::Moneta
       include Compatibility
       include StaleSessionCheck

data/lib/active_support/cache/moneta_store.rb

@@ -79,7 +79,7 @@ module ActiveSupport
         def write_multi(hash, options = nil)
           options = merged_options(options)
 
-          instrument :write_multi, hash, options do |payload|
+          instrument :write_multi, hash, options do
             entries = hash.each_with_object({}) do |(name, value), memo|
               memo[normalize_key(name, options)] = \
                 Entry.new(value, options.merge(version: normalize_version(name, options)))
@@ -118,12 +118,12 @@ module ActiveSupport
 
       def read_multi_entries(names, options)
         keys = names.map { |name| normalize_key(name, options) }
-        entries = @store.
-          values_at(*keys, **moneta_options(options, false)).
-          map(&method(:make_entry))
+        entries = @store
+          .values_at(*keys, **moneta_options(options, false))
+          .map(&method(:make_entry))
 
         names.zip(keys, entries).map do |name, key, entry|
-          next if entry.nil?
+          next if entry == nil
           delete_entry(key, options) if entry.expired?
           next if entry.expired? || entry.mismatched?(normalize_version(name, options))
 

data/lib/moneta.rb

@@ -1,11 +1,17 @@
+# Provides two methods for constructing stores:
+#
+# * {Moneta.new}
+# * {Moneta.build}
 module Moneta
   autoload :Builder,           'moneta/builder'
   autoload :Cache,             'moneta/cache'
   autoload :CreateSupport,     'moneta/mixins'
   autoload :Defaults,          'moneta/mixins'
   autoload :EachKeySupport,    'moneta/mixins'
+  autoload :Enumerable,        'moneta/enumerable'
   autoload :ExpiresSupport,    'moneta/mixins'
   autoload :Expires,           'moneta/expires'
+  autoload :Fallback,          'moneta/fallback'
   autoload :HashAdapter,       'moneta/mixins'
   autoload :IncrementSupport,  'moneta/mixins'
   autoload :Lock,              'moneta/lock'
@@ -26,9 +32,11 @@ module Moneta
   autoload :WeakIncrement,     'moneta/weak'
   autoload :Wrapper,           'moneta/wrapper'
 
+  # Adapters are classes which wrap databases, services etc., as described in
+  # {file:SPEC.md The Moneta Specification}.
   module Adapters
     autoload :ActiveRecord,    'moneta/adapters/activerecord'
-    autoload :ActiveSupportCache,'moneta/adapters/activesupportcache'
+    autoload :ActiveSupportCache, 'moneta/adapters/activesupportcache'
     autoload :Cassandra,       'moneta/adapters/cassandra'
     autoload :Client,          'moneta/adapters/client'
     autoload :Cookie,          'moneta/adapters/cookie'

data/lib/moneta/adapters/activerecord.rb

@@ -40,7 +40,8 @@ module Moneta
       # @param [Hash] options
       # @option options [Object]               :backend A class object inheriting from ActiveRecord::Base to use as a table
       # @option options [String]               :table ('moneta') Table name
-      # @option options [Hash/String/Symbol]   :connection ActiveRecord connection configuration (`Hash` or `String`), or symbol giving the name of a Rails connection (e.g. :production)
+      # @option options [Hash/String/Symbol]   :connection ActiveRecord connection configuration (`Hash` or `String`), or
+      #   symbol giving the name of a Rails connection (e.g. :production)
       # @option options [Proc, Boolean]        :create_table Proc called with a connection if table
       #   needs to be created.  Pass false to skip the create table check all together.
       # @option options [Symbol]               :key_column (:k) The name of the column to use for keys
@@ -87,7 +88,7 @@ module Moneta
 
           table_name = (options.delete(:table) || :moneta).to_sym
           create_table_proc = options.delete(:create_table)
-          if create_table_proc.nil?
+          if create_table_proc == nil
             create_table(table_name)
           elsif create_table_proc
             with_connection(&create_table_proc)
@@ -164,10 +165,11 @@ module Moneta
             end
           end
         end
-      rescue ::ActiveRecord::RecordNotUnique
-        # This handles the "no row updated" issue, above
+      rescue ::ActiveRecord::RecordNotUnique, ::ActiveRecord::Deadlocked
+        # This handles the "no row updated" issue, above, as well as deadlocks
+        # which may occur on some adapters
         tries ||= 0
-        if (tries += 1) <= 3; retry else raise end
+        (tries += 1) <= 3 ? retry : raise
       end
 
       # (see Proxy#create)
@@ -197,14 +199,32 @@ module Moneta
       # (see Proxy#slice)
       def slice(*keys, lock: false, **options)
         with_connection do |conn|
-          sel = arel_slice(keys).project(table[key_column], table[value_column])
-          sel = sel.lock if lock
-          result = conn.select_all(sel)
+          conn.create_table(:slice_keys, temporary: true) do |t|
+            t.string :key, null: false
+          end
 
-          k = key_column.to_s
-          v = value_column.to_s
-          result.map do |row|
-            [row[k], decode(conn, row[v])]
+          begin
+            temp_table = ::Arel::Table.new(:slice_keys)
+            keys.each do |key|
+              conn.insert ::Arel::InsertManager.new
+                .into(temp_table)
+                .insert([[temp_table[:key], key]])
+            end
+
+            sel = arel_sel
+              .join(temp_table)
+              .on(table[key_column].eq(temp_table[:key]))
+              .project(table[key_column], table[value_column])
+            sel = sel.lock if lock
+            result = conn.select_all(sel)
+
+            k = key_column.to_s
+            v = value_column.to_s
+            result.map do |row|
+              [row[k], decode(conn, row[v])]
+            end
+          ensure
+            conn.drop_table(:slice_keys)
           end
         end
       end
@@ -255,7 +275,7 @@ module Moneta
         self.class.retrieve_or_establish_connection_pool(@spec)
       end
 
-      def create_table table_name
+      def create_table(table_name)
         with_connection do |conn|
           return if conn.table_exists?(table_name)
 
@@ -287,10 +307,6 @@ module Moneta
         arel_sel.where(table[key_column].eq(key))
       end
 
-      def arel_slice(keys)
-        arel_sel.where(table[key_column].eq_any(keys))
-      end
-
       def conn_ins(conn, key, value)
         ins = ::Arel::InsertManager.new.into(table)
         ins.insert([[table[key_column], key], [table[value_column], value]])
@@ -311,7 +327,7 @@ module Moneta
         elsif conn.respond_to?(:escape_bytea)
           conn.escape_bytea(value)
         elsif defined?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter) &&
-              conn.is_a?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+            conn.is_a?(::ActiveRecord::ConnectionAdapters::SQLite3Adapter)
           Arel::Nodes::SqlLiteral.new("X'#{value.unpack('H*').first}'")
         else
           value
@@ -322,7 +338,7 @@ module Moneta
         if value == nil
           nil
         elsif defined?(::ActiveModel::Type::Binary::Data) &&
-          value.is_a?(::ActiveModel::Type::Binary::Data)
+            value.is_a?(::ActiveModel::Type::Binary::Data)
           value.to_s
         elsif conn.respond_to?(:unescape_bytea)
           conn.unescape_bytea(value)

data/lib/moneta/adapters/activesupportcache.rb

@@ -25,7 +25,7 @@ module Moneta
       # (see Proxy#key?)
       def key?(key, options = {})
         @backend.exist?(key).tap do |exists|
-          if exists && !(expires = expires_value(options, nil)).nil?
+          if exists && (expires = expires_value(options, nil)) != nil
             value = @backend.read(key, options)
             @backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
           end
@@ -36,14 +36,10 @@ module Moneta
       def load(key, options = {})
         expires = expires_value(options, nil)
         value = @backend.read(key, options)
-        if value and !expires.nil?
+        if value and expires != nil
           @backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
         end
-        if options[:raw]
-          value && value.to_s
-        else
-          value
-        end
+        value
       end
 
       # (see Proxy#store)

data/lib/moneta/adapters/cassandra.rb

@@ -83,10 +83,14 @@ module Moneta
           # 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[@expired_column] != nil
+          @backend.execute(@update_expires,
+                           options.merge(consistency: wc,
+                                         arguments: [(expires || 0).to_i,
+                                                     timestamp,
+                                                     row[@value_column],
+                                                     key,
+                                                     row[@updated_column]]))
           true
         elsif row = @backend.execute(@key, options.merge(consistency: rc, arguments: [key])).first
           row[@expired_column] != nil
@@ -100,9 +104,13 @@ module Moneta
         rc, wc = consistency(options)
         if row = @backend.execute(@load, options.merge(consistency: rc, arguments: [key])).first and row[@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[@value_column],
+                                                       key,
+                                                       row[@updated_column]]))
           end
           row[@value_column]
         end
@@ -150,7 +158,7 @@ module Moneta
 
       # (see Proxy#each_key)
       def each_key
-        rc, _ = consistency
+        rc, = consistency
         return enum_for(:each_key) unless block_given?
         result = @backend.execute(@each_key, consistency: rc, page_size: 100)
         loop do
@@ -229,7 +237,7 @@ module Moneta
           end
         end
 
-        rc, wc = consistency(options)
+        _rc, wc = consistency(options)
         expires = expires_value(options)
         t = timestamp
         batch = @backend.batch do |batch|
@@ -270,16 +278,16 @@ module Moneta
         # but use single quotes instead of double-quotes.
         require 'multi_json'
         option_str = options.map do |key, value|
-          key.to_s + ' = ' +  MultiJson.dump(value).gsub('"', "'")
+          key.to_s + ' = ' + MultiJson.dump(value).tr(?", ?')
         end.join(' AND ')
 
-        @backend.execute "CREATE KEYSPACE IF NOT EXISTS %s WITH %s" % [
-          keyspace,
-          option_str
-        ]
+        @backend.execute "CREATE KEYSPACE IF NOT EXISTS %<keyspace>s WITH %<options>s" % {
+          keyspace: keyspace,
+          options: option_str
+        }
       rescue ::Cassandra::Errors::TimeoutError
         tries ||= 0
-        if (tries += 1) <= 3; retry else raise end
+        (tries += 1) <= 3 ? retry : raise
       end
 
       def prepare_statements
@@ -338,7 +346,7 @@ module Moneta
         CQL
       end
 
-      def consistency(options={})
+      def consistency(options = {})
         [
           options[:read_consistency] || @read_consistency,
           options[:write_consistency] || @write_consistency

data/lib/moneta/adapters/client.rb

@@ -12,8 +12,12 @@ module Moneta
       # @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 = options[:socket] ? UNIXSocket.open(options[:socket]) :
-          TCPSocket.open(options[:host] || '127.0.0.1', options[:port] || 9000)
+        @socket =
+          if options[:socket]
+            UNIXSocket.open(options[:socket])
+          else
+            TCPSocket.open(options[:host] || '127.0.0.1', options[:port] || 9000)
+          end
       end
 
       # (see Proxy#key?)
@@ -83,15 +87,15 @@ module Moneta
       end
 
       def read
-        size = @socket.
-          recv(4).tap do |bytes|
-            raise EOFError.new('failed to read size') unless bytes.bytesize == 4
-          end.
-          unpack('N').
-          first
+        size = @socket
+          .recv(4).tap do |bytes|
+            raise EOFError, 'failed to read size' unless bytes.bytesize == 4
+          end
+          .unpack('N')
+          .first
 
         result = Marshal.load(@socket.recv(size).tap do |bytes|
-          raise EOFError.new("Not enough bytes read") unless bytes.bytesize == size
+          raise EOFError, 'Not enough bytes read' unless bytes.bytesize == size
         end)
 
         raise result if Exception === result

data/lib/moneta/adapters/couch.rb

@@ -1,6 +1,5 @@
 require 'faraday'
 require 'multi_json'
-require 'uri'
 
 module Moneta
   module Adapters
@@ -16,6 +15,19 @@ module Moneta
     class Couch
       include Defaults
 
+      # @api private
+      class HTTPError < StandardError
+        attr_reader :status, :request_method, :key
+
+        def initialize(status, request_method, key)
+          @status = status
+          @request_method = request_method.to_sym
+          @key = key
+
+          super "HTTP Error: #{@status} (#{@request_method.to_s.upcase} #{@key})"
+        end
+      end
+
       attr_reader :backend
 
       supports :create, :each_key
@@ -24,14 +36,26 @@ module Moneta
       # @option options [String] :host ('127.0.0.1') Couch host
       # @option options [String] :port (5984) Couch port
       # @option options [String] :db ('moneta') Couch database
+      # @option options [String] :scheme ('http') HTTP scheme to use
       # @option options [String] :value_field ('value') Document field to store value
       # @option options [String] :type_field ('type') Document field to store value type
-      # @option options [Faraday connection] :backend Use existing backend instance
+      # @option options [Symbol] :adapter Adapter to use with Faraday
+      # @option options [Faraday::Connecton] :backend Use existing backend instance
+      # @option options Other options passed to {Faraday::new} (unless
+      #   :backend option is provided).
       def initialize(options = {})
-        @value_field = options[:value_field] || 'value'
-        @type_field = options[:type_field] || 'type'
-        url = "http://#{options[:host] || '127.0.0.1'}:#{options[:port] || 5984}/#{options[:db] || 'moneta'}"
-        @backend = options[:backend] || ::Faraday.new(url: url)
+        @value_field = options.delete(:value_field) || 'value'
+        @type_field = options.delete(:type_field) || 'type'
+        @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)
+        end
         @rev_cache = Moneta.build do
           use :Lock
           adapter :LRUHash
@@ -40,68 +64,121 @@ module Moneta
       end
 
       # (see Proxy#key?)
+      # @option options [Boolean] :cache_rev (true) Whether to cache the rev of
+      #   the document for faster updating
       def key?(key, options = {})
-        response = @backend.head(key)
-        update_rev_cache(key, response)
-        response.status == 200
+        cache_rev = options[:cache_rev] != false
+        head(key, cache_rev: cache_rev)
       end
 
       # (see Proxy#load)
+      # @option (see #key?)
       def load(key, options = {})
-        response = @backend.get(key)
-        update_rev_cache(key, response)
-        response.status == 200 ? body_to_value(response.body) : nil
+        cache_rev = options[:cache_rev] != false
+        doc = get(key, cache_rev: cache_rev)
+        doc ? doc_to_value(doc) : nil
       end
 
       # (see Proxy#store)
+      # @option (see #key?)
+      # @option options [Boolean] :batch (false) Whether to do a
+      #   {https://docs.couchdb.org/en/stable/api/database/common.html#api-doc-batch-writes
+      #    batch mode write}
+      # @option options [Boolean] :full_commit (nil) Set to `true` or `false`
+      #   to override the server's
+      #   {https://docs.couchdb.org/en/stable/config/couchdb.html#couchdb/delayed_commits
+      #    commit policy}
       def store(key, value, options = {})
-        body = value_to_body(value, rev(key))
-        response = @backend.put(key, body, 'Content-Type' => 'application/json')
-        update_rev_cache(key, response)
-        raise "HTTP error #{response.status} (PUT /#{key})" unless response.status == 201
+        put(key, value_to_doc(value, rev(key)),
+            headers: full_commit_header(options[:full_commit]),
+            query: options[:batch] ? { batch: 'ok' } : {},
+            cache_rev: options[:cache_rev] != false,
+            expect: options[:batch] ? 202 : 201)
         value
-      rescue
+      rescue HTTPError
         tries ||= 0
         (tries += 1) < 10 ? retry : raise
       end
 
       # (see Proxy#delete)
+      # @option options [Boolean] :batch (false) Whether to do a
+      #   {https://docs.couchdb.org/en/stable/api/database/common.html#api-doc-batch-writes
+      #    batch mode write}
+      # @option options [Boolean] :full_commit (nil) Set to `true` or `false`
+      #   to override the server's
+      #   {https://docs.couchdb.org/en/stable/config/couchdb.html#couchdb/delayed_commits
+      #    commit policy}
       def delete(key, options = {})
-        clear_rev_cache(key)
-        get_response = @backend.get(key)
-        if get_response.status == 200
-          existing_rev = get_response['etag'][1..-2]
+        get_response = get(key, returns: :response)
+        if get_response.success?
           value = body_to_value(get_response.body)
-          delete_response = @backend.delete("#{key}?rev=#{existing_rev}")
-          raise "HTTP error #{response.status}" unless delete_response.status == 200
+          existing_rev = parse_rev(get_response)
+          query = { rev: existing_rev }
+          query[:batch] = 'ok' if options[:batch]
+          request(:delete, key,
+                  headers: full_commit_header(options[:full_commit]),
+                  query: query,
+                  expect: options[:batch] ? 202 : 200)
+          delete_cached_rev(key)
           value
         end
-      rescue
+      rescue HTTPError
         tries ||= 0
         (tries += 1) < 10 ? retry : raise
       end
 
       # (see Proxy#clear)
+      # @option options [Boolean] :compact (false) Whether to compact the database after clearing
+      # @option options [Boolean] :await_compact (false) Whether to wait for compaction to complete
+      #   before returning.
+      # @option options [Boolean] :full_commit (nil) Set to `true` or `false`
+      #   to override the server's
+      #   {https://docs.couchdb.org/en/stable/config/couchdb.html#couchdb/delayed_commits
+      #    commit policy}
       def clear(options = {})
-        @backend.delete ''
-        create_db
+        loop do
+          docs = all_docs(limit: 10_000)
+          break if docs['rows'].empty?
+          deletions = docs['rows'].map do |row|
+            { _id: row['id'], _rev: row['value']['rev'], _deleted: true }
+          end
+          bulk_docs(deletions, full_commit: options[:full_commit])
+        end
+
+        # Compact the database unless told not to
+        if options[:compact]
+          post('_compact', expect: 202)
+
+          # Performance won't be great while compaction is happening, so by default we wait for it
+          if options[:await_compact]
+            loop do
+              db_info = get('', expect: 200)
+              break unless db_info['compact_running']
+
+              # wait before checking again
+              sleep 1
+            end
+          end
+        end
+
         self
       end
 
       # (see Proxy#create)
+      # @option (see #key?)
       def create(key, value, options = {})
-        body = value_to_body(value, nil)
-        response = @backend.put(key, body, 'Content-Type' => 'application/json')
-        update_rev_cache(key, response)
+        cache_rev = options[:cache_rev] != false
+        doc = value_to_doc(value, nil)
+        response = put(key, doc, cache_rev: cache_rev, returns: :response)
         case response.status
         when 201
           true
         when 409
           false
         else
-          raise "HTTP error #{response.status}"
+          raise HTTPError.new(response.status, :put, @backend.create_url(key))
         end
-      rescue
+      rescue HTTPError
         tries ||= 0
         (tries += 1) < 10 ? retry : raise
       end
@@ -112,21 +189,14 @@ module Moneta
 
         skip = 0
         limit = 1000
-        total_rows = 1
-        while total_rows > skip do
-          response = @backend.get("_all_docs?" + encode_query(limit: limit, skip: skip))
-          case response.status
-          when 200
-            result = MultiJson.load(response.body)
-            total_rows = result['total_rows']
-            skip += result['rows'].length
-            result['rows'].each do |row|
-              key = row['id']
-              @rev_cache[key] = row['value']['rev']
-              yield key
-            end
-          else
-            raise "HTTP error #{response.status}"
+        loop do
+          docs = all_docs(limit: limit, skip: skip)
+          break if docs['rows'].empty?
+          skip += docs['rows'].length
+          docs['rows'].each do |row|
+            key = row['id']
+            @rev_cache[key] = row['value']['rev']
+            yield key
           end
         end
         self
@@ -140,16 +210,18 @@ module Moneta
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        response = @backend.get('_all_docs?' + encode_query(keys: keys, include_docs: true))
-        raise "HTTP error #{response.status}" unless response.status == 200
-        docs = MultiJson.load(response.body)
+        docs = all_docs(keys: keys, include_docs: true)
         docs["rows"].map do |row|
-          next unless row['doc']
-          [row['id'], doc_to_value(row['doc'])]
+          next unless doc = row['doc']
+          [row['id'], doc_to_value(doc)]
         end.compact
       end
 
       # (see Proxy#merge!)
+      # @option options [Boolean] :full_commit (nil) Set to `true` or `false`
+      #   to override the server's
+      #   {https://docs.couchdb.org/en/stable/config/couchdb.html#couchdb/delayed_commits
+      #    commit policy}
       def merge!(pairs, options = {})
         keys = pairs.map { |key, _| key }.to_a
         cache_revs(*keys.reject { |key| @rev_cache[key] })
@@ -169,16 +241,14 @@ module Moneta
         end
 
         docs = pairs.map { |key, value| value_to_doc(value, @rev_cache[key], key) }.to_a
-        body = MultiJson.dump(docs: docs)
-        response = @backend.post('_bulk_docs', body, "Content-Type" => "application/json")
-        raise "HTTP error #{response.status}" unless response.status == 201
-        retries = []
-        MultiJson.load(response.body).each do |row|
-          if row['ok'] == true
-            @rev_cache[row['id']] = row['rev']
+        results = bulk_docs(docs, full_commit: options[:full_commit], returns: :doc)
+        retries = results.each_with_object([]) do |row, retries|
+          ok, id = row.values_at('ok', 'id')
+          if ok
+            @rev_cache[id] = row['rev']
           elsif row['error'] == 'conflict'
-            clear_rev_cache(row['id'])
-            retries << pairs.find { |key, _| key == row['id'] }
+            delete_cached_rev(id)
+            retries << pairs.find { |key,| key == id }
           else
             raise "Unrecognised response: #{row}"
           end
@@ -194,6 +264,10 @@ module Moneta
 
       private
 
+      def full_commit_header(full_commit)
+        full_commit == nil ? {} : { 'X-Couch-Full-Commit' => (!!full_commit).to_s }
+      end
+
       def body_to_value(body)
         doc_to_value(MultiJson.load(body))
       end
@@ -228,61 +302,127 @@ module Moneta
         doc
       end
 
-      def value_to_body(value, rev)
-        MultiJson.dump(value_to_doc(value, rev))
-      end
-
       def create_db
-        100.times do
-          response = @backend.put('', '')
+        loop do
+          response = put('', returns: :response)
           case response.status
           when 201
             break
           when 412
             # Make sure the database really does exist
-            break if @backend.head('').status == 200
+            # See https://github.com/apache/couchdb/issues/2073
+            break if head('')
           else
-            raise "HTTP error #{response.status}"
+            raise HTTPError.new(response.status, :put, '')
           end
 
           # Wait before trying again
           sleep 1
         end
+
+        self
       end
 
       def cache_revs(*keys)
-        response = @backend.get('_all_docs?' + encode_query(keys: keys))
-        raise "HTTP error #{response.status}" unless response.status == 200
-        docs = MultiJson.load(response.body)
+        docs = all_docs(keys: keys)
         docs['rows'].each do |row|
-          next unless row['value']
+          next if !row['value'] || row['value']['deleted']
           @rev_cache[row['id']] = row['value']['rev']
         end
       end
 
-      def update_rev_cache(key, response)
+      def parse_rev(response)
+        response['etag'][1..-2]
+      end
+
+      def cache_response_rev(key, response)
         case response.status
         when 200, 201
-          @rev_cache[key] = response['etag'][1..-2]
+          @rev_cache[key] = parse_rev(response)
         else
-          clear_rev_cache(key)
+          delete_cached_rev(key)
           nil
         end
       end
 
-      def clear_rev_cache(key)
+      def delete_cached_rev(key)
         @rev_cache.delete(key)
       end
 
       def rev(key)
-        @rev_cache[key] || (
-          response = @backend.head(key) and
-          update_rev_cache(key, response)).tap do |rev|
+        @rev_cache[key] || begin
+          response = @backend.head(key)
+          cache_response_rev(key, response)
         end
       end
 
       def encode_query(query)
-        URI.encode_www_form(query.map { |key, value| [key, MultiJson.dump(value)] })
+        query.map { |key, value| [key, MultiJson.dump(value)] }
+      end
+
+      def request(method, key, body = nil, returns: :nil, cache_rev: false, expect: nil, query: nil, headers: {})
+        url = @backend.build_url(key, query)
+        headers['Content-Type'] = 'application/json' if %i{put post}.include?(method)
+        response = @backend.run_request(method, url, body || '', headers)
+
+        if cache_rev
+          cache_response_rev(key, response)
+        end
+
+        if expect
+          raise HTTPError.new(response.status, method, url) unless response.status == expect
+        end
+
+        case returns
+        when :response
+          response
+        when :success
+          response.success?
+        when :doc
+          response.success? ? MultiJson.load(response.body) : nil
+        when :nil
+          nil
+        else
+          raise "Unknown returns param: #{returns.inspect}"
+        end
+      end
+
+      def get(key, returns: :doc, **options)
+        request(:get, key, returns: returns, **options)
+      end
+
+      def head(key, returns: :success, **options)
+        request(:head, key, returns: returns, **options)
+      end
+
+      def put(key, doc = nil, returns: :success, **options)
+        body = doc == nil ? '' : MultiJson.dump(doc)
+        request(:put, key, body, returns: returns, **options)
+      end
+
+      def post(key, doc = nil, returns: :success, **options)
+        body = doc == nil ? '' : MultiJson.dump(doc)
+        request(:post, key, body, returns: returns, **options)
+      end
+
+      def all_docs(sorted: false, **params)
+        keys = params.delete(:keys)
+        query = encode_query(params.merge(sorted: sorted))
+        if keys
+          post('_all_docs', { keys: keys },
+               query: query,
+               expect: 200,
+               returns: :doc)
+        else
+          get('_all_docs', query: query, expect: 200)
+        end
+      end
+
+      def bulk_docs(docs, returns: :success, full_commit: nil)
+        post('_bulk_docs', { docs: docs },
+             headers: full_commit_header(full_commit),
+             returns: returns,
+             expect: 201)
       end
     end
   end