moneta 1.5.1 → 1.6.0

data/lib/moneta/adapters/activesupportcache.rb

@@ -15,20 +15,29 @@ module Moneta
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        backend.exist?(key).tap do |exists|
-          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))
+        exists =
+          begin
+            backend_exist?(key)
+          rescue ArgumentError, TypeError
+            # these errors happen when certain adapters try to deserialize
+            # values, which means there's something present
+            true
           end
+
+        if exists && (expires = expires_value(options, nil)) != nil
+          value = backend_read(key, **options)
+          backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         end
+
+        exists
       end
 
       # (see Proxy#load)
       def load(key, options = {})
         expires = expires_value(options, nil)
-        value = backend.read(key, options)
+        value = backend_read(key, **options)
         if value and expires != nil
-          backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         end
         value
       end
@@ -36,7 +45,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         expires = expires_value(options)
-        backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+        backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
         value
       end
 
@@ -44,11 +53,11 @@ module Moneta
       def increment(key, amount = 1, options = {})
         expires = expires_value(options)
         options.delete(:raw)
-        existing = Integer(backend.fetch(key, options.merge(raw: true)) { 0 })
+        existing = Integer(backend_fetch(key, raw: true, **options) { 0 })
         if amount > 0
-          backend.increment(key, amount, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_increment(key, amount, expires_in: expires ? expires.seconds : nil, **options)
         elsif amount < 0
-          backend.decrement(key, -amount, options.merge(expires_in: expires ? expires.seconds : nil))
+          backend_decrement(key, -amount, expires_in: expires ? expires.seconds : nil, **options)
         else
           existing
         end
@@ -56,9 +65,9 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        value = backend.read(key, options)
+        value = backend_read(key, options)
         if value != nil
-          backend.delete(key, options)
+          backend_delete(key, **options)
           options[:raw] ? value.to_s : value
         end
       end
@@ -74,7 +83,7 @@ module Moneta
         hash = backend.read_multi(*keys)
         if (expires = expires_value(options, nil)) != nil
           hash.each do |key, value|
-            backend.write(key, value, options.merge(expires_in: expires ? expires.seconds : nil))
+            backend_write(key, value, expires_in: expires ? expires.seconds : nil, **options)
           end
         end
         if options[:raw]
@@ -106,7 +115,7 @@ module Moneta
 
         hash = Hash === pairs ? pairs : Hash[pairs.to_a]
         expires = expires_value(options)
-        backend.write_multi(hash, options.merge(expires_in: expires ? expires.seconds : nil))
+        backend_write_multi(hash, expires_in: expires ? expires.seconds : nil, **options)
         self
       end
 
@@ -115,6 +124,52 @@ module Moneta
       def expires_value(options, default = config.expires)
         super.tap { options.delete(:expires) unless options.frozen? }
       end
+
+      delegate :decrement, :delete, :exist?, :fetch, :increment, :read, :write, :write_multi,
+               to: :@backend,
+               prefix: :backend
+      private :backend_decrement, :backend_delete, :backend_exist?,
+              :backend_fetch, :backend_increment, :backend_read,
+              :backend_write, :backend_write_multi
+
+      # @api private
+      module Rails5Support
+        private
+
+        def backend_decrement(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_delete(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_exist?(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_fetch(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_increment(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_read(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_write(*args, **options)
+          super(*args, options)
+        end
+
+        def backend_write_multi(*args, **options)
+          super(*args, options)
+        end
+      end
+
+      prepend Rails5Support if ::ActiveSupport.version < ::Gem::Version.new('6.1.0')
     end
   end
 end

data/lib/moneta/adapters/client.rb

@@ -132,7 +132,7 @@ module Moneta
       end
 
       def read_msg
-        size = read(4).unpack('N').first
+        size = read(4).unpack1('N')
         result = Marshal.load(read(size))
         raise result if Exception === result
         result

data/lib/moneta/adapters/hbase.rb

@@ -95,7 +95,7 @@ module Moneta
       def unpack(value)
         if value.bytesize == 8
           # Unpack 8 byte big endian
-          value.unpack('Q>').first.to_s
+          value.unpack1('Q>').to_s
         elsif value.bytesize >= 9 && value[-1] == ?\0
           # Remove nul character
           value[0..-2]

data/lib/moneta/adapters/mongo.rb

@@ -164,9 +164,11 @@ module Moneta
         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)
+        unless insert_pairs.empty?
+          @collection.insert_many(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?

data/lib/moneta/adapters/redis.rb

@@ -106,7 +106,8 @@ module Moneta
 
       # (see Defaults#merge!)
       def merge!(pairs, options = {})
-        keys = pairs.map { |key, _| key }
+        keys = pairs.map { |key, _| key }.to_a
+        return self if keys.empty?
 
         if block_given?
           old_values = @backend.mget(*keys)

data/lib/moneta/adapters/sequel/mysql.rb

@@ -9,21 +9,10 @@ module Moneta
         end
 
         def increment(key, amount = 1, options = {})
-          @backend.transaction do
-            # this creates a row-level lock even if there is no existing row (a
-            # "gap lock").
-            if row = @load_for_update.call(key: key)
-              # Integer() will raise an exception if the existing value cannot be parsed
-              amount += Integer(row[config.value_column])
-              @increment_update.call(key: key, value: amount)
-            else
-              @create.call(key: key, value: amount)
-            end
-            amount
+          @backend.transaction(retry_on: [::Sequel::SerializationFailure]) do
+            @increment.call(key: key, amount: amount)
+            Integer(load(key))
           end
-        rescue ::Sequel::SerializationFailure # Thrown on deadlock
-          tries ||= 0
-          (tries += 1) <= 3 ? retry : raise
         end
 
         def merge!(pairs, options = {}, &block)
@@ -55,10 +44,9 @@ module Moneta
         end
 
         def prepare_increment
-          @increment_update = @table
-            .where(config.key_column => :$key)
-            .prepare(:update, statement_id(:increment_update), config.value_column => :$value)
-          super
+          @increment = @table
+            .on_duplicate_key_update(config.value_column => ::Sequel.cast(config.value_column, Integer) + :$amount)
+            .prepare(:insert, statement_id(:increment_insert), config.key_column => :$key, config.value_column => :$amount)
         end
       end
     end

data/lib/moneta/adapters/sequel/postgres_hstore.rb

@@ -213,9 +213,16 @@ module Moneta
         end
 
         def prepare_values_at
+          # Sequel's hstore_ops gets confused if we try to construct this
+          # directly, because the CAST is not an array literal, or a PG array
+          lookup = ::Sequel::SQL::PlaceholderLiteralString.new(
+            ['(', '->', ')'],
+            [config.value_column, ::Sequel.cast(:$keys, :"text[]")]
+          )
+
           @values_at = @table
             .where(config.key_column => :$row)
-            .select(::Sequel[config.value_column].hstore[::Sequel.cast(:$keys, :"text[]")].as(:values))
+            .select(lookup.as(:values))
             .prepare(:first, statement_id(:hstore_values_at))
         end
 

data/lib/moneta/adapters/sqlite.rb

@@ -148,8 +148,10 @@ module Moneta
           pairs = pairs.to_a
         end
 
-        query = "replace into #{config.table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
-        backend.query(query, pairs.flatten).close
+        unless pairs.empty?
+          query = "replace into #{config.table} (k, v) values" + (['(?, ?)'] * pairs.length).join(',')
+          backend.query(query, pairs.flatten).close
+        end
       rescue
         backend.rollback if transaction
         raise

data/lib/moneta/adapters/tokyotyrant.rb

@@ -131,7 +131,7 @@ module Moneta
       def unpack(value)
         if value.bytesize == 4
           # Unpack 4 byte integer
-          value.unpack(@pack).first.to_s
+          value.unpack1(@pack).to_s
         elsif value.bytesize >= 5 && value[-1] == ?\0
           # Remove nul character
           value[0..-2]

data/lib/moneta/adapters/yaml.rb

@@ -5,7 +5,13 @@ module Moneta
     # YAML::Store backend
     # @api public
     class YAML < PStore
-      backend { |file:| ::YAML::Store.new(file) }
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [YAML::Store] :backend YAML store to use
+      #   @option options [String] :file YAML file to open - required unless using :backend
+      #   @option options [Boolean] :threadsafe (false) Makes the YAML store thread-safe
+      #   @option options Other options passed to `YAML::Store#new`
+      backend { |file:, threadsafe: false, **options| ::YAML::Store.new(file, threadsafe, options) }
     end
   end
 end

data/lib/moneta/pool.rb

@@ -123,30 +123,28 @@ module Moneta
 
       def run
         Thread.new do
-          begin
-            populate_stores
+          populate_stores
 
-            until @stopping && @stores.empty?
-              loop_start = Time.now
+          until @stopping && @stores.empty?
+            loop_start = Time.now
 
-              # Block until a message arrives, or until we time out for some reason
-              request = pop
+            # Block until a message arrives, or until we time out for some reason
+            request = pop
 
-              # Record how long we were idle, for stats purposes
-              @idle_time = Time.now - loop_start
+            # Record how long we were idle, for stats purposes
+            @idle_time = Time.now - loop_start
 
-              # If a message arrived, handle it
-              handle_request(request) if request
+            # If a message arrived, handle it
+            handle_request(request) if request
 
-              # Handle any stale checkout requests
-              handle_timed_out_requests
-              # Drop any stores that are no longer needed
-              remove_unneeded_stores
-            end
-          rescue => e
-            reject_waiting(e.message)
-            raise
+            # Handle any stale checkout requests
+            handle_timed_out_requests
+            # Drop any stores that are no longer needed
+            remove_unneeded_stores
           end
+        rescue => e
+          reject_waiting(e.message)
+          raise
         end
       end
 

data/lib/moneta/proxy.rb

@@ -145,7 +145,7 @@ module Moneta
     def config
       unless @proxy_config
         config = super
-        adapter_config = adapter&.config
+        adapter_config = adapter.config if adapter.class.include?(Config)
 
         @proxy_config =
           if config && adapter_config

data/lib/moneta/server.rb

@@ -60,7 +60,7 @@ module Moneta
       end
 
       def read_msg
-        size = read(4).unpack('N').first
+        size = read(4).unpack1('N')
         throw :closed, 'Message too big' if size > @max_size
         Marshal.load(read(size))
       end
@@ -107,16 +107,14 @@ module Moneta
 
       # Detect support for socket#sendmsg_nonblock
       Socket.new(Socket::AF_INET, Socket::SOCK_STREAM).tap do |socket|
-        begin
-          socket.sendmsg_nonblock('probe')
-        rescue Errno::EPIPE, Errno::ENOTCONN
-          def sendmsg(msg)
-            @io.sendmsg_nonblock(msg)
-          end
-        rescue NotImplementedError
-          def sendmsg(msg)
-            @io.write_nonblock(msg)
-          end
+        socket.sendmsg_nonblock('probe')
+      rescue Errno::EPIPE, Errno::ENOTCONN
+        def sendmsg(msg)
+          @io.sendmsg_nonblock(msg)
+        end
+      rescue NotImplementedError
+        def sendmsg(msg)
+          @io.write_nonblock(msg)
         end
       end
 

data/lib/moneta/transformer/config.rb

@@ -20,7 +20,7 @@ module Moneta
       snappy:   [ :compress,  '::Snappy.inflate(%s)',         '::Snappy.deflate(%s)',            'snappy'       ],
       quicklz:  [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',          'qlzruby'      ],
       zlib:     [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',     'zlib'         ],
-      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                 ],
+      base64:   [ :encode,    "%s.unpack1('m0')",        "[%s].pack('m0')"                                 ],
       urlsafe_base64: [
         :encode,
         'Base64.urlsafe_decode64(%s)',
@@ -28,9 +28,9 @@ module Moneta
         'base64'
       ],
       escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                               ],
-      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                           ],
-      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                  ],
-      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                  ],
+      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack1('H*')"                           ],
+      qp:       [ :encode,    "%s.unpack1('M')",         "[%s].pack('M')"                                  ],
+      uuencode: [ :encode,    "%s.unpack1('u')",         "[%s].pack('u')"                                  ],
       hmac:     [
         :hmac,
         'Helper.hmacverify(%s, options[:secret] || @secret)',

data/lib/moneta/transformer.rb

@@ -141,6 +141,8 @@ module Moneta
           end
           def merge!(pairs, options = {})
             keys, values = pairs.to_a.transpose
+            keys ||= []
+            values ||= []
             t_keys = keys.map { |key| #{key} }
             block = if block_given?
                       key_lookup = Hash[t_keys.zip(keys)]
@@ -296,6 +298,8 @@ module Moneta
           end
           def merge!(pairs, options = {})
             keys, values = pairs.to_a.transpose
+            keys ||= []
+            values ||= []
             t_keys = keys.map { |key| #{key} }
             key_lookup = Hash[t_keys.zip(keys)]
 

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '1.5.1'.freeze
+  VERSION = '1.6.0'.freeze
 end

data/lib/moneta.rb

@@ -144,7 +144,7 @@ module Moneta
     a = Adapters.const_get(name).new(options)
     build do
       use :Logger, Hash === logger ? logger : {} if logger
-      use :Expires, expires: options[:expires] if !a.supports?(:expires) && expires
+      use :Expires, expires: options[:expires] if expires && !a.supports?(:expires)
       use :Transformer, transformer
       use :Lock if threadsafe
       adapter a