redis 4.7.1 → 5.4.0

data/lib/redis/commands/strings.rb

@@ -25,7 +25,7 @@ class Redis
       # @param [Integer] decrement
       # @return [Integer] value after decrementing it
       def decrby(key, decrement)
-        send_command([:decrby, key, decrement])
+        send_command([:decrby, key, Integer(decrement)])
       end
 
       # Increment the integer value of a key by one.
@@ -50,7 +50,7 @@ class Redis
       # @param [Integer] increment
       # @return [Integer] value after incrementing it
       def incrby(key, increment)
-        send_command([:incrby, key, increment])
+        send_command([:incrby, key, Integer(increment)])
       end
 
       # Increment the numeric value of a key by the given float number.
@@ -63,7 +63,7 @@ class Redis
       # @param [Float] increment
       # @return [Float] value after incrementing it
       def incrbyfloat(key, increment)
-        send_command([:incrbyfloat, key, increment], &Floatify)
+        send_command([:incrbyfloat, key, Float(increment)], &Floatify)
       end
 
       # Set the string value of a key.
@@ -82,10 +82,10 @@ class Redis
       # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
       def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil, get: nil)
         args = [:set, key, value.to_s]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "NX" if nx
         args << "XX" if xx
         args << "KEEPTTL" if keepttl
@@ -105,7 +105,7 @@ class Redis
       # @param [String] value
       # @return [String] `"OK"`
       def setex(key, ttl, value)
-        send_command([:setex, key, ttl, value.to_s])
+        send_command([:setex, key, Integer(ttl), value.to_s])
       end
 
       # Set the time to live in milliseconds of a key.
@@ -115,7 +115,7 @@ class Redis
       # @param [String] value
       # @return [String] `"OK"`
       def psetex(key, ttl, value)
-        send_command([:psetex, key, ttl, value.to_s])
+        send_command([:psetex, key, Integer(ttl), value.to_s])
       end
 
       # Set the value of a key, only if the key does not exist.
@@ -152,7 +152,7 @@ class Redis
       #
       # @see #mset
       def mapped_mset(hash)
-        mset(hash.to_a.flatten)
+        mset(hash.flatten)
       end
 
       # Set one or more values, only if none of the keys exist.
@@ -180,7 +180,7 @@ class Redis
       #
       # @see #msetnx
       def mapped_msetnx(hash)
-        msetnx(hash.to_a.flatten)
+        msetnx(hash.flatten)
       end
 
       # Get the value of a key.
@@ -202,6 +202,7 @@ class Redis
       #
       # @see #mapped_mget
       def mget(*keys, &blk)
+        keys.flatten!(1)
         send_command([:mget, *keys], &blk)
       end
 
@@ -232,7 +233,7 @@ class Redis
       # @param [String] value
       # @return [Integer] length of the string after it was modified
       def setrange(key, offset, value)
-        send_command([:setrange, key, offset, value.to_s])
+        send_command([:setrange, key, Integer(offset), value.to_s])
       end
 
       # Get a substring of the string stored at a key.
@@ -243,7 +244,7 @@ class Redis
       #   the end of the string
       # @return [Integer] `0` or `1`
       def getrange(key, start, stop)
-        send_command([:getrange, key, start, stop])
+        send_command([:getrange, key, Integer(start), Integer(stop)])
       end
 
       # Append a value to a key.
@@ -291,10 +292,10 @@ class Redis
       # @return [String] The value of key, or nil when key does not exist.
       def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: false)
         args = [:getex, key]
-        args << "EX" << ex if ex
-        args << "PX" << px if px
-        args << "EXAT" << exat if exat
-        args << "PXAT" << pxat if pxat
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
         args << "PERSIST" if persist
 
         send_command(args)

data/lib/redis/commands/transactions.rb

@@ -5,48 +5,26 @@ class Redis
     module Transactions
       # Mark the start of a transaction block.
       #
-      # Passing a block is optional.
-      #
       # @example With a block
       #   redis.multi do |multi|
       #     multi.set("key", "value")
       #     multi.incr("counter")
       #   end # => ["OK", 6]
       #
-      # @example Without a block
-      #   redis.multi
-      #     # => "OK"
-      #   redis.set("key", "value")
-      #     # => "QUEUED"
-      #   redis.incr("counter")
-      #     # => "QUEUED"
-      #   redis.exec
-      #     # => ["OK", 6]
-      #
       # @yield [multi] the commands that are called inside this block are cached
       #   and written to the server upon returning from it
       # @yieldparam [Redis] multi `self`
       #
-      # @return [String, Array<...>]
-      #   - when a block is not given, `OK`
-      #   - when a block is given, an array with replies
+      # @return [Array<...>]
+      #   - an array with replies
       #
       # @see #watch
       # @see #unwatch
-      def multi(&block) # :nodoc:
-        if block_given?
-          if block&.arity == 0
-            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
-          end
-
-          synchronize do |prior_client|
-            pipeline = Pipeline::Multi.new(prior_client)
-            pipelined_connection = PipelinedConnection.new(pipeline)
-            yield pipelined_connection
-            prior_client.call_pipeline(pipeline)
+      def multi
+        synchronize do |client|
+          client.multi do |raw_transaction|
+            yield MultiConnection.new(raw_transaction)
           end
-        else
-          send_command([:multi])
         end
       end
 
@@ -82,7 +60,7 @@ class Redis
       # @see #multi
       def watch(*keys)
         synchronize do |client|
-          res = client.call([:watch, *keys])
+          res = client.call_v([:watch] + keys)
 
           if block_given?
             begin
@@ -125,8 +103,6 @@ class Redis
 
       # Discard all commands issued after MULTI.
       #
-      # Only call this method when `#multi` was called **without** a block.
-      #
       # @return [String] `"OK"`
       #
       # @see #multi

data/lib/redis/commands.rb

@@ -40,14 +40,7 @@ class Redis
     # where the method call will return nil. Propagate the nil instead of falsely
     # returning false.
     Boolify = lambda { |value|
-      case value
-      when 1
-        true
-      when 0
-        false
-      else
-        value
-      end
+      value != 0 unless value.nil?
     }
 
     BoolifySet = lambda { |value|
@@ -90,12 +83,14 @@ class Redis
       end
     }
 
+    FloatifyPair = lambda { |(first, score)|
+      [first, Floatify.call(score)]
+    }
+
     FloatifyPairs = lambda { |value|
       return value unless value.respond_to?(:each_slice)
 
-      value.each_slice(2).map do |member, score|
-        [member, Floatify.call(score)]
-      end
+      value.each_slice(2).map(&FloatifyPair)
     }
 
     HashifyInfo = lambda { |reply|
@@ -126,7 +121,9 @@ class Redis
     HashifyStreamAutoclaim = lambda { |reply|
       {
         'next' => reply[0],
-        'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+        'entries' => reply[1].compact.map do |entry, values|
+          [entry, values.each_slice(2)&.to_h]
+        end
       }
     }
 
@@ -204,8 +201,8 @@ class Redis
     # hash, are up to consumers.
     #
     # Redis error replies are raised as Ruby exceptions.
-    def call(*command)
-      send_command(command)
+    def call(*command, &block)
+      send_command(command, &block)
     end
 
     # Interact with the sentinel command (masters, master, slaves, failover)