redis 4.1.4 → 4.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83f1f7270db68603d63e86ec43e68348cb5ccb2b4e6759642d89898566bdbaf6
-  data.tar.gz: 45c5bcc92629ec7d85cdc2b913e7922cd5425f2e6691891efc379aeec73026b3
+  metadata.gz: 7a7232fef186e6d6a11a90d8dd9aa7c71114f017e0afe9378999a96c9e6b4e05
+  data.tar.gz: 689f176b87909bf61eb60e57d1eb795198162a7e039104c80facf36880964bda
 SHA512:
-  metadata.gz: 692dfc5c73c6410492589f38f279976a023f6a2ff13f7b1476806011eb387f41bed784bdeac746de5f4b990b6d22bf297b36dddc7b8e448a842241a389f50796
-  data.tar.gz: 55a9e305c7563f5dd7d38f50dc7b919967dbb0f6a131ebc5e1569f49f196ab458203b6594394fa9a33ea9e337b741113e781378113783683dd36b87196607b8f
+  metadata.gz: 22b11dee92e298b46bb94a707156d3dbf9afb83c8e9e8cbf82cf366d582a7c1b7295d7f09a0fec01965245f4800c2482c0559d646f46ff1c6bba6423ab398ba9
+  data.tar.gz: 9a74ba29c8cb3d7634a44c78e30018a048e19cca66c7fad6a226722183f66546bebb370c92ecdf20522bb35ee72a09b2fda64891ff6d94db1702375bd1ba6b46

data/CHANGELOG.md

@@ -1,5 +1,81 @@
 # 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.
+* Support AUTH command for ACL. See #967.
+
+# 4.2.5
+
+* Optimize the ruby connector write buffering. See #964.
+
+# 4.2.4
+
+* Fix bytesize calculations in the ruby connector, and work on a copy of the buffer. Fix #961, #962.
+
+# 4.2.3
+
+* Use io/wait instead of IO.select in the ruby connector. See #960.
+* Use exception free non blocking IOs in the ruby connector. See #926.
+* Prevent corruption of the client when an interrupt happen during inside a pipeline block. See #945.
+
+# 4.2.2
+
+* Fix `WATCH` support for `Redis::Distributed`. See #941.
+* Fix handling of empty stream responses. See #905, #929.
+
+# 4.2.1
+
+* Fix `exists?` returning an actual boolean when called with multiple keys. See #918.
+* Setting `Redis.exists_returns_integer = false` disables warning message about new behaviour. See #920.
+
+# 4.2.0
+
+* Convert commands to accept keyword arguments rather than option hashes. This both help catching typos, and reduce needless allocations.
+* Deprecate the synchrony driver. It will be removed in 5.0 and hopefully maintained as a separate gem. See #915.
+* Make `Redis#exists` variadic, will return an Integer if called with multiple keys.
+* Add `Redis#exists?` to get a Boolean if any of the keys exists.
+* `Redis#exists` when called with a single key will warn that future versions will return an Integer.
+  Set `Redis.exists_returns_integer = true` to opt-in to the new behavior.
+* Support `keepttl` ooption in `set`. See #913.
+* Optimized initialization of Redis::Cluster. See #912.
+* Accept sentinel options even with string key. See #599.
+* Verify TLS connections by default. See #900.
+* Make `Redis#hset` variadic. It now returns an integer, not a boolean. See #910.
+
 # 4.1.4
 
 * Alias `Redis#disconnect` as `#close`. See #901.
@@ -9,6 +85,7 @@
 * Increase buffer size in the ruby connector. See #880.
 * Fix thread safety of `Redis.queue`. See #878.
 * Deprecate `Redis::Future#==` as it's likely to be a mistake. See #876.
+* Support `KEEPTTL` option for SET command. See #913.
 
 # 4.1.3
 

data/README.md

@@ -1,8 +1,9 @@
-# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link] ![](https://github.com/redis/redis-rb/workflows/Test/badge.svg?branch=master)
+# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
 providing an idiomatic interface.
 
+See [RubyDoc.info][rubydoc] for the API docs of the latest published gem.
 
 ## Getting started
 
@@ -34,6 +35,9 @@ You can also specify connection options as a [`redis://` URL][redis-url]:
 redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
 ```
 
+The client expects passwords with special chracters to be URL-encoded (i.e.
+`CGI.escape(password)`).
+
 By default, the client will try to read the `REDIS_URL` environment variable
 and use that as URL to connect to. The above statement is therefore equivalent
 to setting this environment variable and calling `Redis.new` without arguments.
@@ -50,6 +54,12 @@ To connect to a password protected Redis instance, use:
 redis = Redis.new(password: "mysecret")
 ```
 
+To connect a Redis instance using [ACL](https://redis.io/topics/acl), use:
+
+```ruby
+redis = Redis.new(username: 'myname', password: 'mysecret')
+```
+
 The Redis class exports methods that are named identical to the commands
 they execute. The arguments these methods accept are often identical to
 the arguments specified on the [Redis website][redis-commands]. For
@@ -147,8 +157,8 @@ redis.mget('{key}1', '{key}2')
 
 ## Storing objects
 
-Redis only stores strings as values. If you want to store an object, you
-can use a serialization mechanism such as JSON:
+Redis "string" types can be used to store serialized Ruby objects, for
+example with JSON:
 
 ```ruby
 require "json"
@@ -261,6 +271,7 @@ All timeout values are specified in seconds.
 When using pub/sub, you can subscribe to a channel using a timeout as well:
 
 ```ruby
+redis = Redis.new(reconnect_attempts: 0)
 redis.subscribe_with_timeout(5, "news") do |on|
   on.message do |channel, message|
     # ...
@@ -322,7 +333,7 @@ This library supports natively terminating client side SSL/TLS connections
 when talking to Redis via a server-side proxy such as [stunnel], [hitch],
 or [ghostunnel].
 
-To enable SSL support, pass the `:ssl => :true` option when configuring the
+To enable SSL support, pass the `:ssl => true` option when configuring the
 Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis).
 You will also need to pass in an `:ssl_params => { ... }` hash used to
 configure the `OpenSSL::SSL::SSLContext` object used for the connection:
@@ -435,7 +446,7 @@ redis = Redis.new(:driver => :synchrony)
 ## Testing
 
 This library is tested against recent Ruby and Redis versions.
-Check [Travis][travis-link] for the exact versions supported.
+Check [Github Actions][gh-actions-link] for the exact versions supported.
 
 ## See Also
 
@@ -451,15 +462,14 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 ## Contributing
 
 [Fork the project](https://github.com/redis/redis-rb) and send pull
-requests. You can also ask for help at `#redis-rb` on Freenode.
-
-
-[inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg
-[inchpages-link]:  https://inch-ci.org/github/redis/redis-rb
-[redis-commands]:  https://redis.io/commands
-[redis-home]:      https://redis.io
-[redis-url]:       http://www.iana.org/assignments/uri-schemes/prov/redis
-[travis-home]:     https://travis-ci.org/
-[travis-image]:    https://secure.travis-ci.org/redis/redis-rb.svg?branch=master
-[travis-link]:     https://travis-ci.org/redis/redis-rb
-[rubydoc]:         http://www.rubydoc.info/gems/redis
+requests.
+
+
+[inchpages-image]:  https://inch-ci.org/github/redis/redis-rb.svg
+[inchpages-link]:   https://inch-ci.org/github/redis/redis-rb
+[redis-commands]:   https://redis.io/commands
+[redis-home]:       https://redis.io
+[redis-url]:        http://www.iana.org/assignments/uri-schemes/prov/redis
+[gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
+[gh-actions-link]:  https://github.com/redis/redis-rb/actions
+[rubydoc]:          http://www.rubydoc.info/gems/redis

data/lib/redis/client.rb

@@ -6,24 +6,31 @@ require "cgi"
 
 class Redis
   class Client
-
+    # Defaults are also used for converting string keys to symbols.
     DEFAULTS = {
-      :url => lambda { ENV["REDIS_URL"] },
-      :scheme => "redis",
-      :host => "127.0.0.1",
-      :port => 6379,
-      :path => nil,
-      :timeout => 5.0,
-      :password => nil,
-      :db => 0,
-      :driver => nil,
-      :id => nil,
-      :tcp_keepalive => 0,
-      :reconnect_attempts => 1,
-      :reconnect_delay => 0,
-      :reconnect_delay_max => 0.5,
-      :inherit_socket => false
-    }
+      url: -> { ENV["REDIS_URL"] },
+      scheme: "redis",
+      host: "127.0.0.1",
+      port: 6379,
+      path: nil,
+      read_timeout: nil,
+      write_timeout: nil,
+      connect_timeout: nil,
+      timeout: 5.0,
+      username: nil,
+      password: nil,
+      db: 0,
+      driver: nil,
+      id: nil,
+      tcp_keepalive: 0,
+      reconnect_attempts: 1,
+      reconnect_delay: 0,
+      reconnect_delay_max: 0.5,
+      inherit_socket: false,
+      logger: nil,
+      sentinels: nil,
+      role: nil
+    }.freeze
 
     attr_reader :options
 
@@ -55,6 +62,10 @@ class Redis
       @options[:read_timeout]
     end
 
+    def username
+      @options[:username]
+    end
+
     def password
       @options[:password]
     end
@@ -89,7 +100,7 @@ class Redis
       @pending_reads = 0
 
       @connector =
-        if options.include?(:sentinels)
+        if !@options[:sentinels].nil?
           Connector::Sentinel.new(@options)
         elsif options.include?(:connector) && options[:connector].respond_to?(:new)
           options.delete(:connector).new(@options)
@@ -104,7 +115,33 @@ class Redis
       # Don't try to reconnect when the connection is fresh
       with_reconnect(false) do
         establish_connection
-        call [:auth, password] if 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)
@@ -125,7 +162,7 @@ class Redis
       reply = process([command]) { read }
       raise reply if reply.is_a?(CommandError)
 
-      if block_given?
+      if block_given? && reply != 'QUEUED'
         yield reply
       else
         reply
@@ -166,6 +203,7 @@ class Redis
           end
         rescue ConnectionError => e
           return nil if pipeline.shutdown?
+
           # Assume the pipeline was sent in one piece, but execution of
           # SHUTDOWN caused none of the replies for commands that were executed
           # prior to it from coming back around.
@@ -244,13 +282,13 @@ class Redis
     end
 
     def connected?
-      !! (connection && connection.connected?)
+      !!(connection && connection.connected?)
     end
 
     def disconnect
       connection.disconnect if connected?
     end
-    alias_method :close, :disconnect
+    alias close disconnect
 
     def reconnect
       disconnect
@@ -301,30 +339,27 @@ class Redis
       with_socket_timeout(0, &blk)
     end
 
-    def with_reconnect(val=true)
-      begin
-        original, @reconnect = @reconnect, val
-        yield
-      ensure
-        @reconnect = original
-      end
+    def with_reconnect(val = true)
+      original, @reconnect = @reconnect, val
+      yield
+    ensure
+      @reconnect = original
     end
 
     def without_reconnect(&blk)
       with_reconnect(false, &blk)
     end
 
-  protected
+    protected
 
     def logging(commands)
-      return yield unless @logger && @logger.debug?
+      return yield unless @logger&.debug?
 
       begin
         commands.each do |name, *args|
           logged_args = args.map do |a|
-            case
-            when a.respond_to?(:inspect) then a.inspect
-            when a.respond_to?(:to_s)    then a.to_s
+            if a.respond_to?(:inspect) then a.inspect
+            elsif a.respond_to?(:to_s) then a.to_s
             else
               # handle poorly-behaved descendants of BasicObject
               klass = a.instance_exec { (class << self; self end).superclass }
@@ -358,9 +393,9 @@ class Redis
            Errno::ENETUNREACH,
            Errno::ENOENT,
            Errno::ETIMEDOUT,
-           Errno::EINVAL
+           Errno::EINVAL => error
 
-      raise CannotConnectError, "Error connecting to Redis on #{location} (#{$!.class})"
+      raise CannotConnectError, "Error connecting to Redis on #{location} (#{error.class})"
     end
 
     def ensure_connected
@@ -374,9 +409,9 @@ class Redis
         if connected?
           unless inherit_socket? || Process.pid == @pid
             raise InheritedError,
-              "Tried to use a connection from a child process without reconnecting. " +
-              "You need to reconnect to Redis after forking " +
-              "or set :inherit_socket to true."
+                  "Tried to use a connection from a child process without reconnecting. " \
+                  "You need to reconnect to Redis after forking " \
+                  "or set :inherit_socket to true."
           end
         else
           connect
@@ -387,7 +422,7 @@ class Redis
         disconnect
 
         if attempts <= @options[:reconnect_attempts] && @reconnect
-          sleep_t = [(@options[:reconnect_delay] * 2**(attempts-1)),
+          sleep_t = [(@options[:reconnect_delay] * 2**(attempts - 1)),
                      @options[:reconnect_delay_max]].min
 
           Kernel.sleep(sleep_t)
@@ -409,16 +444,14 @@ class Redis
 
       defaults.keys.each do |key|
         # Fill in defaults if needed
-        if defaults[key].respond_to?(:call)
-          defaults[key] = defaults[key].call
-        end
+        defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
 
         # Symbolize only keys that are needed
-        options[key] = options[key.to_s] if options.has_key?(key.to_s)
+        options[key] = options[key.to_s] if options.key?(key.to_s)
       end
 
       url = options[:url]
-      url = defaults[:url] if url == nil
+      url = defaults[:url] if url.nil?
 
       # Override defaults from URL if given
       if url
@@ -427,12 +460,13 @@ class Redis
         uri = URI(url)
 
         if uri.scheme == "unix"
-          defaults[:path]   = uri.path
+          defaults[:path] = uri.path
         elsif uri.scheme == "redis" || uri.scheme == "rediss"
           defaults[:scheme]   = uri.scheme
           defaults[:host]     = uri.host if uri.host
           defaults[:port]     = uri.port if uri.port
-          defaults[:password] = CGI.unescape(uri.password) if uri.password
+          defaults[:username] = CGI.unescape(uri.user) if uri.user && !uri.user.empty?
+          defaults[:password] = CGI.unescape(uri.password) if uri.password && !uri.password.empty?
           defaults[:db]       = uri.path[1..-1].to_i if uri.path
           defaults[:role] = :master
         else
@@ -458,7 +492,7 @@ class Redis
         options[:port] = options[:port].to_i
       end
 
-      if options.has_key?(:timeout)
+      if options.key?(:timeout)
         options[:connect_timeout] ||= options[:timeout]
         options[:read_timeout]    ||= options[:timeout]
         options[:write_timeout]   ||= options[:timeout]
@@ -477,7 +511,7 @@ class Redis
 
       case options[:tcp_keepalive]
       when Hash
-        [:time, :intvl, :probes].each do |key|
+        %i[time intvl probes].each do |key|
           unless options[:tcp_keepalive][key].is_a?(Integer)
             raise "Expected the #{key.inspect} key in :tcp_keepalive to be an Integer"
           end
@@ -485,13 +519,13 @@ class Redis
 
       when Integer
         if options[:tcp_keepalive] >= 60
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 20, intvl: 10, probes: 2 }
 
         elsif options[:tcp_keepalive] >= 30
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 10, intvl: 5, probes: 2 }
 
         elsif options[:tcp_keepalive] >= 5
-          options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1}
+          options[:tcp_keepalive] = { time: options[:tcp_keepalive] - 2, intvl: 2, probes: 1 }
         end
       end
 
@@ -503,14 +537,14 @@ class Redis
     def _parse_driver(driver)
       driver = driver.to_s if driver.is_a?(Symbol)
 
-      if driver.kind_of?(String)
+      if driver.is_a?(String)
         begin
           require_relative "connection/#{driver}"
-        rescue LoadError, NameError => e
+        rescue LoadError, NameError
           begin
-            require "connection/#{driver}"
-          rescue LoadError, NameError => e
-            raise RuntimeError, "Cannot load driver #{driver.inspect}: #{e.message}"
+            require "redis/connection/#{driver}"
+          rescue LoadError, NameError => error
+            raise "Cannot load driver #{driver.inspect}: #{error.message}"
           end
         end
 
@@ -529,8 +563,7 @@ class Redis
         @options
       end
 
-      def check(client)
-      end
+      def check(client); end
 
       class Sentinel < Connector
         def initialize(options)
@@ -539,7 +572,7 @@ class Redis
           @options[:db] = DEFAULTS.fetch(:db)
 
           @sentinels = @options.delete(:sentinels).dup
-          @role = @options.fetch(:role, "master").to_s
+          @role = (@options[:role] || "master").to_s
           @master = @options[:host]
         end
 
@@ -562,13 +595,13 @@ class Redis
 
         def resolve
           result = case @role
-                   when "master"
-                     resolve_master
-                   when "slave"
-                     resolve_slave
-                   else
-                     raise ArgumentError, "Unknown instance role #{@role}"
-                   end
+          when "master"
+            resolve_master
+          when "slave"
+            resolve_slave
+          else
+            raise ArgumentError, "Unknown instance role #{@role}"
+          end
 
           result || (raise ConnectionError, "Unable to fetch #{@role} via Sentinel.")
         end
@@ -576,11 +609,12 @@ class Redis
         def sentinel_detect
           @sentinels.each do |sentinel|
             client = Client.new(@options.merge({
-              :host => sentinel[:host],
-              :port => sentinel[:port],
-              password: sentinel[:password],
-              :reconnect_attempts => 0,
-            }))
+                                                 host: sentinel[:host] || sentinel["host"],
+                                                 port: sentinel[:port] || sentinel["port"],
+                                                 username: sentinel[:username] || sentinel["username"],
+                                                 password: sentinel[:password] || sentinel["password"],
+                                                 reconnect_attempts: 0
+                                               }))
 
             begin
               if result = yield(client)
@@ -602,7 +636,7 @@ class Redis
         def resolve_master
           sentinel_detect do |client|
             if reply = client.call(["sentinel", "get-master-addr-by-name", @master])
-              {:host => reply[0], :port => reply[1]}
+              { host: reply[0], port: reply[1] }
             end
           end
         end
@@ -620,7 +654,7 @@ class Redis
                 slave = slaves.sample
                 {
                   host: slave.fetch('ip'),
-                  port: slave.fetch('port'),
+                  port: slave.fetch('port')
                 }
               end
             end

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

@@ -39,6 +39,7 @@ class Redis
       def call_master(command, &block)
         try_map do |node_key, client|
           next if slave?(node_key)
+
           client.call(command, &block)
         end.values
       end
@@ -48,6 +49,7 @@ class Redis
 
         try_map do |node_key, client|
           next if master?(node_key)
+
           client.call(command, &block)
         end.values
       end
@@ -74,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
 
@@ -97,6 +100,7 @@ class Redis
         end
 
         return results if errors.empty?
+
         raise CommandErrorCollection, errors
       end
     end

data/lib/redis/cluster/option.rb

@@ -18,6 +18,7 @@ class Redis
         @node_opts = build_node_options(node_addrs)
         @replica = options.delete(:replica) == true
         add_common_node_option_if_needed(options, @node_opts, :scheme)
+        add_common_node_option_if_needed(options, @node_opts, :username)
         add_common_node_option_if_needed(options, @node_opts, :password)
         @options = options
       end
@@ -43,6 +44,7 @@ class Redis
 
       def build_node_options(addrs)
         raise InvalidClientOptionError, 'Redis option of `cluster` must be an Array' unless addrs.is_a?(Array)
+
         addrs.map { |addr| parse_node_addr(addr) }
       end
 
@@ -62,21 +64,25 @@ class Redis
         raise InvalidClientOptionError, "Invalid uri scheme #{addr}" unless VALID_SCHEMES.include?(uri.scheme)
 
         db = uri.path.split('/')[1]&.to_i
-        { scheme: uri.scheme, password: uri.password, host: uri.host, port: uri.port, db: db }.reject { |_, v| v.nil? }
+
+        { scheme: uri.scheme, username: uri.user, password: uri.password, host: uri.host, port: uri.port, db: db }
+          .reject { |_, v| v.nil? || v == '' }
       rescue URI::InvalidURIError => err
         raise InvalidClientOptionError, err.message
       end
 
       def parse_node_option(addr)
         addr = addr.map { |k, v| [k.to_sym, v] }.to_h
-        raise InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys' if addr.values_at(:host, :port).any?(&:nil?)
+        if addr.values_at(:host, :port).any?(&:nil?)
+          raise InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys'
+        end
 
         addr
       end
 
       # Redis cluster node returns only host and port information.
       # So we should complement additional information such as:
-      #   scheme, password and so on.
+      #   scheme, username, password and so on.
       def add_common_node_option_if_needed(options, node_opts, key)
         return options if options[key].nil? && node_opts.first[key].nil?