moneta 1.0.0 → 1.5.1

data/lib/moneta/adapters/lruhash.rb

@@ -2,96 +2,93 @@ module Moneta
   module Adapters
     # LRUHash backend
     #
-    # Based on Hashery::LRUHash but simpler and measures both memory usage and hash size.
+    # Based on {https://rubygems.org/gems/lru_redux lru_redux} but measures
+    # both memory usage and hash size.
     #
     # @api public
-    class LRUHash
-      include Defaults
+    class LRUHash < Adapter
       include IncrementSupport
       include CreateSupport
 
-      DEFAULT_MAX_SIZE = 1024000
-      DEFAULT_MAX_COUNT = 10240
+      config :max_size, default: 1024000
+      config(:max_value) { |max_size:, max_value:, **| [max_value, max_size].compact.min }
+      config :max_count, default: 10240
+
+      supports :each_key
+
+      backend { {} }
 
       # @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
       # @option options [Integer] :max_count (10240) Maximum number of values, nil disables the limit
       def initialize(options = {})
-        @max_size = options.fetch(:max_size) { DEFAULT_MAX_SIZE }
-        @max_count = options.fetch(:max_count) { DEFAULT_MAX_COUNT }
-        @max_value = [options[:max_value], @max_size].compact.min
+        super
         clear
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @entry.key?(key)
+        backend.key?(key)
+      end
+
+      # (see Proxy#each_key)
+      def each_key(&block)
+        return enum_for(:each_key) { backend.length } unless block_given?
+
+        # The backend needs to be duplicated because reading mutates this
+        # store.
+        backend.dup.each_key { |k| yield(k) }
+        self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        if entry = @entry[key]
-          entry.insert_after(@list)
-          entry.value
+        if value = backend.delete(key)
+          backend[key] = value
+          value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        if @max_value && value.bytesize > @max_value
+        if config.max_value && value.bytesize > config.max_value
           delete(key)
         else
-          if entry = @entry[key]
-            @size -= entry.value.bytesize if @max_size
-          else
-            @entry[key] = entry = Entry.new
-            entry.key = key
+          if config.max_size
+            if old_value = backend.delete(key)
+              @size -= old_value.bytesize
+            end
+            @size += value.bytesize
           end
-          entry.value = value
-          @size += entry.value.bytesize if @max_size
-          entry.insert_after(@list)
-          delete(@list.prev.key) while @list.next != @list.prev && (@max_size && @size > @max_size || @max_count && @entry.size > @max_count)
+          backend[key] = value
+          drop while config.max_size && @size > config.max_size || config.max_count && backend.size > config.max_count
         end
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        if entry = @entry.delete(key)
-          @size -= entry.value.bytesize if @max_size
-          entry.unlink
-          entry.value
+        if value = backend.delete(key) and config.max_size
+          @size -= value.bytesize
         end
+        value
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @entry, @size = {}, 0
-        @list = Entry.new
-        @list.prev = @list.next = @list
+        backend.clear
+        @size = 0
         self
       end
 
-      private
-
-      class Entry
-        attr_accessor :key, :value, :prev, :next
-
-        def unlink
-          @prev.next = @next if @prev
-          @next.prev = @prev if @next
-          @prev = @next = nil
-        end
-
-        def insert_after(entry)
-          if entry.next != self
-            unlink
-            @next = entry.next
-            @prev = entry
-            entry.next.prev = self
-            entry.next = self
-          end
+      # Drops the least-recently-used pair, if any
+      #
+      # @param [Hash] options Options to merge
+      # @return [(Object, String), nil] The dropped pair, if any
+      def drop(options = {})
+        if key = backend.keys.first
+          [key, delete(key)]
         end
       end
     end

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

@@ -4,60 +4,49 @@ module Moneta
   module Adapters
     # Memcached backend (using gem dalli)
     # @api public
-    class MemcachedDalli
-      include Defaults
+    class MemcachedDalli < Adapter
       include ExpiresSupport
 
       supports :create, :increment
-      attr_reader :backend
-
-      # @param [Hash] options
-      # @option options [String] :server ('127.0.0.1:11211') Memcached server
-      # @option options [Integer] :expires Default expiration time
-      # @option options [::Dalli::Client] :backend Use existing backend instance
-      # @option options Other options passed to `Dalli::Client#new`
-      def initialize(options = {})
-        self.default_expires = options.delete(:expires)
-        @backend = options[:backend] ||
-          begin
-            server = options.delete(:server) || '127.0.0.1:11211'
-            ::Dalli::Client.new(server, options)
-          end
-      end
+
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :server ('127.0.0.1:11211') Memcached server
+      #   @option options [Integer] :expires Default expiration time
+      #   @option options [::Dalli::Client] :backend Use existing backend instance
+      #   @option options Other options passed to `Dalli::Client#new`
+      backend { |server: '127.0.0.1:11211', **options| ::Dalli::Client.new(server, options) }
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @backend.get(key)
+        value = backend.get(key)
         if value
           expires = expires_value(options, nil)
-          @backend.set(key, value, expires || nil, raw: true) if expires != nil
+          backend.set(key, value, expires || nil, raw: true) if expires != nil
           value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.set(key, value, expires_value(options) || nil, raw: true)
+        backend.set(key, value, expires_value(options) || nil, raw: true)
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        value = @backend.get(key)
-        @backend.delete(key)
+        value = backend.get(key)
+        backend.delete(key)
         value
       end
 
       # (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
@@ -70,20 +59,68 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.flush_all
+        backend.flush_all
         self
       end
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        !!@backend.add(key, value, expires_value(options) || nil, raw: true)
+        !!backend.add(key, value, expires_value(options) || nil, raw: true)
       end
 
       # (see Proxy#close)
       def close
-        @backend.close
+        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

@@ -4,30 +4,24 @@ module Moneta
   module Adapters
     # Memcached backend (using gem memcached)
     # @api public
-    class MemcachedNative
-      include Defaults
+    class MemcachedNative < Adapter
       include ExpiresSupport
 
       supports :create, :increment
-      attr_reader :backend
 
-      # @param [Hash] options
-      # @option options [String] :server ('127.0.0.1:11211') Memcached server
-      # @option options [String] :namespace Key namespace
-      # @option options [Integer] :expires (604800) Default expiration time
-      # @option options [::Memcached] :backend Use existing backend instance
-      # @option options Other options passed to `Memcached#new`
-      def initialize(options = {})
-        server = options.delete(:server) || '127.0.0.1:11211'
-        self.default_expires = options.delete(:expires)
-        @backend = options[:backend] ||
-          begin
-            options.merge!(prefix_key: options.delete(:namespace)) if options[:namespace]
-            # We don't want a limitation on the key charset. Therefore we use the binary protocol.
-            # It is also faster.
-            options[:binary_protocol] = true unless options.include?(:binary_protocol)
-            ::Memcached.new(server, options)
-          end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :server ('127.0.0.1:11211') Memcached server
+      #   @option options [String] :namespace Key namespace
+      #   @option options [Integer] :expires (604800) Default expiration time
+      #   @option options [::Memcached] :backend Use existing backend instance
+      #   @option options Other options passed to `Memcached#new`
+      backend do |server: '127.0.0.1:11211', namespace: nil, **options|
+        options[:prefix_key] = namespace if namespace
+        # We don't want a limitation on the key charset. Therefore we use the binary protocol.
+        # It is also faster.
+        options[:binary_protocol] = true unless options.include?(:binary_protocol)
+        ::Memcached.new(server, options)
       end
 
       # (see Proxy#load)
@@ -35,16 +29,22 @@ 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
+        nil
       end
 
       # (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
 
@@ -54,27 +54,30 @@ module Moneta
         @backend.delete(key)
         value
       rescue ::Memcached::NotFound
+        nil
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         result = if amount >= 0
-          @backend.increment(key, amount)
-        else
-          @backend.decrement(key, -amount)
-        end
+                   @backend.increment(key, amount)
+                 else
+                   @backend.decrement(key, -amount)
+                 end
         # HACK: Throw error if applied to invalid value
         # see https://github.com/evan/memcached/issues/110
-        Utils.to_int((@backend.get(key, false) rescue nil)) if result == 0
+        Integer((@backend.get(key, false) rescue 0)) if result == 0
         result
-      rescue ::Memcached::NotFound => ex
+      rescue ::Memcached::NotFound
         retry unless create(key, amount.to_s, options)
         amount
       end
 
       # (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/memcached.rb

@@ -1,4 +1,5 @@
 module Moneta
+  # @api private
   module Adapters
     # Prefer Dalli over native Memcached!
     #

data/lib/moneta/adapters/memory.rb

@@ -2,17 +2,17 @@ module Moneta
   module Adapters
     # Memory backend using a hash to store the entries
     # @api public
-    class Memory
-      include Defaults
+    class Memory < Adapter
+      include NilValues
       include HashAdapter
       include IncrementSupport
       include CreateSupport
+      include EachKeySupport
 
-      # @param [Hash] options Options hash
-      # @option options [Hash] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] || {}
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options Options hash
+      #   @option options [Hash] :backend Use existing backend instance
+      backend { {} }
     end
   end
 end