redis 4.8.1 → 5.0.0.beta3

data/lib/redis/commands/bitmaps.rb

@@ -39,7 +39,10 @@ class Redis
       # @param [String, Array<String>] keys one or more source keys to perform `operation`
       # @return [Integer] the length of the string stored in `destkey`
       def bitop(operation, destkey, *keys)
-        send_command([:bitop, operation, destkey, *keys])
+        keys.flatten!(1)
+        command = [:bitop, operation, destkey]
+        command.concat(keys)
+        send_command(command)
       end
 
       # Return the position of the first bit set to 1 or 0 in a string.

data/lib/redis/commands/cluster.rb

@@ -12,24 +12,7 @@ class Redis
       #
       # @return [Object] depends on the subcommand
       def cluster(subcommand, *args)
-        subcommand = subcommand.to_s.downcase
-        block = case subcommand
-        when 'slots'
-          HashifyClusterSlots
-        when 'nodes'
-          HashifyClusterNodes
-        when 'slaves'
-          HashifyClusterSlaves
-        when 'info'
-          HashifyInfo
-        else
-          Noop
-        end
-
-        # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
-        block = Noop unless @cluster_mode
-
-        send_command([:cluster, subcommand] + args, &block)
+        send_command([:cluster, subcommand] + args)
       end
 
       # Sends `ASKING` command to random node and returns its reply.

data/lib/redis/commands/connection.rb

@@ -34,10 +34,7 @@ class Redis
       # @param [Integer] db zero-based index of the DB to use (0 to 15)
       # @return [String] `OK`
       def select(db)
-        synchronize do |client|
-          client.db = db
-          client.call([:select, db])
-        end
+        send_command([:select, db])
       end
 
       # Close the connection.
@@ -45,12 +42,10 @@ class Redis
       # @return [String] `OK`
       def quit
         synchronize do |client|
-          begin
-            client.call([:quit])
-          rescue ConnectionError
-          ensure
-            client.disconnect
-          end
+          client.call_v([:quit])
+        rescue ConnectionError
+        ensure
+          client.close
         end
       end
     end

data/lib/redis/commands/hashes.rb

@@ -87,7 +87,8 @@ class Redis
       #
       # @see #mapped_hmget
       def hmget(key, *fields, &blk)
-        send_command([:hmget, key] + fields, &blk)
+        fields.flatten!(1)
+        send_command([:hmget, key].concat(fields), &blk)
       end
 
       # Get the values of all the given hash fields.
@@ -102,7 +103,8 @@ class Redis
       #
       # @see #hmget
       def mapped_hmget(key, *fields)
-        hmget(key, *fields) do |reply|
+        fields.flatten!(1)
+        hmget(key, fields) do |reply|
           if reply.is_a?(Array)
             Hash[fields.zip(reply)]
           else
@@ -152,7 +154,8 @@ class Redis
       # @param [String, Array<String>] field
       # @return [Integer] the number of fields that were removed from the hash
       def hdel(key, *fields)
-        send_command([:hdel, key, *fields])
+        fields.flatten!(1)
+        send_command([:hdel, key].concat(fields))
       end
 
       # Determine if a hash field exists.

data/lib/redis/commands/hyper_log_log.rb

@@ -20,7 +20,7 @@ class Redis
       # @param [String, Array<String>] keys
       # @return [Integer]
       def pfcount(*keys)
-        send_command([:pfcount] + keys)
+        send_command([:pfcount] + keys.flatten(1))
       end
 
       # Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of

data/lib/redis/commands/keys.rb

@@ -249,24 +249,6 @@ class Redis
       # @param [String, Array<String>] keys
       # @return [Integer]
       def exists(*keys)
-        if !Redis.exists_returns_integer && keys.size == 1
-          if Redis.exists_returns_integer.nil?
-            message = "`Redis#exists(key)` will return an Integer in redis-rb 4.3. `exists?` returns a boolean, you " \
-              "should use it instead. To opt-in to the new behavior now you can set Redis.exists_returns_integer =  " \
-              "true. To disable this message and keep the current (boolean) behaviour of 'exists' you can set " \
-              "`Redis.exists_returns_integer = false`, but this option will be removed in 5.0.0. " \
-              "(#{::Kernel.caller(1, 1).first})\n"
-
-            ::Redis.deprecate!(message)
-          end
-
-          exists?(*keys)
-        else
-          _exists(*keys)
-        end
-      end
-
-      def _exists(*keys)
         send_command([:exists, *keys])
       end
 

data/lib/redis/commands/lists.rb

@@ -48,7 +48,7 @@ class Redis
       # @param [String, Symbol] where_destination where to push the element to the source list
       #     e.g. 'LEFT' - to head, 'RIGHT' - to tail
       # @param [Hash] options
-      #   - `:timeout => Numeric`: timeout in seconds, defaults to no timeout
+      #   - `:timeout => [Float, Integer]`: timeout in seconds, defaults to no timeout
       #
       # @return [nil, String] the element, or nil when the source key does not exist or the timeout expired
       #
@@ -142,7 +142,7 @@ class Redis
       # @param [String, Array<String>] keys one or more keys to perform the
       #   blocking pop on
       # @param [Hash] options
-      #   - `:timeout => Integer`: timeout in seconds, defaults to no timeout
+      #   - `:timeout => [Float, Integer]`: timeout in seconds, defaults to no timeout
       #
       # @return [nil, [String, String]]
       #   - `nil` when the operation timed out
@@ -156,7 +156,7 @@ class Redis
       # @param [String, Array<String>] keys one or more keys to perform the
       #   blocking pop on
       # @param [Hash] options
-      #   - `:timeout => Integer`: timeout in seconds, defaults to no timeout
+      #   - `:timeout => [Float, Integer]`: timeout in seconds, defaults to no timeout
       #
       # @return [nil, [String, String]]
       #   - `nil` when the operation timed out
@@ -173,12 +173,12 @@ class Redis
       # @param [String] source source key
       # @param [String] destination destination key
       # @param [Hash] options
-      #   - `:timeout => Integer`: timeout in seconds, defaults to no timeout
+      #   - `:timeout => [Float, Integer]`: timeout in seconds, defaults to no timeout
       #
       # @return [nil, String]
       #   - `nil` when the operation timed out
       #   - the element was popped and pushed otherwise
-      def brpoplpush(source, destination, deprecated_timeout = 0, timeout: deprecated_timeout)
+      def brpoplpush(source, destination, timeout: 0)
         command = [:brpoplpush, source, destination, timeout]
         send_blocking_command(command, timeout)
       end
@@ -253,21 +253,16 @@ class Redis
         timeout = if args.last.is_a?(Hash)
           options = args.pop
           options[:timeout]
-        elsif args.last.respond_to?(:to_int)
-          last_arg = args.pop
-          ::Redis.deprecate!(
-            "Passing the timeout as a positional argument is deprecated, it should be passed as a keyword argument:\n" \
-            "  redis.#{cmd}(#{args.map(&:inspect).join(', ')}, timeout: #{last_arg.to_int})" \
-            "(called from: #{caller(2, 1).first})"
-          )
-          last_arg.to_int
         end
 
         timeout ||= 0
+        unless timeout.is_a?(Integer) || timeout.is_a?(Float)
+          raise ArgumentError, "timeout must be an Integer or Float, got: #{timeout.class}"
+        end
 
-        keys = args.flatten
-
-        command = [cmd, keys, timeout]
+        args.flatten!(1)
+        command = [cmd].concat(args)
+        command << timeout
         send_blocking_command(command, timeout, &blk)
       end
 

data/lib/redis/commands/pubsub.rb

@@ -9,9 +9,7 @@ class Redis
       end
 
       def subscribed?
-        synchronize do |client|
-          client.is_a? SubscribedClient
-        end
+        !@subscription_client.nil?
       end
 
       # Listen for messages published to the given channels.
@@ -31,10 +29,10 @@ class Redis
 
       # Stop listening for messages posted to the given channels.
       def unsubscribe(*channels)
-        synchronize do |client|
-          raise "Can't unsubscribe if not subscribed." unless subscribed?
+        raise "Can't unsubscribe if not subscribed." unless subscribed?
 
-          client.unsubscribe(*channels)
+        synchronize do |_client|
+          _subscription(:unsubscribe, 0, channels, nil)
         end
       end
 
@@ -55,10 +53,10 @@ class Redis
 
       # Stop listening for messages posted to channels matching the given patterns.
       def punsubscribe(*channels)
-        synchronize do |client|
-          raise "Can't unsubscribe if not subscribed." unless subscribed?
+        raise "Can't unsubscribe if not subscribed." unless subscribed?
 
-          client.punsubscribe(*channels)
+        synchronize do |_client|
+          _subscription(:punsubscribe, 0, channels, nil)
         end
       end
 

data/lib/redis/commands/server.rb

@@ -117,9 +117,13 @@ class Redis
       #
       # @yield a block to be called for every line of output
       # @yieldparam [String] line timestamp and command that was executed
-      def monitor(&block)
+      def monitor
         synchronize do |client|
-          client.call_loop([:monitor], &block)
+          client = client.pubsub
+          client.call_v([:monitor])
+          loop do
+            yield client.next_event
+          end
         end
       end
 
@@ -133,13 +137,11 @@ class Redis
       # Synchronously save the dataset to disk and then shut down the server.
       def shutdown
         synchronize do |client|
-          client.with_reconnect(false) do
-            begin
-              client.call([:shutdown])
-            rescue ConnectionError
-              # This means Redis has probably exited.
-              nil
-            end
+          client.disable_reconnection do
+            client.call_v([:shutdown])
+          rescue ConnectionError
+            # This means Redis has probably exited.
+            nil
           end
         end
       end
@@ -155,11 +157,9 @@ class Redis
       # @param [Integer] length maximum number of entries to return
       # @return [Array<String>, Integer, String] depends on subcommand
       def slowlog(subcommand, length = nil)
-        synchronize do |client|
-          args = [:slowlog, subcommand]
-          args << length if length
-          client.call args
-        end
+        args = [:slowlog, subcommand]
+        args << length if length
+        send_command(args)
       end
 
       # Internal command used for replication.

data/lib/redis/commands/sets.rb

@@ -15,56 +15,40 @@ class Redis
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean, Integer] `Boolean` when a single member is specified,
-      #   holding whether or not adding the member succeeded, or `Integer` when an
-      #   array of members is specified, holding the number of members that were
-      #   successfully added
-      def sadd(key, member)
-        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
-          ::Redis.deprecate!(
-            "Redis#sadd will always return an Integer in Redis 5.0.0. Use Redis#sadd? instead." \
-            "(called from: #{caller(1, 1).first})"
-          )
-          Boolify
-        end
-        send_command([:sadd, key, member], &block)
+      # @return [Integer] The number of members that were successfully added
+      def sadd(key, *members)
+        members.flatten!(1)
+        send_command([:sadd, key].concat(members))
       end
 
       # Add one or more members to a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean] Whether or not at least one member was added.
-      def sadd?(key, member)
-        send_command([:sadd, key, member], &Boolify)
+      # @return [Boolean] Wether at least one member was successfully added.
+      def sadd?(key, *members)
+        members.flatten!(1)
+        send_command([:sadd, key].concat(members), &Boolify)
       end
 
       # Remove one or more members from a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean, Integer] `Boolean` when a single member is specified,
-      #   holding whether or not removing the member succeeded, or `Integer` when an
-      #   array of members is specified, holding the number of members that were
-      #   successfully removed
-      def srem(key, member)
-        block = if Redis.sadd_returns_boolean && !member.is_a?(Array)
-          ::Redis.deprecate!(
-            "Redis#srem will always return an Integer in Redis 5.0.0. Use Redis#srem? instead." \
-            "(called from: #{caller(1, 1).first})"
-          )
-          Boolify
-        end
-        send_command([:srem, key, member], &block)
+      # @return [Integer] The number of members that were successfully removed
+      def srem(key, *members)
+        members.flatten!(1)
+        send_command([:srem, key].concat(members))
       end
 
       # Remove one or more members from a set.
       #
       # @param [String] key
       # @param [String, Array<String>] member one member, or array of members
-      # @return [Boolean] `Boolean` Whether or not a member was removed.
-      def srem?(key, member)
-        send_command([:srem, key, member], &Boolify)
+      # @return [Boolean] Wether at least one member was successfully removed.
+      def srem?(key, *members)
+        members.flatten!(1)
+        send_command([:srem, key].concat(members), &Boolify)
       end
 
       # Remove and return one or more random member from a set.
@@ -118,7 +102,8 @@ class Redis
       # @param [String, Array<String>] members
       # @return [Array<Boolean>]
       def smismember(key, *members)
-        send_command([:smismember, key, *members]) do |reply|
+        members.flatten!(1)
+        send_command([:smismember, key].concat(members)) do |reply|
           reply.map(&Boolify)
         end
       end
@@ -136,7 +121,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to subtract
       # @return [Array<String>] members in the difference
       def sdiff(*keys)
-        send_command([:sdiff, *keys])
+        keys.flatten!(1)
+        send_command([:sdiff].concat(keys))
       end
 
       # Subtract multiple sets and store the resulting set in a key.
@@ -145,7 +131,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to subtract
       # @return [Integer] number of elements in the resulting set
       def sdiffstore(destination, *keys)
-        send_command([:sdiffstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sdiffstore, destination].concat(keys))
       end
 
       # Intersect multiple sets.
@@ -153,7 +140,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to intersect
       # @return [Array<String>] members in the intersection
       def sinter(*keys)
-        send_command([:sinter, *keys])
+        keys.flatten!(1)
+        send_command([:sinter].concat(keys))
       end
 
       # Intersect multiple sets and store the resulting set in a key.
@@ -162,7 +150,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to intersect
       # @return [Integer] number of elements in the resulting set
       def sinterstore(destination, *keys)
-        send_command([:sinterstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sinterstore, destination].concat(keys))
       end
 
       # Add multiple sets.
@@ -170,7 +159,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to unify
       # @return [Array<String>] members in the union
       def sunion(*keys)
-        send_command([:sunion, *keys])
+        keys.flatten!(1)
+        send_command([:sunion].concat(keys))
       end
 
       # Add multiple sets and store the resulting set in a key.
@@ -179,7 +169,8 @@ class Redis
       # @param [String, Array<String>] keys keys pointing to sets to unify
       # @return [Integer] number of elements in the resulting set
       def sunionstore(destination, *keys)
-        send_command([:sunionstore, destination, *keys])
+        keys.flatten!(1)
+        send_command([:sunionstore, destination].concat(keys))
       end
 
       # Scan a set

data/lib/redis/commands/sorted_sets.rb

@@ -778,7 +778,8 @@ class Redis
       private
 
       def _zsets_operation(cmd, *keys, weights: nil, aggregate: nil, with_scores: false)
-        command = [cmd, keys.size, *keys]
+        keys.flatten!(1)
+        command = [cmd, keys.size].concat(keys)
 
         if weights
           command << "WEIGHTS"
@@ -796,7 +797,8 @@ class Redis
       end
 
       def _zsets_operation_store(cmd, destination, keys, weights: nil, aggregate: nil)
-        command = [cmd, destination, keys.size, *keys]
+        keys.flatten!(1)
+        command = [cmd, destination, keys.size].concat(keys)
 
         if weights
           command << "WEIGHTS"

data/lib/redis/commands/streams.rb

@@ -21,15 +21,12 @@ class Redis
       # @return [Array<Hash>] information of the consumers if subcommand is `consumers`
       def xinfo(subcommand, key, group = nil)
         args = [:xinfo, subcommand, key, group].compact
-        synchronize do |client|
-          client.call(args) do |reply|
-            case subcommand.to_s.downcase
-            when 'stream'              then Hashify.call(reply)
-            when 'groups', 'consumers' then reply.map { |arr| Hashify.call(arr) }
-            else reply
-            end
-          end
+        block = case subcommand.to_s.downcase
+        when 'stream'              then Hashify
+        when 'groups', 'consumers' then proc { |r| r.map(&Hashify) }
         end
+
+        send_command(args, &block)
       end
 
       # Add new entry to the stream.
@@ -113,7 +110,7 @@ class Redis
       def xrange(key, start = '-', range_end = '+', count: nil)
         args = [:xrange, key, start, range_end]
         args.concat(['COUNT', count]) if count
-        synchronize { |client| client.call(args, &HashifyStreamEntries) }
+        send_command(args, &HashifyStreamEntries)
       end
 
       # Fetches entries of the stream in descending order.
@@ -334,6 +331,8 @@ class Redis
       #   redis.xpending('mystream', 'mygroup')
       # @example With range options
       #   redis.xpending('mystream', 'mygroup', '-', '+', 10)
+      # @example With range and idle time options
+      #   redis.xpending('mystream', 'mygroup', '-', '+', 10, idle: 9000)
       # @example With range and consumer options
       #   redis.xpending('mystream', 'mygroup', '-', '+', 10, 'consumer1')
       #
@@ -344,10 +343,13 @@ class Redis
       # @param count    [Integer] count the number of entries as limit
       # @param consumer [String]  the consumer name
       #
+      # @option opts [Integer] :idle       pending message minimum idle time in milliseconds
+      #
       # @return [Hash]        the summary of pending entries
       # @return [Array<Hash>] the pending entries details if options were specified
-      def xpending(key, group, *args)
+      def xpending(key, group, *args, idle: nil)
         command_args = [:xpending, key, group]
+        command_args << 'IDLE' << Integer(idle) if idle
         case args.size
         when 0, 3, 4
           command_args.concat(args)

data/lib/redis/commands/strings.rb

@@ -202,6 +202,7 @@ class Redis
       #
       # @see #mapped_mget
       def mget(*keys, &blk)
+        keys.flatten!(1)
         send_command([:mget, *keys], &blk)
       end
 

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,12 +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 Integer
-        value > 0
-      else
-        value
-      end
+      value != 0 unless value.nil?
     }
 
     BoolifySet = lambda { |value|