redis 4.3.0 → 4.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d173abb7a6c08e1feb87c9fd5ba33a2a0d907c6d045f6959d55f3234e56ceeb
-  data.tar.gz: 7463d58522a3db5262eeea4b95834d82ede95cf102d2375e051cf4ada1b235c3
+  metadata.gz: 7a7232fef186e6d6a11a90d8dd9aa7c71114f017e0afe9378999a96c9e6b4e05
+  data.tar.gz: 689f176b87909bf61eb60e57d1eb795198162a7e039104c80facf36880964bda
 SHA512:
-  metadata.gz: 0b34ab14e41e1bd63a99319f3ee5e1e7ea0c1e89581e525dfd82b77968a834525807b025f02d8ff5df4e7a994f19cc7ee4098103c70abd78ab6c22ec435a055c
-  data.tar.gz: 84da776467bebb7fd59333084787e484203e55b81be5031c78b44741f2b79342cc1f6f48c1f9663b15f360a3af590783ee2f403da07a3e04486e35ba70e49e01
+  metadata.gz: 22b11dee92e298b46bb94a707156d3dbf9afb83c8e9e8cbf82cf366d582a7c1b7295d7f09a0fec01965245f4800c2482c0559d646f46ff1c6bba6423ab398ba9
+  data.tar.gz: 9a74ba29c8cb3d7634a44c78e30018a048e19cca66c7fad6a226722183f66546bebb370c92ecdf20522bb35ee72a09b2fda64891ff6d94db1702375bd1ba6b46

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Unreleased
 
+# 4.5.1
+
+* Restore the accidential auth behavior of redis-rb 4.3.0 with a warning. If provided with the `default` user's password, but a wrong username,
+  redis-rb will first try to connect as the provided user, but then will fallback to connect as the `default` user with the provided password.
+  This behavior is deprecated and will be removed in Redis 4.6.0. Fix #1038.
+
+# 4.5.0
+
+* Handle parts of the command using incompatible encodings. See #1037.
+* Add GET option to SET command. See #1036.
+* Add ZRANDMEMBER command. See #1035.
+* Add LMOVE/BLMOVE commands. See #1034.
+* Add ZMSCORE command. See #1032.
+* Add LT/GT options to ZADD. See #1033.
+* Add SMISMEMBER command. See #1031.
+* Add EXAT/PXAT options to SET. See #1028.
+* Add GETDEL/GETEX commands. See #1024.
+* `Redis#exists` now returns an Integer by default, as warned since 4.2.0. The old behavior can be restored with `Redis.exists_returns_integer = false`.
+* Fix Redis < 6 detection during connect. See #1025.
+* Fix fetching command details in Redis cluster when the first node is unhealthy. See #1026.
+
+# 4.4.0
+
+* Redis cluster: fix cross-slot validation in pipelines. Fix ##1019.
+* Add support for `XAUTOCLAIM`. See #1018.
+* Properly issue `READONLY` when reconnecting to replicas. Fix #1017.
+* Make `del` a noop if passed an empty list of keys. See #998.
+* Add support for `ZINTER`. See #995.
+
+# 4.3.1
+
+* Fix password authentication against redis server 5 and older.
+
 # 4.3.0
 
 * Add the TYPE argument to scan and scan_each. See #985.

data/lib/redis/client.rb

@@ -115,7 +115,33 @@ class Redis
       # Don't try to reconnect when the connection is fresh
       with_reconnect(false) do
         establish_connection
-        call [:auth, username, password].compact if username || password
+        if password
+          if username
+            begin
+              call [:auth, username, password]
+            rescue CommandError => err # Likely on Redis < 6
+              if err.message.match?(/ERR wrong number of arguments for \'auth\' command/)
+                call [:auth, password]
+              elsif err.message.match?(/WRONGPASS invalid username-password pair/)
+                begin
+                  call [:auth, password]
+                rescue CommandError
+                  raise err
+                end
+                ::Kernel.warn(
+                  "[redis-rb] The Redis connection was configured with username #{username.inspect}, but" \
+                  " the provided password was for the default user. This will start failing in redis-rb 4.6."
+                )
+              else
+                raise
+              end
+            end
+          else
+            call [:auth, password]
+          end
+        end
+
+        call [:readonly] if @options[:readonly]
         call [:select, db] if db != 0
         call [:client, :setname, @options[:id]] if @options[:id]
         @connector.check(self)

data/lib/redis/cluster/command_loader.rb

@@ -10,22 +10,21 @@ class Redis
       module_function
 
       def load(nodes)
-        details = {}
-
         nodes.each do |node|
-          details = fetch_command_details(node)
-          details.empty? ? next : break
+          begin
+            return fetch_command_details(node)
+          rescue CannotConnectError, ConnectionError, CommandError
+            next # can retry on another node
+          end
         end
 
-        details
+        raise CannotConnectError, 'Redis client could not connect to any cluster nodes'
       end
 
       def fetch_command_details(node)
         node.call(%i[command]).map do |reply|
           [reply[0], { arity: reply[1], flags: reply[2], first: reply[3], last: reply[4], step: reply[5] }]
         end.to_h
-      rescue CannotConnectError, ConnectionError, CommandError
-        {} # can retry on another node
       end
 
       private_class_method :fetch_command_details

data/lib/redis/cluster/node.rb

@@ -76,8 +76,9 @@ class Redis
         clients = options.map do |node_key, option|
           next if replica_disabled? && slave?(node_key)
 
+          option = option.merge(readonly: true) if slave?(node_key)
+
           client = Client.new(option)
-          client.call(%i[readonly]) if slave?(node_key)
           [node_key, client]
         end
 

data/lib/redis/cluster.rb

@@ -78,11 +78,13 @@ class Redis
     end
 
     def call_pipeline(pipeline)
-      node_keys, command_keys = extract_keys_in_pipeline(pipeline)
-      raise CrossSlotPipeliningError, command_keys if node_keys.size > 1
+      node_keys = pipeline.commands.map { |cmd| find_node_key(cmd, primary_only: true) }.compact.uniq
+      if node_keys.size > 1
+        raise(CrossSlotPipeliningError,
+              pipeline.commands.map { |cmd| @command.extract_first_key(cmd) }.reject(&:empty?).uniq)
+      end
 
-      node = find_node(node_keys.first)
-      try_send(node, :call_pipeline, pipeline)
+      try_send(find_node(node_keys.first), :call_pipeline, pipeline)
     end
 
     def call_with_timeout(command, timeout, &block)
@@ -253,14 +255,14 @@ class Redis
       find_node(node_key)
     end
 
-    def find_node_key(command)
+    def find_node_key(command, primary_only: false)
       key = @command.extract_first_key(command)
       return if key.empty?
 
       slot = KeySlotConverter.convert(key)
       return unless @slot.exists?(slot)
 
-      if @command.should_send_to_master?(command)
+      if @command.should_send_to_master?(command) || primary_only
         @slot.find_node_key_of_master(slot)
       else
         @slot.find_node_key_of_slave(slot)
@@ -285,11 +287,5 @@ class Redis
       @node.map(&:disconnect)
       @node, @slot = fetch_cluster_info!(@option)
     end
-
-    def extract_keys_in_pipeline(pipeline)
-      node_keys = pipeline.commands.map { |cmd| find_node_key(cmd) }.compact.uniq
-      command_keys = pipeline.commands.map { |cmd| @command.extract_first_key(cmd) }.reject(&:empty?)
-      [node_keys, command_keys]
-    end
   end
 end

data/lib/redis/connection/command_helper.rb

@@ -12,11 +12,13 @@ class Redis
           if i.is_a? Array
             i.each do |j|
               j = j.to_s
+              j = j.encoding == Encoding::BINARY ? j : j.b
               command << "$#{j.bytesize}"
               command << j
             end
           else
             i = i.to_s
+            i = i.encoding == Encoding::BINARY ? i : i.b
             command << "$#{i.bytesize}"
             command << i
           end

data/lib/redis/connection/ruby.rb

@@ -21,7 +21,7 @@ class Redis
         super(*args)
 
         @timeout = @write_timeout = nil
-        @buffer = "".dup
+        @buffer = "".b
       end
 
       def timeout=(timeout)
@@ -35,7 +35,8 @@ class Redis
       def read(nbytes)
         result = @buffer.slice!(0, nbytes)
 
-        result << _read_from_socket(nbytes - result.bytesize) while result.bytesize < nbytes
+        buffer = String.new(capacity: nbytes, encoding: Encoding::ASCII_8BIT)
+        result << _read_from_socket(nbytes - result.bytesize, buffer) while result.bytesize < nbytes
 
         result
       end
@@ -48,9 +49,9 @@ class Redis
         @buffer.slice!(0, crlf + CRLF.bytesize)
       end
 
-      def _read_from_socket(nbytes)
+      def _read_from_socket(nbytes, buffer = nil)
         loop do
-          case chunk = read_nonblock(nbytes, exception: false)
+          case chunk = read_nonblock(nbytes, buffer, exception: false)
           when :wait_readable
             unless wait_readable(@timeout)
               raise Redis::TimeoutError

data/lib/redis/distributed.rb

@@ -316,6 +316,16 @@ class Redis
       node_for(key).get(key)
     end
 
+    # Get the value of a key and delete it.
+    def getdel(key)
+      node_for(key).getdel(key)
+    end
+
+    # Get the value of a key and sets its time to live based on options.
+    def getex(key, **options)
+      node_for(key).getex(key, **options)
+    end
+
     # Get the values of all the given keys as an Array.
     def mget(*keys)
       mapped_mget(*keys).values_at(*keys)
@@ -393,6 +403,21 @@ class Redis
       node_for(key).llen(key)
     end
 
+    # Remove the first/last element in a list, append/prepend it to another list and return it.
+    def lmove(source, destination, where_source, where_destination)
+      ensure_same_node(:lmove, [source, destination]) do |node|
+        node.lmove(source, destination, where_source, where_destination)
+      end
+    end
+
+    # Remove the first/last element in a list and append/prepend it
+    # to another list and return it, or block until one is available.
+    def blmove(source, destination, where_source, where_destination, timeout: 0)
+      ensure_same_node(:lmove, [source, destination]) do |node|
+        node.blmove(source, destination, where_source, where_destination, timeout: timeout)
+      end
+    end
+
     # Prepend one or more values to a list.
     def lpush(key, value)
       node_for(key).lpush(key, value)
@@ -413,14 +438,14 @@ class Redis
       node_for(key).rpushx(key, value)
     end
 
-    # Remove and get the first element in a list.
-    def lpop(key)
-      node_for(key).lpop(key)
+    # Remove and get the first elements in a list.
+    def lpop(key, count = nil)
+      node_for(key).lpop(key, count)
     end
 
-    # Remove and get the last element in a list.
-    def rpop(key)
-      node_for(key).rpop(key)
+    # Remove and get the last elements in a list.
+    def rpop(key, count = nil)
+      node_for(key).rpop(key, count)
     end
 
     # Remove the last element in a list, append it to another list and return
@@ -542,6 +567,11 @@ class Redis
       node_for(key).sismember(key, member)
     end
 
+    # Determine if multiple values are members of a set.
+    def smismember(key, *members)
+      node_for(key).smismember(key, *members)
+    end
+
     # Get all the members in a set.
     def smembers(key)
       node_for(key).smembers(key)
@@ -626,6 +656,16 @@ class Redis
       node_for(key).zscore(key, member)
     end
 
+    # Get one or more random members from a sorted set.
+    def zrandmember(key, count = nil, **options)
+      node_for(key).zrandmember(key, count, **options)
+    end
+
+    # Get the scores associated with the given members in a sorted set.
+    def zmscore(key, *members)
+      node_for(key).zmscore(key, *members)
+    end
+
     # Return a range of members in a sorted set, by index.
     def zrange(key, start, stop, **options)
       node_for(key).zrange(key, start, stop, **options)
@@ -674,6 +714,13 @@ class Redis
       node_for(key).zcount(key, min, max)
     end
 
+    # Get the intersection of multiple sorted sets
+    def zinter(*keys, **options)
+      ensure_same_node(:zinter, keys) do |node|
+        node.zinter(*keys, **options)
+      end
+    end
+
     # Intersect multiple sorted sets and store the resulting sorted set in a new
     # key.
     def zinterstore(destination, keys, **options)

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '4.3.0'
+  VERSION = '4.5.1'
 end

data/lib/redis.rb

@@ -4,6 +4,8 @@ require "monitor"
 require_relative "redis/errors"
 
 class Redis
+  @exists_returns_integer = true
+
   class << self
     attr_reader :exists_returns_integer
 
@@ -555,6 +557,9 @@ class Redis
   # @param [String, Array<String>] keys
   # @return [Integer] number of keys that were deleted
   def del(*keys)
+    keys.flatten!(1)
+    return 0 if keys.empty?
+
     synchronize do |client|
       client.call([:del] + keys)
     end
@@ -831,17 +836,23 @@ class Redis
   # @param [Hash] options
   #   - `:ex => Integer`: Set the specified expire time, in seconds.
   #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+  #   - `:exat => Integer` : Set the specified Unix time at which the key will expire, in seconds.
+  #   - `:pxat => Integer` : Set the specified Unix time at which the key will expire, in milliseconds.
   #   - `:nx => true`: Only set the key if it does not already exist.
   #   - `:xx => true`: Only set the key if it already exist.
   #   - `:keepttl => true`: Retain the time to live associated with the key.
+  #   - `:get => true`: Return the old string stored at key, or nil if key did not exist.
   # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
-  def set(key, value, ex: nil, px: nil, nx: nil, xx: nil, keepttl: nil)
+  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 << "NX" if nx
     args << "XX" if xx
     args << "KEEPTTL" if keepttl
+    args << "GET" if get
 
     synchronize do |client|
       if nx || xx
@@ -1107,6 +1118,45 @@ class Redis
     end
   end
 
+  # Get the value of key and delete the key. This command is similar to GET,
+  # except for the fact that it also deletes the key on success.
+  #
+  # @param [String] key
+  # @return [String] the old value stored in the key, or `nil` if the key
+  #   did not exist
+  def getdel(key)
+    synchronize do |client|
+      client.call([:getdel, key])
+    end
+  end
+
+  # Get the value of key and optionally set its expiration. GETEX is similar to
+  # GET, but is a write command with additional options. When no options are
+  # provided, GETEX behaves like GET.
+  #
+  # @param [String] key
+  # @param [Hash] options
+  #   - `:ex => Integer`: Set the specified expire time, in seconds.
+  #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+  #   - `:exat => true`: Set the specified Unix time at which the key will
+  #      expire, in seconds.
+  #   - `:pxat => true`: Set the specified Unix time at which the key will
+  #      expire, in milliseconds.
+  #   - `:persist => true`: Remove the time to live associated with the key.
+  # @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 << "PERSIST" if persist
+
+    synchronize do |client|
+      client.call(args)
+    end
+  end
+
   # Get the length of the value stored in a key.
   #
   # @param [String] key
@@ -1128,6 +1178,59 @@ class Redis
     end
   end
 
+  # Remove the first/last element in a list, append/prepend it to another list and return it.
+  #
+  # @param [String] source source key
+  # @param [String] destination destination key
+  # @param [String, Symbol] where_source from where to remove the element from the source list
+  #     e.g. 'LEFT' - from head, 'RIGHT' - from tail
+  # @param [String, Symbol] where_destination where to push the element to the source list
+  #     e.g. 'LEFT' - to head, 'RIGHT' - to tail
+  #
+  # @return [nil, String] the element, or nil when the source key does not exist
+  #
+  # @note This command comes in place of the now deprecated RPOPLPUSH.
+  #     Doing LMOVE RIGHT LEFT is equivalent.
+  def lmove(source, destination, where_source, where_destination)
+    where_source, where_destination = _normalize_move_wheres(where_source, where_destination)
+
+    synchronize do |client|
+      client.call([:lmove, source, destination, where_source, where_destination])
+    end
+  end
+
+  # Remove the first/last element in a list and append/prepend it
+  # to another list and return it, or block until one is available.
+  #
+  # @example With timeout
+  #   element = redis.blmove("foo", "bar", "LEFT", "RIGHT", timeout: 5)
+  #     # => nil on timeout
+  #     # => "element" on success
+  # @example Without timeout
+  #   element = redis.blmove("foo", "bar", "LEFT", "RIGHT")
+  #     # => "element"
+  #
+  # @param [String] source source key
+  # @param [String] destination destination key
+  # @param [String, Symbol] where_source from where to remove the element from the source list
+  #     e.g. 'LEFT' - from head, 'RIGHT' - from tail
+  # @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
+  #
+  # @return [nil, String] the element, or nil when the source key does not exist or the timeout expired
+  #
+  def blmove(source, destination, where_source, where_destination, timeout: 0)
+    where_source, where_destination = _normalize_move_wheres(where_source, where_destination)
+
+    synchronize do |client|
+      command = [:blmove, source, destination, where_source, where_destination, timeout]
+      timeout += client.timeout if timeout > 0
+      client.call_with_timeout(command, timeout)
+    end
+  end
+
   # Prepend one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
@@ -1172,23 +1275,29 @@ class Redis
     end
   end
 
-  # Remove and get the first element in a list.
+  # Remove and get the first elements in a list.
   #
   # @param [String] key
-  # @return [String]
-  def lpop(key)
+  # @param [Integer] count number of elements to remove
+  # @return [String, Array<String>] the values of the first elements
+  def lpop(key, count = nil)
     synchronize do |client|
-      client.call([:lpop, key])
+      command = [:lpop, key]
+      command << count if count
+      client.call(command)
     end
   end
 
-  # Remove and get the last element in a list.
+  # Remove and get the last elements in a list.
   #
   # @param [String] key
-  # @return [String]
-  def rpop(key)
+  # @param [Integer] count number of elements to remove
+  # @return [String, Array<String>] the values of the last elements
+  def rpop(key, count = nil)
     synchronize do |client|
-      client.call([:rpop, key])
+      command = [:rpop, key]
+      command << count if count
+      client.call(command)
     end
   end
 
@@ -1470,6 +1579,19 @@ class Redis
     end
   end
 
+  # Determine if multiple values are members of a set.
+  #
+  # @param [String] key
+  # @param [String, Array<String>] members
+  # @return [Array<Boolean>]
+  def smismember(key, *members)
+    synchronize do |client|
+      client.call([:smismember, key, *members]) do |reply|
+        reply.map(&Boolify)
+      end
+    end
+  end
+
   # Get all the members in a set.
   #
   # @param [String] key
@@ -1574,6 +1696,10 @@ class Redis
   #   add elements)
   #   - `:nx => true`: Don't update already existing elements (always
   #   add new elements)
+  #   - `:lt => true`: Only update existing elements if the new score
+  #   is less than the current score
+  #   - `:gt => true`: Only update existing elements if the new score
+  #   is greater than the current score
   #   - `:ch => true`: Modify the return value from the number of new
   #   elements added, to the total number of elements changed (CH is an
   #   abbreviation of changed); changed elements are new elements added
@@ -1588,10 +1714,12 @@ class Redis
   #   pairs that were **added** to the sorted set.
   #   - `Float` when option :incr is specified, holding the score of the member
   #   after incrementing it.
-  def zadd(key, *args, nx: nil, xx: nil, ch: nil, incr: nil)
+  def zadd(key, *args, nx: nil, xx: nil, lt: nil, gt: nil, ch: nil, incr: nil)
     command = [:zadd, key]
     command << "NX" if nx
     command << "XX" if xx
+    command << "LT" if lt
+    command << "GT" if gt
     command << "CH" if ch
     command << "INCR" if incr
 
@@ -1754,6 +1882,63 @@ class Redis
     end
   end
 
+  # Get the scores associated with the given members in a sorted set.
+  #
+  # @example Get the scores for members "a" and "b"
+  #   redis.zmscore("zset", "a", "b")
+  #     # => [32.0, 48.0]
+  #
+  # @param [String] key
+  # @param [String, Array<String>] members
+  # @return [Array<Float>] scores of the members
+  def zmscore(key, *members)
+    synchronize do |client|
+      client.call([:zmscore, key, *members]) do |reply|
+        reply.map(&Floatify)
+      end
+    end
+  end
+
+  # Get one or more random members from a sorted set.
+  #
+  # @example Get one random member
+  #   redis.zrandmember("zset")
+  #     # => "a"
+  # @example Get multiple random members
+  #   redis.zrandmember("zset", 2)
+  #     # => ["a", "b"]
+  # @example Gem multiple random members with scores
+  #   redis.zrandmember("zset", 2, with_scores: true)
+  #     # => [["a", 2.0], ["b", 3.0]]
+  #
+  # @param [String] key
+  # @param [Integer] count
+  # @param [Hash] options
+  #   - `:with_scores => true`: include scores in output
+  #
+  # @return [nil, String, Array<String>, Array<[String, Float]>]
+  #   - when `key` does not exist or set is empty, `nil`
+  #   - when `count` is not specified, a member
+  #   - when `count` is specified and `:with_scores` is not specified, an array of members
+  #   - when `:with_scores` is specified, an array with `[member, score]` pairs
+  def zrandmember(key, count = nil, withscores: false, with_scores: withscores)
+    if with_scores && count.nil?
+      raise ArgumentError, "count argument must be specified"
+    end
+
+    args = [:zrandmember, key]
+    args << count if count
+
+    if with_scores
+      args << "WITHSCORES"
+      block = FloatifyPairs
+    end
+
+    synchronize do |client|
+      client.call(args, &block)
+    end
+  end
+
   # Return a range of members in a sorted set, by index.
   #
   # @example Retrieve all members from a sorted set
@@ -2056,6 +2241,45 @@ class Redis
     end
   end
 
+  # Return the intersection of multiple sorted sets
+  #
+  # @example Retrieve the intersection of `2*zsetA` and `1*zsetB`
+  #   redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0])
+  #     # => ["v1", "v2"]
+  # @example Retrieve the intersection of `2*zsetA` and `1*zsetB`, and their scores
+  #   redis.zinter("zsetA", "zsetB", :weights => [2.0, 1.0], :with_scores => true)
+  #     # => [["v1", 3.0], ["v2", 6.0]]
+  #
+  # @param [String, Array<String>] keys one or more keys to intersect
+  # @param [Hash] options
+  #   - `:weights => [Float, Float, ...]`: weights to associate with source
+  #   sorted sets
+  #   - `:aggregate => String`: aggregate function to use (sum, min, max, ...)
+  #   - `:with_scores => true`: include scores in output
+  #
+  # @return [Array<String>, Array<[String, Float]>]
+  #   - when `:with_scores` is not specified, an array of members
+  #   - when `:with_scores` is specified, an array with `[member, score]` pairs
+  def zinter(*keys, weights: nil, aggregate: nil, with_scores: false)
+    args = [:zinter, keys.size, *keys]
+
+    if weights
+      args << "WEIGHTS"
+      args.concat(weights)
+    end
+
+    args << "AGGREGATE" << aggregate if aggregate
+
+    if with_scores
+      args << "WITHSCORES"
+      block = FloatifyPairs
+    end
+
+    synchronize do |client|
+      client.call(args, &block)
+    end
+  end
+
   # Intersect multiple sorted sets and store the resulting sorted set in a new
   # key.
   #
@@ -3232,6 +3456,38 @@ class Redis
     synchronize { |client| client.call(args, &blk) }
   end
 
+  # Transfers ownership of pending stream entries that match the specified criteria.
+  #
+  # @example Claim next pending message stuck > 5 minutes  and mark as retry
+  #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0')
+  # @example Claim 50 next pending messages stuck > 5 minutes  and mark as retry
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', count: 50)
+  # @example Claim next pending message stuck > 5 minutes and don't mark as retry
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-0', justid: true)
+  # @example Claim next pending message after this id stuck > 5 minutes  and mark as retry
+  #   redis.xautoclaim('mystream', 'mygroup', 'consumer1', 3600000, '1641321233-0')
+  #
+  # @param key           [String]        the stream key
+  # @param group         [String]        the consumer group name
+  # @param consumer      [String]        the consumer name
+  # @param min_idle_time [Integer]       the number of milliseconds
+  # @param start         [String]        entry id to start scanning from or 0-0 for everything
+  # @param count         [Integer]       number of messages to claim (default 1)
+  # @param justid        [Boolean]       whether to fetch just an array of entry ids or not.
+  #                                      Does not increment retry count when true
+  #
+  # @return [Hash{String => Hash}] the entries successfully claimed
+  # @return [Array<String>]        the entry ids successfully claimed if justid option is `true`
+  def xautoclaim(key, group, consumer, min_idle_time, start, count: nil, justid: false)
+    args = [:xautoclaim, key, group, consumer, min_idle_time, start]
+    if count
+      args << 'COUNT' << count.to_s
+    end
+    args << 'JUSTID' if justid
+    blk = justid ? HashifyStreamAutoclaimJustId : HashifyStreamAutoclaim
+    synchronize { |client| client.call(args, &blk) }
+  end
+
   # Fetches not acknowledging pending entries
   #
   # @example With key and group
@@ -3438,10 +3694,24 @@ class Redis
 
   HashifyStreamEntries = lambda { |reply|
     reply.compact.map do |entry_id, values|
-      [entry_id, values.each_slice(2).to_h]
+      [entry_id, values&.each_slice(2)&.to_h]
     end
   }
 
+  HashifyStreamAutoclaim = lambda { |reply|
+    {
+      'next' => reply[0],
+      'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+    }
+  }
+
+  HashifyStreamAutoclaimJustId = lambda { |reply|
+    {
+      'next' => reply[0],
+      'entries' => reply[1]
+    }
+  }
+
   HashifyStreamPendings = lambda { |reply|
     {
       'size' => reply[0],
@@ -3541,6 +3811,21 @@ class Redis
       end
     end
   end
+
+  def _normalize_move_wheres(where_source, where_destination)
+    where_source      = where_source.to_s.upcase
+    where_destination = where_destination.to_s.upcase
+
+    if where_source != "LEFT" && where_source != "RIGHT"
+      raise ArgumentError, "where_source must be 'LEFT' or 'RIGHT'"
+    end
+
+    if where_destination != "LEFT" && where_destination != "RIGHT"
+      raise ArgumentError, "where_destination must be 'LEFT' or 'RIGHT'"
+    end
+
+    [where_source, where_destination]
+  end
 end
 
 require_relative "redis/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.5.1
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-11 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-synchrony
@@ -102,9 +102,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/4.3.0
+  documentation_uri: https://www.rubydoc.info/gems/redis/4.5.1
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v4.3.0
+  source_code_uri: https://github.com/redis/redis-rb/tree/v4.5.1
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -113,7 +113,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="