redis 4.6.0 → 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

@@ -69,18 +69,40 @@ class Redis
       #
       # @param [String] key
       # @param [Integer] seconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expire(key, seconds)
-        send_command([:expire, key, seconds], &Boolify)
+      def expire(key, seconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expire, key, seconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as a UNIX timestamp.
       #
       # @param [String] key
       # @param [Integer] unix_time expiry time specified as a UNIX timestamp
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def expireat(key, unix_time)
-        send_command([:expireat, key, unix_time], &Boolify)
+      def expireat(key, unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:expireat, key, unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in seconds) for a key.
@@ -103,18 +125,40 @@ class Redis
       #
       # @param [String] key
       # @param [Integer] milliseconds time to live
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpire(key, milliseconds)
-        send_command([:pexpire, key, milliseconds], &Boolify)
+      def pexpire(key, milliseconds, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpire, key, milliseconds]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Set the expiration for a key as number of milliseconds from UNIX Epoch.
       #
       # @param [String] key
       # @param [Integer] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch.
+      # @param [Hash] options
+      #   - `:nx => true`: Set expiry only when the key has no expiry.
+      #   - `:xx => true`: Set expiry only when the key has an existing expiry.
+      #   - `:gt => true`: Set expiry only when the new expiry is greater than current one.
+      #   - `:lt => true`: Set expiry only when the new expiry is less than current one.
       # @return [Boolean] whether the timeout was set or not
-      def pexpireat(key, ms_unix_time)
-        send_command([:pexpireat, key, ms_unix_time], &Boolify)
+      def pexpireat(key, ms_unix_time, nx: nil, xx: nil, gt: nil, lt: nil)
+        args = [:pexpireat, key, ms_unix_time]
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "GT" if gt
+        args << "LT" if lt
+
+        send_command(args, &Boolify)
       end
 
       # Get the time to live (in milliseconds) for a key.
@@ -205,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,20 +253,16 @@ class Redis
         timeout = if args.last.is_a?(Hash)
           options = args.pop
           options[:timeout]
-        elsif args.last.respond_to?(:to_int)
-          # Issue deprecation notice in obnoxious mode...
-          args.pop.to_int
         end
 
         timeout ||= 0
-
-        if args.size > 1
-          # Issue deprecation notice in obnoxious mode...
+        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,40 +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)
-        send_command([:sadd, key, member]) do |reply|
-          if member.is_a? Array
-            # Variadic: return integer
-            reply
-          else
-            # Single argument: return boolean
-            Boolify.call(reply)
-          end
-        end
+      # @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] 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)
-        send_command([:srem, key, member]) do |reply|
-          if member.is_a? Array
-            # Variadic: return integer
-            reply
-          else
-            # Single argument: return boolean
-            Boolify.call(reply)
-          end
-        end
+      # @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] 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.
@@ -102,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
@@ -120,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.
@@ -129,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.
@@ -137,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.
@@ -146,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.
@@ -154,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.
@@ -163,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

@@ -60,8 +60,11 @@ class Redis
         command << "INCR" if incr
 
         if args.size == 1 && args[0].is_a?(Array)
+          members_to_add = args[0]
+          return 0 if members_to_add.empty?
+
           # Variadic: return float if INCR, integer if !INCR
-          send_command(command + args[0], &(incr ? Floatify : nil))
+          send_command(command + members_to_add, &(incr ? Floatify : nil))
         elsif args.size == 2
           # Single pair: return float if INCR, boolean if !INCR
           send_command(command + args, &(incr ? Floatify : Boolify))
@@ -102,6 +105,11 @@ class Redis
       #   - `Integer` when an array of pairs is specified, holding the number of
       #   members that were removed to the sorted set
       def zrem(key, member)
+        if member.is_a?(Array)
+          members_to_remove = member
+          return 0 if members_to_remove.empty?
+        end
+
         send_command([:zrem, key, member]) do |reply|
           if member.is_a? Array
             # Variadic: return integer
@@ -770,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"
@@ -788,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