moneta 1.0.0 → 1.1.0

data/lib/moneta/adapters/leveldb.rb

@@ -4,7 +4,13 @@ module Moneta
   module Adapters
     # LevelDB backend
     # @api public
-    class LevelDB < Memory
+    class LevelDB
+      include Defaults
+      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`
@@ -33,6 +39,26 @@ module Moneta
         @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 }
+        self
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        ret = nil
+        @backend.batch { ret = super }
+        ret
+      end
+
+      # (see Proxy#merge!)
+      def merge!(*keys, **options)
+        @backend.batch { super }
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/lmdb.rb

@@ -8,7 +8,7 @@ module Moneta
     class LMDB
       include Defaults
 
-      supports :create, :increment
+      supports :create, :increment, :each_key
       attr_reader :backend, :db
 
       PUT_FLAGS = [:nooverwrite, :nodupdata, :current, :append, :appenddup]
@@ -88,6 +88,34 @@ module Moneta
         @backend.close
         nil
       end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) { @db.size } unless block_given?
+
+        @db.cursor do |cursor|
+          while record = cursor.next
+            yield record[0]
+          end
+        end
+
+        self
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        @backend.transaction { super }
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        @backend.transaction { super }
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        @backend.transaction { super }
+      end
     end
   end
 end

data/lib/moneta/adapters/lruhash.rb

@@ -13,6 +13,8 @@ module Moneta
       DEFAULT_MAX_SIZE = 1024000
       DEFAULT_MAX_COUNT = 10240
 
+      supports :each_key
+
       # @param [Hash] options
       # @option options [Integer] :max_size (1024000) Maximum byte size of all values, nil disables the limit
       # @option options [Integer] :max_value (options[:max_size]) Maximum byte size of one value, nil disables the limit
@@ -29,6 +31,14 @@ module Moneta
         @entry.key?(key)
       end
 
+      # (see Proxy#each_key)
+      def each_key(&block)
+        return enum_for(:each_key) { @entry.length } unless block_given?
+
+        @entry.each_key { |k| yield(k) }
+        self
+      end
+
       # (see Proxy#load)
       def load(key, options = {})
         if entry = @entry[key]
@@ -73,6 +83,26 @@ module Moneta
         self
       end
 
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        @entry.values_at(*keys).map do |entry|
+          if entry
+            entry.insert_after(@list)
+            entry.value
+          end
+        end
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        return super unless @entry.respond_to?(:slice)
+        hash = @entry.slice(*keys)
+        hash.each do |key, entry|
+          entry.insert_after(@list)
+          hash[key] = entry.value
+        end
+      end
+
       private
 
       class Entry

data/lib/moneta/adapters/memcached/dalli.rb

@@ -50,14 +50,11 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        # FIXME: There is a Dalli bug, load(key) returns a wrong value after increment
-        # therefore we set default = nil and create the counter manually
-        # See https://github.com/mperham/dalli/issues/309
         result =
           if amount >= 0
-            @backend.incr(key, amount, expires_value(options) || nil, nil)
+            @backend.incr(key, amount, expires_value(options) || nil)
           else
-            @backend.decr(key, -amount, expires_value(options) || nil, nil)
+            @backend.decr(key, -amount, expires_value(options) || nil)
           end
         if result
           result
@@ -84,6 +81,54 @@ module Moneta
         @backend.close
         nil
       end
+
+      # (see Defaults#slice)
+      def slice(*keys, **options)
+        @backend.get_multi(keys).tap do |pairs|
+          next if pairs.empty?
+          expires = expires_value(options, nil)
+          next if expires.nil?
+          expires = expires.to_i if Numeric === expires
+          expires ||= 0
+          @backend.multi do
+            pairs.each do |key, value|
+              @backend.set(key, value, expires, false)
+            end
+          end
+        end
+      end
+
+      # (see Defaults#values_at)
+      def values_at(*keys, **options)
+        pairs = slice(*keys, **options)
+        keys.map { |key| pairs.delete(key) }
+      end
+
+      # (see Defaults#merge!)
+      def merge!(pairs, options = {})
+        expires = expires_value(options)
+        expires = expires.to_i if Numeric === expires
+        expires ||= nil
+
+        if block_given?
+          keys = pairs.map { |key, _| key }.to_a
+          old_pairs = @backend.get_multi(keys)
+          pairs = pairs.map do |key, new_value|
+            if old_pairs.key? key
+              new_value = yield(key, old_pairs[key], new_value)
+            end
+            [key, new_value]
+          end
+        end
+
+        @backend.multi do
+          pairs.each do |key, value|
+            @backend.set(key, value, expires, raw: true)
+          end
+        end
+
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/memcached/native.rb

@@ -35,7 +35,10 @@ module Moneta
         value = @backend.get(key, false)
         if value
           expires = expires_value(options, nil)
-          @backend.set(key, value, expires || 0, false) if expires != nil
+          unless expires.nil?
+            Numeric === expires and expires = expires.to_i
+            @backend.set(key, value, expires || 0, false)
+          end
           value
         end
       rescue ::Memcached::NotFound
@@ -43,8 +46,10 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        # TTL must be Fixnum
-        @backend.set(key, value, expires_value(options) || 0, false)
+        # TTL must be Integer
+        expires = expires_value(options)
+        Numeric === expires and expires = expires.to_i
+        @backend.set(key, value, expires || 0, false)
         value
       end
 
@@ -74,7 +79,9 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @backend.add(key, value, expires_value(options) || 0, false)
+        expires = expires_value(options)
+        Numeric === expires and expires = expires.to_i
+        @backend.add(key, value, expires || 0, false)
         true
       rescue ::Memcached::ConnectionDataExists
         false

data/lib/moneta/adapters/memory.rb

@@ -4,9 +4,11 @@ module Moneta
     # @api public
     class Memory
       include Defaults
+      include NilValues
       include HashAdapter
       include IncrementSupport
       include CreateSupport
+      include EachKeySupport
 
       # @param [Hash] options Options hash
       # @option options [Hash] :backend Use existing backend instance

data/lib/moneta/adapters/mongo/base.rb

@@ -7,7 +7,7 @@ module Moneta
       include Defaults
       include ExpiresSupport
 
-      supports :create, :increment
+      supports :each_key, :create, :increment
       attr_reader :backend
 
       DEFAULT_PORT = 27017
@@ -19,6 +19,25 @@ module Moneta
         @type_field = options.delete(:type_field) || 'type'
       end
 
+      # (see Proxy#fetch_values)
+      def fetch_values(*keys, **options)
+        return values_at(*keys, **options) unless block_given?
+        hash = Hash[slice(*keys, **options)]
+        keys.map do |key|
+          if hash.key?(key)
+            hash[key]
+          else
+            yield key
+          end
+        end
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
       protected
 
       def doc_to_value(doc)
@@ -33,11 +52,7 @@ module Moneta
           doc[@value_field]
         else
           # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
-          if doc[@value_field].is_a? ::BSON::Binary and defined? ::BSON::VERSION and ::BSON::VERSION[0].to_i >= 2
-            doc[@value_field].data
-          else
-            doc[@value_field].to_s
-          end
+          from_binary(doc[@value_field])
         end
       end
 
@@ -48,7 +63,7 @@ module Moneta
                       @type_field => 'Hash',
                       # @expires_field must be a Time object (BSON date datatype)
                       @expires_field => expires_at(options) || nil)
-        when Float, Fixnum
+        when Float, Integer
           { '_id' => key,
             @type_field => 'Number',
             @value_field => value,
@@ -73,6 +88,16 @@ module Moneta
         s = s.dup if s.frozen? || s.encoding != Encoding::ASCII_8BIT
         ::BSON::Binary.new(s)
       end
+
+      if defined?(::BSON::VERSION) and ::BSON::VERSION[0].to_i >= 2
+        def from_binary(binary)
+          binary.is_a?(::BSON::Binary) ? binary.data : binary.to_s
+        end
+      else
+        def from_binary(binary)
+          binary.to_s
+        end
+      end
     end
   end
 end

data/lib/moneta/adapters/mongo/moped.rb

@@ -70,6 +70,13 @@ module Moneta
         value
       end
 
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) unless block_given?
+        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
+        self
+      end
+
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
@@ -80,9 +87,17 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @backend.with(safe: true, consistency: :strong) do |safe|
-          safe[@collection.name].find(_id: to_binary(key)).modify({:$inc => { @value_field => amount }},
-                                                                     new: true, upsert: true)[@value_field]
+          safe[@collection.name].
+            find(_id: to_binary(key)).
+            modify({:$inc => { @value_field => amount }},
+                   new: true,
+                   upsert: true)[@value_field]
         end
+      rescue ::Moped::Errors::OperationFailure
+        tries ||= 0
+        tries += 1
+        retry if tries < 3
+        raise # otherwise
       end
 
       # (see Proxy#create)
@@ -102,6 +117,48 @@ module Moneta
         @collection.find.remove_all
         self
       end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        query = @collection.find(_id: {:$in => keys.map(&method(:to_binary))})
+        pairs = query.map do |doc|
+          next if doc[@expires_field] && doc[@expires_field] < Time.now
+          [from_binary(doc[:_id]), doc_to_value(doc)]
+        end.compact
+
+        if (expires = expires_at(options, nil)) != nil
+          query.update_all(:$set => { @expires_field => expires || nil })
+        end
+
+        pairs
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        @backend.with(safe: true, consistency: :strong) do |safe|
+          collection = safe[@collection.name]
+          existing = collection.
+            find(_id: {:$in => pairs.map { |key, _| to_binary(key) }.to_a}).
+            map{ |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }.
+            to_h
+
+          update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
+          unless insert_pairs.empty?
+            collection.insert(insert_pairs.map do |key, value|
+              value_to_doc(to_binary(key), value, options)
+            end)
+          end
+
+          update_pairs.each do |key, value|
+            value = yield(key, existing[key], value) if block_given?
+            binary = to_binary(key)
+            collection.
+              find(_id: binary).
+              update(value_to_doc(binary, value, options))
+          end
+        end
+        self
+      end
     end
   end
 end

data/lib/moneta/adapters/mongo/official.rb

@@ -73,6 +73,13 @@ module Moneta
         value
       end
 
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) unless block_given?
+        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
+        self
+      end
+
       # (see Proxy#delete)
       def delete(key, options = {})
         key = to_binary(key)
@@ -112,6 +119,39 @@ module Moneta
         @backend.close
         nil
       end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        query = @collection.find(_id: {:$in => keys.map(&method(:to_binary))})
+        pairs = query.map do |doc|
+          next if doc[@expires_field] && doc[@expires_field] < Time.now
+          [from_binary(doc[:_id]), doc_to_value(doc)]
+        end.compact
+
+        if (expires = expires_at(options, nil)) != nil
+          query.update_many(:$set => { @expires_field => expires || nil })
+        end
+
+        pairs
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        existing = Hash[slice(*pairs.map { |key, _| key })]
+        update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
+
+        @collection.insert_many(insert_pairs.map do |key, value|
+          value_to_doc(to_binary(key), value, options)
+        end)
+
+        update_pairs.each do |key, value|
+          value = yield(key, existing[key], value) if block_given?
+          binary = to_binary(key)
+          @collection.replace_one({_id: binary}, value_to_doc(binary, value, options))
+        end
+
+        self
+      end
     end
   end
 end