moneta 1.0.0 → 1.1.0

data/lib/moneta/adapters/client.rb

@@ -83,8 +83,17 @@ module Moneta
       end
 
       def read
-        size = @socket.read(4).unpack('N').first
-        result = Marshal.load(@socket.read(size))
+        size = @socket.
+          recv(4).tap do |bytes|
+            raise EOFError.new('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
+        end)
+
         raise result if Exception === result
         result
       end

data/lib/moneta/adapters/couch.rb

@@ -1,5 +1,6 @@
 require 'faraday'
 require 'multi_json'
+require 'uri'
 
 module Moneta
   module Adapters
@@ -8,7 +9,7 @@ module Moneta
     # You can store hashes directly using this adapter.
     #
     # @example Store hashes
-    #     db = Moneta::Adapters::Mongo.new
+    #     db = Moneta::Adapters::Couch.new
     #     db['key'] = {a: 1, b: 2}
     #
     # @api public
@@ -17,7 +18,7 @@ module Moneta
 
       attr_reader :backend
 
-      supports :create
+      supports :create, :each_key
 
       # @param [Hash] options
       # @option options [String] :host ('127.0.0.1') Couch host
@@ -31,26 +32,33 @@ module Moneta
         @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)
+        @rev_cache = Moneta.build do
+          use :Lock
+          adapter :LRUHash
+        end
         create_db
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @backend.head(key).status == 200
+        response = @backend.head(key)
+        update_rev_cache(key, response)
+        response.status == 200
       end
 
       # (see Proxy#load)
       def load(key, options = {})
         response = @backend.get(key)
+        update_rev_cache(key, response)
         response.status == 200 ? body_to_value(response.body) : nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        response = @backend.head(key)
-        body = value_to_body(value, response.status == 200 && response['etag'][1..-2])
+        body = value_to_body(value, rev(key))
         response = @backend.put(key, body, 'Content-Type' => 'application/json')
-        raise "HTTP error #{response.status}" unless response.status == 201
+        update_rev_cache(key, response)
+        raise "HTTP error #{response.status} (PUT /#{key})" unless response.status == 201
         value
       rescue
         tries ||= 0
@@ -59,11 +67,13 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        response = @backend.get(key)
-        if response.status == 200
-          value = body_to_value(response.body)
-          response = @backend.delete("#{key}?rev=#{response['etag'][1..-2]}")
-          raise "HTTP error #{response.status}" unless response.status == 200
+        clear_rev_cache(key)
+        get_response = @backend.get(key)
+        if get_response.status == 200
+          existing_rev = get_response['etag'][1..-2]
+          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
           value
         end
       rescue
@@ -82,6 +92,7 @@ module Moneta
       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)
         case response.status
         when 201
           true
@@ -95,10 +106,99 @@ module Moneta
         (tries += 1) < 10 ? retry : raise
       end
 
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) unless block_given?
+
+        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}"
+          end
+        end
+        self
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
+      # (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["rows"].map do |row|
+          next unless row['doc']
+          [row['id'], doc_to_value(row['doc'])]
+        end.compact
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        keys = pairs.map { |key, _| key }.to_a
+        cache_revs(*keys.reject { |key| @rev_cache[key] })
+
+        if block_given?
+          existing = Hash[slice(*keys, **options)]
+          pairs = pairs.map do |key, new_value|
+            [
+              key,
+              if existing.key?(key)
+                yield(key, existing[key], new_value)
+              else
+                new_value
+              end
+            ]
+          end
+        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']
+          elsif row['error'] == 'conflict'
+            clear_rev_cache(row['id'])
+            retries << pairs.find { |key, _| key == row['id'] }
+          else
+            raise "Unrecognised response: #{row}"
+          end
+        end
+
+        # Recursive call with all conflicts
+        if retries.empty?
+          self
+        else
+          merge!(retries, options)
+        end
+      end
+
       private
 
       def body_to_value(body)
-        doc = MultiJson.load(body)
+        doc_to_value(MultiJson.load(body))
+      end
+
+      def doc_to_value(doc)
         case doc[@type_field]
         when 'Hash'
           doc = doc.dup
@@ -111,24 +211,78 @@ module Moneta
         end
       end
 
+      def value_to_doc(value, rev, id = nil)
+        doc =
+          case value
+          when Hash
+            value.merge(@type_field => 'Hash')
+          when String
+            { @value_field => value, @type_field => 'String' }
+          when Float, Integer
+            { @value_field => value, @type_field => 'Number' }
+          else
+            raise ArgumentError, "Invalid value type: #{value.class}"
+          end
+        doc['_rev'] = rev if rev
+        doc['_id'] = id if id
+        doc
+      end
+
       def value_to_body(value, rev)
-        case value
-        when Hash
-          doc = value.merge(@type_field => 'Hash')
-        when String
-          doc = { @value_field => value, @type_field => 'String' }
-        when Float, Fixnum
-          doc = { @value_field => value, @type_field => 'Number' }
+        MultiJson.dump(value_to_doc(value, rev))
+      end
+
+      def create_db
+        100.times do
+          response = @backend.put('', '')
+          case response.status
+          when 201
+            break
+          when 412
+            # Make sure the database really does exist
+            break if @backend.head('').status == 200
+          else
+            raise "HTTP error #{response.status}"
+          end
+
+          # Wait before trying again
+          sleep 1
+        end
+      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['rows'].each do |row|
+          next unless row['value']
+          @rev_cache[row['id']] = row['value']['rev']
+        end
+      end
+
+      def update_rev_cache(key, response)
+        case response.status
+        when 200, 201
+          @rev_cache[key] = response['etag'][1..-2]
         else
-          raise ArgumentError, "Invalid value type: #{value.class}"
+          clear_rev_cache(key)
+          nil
         end
-        doc['_rev'] = rev if rev
-        MultiJson.dump(doc)
       end
 
-      def create_db
-        response = @backend.put '', ''
-        raise "HTTP error #{response.status}" unless response.status == 201 || response.status == 412
+      def clear_rev_cache(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|
+        end
+      end
+
+      def encode_query(query)
+        URI.encode_www_form(query.map { |key, value| [key, MultiJson.dump(value)] })
       end
     end
   end

data/lib/moneta/adapters/datamapper.rb

@@ -7,6 +7,7 @@ module Moneta
     # @api public
     class DataMapper
       include Defaults
+      include NilValues
 
       supports :create
 

data/lib/moneta/adapters/daybreak.rb

@@ -4,7 +4,13 @@ module Moneta
   module Adapters
     # Daybreak backend
     # @api public
-    class Daybreak < Memory
+    class Daybreak
+      include Defaults
+      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
@@ -39,9 +45,20 @@ module Moneta
         @backend.lock { super }
       end
 
-      # (see Proxy#close)
-      def close
-        @backend.close
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        if block_given?
+          @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)
+        end
+
+        self
       end
     end
   end

data/lib/moneta/adapters/dbm.rb

@@ -4,7 +4,13 @@ module Moneta
   module Adapters
     # DBM backend (Berkeley DB)
     # @api public
-    class DBM < Memory
+    class DBM
+      include Defaults
+      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
@@ -15,12 +21,6 @@ module Moneta
             ::DBM.new(options[:file])
           end
       end
-
-      # (see Proxy#close)
-      def close
-        @backend.close
-        nil
-      end
     end
   end
 end

data/lib/moneta/adapters/file.rb

@@ -6,7 +6,7 @@ module Moneta
     # @api public
     class File
       include Defaults
-      supports :create, :increment
+      supports :create, :increment, :each_key
 
       # @param [Hash] options
       # @option options [String] :dir Directory where files will be stored
@@ -21,6 +21,16 @@ module Moneta
         ::File.exist?(store_path(key))
       end
 
+      # (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.each { |k| yield(k) }
+        self
+      end
+
       # (see Proxy#load)
       def load(key, options = {})
         ::File.read(store_path(key), mode: 'rb')

data/lib/moneta/adapters/gdbm.rb

@@ -4,7 +4,13 @@ module Moneta
   module Adapters
     # GDBM backend
     # @api public
-    class GDBM < Memory
+    class GDBM
+      include Defaults
+      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
@@ -15,12 +21,6 @@ module Moneta
             ::GDBM.new(options[:file])
           end
       end
-
-      # (see Proxy#close)
-      def close
-        @backend.close
-        nil
-      end
     end
   end
 end

data/lib/moneta/adapters/kyotocabinet.rb

@@ -4,7 +4,12 @@ module Moneta
   module Adapters
     # KyotoCabinet backend
     # @api public
-    class KyotoCabinet < Memory
+    class KyotoCabinet
+      include Defaults
+      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
@@ -39,6 +44,66 @@ module Moneta
         @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] }
+        self
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        ret = nil
+        success = @backend.accept(key) do |key, value|
+          if value
+            ret = Integer(value) + amount
+          else
+            ret = amount
+          end
+          ret.to_s
+        end
+
+        raise @backend.error unless success
+        ret
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, atomic: true, **options)
+        @backend.get_bulk(keys, atomic)
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = slice(*keys, **options)
+        keys.map { |key| hash[key] }
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        hard = options.key?(:hard) ? options[:hard] : false
+        atomic = options.key?(:atomic) ? options[:atomic] : true
+
+        success =
+          if block_given?
+            @backend.transaction(hard) do
+              existing = slice(*pairs.map { |k, _| k }, **options)
+              pairs = pairs.map do |key, new_value|
+                if existing.key?(key)
+                  [key, yield(key, existing[key], new_value)]
+                else
+                  [key, new_value]
+                end
+              end
+              @backend.set_bulk(pairs.to_h, atomic) >= 0
+            end
+          else
+            @backend.set_bulk(pairs.to_h, atomic) >= 0
+          end
+
+        raise @backend.error unless success
+        self
+      end
     end
   end
 end