redis 4.1.2 → 4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0b16163b5714933ba20edb9595d7669c7270502586546f3e8758192039113c1
-  data.tar.gz: 150dacb8ae77a51536e3f2bc6813144b0176415d008adaa5d5e6c4d7f25624a1
+  metadata.gz: 28eb23d20152436fc47f334f517c6fa62855e8e4711b44979cb05d86f8dcdd34
+  data.tar.gz: 46d01b3f5539800142582aeb7ebeabe4327bce970e31ce2048dcba027dfe6eb1
 SHA512:
-  metadata.gz: 90a9fcfdefc41f5feaedfea2bde2be1ad39308dee10f0045ec227577d067d795aaaede4aec200ed6f5777167842540ff5adb6a927fe6a0a0e5ac46ea8eeaf737
-  data.tar.gz: 90c74c87892ef96d0d6ef2bd5934f8e3064d30064a9310fc2b1e31aba066ccb6a005d030458a35d9ad09ed403749e3356df3072927e6a749fc21caedee75f936
+  metadata.gz: f2f11269c6a3a030231eeb93dfa6bee54b340ff5ad244df6d79074c95f111e3d2081f49f77756576cb8225640e8b8cad144884c8519bcf1b0e7bedea3ca1b00f
+  data.tar.gz: 44ec06531632060b497cf1d02e6678c3d087ec3371cba86f53f9687848f73bb4e02c166b11d4db9e6b531b62ba2ca830649d71114063560f6dd764ca2ef10f07

data/CHANGELOG.md

@@ -1,8 +1,46 @@
 # Unreleased
 
-# 4.1.2
+# 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.
+* Handle clusters with multiple slot ranges. See #894.
+* Fix password authentication to a redis cluster. See #889.
+* Handle recursive MOVED responses. See #882.
+* 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
 
 * Fix the client hanging forever when connecting with SSL to a non-SSL server. See #835.
+
+# 4.1.2
+
 * Fix several authentication problems with sentinel. See #850 and #856.
 * Explicitly drop Ruby 2.2 support.
 

data/README.md

@@ -1,8 +1,9 @@
-# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link]
+# 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)
 
 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.
@@ -142,12 +146,13 @@ redis.mget('{key}1', '{key}2')
 ```
 
 * The client automatically reconnects after a failover occurred, but the caller is responsible for handling errors while it is happening.
+* The client support permanent node failures, and will reroute requests to promoted slaves.
 * The client supports `MOVED` and `ASK` redirections transparently.
 
 ## 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"
@@ -321,7 +326,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:
@@ -436,6 +441,10 @@ redis = Redis.new(:driver => :synchrony)
 This library is tested against recent Ruby and Redis versions.
 Check [Travis][travis-link] for the exact versions supported.
 
+## See Also
+
+- [async-redis](https://github.com/socketry/async-redis) — An [async](https://github.com/socketry/async) compatible Redis client.
+
 ## Contributors
 
 Several people contributed to redis-rb, but we would like to especially
@@ -446,7 +455,7 @@ 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.
+requests.
 
 
 [inchpages-image]: https://inch-ci.org/github/redis/redis-rb.svg

data/lib/redis.rb

@@ -4,13 +4,26 @@ require "monitor"
 require_relative "redis/errors"
 
 class Redis
+  class << self
+    attr_reader :exists_returns_integer
 
-  def self.current
-    @current ||= Redis.new
+    def exists_returns_integer=(value)
+      unless value
+        message = "`Redis#exists(key)` will return an Integer by default in redis-rb 4.3. The option to explicitly " \
+          "disable this behaviour via `Redis.exists_returns_integer` will be removed in 5.0. You should use " \
+          "`exists?` instead."
+
+        ::Kernel.warn(message)
+      end
+
+      @exists_returns_integer = value
+    end
+
+    attr_writer :current
   end
 
-  def self.current=(redis)
-    @current = redis
+  def self.current
+    @current ||= Redis.new
   end
 
   include MonitorMixin
@@ -18,18 +31,22 @@ class Redis
   # Create a new client instance
   #
   # @param [Hash] options
-  # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options.
+  # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection:
+  #   `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket
+  #    connection: `unix://[path to Redis socket]`. This overrides all other options.
   # @option options [String] :host ("127.0.0.1") server hostname
-  # @option options [Fixnum] :port (6379) server port
+  # @option options [Integer] :port (6379) server port
   # @option options [String] :path path to server socket (overrides host and port)
   # @option options [Float] :timeout (5.0) timeout in seconds
   # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
   # @option options [String] :password Password to authenticate against server
-  # @option options [Fixnum] :db (0) Database to select after initial connect
+  # @option options [Integer] :db (0) Database to select after initial connect
   # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony`
-  # @option options [String] :id ID for the client connection, assigns name to current connection by sending `CLIENT SETNAME`
-  # @option options [Hash, Fixnum] :tcp_keepalive Keepalive values, if Fixnum `intvl` and `probe` are calculated based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Fixnum
-  # @option options [Fixnum] :reconnect_attempts Number of attempts trying to connect
+  # @option options [String] :id ID for the client connection, assigns name to current connection by sending
+  #   `CLIENT SETNAME`
+  # @option options [Hash, Integer] :tcp_keepalive Keepalive values, if Integer `intvl` and `probe` are calculated
+  #   based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Integer
+  # @option options [Integer] :reconnect_attempts Number of attempts trying to connect
   # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
   # @option options [Array] :sentinels List of sentinels to contact
   # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
@@ -53,7 +70,7 @@ class Redis
   end
 
   # Run code with the client reconnecting
-  def with_reconnect(val=true, &blk)
+  def with_reconnect(val = true, &blk)
     synchronize do |client|
       client.with_reconnect(val, &blk)
     end
@@ -96,7 +113,9 @@ class Redis
   # See http://redis.io/topics/pipelining for more details.
   #
   def queue(*command)
-    @queue[Thread.current.object_id] << command
+    synchronize do
+      @queue[Thread.current.object_id] << command
+    end
   end
 
   # Sends all commands in the queue.
@@ -135,7 +154,7 @@ class Redis
 
   # Change the selected database for the current connection.
   #
-  # @param [Fixnum] db zero-based index of the DB to use (0 to 15)
+  # @param [Integer] db zero-based index of the DB to use (0 to 15)
   # @return [String] `OK`
   def select(db)
     synchronize do |client|
@@ -204,7 +223,7 @@ class Redis
   def config(action, *args)
     synchronize do |client|
       client.call([:config, action] + args) do |reply|
-        if reply.kind_of?(Array) && action == :get
+        if reply.is_a?(Array) && action == :get
           Hashify.call(reply)
         else
           reply
@@ -234,7 +253,7 @@ class Redis
 
   # Return the number of keys in the selected database.
   #
-  # @return [Fixnum]
+  # @return [Integer]
   def dbsize
     synchronize do |client|
       client.call([:dbsize])
@@ -255,7 +274,7 @@ class Redis
   def flushall(options = nil)
     synchronize do |client|
       if options && options[:async]
-        client.call([:flushall, :async])
+        client.call(%i[flushall async])
       else
         client.call([:flushall])
       end
@@ -270,7 +289,7 @@ class Redis
   def flushdb(options = nil)
     synchronize do |client|
       if options && options[:async]
-        client.call([:flushdb, :async])
+        client.call(%i[flushdb async])
       else
         client.call([:flushdb])
       end
@@ -284,7 +303,7 @@ class Redis
   def info(cmd = nil)
     synchronize do |client|
       client.call([:info, cmd].compact) do |reply|
-        if reply.kind_of?(String)
+        if reply.is_a?(String)
           reply = HashifyInfo.call(reply)
 
           if cmd && cmd.to_s == "commandstats"
@@ -303,7 +322,7 @@ class Redis
 
   # Get the UNIX time stamp of the last successful save to disk.
   #
-  # @return [Fixnum]
+  # @return [Integer]
   def lastsave
     synchronize do |client|
       client.call([:lastsave])
@@ -355,9 +374,9 @@ class Redis
   # Interact with the slowlog (get, len, reset)
   #
   # @param [String] subcommand e.g. `get`, `len`, `reset`
-  # @param [Fixnum] length maximum number of entries to return
-  # @return [Array<String>, Fixnum, String] depends on subcommand
-  def slowlog(subcommand, length=nil)
+  # @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
@@ -377,12 +396,12 @@ class Redis
   # @example
   #   r.time # => [ 1333093196, 606806 ]
   #
-  # @return [Array<Fixnum>] tuple of seconds since UNIX epoch and
+  # @return [Array<Integer>] tuple of seconds since UNIX epoch and
   #   microseconds in the current second
   def time
     synchronize do |client|
       client.call([:time]) do |reply|
-        reply.map(&:to_i) if reply
+        reply&.map(&:to_i)
       end
     end
   end
@@ -400,7 +419,7 @@ class Redis
   # Set a key's time to live in seconds.
   #
   # @param [String] key
-  # @param [Fixnum] seconds time to live
+  # @param [Integer] seconds time to live
   # @return [Boolean] whether the timeout was set or not
   def expire(key, seconds)
     synchronize do |client|
@@ -411,7 +430,7 @@ class Redis
   # Set the expiration for a key as a UNIX timestamp.
   #
   # @param [String] key
-  # @param [Fixnum] unix_time expiry time specified as a UNIX timestamp
+  # @param [Integer] unix_time expiry time specified as a UNIX timestamp
   # @return [Boolean] whether the timeout was set or not
   def expireat(key, unix_time)
     synchronize do |client|
@@ -422,7 +441,7 @@ class Redis
   # Get the time to live (in seconds) for a key.
   #
   # @param [String] key
-  # @return [Fixnum] remaining time to live in seconds.
+  # @return [Integer] remaining time to live in seconds.
   #
   # In Redis 2.6 or older the command returns -1 if the key does not exist or if
   # the key exist but has no associated expire.
@@ -440,7 +459,7 @@ class Redis
   # Set a key's time to live in milliseconds.
   #
   # @param [String] key
-  # @param [Fixnum] milliseconds time to live
+  # @param [Integer] milliseconds time to live
   # @return [Boolean] whether the timeout was set or not
   def pexpire(key, milliseconds)
     synchronize do |client|
@@ -451,7 +470,7 @@ class Redis
   # Set the expiration for a key as number of milliseconds from UNIX Epoch.
   #
   # @param [String] key
-  # @param [Fixnum] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch.
+  # @param [Integer] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch.
   # @return [Boolean] whether the timeout was set or not
   def pexpireat(key, ms_unix_time)
     synchronize do |client|
@@ -462,7 +481,7 @@ class Redis
   # Get the time to live (in milliseconds) for a key.
   #
   # @param [String] key
-  # @return [Fixnum] remaining time to live in milliseconds
+  # @return [Integer] remaining time to live in milliseconds
   # In Redis 2.6 or older the command returns -1 if the key does not exist or if
   # the key exist but has no associated expire.
   #
@@ -495,9 +514,9 @@ class Redis
   #   - `:replace => Boolean`: if false, raises an error if key already exists
   # @raise [Redis::CommandError]
   # @return [String] `"OK"`
-  def restore(key, ttl, serialized_value, options = {})
+  def restore(key, ttl, serialized_value, replace: nil)
     args = [:restore, key, ttl, serialized_value]
-    args << 'REPLACE' if options[:replace]
+    args << 'REPLACE' if replace
 
     synchronize do |client|
       client.call(args)
@@ -532,7 +551,7 @@ class Redis
   # Delete one or more keys.
   #
   # @param [String, Array<String>] keys
-  # @return [Fixnum] number of keys that were deleted
+  # @return [Integer] number of keys that were deleted
   def del(*keys)
     synchronize do |client|
       client.call([:del] + keys)
@@ -542,20 +561,50 @@ class Redis
   # Unlink one or more keys.
   #
   # @param [String, Array<String>] keys
-  # @return [Fixnum] number of keys that were unlinked
+  # @return [Integer] number of keys that were unlinked
   def unlink(*keys)
     synchronize do |client|
       client.call([:unlink] + keys)
     end
   end
 
-  # Determine if a key exists.
+  # Determine how many of the keys exists.
   #
-  # @param [String] key
+  # @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. " \
+          "(#{::Kernel.caller(1, 1).first})\n"
+
+        ::Kernel.warn(message)
+      end
+
+      exists?(*keys)
+    else
+      _exists(*keys)
+    end
+  end
+
+  def _exists(*keys)
+    synchronize do |client|
+      client.call([:exists, *keys])
+    end
+  end
+
+  # Determine if any of the keys exists.
+  #
+  # @param [String, Array<String>] keys
   # @return [Boolean]
-  def exists(key)
+  def exists?(*keys)
     synchronize do |client|
-      client.call([:exists, key], &Boolify)
+      client.call([:exists, *keys]) do |value|
+        value > 0
+      end
     end
   end
 
@@ -566,7 +615,7 @@ class Redis
   def keys(pattern = "*")
     synchronize do |client|
       client.call([:keys, pattern]) do |reply|
-        if reply.kind_of?(String)
+        if reply.is_a?(String)
           reply.split(" ")
         else
           reply
@@ -592,7 +641,7 @@ class Redis
   #     # => "bar"
   #
   # @param [String] key
-  # @param [Fixnum] db
+  # @param [Integer] db
   # @return [Boolean] whether the key was moved or not
   def move(key, db)
     synchronize do |client|
@@ -656,36 +705,33 @@ class Redis
   #   - `:order => String`: combination of `ASC`, `DESC` and optionally `ALPHA`
   #   - `:store => String`: key to store the result at
   #
-  # @return [Array<String>, Array<Array<String>>, Fixnum]
+  # @return [Array<String>, Array<Array<String>>, Integer]
   #   - when `:get` is not specified, or holds a single element, an array of elements
   #   - when `:get` is specified, and holds more than one element, an array of
   #   elements where every element is an array with the result for every
   #   element specified in `:get`
   #   - when `:store` is specified, the number of elements in the stored result
-  def sort(key, options = {})
-    args = []
-
-    by = options[:by]
-    args.concat(["BY", by]) if by
+  def sort(key, by: nil, limit: nil, get: nil, order: nil, store: nil)
+    args = [:sort, key]
+    args << "BY" << by if by
 
-    limit = options[:limit]
-    args.concat(["LIMIT"] + limit) if limit
+    if limit
+      args << "LIMIT"
+      args.concat(limit)
+    end
 
-    get = Array(options[:get])
-    args.concat(["GET"].product(get).flatten) unless get.empty?
+    get = Array(get)
+    get.each do |item|
+      args << "GET" << item
+    end
 
-    order = options[:order]
     args.concat(order.split(" ")) if order
-
-    store = options[:store]
-    args.concat(["STORE", store]) if store
+    args << "STORE" << store if store
 
     synchronize do |client|
-      client.call([:sort, key] + args) do |reply|
+      client.call(args) do |reply|
         if get.size > 1 && !store
-          if reply
-            reply.each_slice(get.size).to_a
-          end
+          reply.each_slice(get.size).to_a if reply
         else
           reply
         end
@@ -710,7 +756,7 @@ class Redis
   #     # => 4
   #
   # @param [String] key
-  # @return [Fixnum] value after decrementing it
+  # @return [Integer] value after decrementing it
   def decr(key)
     synchronize do |client|
       client.call([:decr, key])
@@ -724,8 +770,8 @@ class Redis
   #     # => 0
   #
   # @param [String] key
-  # @param [Fixnum] decrement
-  # @return [Fixnum] value after decrementing it
+  # @param [Integer] decrement
+  # @return [Integer] value after decrementing it
   def decrby(key, decrement)
     synchronize do |client|
       client.call([:decrby, key, decrement])
@@ -739,7 +785,7 @@ class Redis
   #     # => 6
   #
   # @param [String] key
-  # @return [Fixnum] value after incrementing it
+  # @return [Integer] value after incrementing it
   def incr(key)
     synchronize do |client|
       client.call([:incr, key])
@@ -753,8 +799,8 @@ class Redis
   #     # => 10
   #
   # @param [String] key
-  # @param [Fixnum] increment
-  # @return [Fixnum] value after incrementing it
+  # @param [Integer] increment
+  # @return [Integer] value after incrementing it
   def incrby(key, increment)
     synchronize do |client|
       client.call([:incrby, key, increment])
@@ -781,31 +827,25 @@ class Redis
   # @param [String] key
   # @param [String] value
   # @param [Hash] options
-  #   - `:ex => Fixnum`: Set the specified expire time, in seconds.
-  #   - `:px => Fixnum`: Set the specified expire time, in milliseconds.
+  #   - `:ex => Integer`: Set the specified expire time, in seconds.
+  #   - `:px => Integer`: Set the specified expire time, 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.
   # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
-  def set(key, value, options = {})
-    args = []
-
-    ex = options[:ex]
-    args.concat(["EX", ex]) if ex
-
-    px = options[:px]
-    args.concat(["PX", px]) if px
-
-    nx = options[:nx]
-    args.concat(["NX"]) if nx
-
-    xx = options[:xx]
-    args.concat(["XX"]) if xx
+  def set(key, value, ex: nil, px: nil, nx: nil, xx: nil, keepttl: nil)
+    args = [:set, key, value.to_s]
+    args << "EX" << ex if ex
+    args << "PX" << px if px
+    args << "NX" if nx
+    args << "XX" if xx
+    args << "KEEPTTL" if keepttl
 
     synchronize do |client|
       if nx || xx
-        client.call([:set, key, value.to_s] + args, &BoolifySet)
+        client.call(args, &BoolifySet)
       else
-        client.call([:set, key, value.to_s] + args)
+        client.call(args)
       end
     end
   end
@@ -813,7 +853,7 @@ class Redis
   # Set the time to live in seconds of a key.
   #
   # @param [String] key
-  # @param [Fixnum] ttl
+  # @param [Integer] ttl
   # @param [String] value
   # @return [String] `"OK"`
   def setex(key, ttl, value)
@@ -825,7 +865,7 @@ class Redis
   # Set the time to live in milliseconds of a key.
   #
   # @param [String] key
-  # @param [Fixnum] ttl
+  # @param [Integer] ttl
   # @param [String] value
   # @return [String] `"OK"`
   def psetex(key, ttl, value)
@@ -887,7 +927,7 @@ class Redis
   # @see #mapped_msetnx
   def msetnx(*args)
     synchronize do |client|
-      client.call([:msetnx] + args, &Boolify)
+      client.call([:msetnx, *args], &Boolify)
     end
   end
 
@@ -918,7 +958,7 @@ class Redis
   # Get the values of all the given keys.
   #
   # @example
-  #   redis.mget("key1", "key1")
+  #   redis.mget("key1", "key2")
   #     # => ["v1", "v2"]
   #
   # @param [Array<String>] keys
@@ -927,7 +967,7 @@ class Redis
   # @see #mapped_mget
   def mget(*keys, &blk)
     synchronize do |client|
-      client.call([:mget] + keys, &blk)
+      client.call([:mget, *keys], &blk)
     end
   end
 
@@ -943,7 +983,7 @@ class Redis
   # @see #mget
   def mapped_mget(*keys)
     mget(*keys) do |reply|
-      if reply.kind_of?(Array)
+      if reply.is_a?(Array)
         Hash[keys.zip(reply)]
       else
         reply
@@ -954,9 +994,9 @@ class Redis
   # Overwrite part of a string at key starting at the specified offset.
   #
   # @param [String] key
-  # @param [Fixnum] offset byte offset
+  # @param [Integer] offset byte offset
   # @param [String] value
-  # @return [Fixnum] length of the string after it was modified
+  # @return [Integer] length of the string after it was modified
   def setrange(key, offset, value)
     synchronize do |client|
       client.call([:setrange, key, offset, value.to_s])
@@ -966,10 +1006,10 @@ class Redis
   # Get a substring of the string stored at a key.
   #
   # @param [String] key
-  # @param [Fixnum] start zero-based start offset
-  # @param [Fixnum] stop zero-based end offset. Use -1 for representing
+  # @param [Integer] start zero-based start offset
+  # @param [Integer] stop zero-based end offset. Use -1 for representing
   #   the end of the string
-  # @return [Fixnum] `0` or `1`
+  # @return [Integer] `0` or `1`
   def getrange(key, start, stop)
     synchronize do |client|
       client.call([:getrange, key, start, stop])
@@ -979,9 +1019,9 @@ class Redis
   # Sets or clears the bit at offset in the string value stored at key.
   #
   # @param [String] key
-  # @param [Fixnum] offset bit offset
-  # @param [Fixnum] value bit value `0` or `1`
-  # @return [Fixnum] the original bit value stored at `offset`
+  # @param [Integer] offset bit offset
+  # @param [Integer] value bit value `0` or `1`
+  # @return [Integer] the original bit value stored at `offset`
   def setbit(key, offset, value)
     synchronize do |client|
       client.call([:setbit, key, offset, value])
@@ -991,8 +1031,8 @@ class Redis
   # Returns the bit value at offset in the string value stored at key.
   #
   # @param [String] key
-  # @param [Fixnum] offset bit offset
-  # @return [Fixnum] `0` or `1`
+  # @param [Integer] offset bit offset
+  # @return [Integer] `0` or `1`
   def getbit(key, offset)
     synchronize do |client|
       client.call([:getbit, key, offset])
@@ -1003,7 +1043,7 @@ class Redis
   #
   # @param [String] key
   # @param [String] value value to append
-  # @return [Fixnum] length of the string after appending
+  # @return [Integer] length of the string after appending
   def append(key, value)
     synchronize do |client|
       client.call([:append, key, value])
@@ -1013,9 +1053,9 @@ class Redis
   # Count the number of set bits in a range of the string value stored at key.
   #
   # @param [String] key
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
-  # @return [Fixnum] the number of bits set to 1
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
+  # @return [Integer] the number of bits set to 1
   def bitcount(key, start = 0, stop = -1)
     synchronize do |client|
       client.call([:bitcount, key, start, stop])
@@ -1027,25 +1067,23 @@ class Redis
   # @param [String] operation e.g. `and`, `or`, `xor`, `not`
   # @param [String] destkey destination key
   # @param [String, Array<String>] keys one or more source keys to perform `operation`
-  # @return [Fixnum] the length of the string stored in `destkey`
+  # @return [Integer] the length of the string stored in `destkey`
   def bitop(operation, destkey, *keys)
     synchronize do |client|
-      client.call([:bitop, operation, destkey] + keys)
+      client.call([:bitop, operation, destkey, *keys])
     end
   end
 
   # Return the position of the first bit set to 1 or 0 in a string.
   #
   # @param [String] key
-  # @param [Fixnum] bit whether to look for the first 1 or 0 bit
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
-  # @return [Fixnum] the position of the first 1/0 bit.
+  # @param [Integer] bit whether to look for the first 1 or 0 bit
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
+  # @return [Integer] the position of the first 1/0 bit.
   #                  -1 if looking for 1 and it is not found or start and stop are given.
-  def bitpos(key, bit, start=nil, stop=nil)
-    if stop and not start
-      raise(ArgumentError, 'stop parameter specified without start parameter')
-    end
+  def bitpos(key, bit, start = nil, stop = nil)
+    raise(ArgumentError, 'stop parameter specified without start parameter') if stop && !start
 
     synchronize do |client|
       command = [:bitpos, key, bit]
@@ -1070,7 +1108,7 @@ class Redis
   # Get the length of the value stored in a key.
   #
   # @param [String] key
-  # @return [Fixnum] the length of the value stored in the key, or 0
+  # @return [Integer] the length of the value stored in the key, or 0
   #   if the key does not exist
   def strlen(key)
     synchronize do |client|
@@ -1081,7 +1119,7 @@ class Redis
   # Get the length of a list.
   #
   # @param [String] key
-  # @return [Fixnum]
+  # @return [Integer]
   def llen(key)
     synchronize do |client|
       client.call([:llen, key])
@@ -1092,7 +1130,7 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] value string value, or array of string values to push
-  # @return [Fixnum] the length of the list after the push operation
+  # @return [Integer] the length of the list after the push operation
   def lpush(key, value)
     synchronize do |client|
       client.call([:lpush, key, value])
@@ -1103,7 +1141,7 @@ class Redis
   #
   # @param [String] key
   # @param [String] value
-  # @return [Fixnum] the length of the list after the push operation
+  # @return [Integer] the length of the list after the push operation
   def lpushx(key, value)
     synchronize do |client|
       client.call([:lpushx, key, value])
@@ -1114,7 +1152,7 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] value string value, or array of string values to push
-  # @return [Fixnum] the length of the list after the push operation
+  # @return [Integer] the length of the list after the push operation
   def rpush(key, value)
     synchronize do |client|
       client.call([:rpush, key, value])
@@ -1125,7 +1163,7 @@ class Redis
   #
   # @param [String] key
   # @param [String] value
-  # @return [Fixnum] the length of the list after the push operation
+  # @return [Integer] the length of the list after the push operation
   def rpushx(key, value)
     synchronize do |client|
       client.call([:rpushx, key, value])
@@ -1164,21 +1202,21 @@ class Redis
   end
 
   def _bpop(cmd, args, &blk)
-    options = {}
-
-    if args.last.is_a?(Hash)
+    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...
-      options[:timeout] = args.pop.to_int
+      args.pop.to_int
     end
 
+    timeout ||= 0
+
     if args.size > 1
       # Issue deprecation notice in obnoxious mode...
     end
 
     keys = args.flatten
-    timeout = options[:timeout] || 0
 
     synchronize do |client|
       command = [cmd, keys, timeout]
@@ -1203,7 +1241,7 @@ class Redis
   # @param [String, Array<String>] keys one or more keys to perform the
   #   blocking pop on
   # @param [Hash] options
-  #   - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout
+  #   - `:timeout => Integer`: timeout in seconds, defaults to no timeout
   #
   # @return [nil, [String, String]]
   #   - `nil` when the operation timed out
@@ -1217,7 +1255,7 @@ class Redis
   # @param [String, Array<String>] keys one or more keys to perform the
   #   blocking pop on
   # @param [Hash] options
-  #   - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout
+  #   - `:timeout => Integer`: timeout in seconds, defaults to no timeout
   #
   # @return [nil, [String, String]]
   #   - `nil` when the operation timed out
@@ -1234,20 +1272,12 @@ class Redis
   # @param [String] source source key
   # @param [String] destination destination key
   # @param [Hash] options
-  #   - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout
+  #   - `:timeout => 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, options = {})
-    case options
-    when Integer
-      # Issue deprecation notice in obnoxious mode...
-      options = { :timeout => options }
-    end
-
-    timeout = options[:timeout] || 0
-
+  def brpoplpush(source, destination, deprecated_timeout = 0, timeout: deprecated_timeout)
     synchronize do |client|
       command = [:brpoplpush, source, destination, timeout]
       timeout += client.timeout if timeout > 0
@@ -1258,7 +1288,7 @@ class Redis
   # Get an element from a list by its index.
   #
   # @param [String] key
-  # @param [Fixnum] index
+  # @param [Integer] index
   # @return [String]
   def lindex(key, index)
     synchronize do |client|
@@ -1272,7 +1302,7 @@ class Redis
   # @param [String, Symbol] where `BEFORE` or `AFTER`
   # @param [String] pivot reference element
   # @param [String] value
-  # @return [Fixnum] length of the list after the insert operation, or `-1`
+  # @return [Integer] length of the list after the insert operation, or `-1`
   #   when the element `pivot` was not found
   def linsert(key, where, pivot, value)
     synchronize do |client|
@@ -1283,8 +1313,8 @@ class Redis
   # Get a range of elements from a list.
   #
   # @param [String] key
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
   # @return [Array<String>]
   def lrange(key, start, stop)
     synchronize do |client|
@@ -1295,12 +1325,12 @@ class Redis
   # Remove elements from a list.
   #
   # @param [String] key
-  # @param [Fixnum] count number of elements to remove. Use a positive
+  # @param [Integer] count number of elements to remove. Use a positive
   #   value to remove the first `count` occurrences of `value`. A negative
   #   value to remove the last `count` occurrences of `value`. Or zero, to
   #   remove all occurrences of `value` from the list.
   # @param [String] value
-  # @return [Fixnum] the number of removed elements
+  # @return [Integer] the number of removed elements
   def lrem(key, count, value)
     synchronize do |client|
       client.call([:lrem, key, count, value])
@@ -1310,7 +1340,7 @@ class Redis
   # Set the value of an element in a list by its index.
   #
   # @param [String] key
-  # @param [Fixnum] index
+  # @param [Integer] index
   # @param [String] value
   # @return [String] `OK`
   def lset(key, index, value)
@@ -1322,8 +1352,8 @@ class Redis
   # Trim a list to the specified range.
   #
   # @param [String] key
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
   # @return [String] `OK`
   def ltrim(key, start, stop)
     synchronize do |client|
@@ -1334,7 +1364,7 @@ class Redis
   # Get the number of members in a set.
   #
   # @param [String] key
-  # @return [Fixnum]
+  # @return [Integer]
   def scard(key)
     synchronize do |client|
       client.call([:scard, key])
@@ -1345,8 +1375,8 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] member one member, or array of members
-  # @return [Boolean, Fixnum] `Boolean` when a single member is specified,
-  #   holding whether or not adding the member succeeded, or `Fixnum` when an
+  # @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)
@@ -1367,8 +1397,8 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] member one member, or array of members
-  # @return [Boolean, Fixnum] `Boolean` when a single member is specified,
-  #   holding whether or not removing the member succeeded, or `Fixnum` when an
+  # @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)
@@ -1389,7 +1419,7 @@ class Redis
   #
   # @param [String] key
   # @return [String]
-  # @param [Fixnum] count
+  # @param [Integer] count
   def spop(key, count = nil)
     synchronize do |client|
       if count.nil?
@@ -1403,7 +1433,7 @@ class Redis
   # Get one or more random members from a set.
   #
   # @param [String] key
-  # @param [Fixnum] count
+  # @param [Integer] count
   # @return [String]
   def srandmember(key, count = nil)
     synchronize do |client|
@@ -1454,7 +1484,7 @@ class Redis
   # @return [Array<String>] members in the difference
   def sdiff(*keys)
     synchronize do |client|
-      client.call([:sdiff] + keys)
+      client.call([:sdiff, *keys])
     end
   end
 
@@ -1462,10 +1492,10 @@ class Redis
   #
   # @param [String] destination destination key
   # @param [String, Array<String>] keys keys pointing to sets to subtract
-  # @return [Fixnum] number of elements in the resulting set
+  # @return [Integer] number of elements in the resulting set
   def sdiffstore(destination, *keys)
     synchronize do |client|
-      client.call([:sdiffstore, destination] + keys)
+      client.call([:sdiffstore, destination, *keys])
     end
   end
 
@@ -1475,7 +1505,7 @@ class Redis
   # @return [Array<String>] members in the intersection
   def sinter(*keys)
     synchronize do |client|
-      client.call([:sinter] + keys)
+      client.call([:sinter, *keys])
     end
   end
 
@@ -1483,10 +1513,10 @@ class Redis
   #
   # @param [String] destination destination key
   # @param [String, Array<String>] keys keys pointing to sets to intersect
-  # @return [Fixnum] number of elements in the resulting set
+  # @return [Integer] number of elements in the resulting set
   def sinterstore(destination, *keys)
     synchronize do |client|
-      client.call([:sinterstore, destination] + keys)
+      client.call([:sinterstore, destination, *keys])
     end
   end
 
@@ -1496,7 +1526,7 @@ class Redis
   # @return [Array<String>] members in the union
   def sunion(*keys)
     synchronize do |client|
-      client.call([:sunion] + keys)
+      client.call([:sunion, *keys])
     end
   end
 
@@ -1504,10 +1534,10 @@ class Redis
   #
   # @param [String] destination destination key
   # @param [String, Array<String>] keys keys pointing to sets to unify
-  # @return [Fixnum] number of elements in the resulting set
+  # @return [Integer] number of elements in the resulting set
   def sunionstore(destination, *keys)
     synchronize do |client|
-      client.call([:sunionstore, destination] + keys)
+      client.call([:sunionstore, destination, *keys])
     end
   end
 
@@ -1518,7 +1548,7 @@ class Redis
   #     # => 4
   #
   # @param [String] key
-  # @return [Fixnum]
+  # @return [Integer]
   def zcard(key)
     synchronize do |client|
       client.call([:zcard, key])
@@ -1549,38 +1579,27 @@ class Redis
   #   - `:incr => true`: When this option is specified ZADD acts like
   #   ZINCRBY; only one score-element pair can be specified in this mode
   #
-  # @return [Boolean, Fixnum, Float]
+  # @return [Boolean, Integer, Float]
   #   - `Boolean` when a single pair is specified, holding whether or not it was
   #   **added** to the sorted set.
-  #   - `Fixnum` when an array of pairs is specified, holding the number of
+  #   - `Integer` when an array of pairs is specified, holding the number of
   #   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) #, options
-    zadd_options = []
-    if args.last.is_a?(Hash)
-      options = args.pop
-
-      nx = options[:nx]
-      zadd_options << "NX" if nx
-
-      xx = options[:xx]
-      zadd_options << "XX" if xx
-
-      ch = options[:ch]
-      zadd_options << "CH" if ch
-
-      incr = options[:incr]
-      zadd_options << "INCR" if incr
-    end
+  def zadd(key, *args, nx: nil, xx: nil, ch: nil, incr: nil)
+    command = [:zadd, key]
+    command << "NX" if nx
+    command << "XX" if xx
+    command << "CH" if ch
+    command << "INCR" if incr
 
     synchronize do |client|
       if args.size == 1 && args[0].is_a?(Array)
         # Variadic: return float if INCR, integer if !INCR
-        client.call([:zadd, key] + zadd_options + args[0], &(incr ? Floatify : nil))
+        client.call(command + args[0], &(incr ? Floatify : nil))
       elsif args.size == 2
         # Single pair: return float if INCR, boolean if !INCR
-        client.call([:zadd, key] + zadd_options + args, &(incr ? Floatify : Boolify))
+        client.call(command + args, &(incr ? Floatify : Boolify))
       else
         raise ArgumentError, "wrong number of arguments"
       end
@@ -1615,10 +1634,10 @@ class Redis
   #   - a single member
   #   - an array of members
   #
-  # @return [Boolean, Fixnum]
+  # @return [Boolean, Integer]
   #   - `Boolean` when a single member is specified, holding whether or not it
   #   was removed from the sorted set
-  #   - `Fixnum` when an array of pairs is specified, holding the number of
+  #   - `Integer` when an array of pairs is specified, holding the number of
   #   members that were removed to the sorted set
   def zrem(key, member)
     synchronize do |client|
@@ -1743,18 +1762,16 @@ class Redis
   #     # => [["a", 32.0], ["b", 64.0]]
   #
   # @param [String] key
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
   # @param [Hash] options
   #   - `: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 zrange(key, start, stop, options = {})
-    args = []
-
-    with_scores = options[:with_scores] || options[:withscores]
+  def zrange(key, start, stop, withscores: false, with_scores: withscores)
+    args = [:zrange, key, start, stop]
 
     if with_scores
       args << "WITHSCORES"
@@ -1762,7 +1779,7 @@ class Redis
     end
 
     synchronize do |client|
-      client.call([:zrange, key, start, stop] + args, &block)
+      client.call(args, &block)
     end
   end
 
@@ -1777,10 +1794,8 @@ class Redis
   #     # => [["b", 64.0], ["a", 32.0]]
   #
   # @see #zrange
-  def zrevrange(key, start, stop, options = {})
-    args = []
-
-    with_scores = options[:with_scores] || options[:withscores]
+  def zrevrange(key, start, stop, withscores: false, with_scores: withscores)
+    args = [:zrevrange, key, start, stop]
 
     if with_scores
       args << "WITHSCORES"
@@ -1788,7 +1803,7 @@ class Redis
     end
 
     synchronize do |client|
-      client.call([:zrevrange, key, start, stop] + args, &block)
+      client.call(args, &block)
     end
   end
 
@@ -1796,7 +1811,7 @@ class Redis
   #
   # @param [String] key
   # @param [String] member
-  # @return [Fixnum]
+  # @return [Integer]
   def zrank(key, member)
     synchronize do |client|
       client.call([:zrank, key, member])
@@ -1808,7 +1823,7 @@ class Redis
   #
   # @param [String] key
   # @param [String] member
-  # @return [Fixnum]
+  # @return [Integer]
   def zrevrank(key, member)
     synchronize do |client|
       client.call([:zrevrank, key, member])
@@ -1825,9 +1840,9 @@ class Redis
   #     # => 5
   #
   # @param [String] key
-  # @param [Fixnum] start start index
-  # @param [Fixnum] stop stop index
-  # @return [Fixnum] number of members that were removed
+  # @param [Integer] start start index
+  # @param [Integer] stop stop index
+  # @return [Integer] number of members that were removed
   def zremrangebyrank(key, start, stop)
     synchronize do |client|
       client.call([:zremrangebyrank, key, start, stop])
@@ -1851,7 +1866,7 @@ class Redis
   #   - inclusive maximum is specified by prefixing `(`
   #   - exclusive maximum is specified by prefixing `[`
   #
-  # @return [Fixnum] number of members within the specified lexicographical range
+  # @return [Integer] number of members within the specified lexicographical range
   def zlexcount(key, min, max)
     synchronize do |client|
       client.call([:zlexcount, key, min, max])
@@ -1879,14 +1894,16 @@ class Redis
   #   `count` members
   #
   # @return [Array<String>, Array<[String, Float]>]
-  def zrangebylex(key, min, max, options = {})
-    args = []
+  def zrangebylex(key, min, max, limit: nil)
+    args = [:zrangebylex, key, min, max]
 
-    limit = options[:limit]
-    args.concat(["LIMIT"] + limit) if limit
+    if limit
+      args << "LIMIT"
+      args.concat(limit)
+    end
 
     synchronize do |client|
-      client.call([:zrangebylex, key, min, max] + args)
+      client.call(args)
     end
   end
 
@@ -1901,14 +1918,16 @@ class Redis
   #     # => ["abbygail", "abby"]
   #
   # @see #zrangebylex
-  def zrevrangebylex(key, max, min, options = {})
-    args = []
+  def zrevrangebylex(key, max, min, limit: nil)
+    args = [:zrevrangebylex, key, max, min]
 
-    limit = options[:limit]
-    args.concat(["LIMIT"] + limit) if limit
+    if limit
+      args << "LIMIT"
+      args.concat(limit)
+    end
 
     synchronize do |client|
-      client.call([:zrevrangebylex, key, max, min] + args)
+      client.call(args)
     end
   end
 
@@ -1939,21 +1958,21 @@ class Redis
   # @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 zrangebyscore(key, min, max, options = {})
-    args = []
-
-    with_scores = options[:with_scores] || options[:withscores]
+  def zrangebyscore(key, min, max, withscores: false, with_scores: withscores, limit: nil)
+    args = [:zrangebyscore, key, min, max]
 
     if with_scores
       args << "WITHSCORES"
       block = FloatifyPairs
     end
 
-    limit = options[:limit]
-    args.concat(["LIMIT"] + limit) if limit
+    if limit
+      args << "LIMIT"
+      args.concat(limit)
+    end
 
     synchronize do |client|
-      client.call([:zrangebyscore, key, min, max] + args, &block)
+      client.call(args, &block)
     end
   end
 
@@ -1971,21 +1990,21 @@ class Redis
   #     # => [["b", 64.0], ["a", 32.0]]
   #
   # @see #zrangebyscore
-  def zrevrangebyscore(key, max, min, options = {})
-    args = []
-
-    with_scores = options[:with_scores] || options[:withscores]
+  def zrevrangebyscore(key, max, min, withscores: false, with_scores: withscores, limit: nil)
+    args = [:zrevrangebyscore, key, max, min]
 
     if with_scores
-      args << ["WITHSCORES"]
+      args << "WITHSCORES"
       block = FloatifyPairs
     end
 
-    limit = options[:limit]
-    args.concat(["LIMIT"] + limit) if limit
+    if limit
+      args << "LIMIT"
+      args.concat(limit)
+    end
 
     synchronize do |client|
-      client.call([:zrevrangebyscore, key, max, min] + args, &block)
+      client.call(args, &block)
     end
   end
 
@@ -2005,7 +2024,7 @@ class Redis
   # @param [String] max
   #   - inclusive maximum score is specified verbatim
   #   - exclusive maximum score is specified by prefixing `(`
-  # @return [Fixnum] number of members that were removed
+  # @return [Integer] number of members that were removed
   def zremrangebyscore(key, min, max)
     synchronize do |client|
       client.call([:zremrangebyscore, key, min, max])
@@ -2028,7 +2047,7 @@ class Redis
   # @param [String] max
   #   - inclusive maximum score is specified verbatim
   #   - exclusive maximum score is specified by prefixing `(`
-  # @return [Fixnum] number of members in within the specified range
+  # @return [Integer] number of members in within the specified range
   def zcount(key, min, max)
     synchronize do |client|
       client.call([:zcount, key, min, max])
@@ -2048,18 +2067,19 @@ class Redis
   #   - `:weights => [Float, Float, ...]`: weights to associate with source
   #   sorted sets
   #   - `:aggregate => String`: aggregate function to use (sum, min, max, ...)
-  # @return [Fixnum] number of elements in the resulting sorted set
-  def zinterstore(destination, keys, options = {})
-    args = []
+  # @return [Integer] number of elements in the resulting sorted set
+  def zinterstore(destination, keys, weights: nil, aggregate: nil)
+    args = [:zinterstore, destination, keys.size, *keys]
 
-    weights = options[:weights]
-    args.concat(["WEIGHTS"] + weights) if weights
+    if weights
+      args << "WEIGHTS"
+      args.concat(weights)
+    end
 
-    aggregate = options[:aggregate]
-    args.concat(["AGGREGATE", aggregate]) if aggregate
+    args << "AGGREGATE" << aggregate if aggregate
 
     synchronize do |client|
-      client.call([:zinterstore, destination, keys.size] + keys + args)
+      client.call(args)
     end
   end
 
@@ -2075,40 +2095,46 @@ class Redis
   #   - `:weights => [Float, Float, ...]`: weights to associate with source
   #   sorted sets
   #   - `:aggregate => String`: aggregate function to use (sum, min, max, ...)
-  # @return [Fixnum] number of elements in the resulting sorted set
-  def zunionstore(destination, keys, options = {})
-    args = []
+  # @return [Integer] number of elements in the resulting sorted set
+  def zunionstore(destination, keys, weights: nil, aggregate: nil)
+    args = [:zunionstore, destination, keys.size, *keys]
 
-    weights = options[:weights]
-    args.concat(["WEIGHTS"] + weights) if weights
+    if weights
+      args << "WEIGHTS"
+      args.concat(weights)
+    end
 
-    aggregate = options[:aggregate]
-    args.concat(["AGGREGATE", aggregate]) if aggregate
+    args << "AGGREGATE" << aggregate if aggregate
 
     synchronize do |client|
-      client.call([:zunionstore, destination, keys.size] + keys + args)
+      client.call(args)
     end
   end
 
   # Get the number of fields in a hash.
   #
   # @param [String] key
-  # @return [Fixnum] number of fields in the hash
+  # @return [Integer] number of fields in the hash
   def hlen(key)
     synchronize do |client|
       client.call([:hlen, key])
     end
   end
 
-  # Set the string value of a hash field.
+  # Set one or more hash values.
+  #
+  # @example
+  #   redis.hset("hash", "f1", "v1", "f2", "v2") # => 2
+  #   redis.hset("hash", { "f1" => "v1", "f2" => "v2" }) # => 2
   #
   # @param [String] key
-  # @param [String] field
-  # @param [String] value
-  # @return [Boolean] whether or not the field was **added** to the hash
-  def hset(key, field, value)
+  # @param [Array<String> | Hash<String, String>] attrs array or hash of fields and values
+  # @return [Integer] The number of fields that were added to the hash
+  def hset(key, *attrs)
+    attrs = attrs.first.flatten if attrs.size == 1 && attrs.first.is_a?(Hash)
+
     synchronize do |client|
-      client.call([:hset, key, field, value], &Boolify)
+      client.call([:hset, key, *attrs])
     end
   end
 
@@ -2197,7 +2223,7 @@ class Redis
   # @see #hmget
   def mapped_hmget(key, *fields)
     hmget(key, *fields) do |reply|
-      if reply.kind_of?(Array)
+      if reply.is_a?(Array)
         Hash[fields.zip(reply)]
       else
         reply
@@ -2209,7 +2235,7 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] field
-  # @return [Fixnum] the number of fields that were removed from the hash
+  # @return [Integer] the number of fields that were removed from the hash
   def hdel(key, *fields)
     synchronize do |client|
       client.call([:hdel, key, *fields])
@@ -2231,8 +2257,8 @@ class Redis
   #
   # @param [String] key
   # @param [String] field
-  # @param [Fixnum] increment
-  # @return [Fixnum] value of the field after incrementing it
+  # @param [Integer] increment
+  # @return [Integer] value of the field after incrementing it
   def hincrby(key, field, increment)
     synchronize do |client|
       client.call([:hincrby, key, field, increment])
@@ -2290,20 +2316,21 @@ class Redis
 
   def subscribed?
     synchronize do |client|
-      client.kind_of? SubscribedClient
+      client.is_a? SubscribedClient
     end
   end
 
   # Listen for messages published to the given channels.
   def subscribe(*channels, &block)
-    synchronize do |client|
+    synchronize do |_client|
       _subscription(:subscribe, 0, channels, block)
     end
   end
 
-  # Listen for messages published to the given channels. Throw a timeout error if there is no messages for a timeout period.
+  # Listen for messages published to the given channels. Throw a timeout error
+  # if there is no messages for a timeout period.
   def subscribe_with_timeout(timeout, *channels, &block)
-    synchronize do |client|
+    synchronize do |_client|
       _subscription(:subscribe_with_timeout, timeout, channels, block)
     end
   end
@@ -2311,21 +2338,23 @@ class Redis
   # Stop listening for messages posted to the given channels.
   def unsubscribe(*channels)
     synchronize do |client|
-      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      raise "Can't unsubscribe if not subscribed." unless subscribed?
+
       client.unsubscribe(*channels)
     end
   end
 
   # Listen for messages published to channels matching the given patterns.
   def psubscribe(*channels, &block)
-    synchronize do |client|
+    synchronize do |_client|
       _subscription(:psubscribe, 0, channels, block)
     end
   end
 
-  # Listen for messages published to channels matching the given patterns. Throw a timeout error if there is no messages for a timeout period.
+  # Listen for messages published to channels matching the given patterns.
+  # Throw a timeout error if there is no messages for a timeout period.
   def psubscribe_with_timeout(timeout, *channels, &block)
-    synchronize do |client|
+    synchronize do |_client|
       _subscription(:psubscribe_with_timeout, timeout, channels, block)
     end
   end
@@ -2333,7 +2362,8 @@ class Redis
   # Stop listening for messages posted to channels matching the given patterns.
   def punsubscribe(*channels)
     synchronize do |client|
-      raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+      raise "Can't unsubscribe if not subscribed." unless subscribed?
+
       client.punsubscribe(*channels)
     end
   end
@@ -2378,7 +2408,7 @@ class Redis
   # @see #multi
   def watch(*keys)
     synchronize do |client|
-      res = client.call([:watch] + keys)
+      res = client.call([:watch, *keys])
 
       if block_given?
         begin
@@ -2408,7 +2438,7 @@ class Redis
   end
 
   def pipelined
-    synchronize do |client|
+    synchronize do |_client|
       begin
         pipeline = Pipeline.new(@client)
         original, @client = @client, pipeline
@@ -2608,18 +2638,12 @@ class Redis
     _eval(:evalsha, args)
   end
 
-  def _scan(command, cursor, args, options = {}, &block)
+  def _scan(command, cursor, args, match: nil, count: nil, &block)
     # SSCAN/ZSCAN/HSCAN already prepend the key to +args+.
 
     args << cursor
-
-    if match = options[:match]
-      args.concat(["MATCH", match])
-    end
-
-    if count = options[:count]
-      args.concat(["COUNT", count])
-    end
+    args << "MATCH" << match if match
+    args << "COUNT" << count if count
 
     synchronize do |client|
       client.call([command] + args, &block)
@@ -2641,8 +2665,8 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [String, Array<String>] the next cursor and all found keys
-  def scan(cursor, options={})
-    _scan(:scan, cursor, [], options)
+  def scan(cursor, **options)
+    _scan(:scan, cursor, [], **options)
   end
 
   # Scan the keyspace
@@ -2660,11 +2684,12 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [Enumerator] an enumerator for all found keys
-  def scan_each(options={}, &block)
-    return to_enum(:scan_each, options) unless block_given?
+  def scan_each(**options, &block)
+    return to_enum(:scan_each, **options) unless block_given?
+
     cursor = 0
     loop do
-      cursor, keys = scan(cursor, options)
+      cursor, keys = scan(cursor, **options)
       keys.each(&block)
       break if cursor == "0"
     end
@@ -2681,8 +2706,8 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [String, Array<[String, String]>] the next cursor and all found keys
-  def hscan(key, cursor, options={})
-    _scan(:hscan, cursor, [key], options) do |reply|
+  def hscan(key, cursor, **options)
+    _scan(:hscan, cursor, [key], **options) do |reply|
       [reply[0], reply[1].each_slice(2).to_a]
     end
   end
@@ -2698,11 +2723,12 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [Enumerator] an enumerator for all found keys
-  def hscan_each(key, options={}, &block)
-    return to_enum(:hscan_each, key, options) unless block_given?
+  def hscan_each(key, **options, &block)
+    return to_enum(:hscan_each, key, **options) unless block_given?
+
     cursor = 0
     loop do
-      cursor, values = hscan(key, cursor, options)
+      cursor, values = hscan(key, cursor, **options)
       values.each(&block)
       break if cursor == "0"
     end
@@ -2720,8 +2746,8 @@ class Redis
   #
   # @return [String, Array<[String, Float]>] the next cursor and all found
   #   members and scores
-  def zscan(key, cursor, options={})
-    _scan(:zscan, cursor, [key], options) do |reply|
+  def zscan(key, cursor, **options)
+    _scan(:zscan, cursor, [key], **options) do |reply|
       [reply[0], FloatifyPairs.call(reply[1])]
     end
   end
@@ -2737,11 +2763,12 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [Enumerator] an enumerator for all found scores and members
-  def zscan_each(key, options={}, &block)
-    return to_enum(:zscan_each, key, options) unless block_given?
+  def zscan_each(key, **options, &block)
+    return to_enum(:zscan_each, key, **options) unless block_given?
+
     cursor = 0
     loop do
-      cursor, values = zscan(key, cursor, options)
+      cursor, values = zscan(key, cursor, **options)
       values.each(&block)
       break if cursor == "0"
     end
@@ -2758,8 +2785,8 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [String, Array<String>] the next cursor and all found members
-  def sscan(key, cursor, options={})
-    _scan(:sscan, cursor, [key], options)
+  def sscan(key, cursor, **options)
+    _scan(:sscan, cursor, [key], **options)
   end
 
   # Scan a set
@@ -2773,11 +2800,12 @@ class Redis
   #   - `:count => Integer`: return count keys at most per iteration
   #
   # @return [Enumerator] an enumerator for all keys in the set
-  def sscan_each(key, options={}, &block)
-    return to_enum(:sscan_each, key, options) unless block_given?
+  def sscan_each(key, **options, &block)
+    return to_enum(:sscan_each, key, **options) unless block_given?
+
     cursor = 0
     loop do
-      cursor, keys = sscan(key, cursor, options)
+      cursor, keys = sscan(key, cursor, **options)
       keys.each(&block)
       break if cursor == "0"
     end
@@ -2800,7 +2828,7 @@ class Redis
   # union of the HyperLogLogs contained in the keys.
   #
   # @param [String, Array<String>] keys
-  # @return [Fixnum]
+  # @return [Integer]
   def pfcount(*keys)
     synchronize do |client|
       client.call([:pfcount] + keys)
@@ -2841,12 +2869,12 @@ class Redis
     end
   end
 
-
   # Query a sorted set representing a geospatial index to fetch members matching a
   # given maximum distance from a point
   #
   # @param [Array] args key, longitude, latitude, radius, unit(m|km|ft|mi)
-  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest
+  #   or the farthest to the nearest relative to the center
   # @param [Integer] count limit the results to the first N matching items
   # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
   # @return [Array<String>] may be changed with `options`
@@ -2863,7 +2891,8 @@ class Redis
   # given maximum distance from an already existing member
   #
   # @param [Array] args key, member, radius, unit(m|km|ft|mi)
-  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest
+  #   to the nearest relative to the center
   # @param [Integer] count limit the results to the first N matching items
   # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
   # @return [Array<String>] may be changed with `options`
@@ -2880,7 +2909,8 @@ class Redis
   #
   # @param [String] key
   # @param [String, Array<String>] member one member or array of members
-  # @return [Array<Array<String>, nil>] returns array of elements, where each element is either array of longitude and latitude or nil
+  # @return [Array<Array<String>, nil>] returns array of elements, where each
+  #   element is either array of longitude and latitude or nil
   def geopos(key, member)
     synchronize do |client|
       client.call([:geopos, key, member])
@@ -2944,10 +2974,14 @@ class Redis
   # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
   #
   # @return [String] the entry id
-  def xadd(key, entry, opts = {})
+  def xadd(key, entry, approximate: nil, maxlen: nil, id: '*')
     args = [:xadd, key]
-    args.concat(['MAXLEN', (opts[:approximate] ? '~' : nil), opts[:maxlen]].compact) if opts[:maxlen]
-    args << (opts[:id] || '*')
+    if maxlen
+      args << "MAXLEN"
+      args << "~" if approximate
+      args << maxlen
+    end
+    args << id
     args.concat(entry.to_a.flatten)
     synchronize { |client| client.call(args) }
   end
@@ -3002,8 +3036,8 @@ class Redis
   # @param count [Integer] the number of entries as limit
   #
   # @return [Array<Array<String, Hash>>] the ids and entries pairs
-  def xrange(key, start = '-', _end = '+', count: nil)
-    args = [:xrange, key, start, _end]
+  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) }
   end
@@ -3025,8 +3059,8 @@ class Redis
   # @params count [Integer] the number of entries as limit
   #
   # @return [Array<Array<String, Hash>>] the ids and entries pairs
-  def xrevrange(key, _end = '+', start = '-', count: nil)
-    args = [:xrevrange, key, _end, start]
+  def xrevrange(key, range_end = '+', start = '-', count: nil)
+    args = [:xrevrange, key, range_end, start]
     args.concat(['COUNT', count]) if count
     synchronize { |client| client.call(args, &HashifyStreamEntries) }
   end
@@ -3118,12 +3152,12 @@ class Redis
   # @option opts [Boolean] :noack whether message loss is acceptable or not
   #
   # @return [Hash{String => Hash{String => Hash}}] the entries
-  def xreadgroup(group, consumer, keys, ids, opts = {})
+  def xreadgroup(group, consumer, keys, ids, count: nil, block: nil, noack: nil)
     args = [:xreadgroup, 'GROUP', group, consumer]
-    args << 'COUNT' << opts[:count] if opts[:count]
-    args << 'BLOCK' << opts[:block].to_i if opts[:block]
-    args << 'NOACK' if opts[:noack]
-    _xread(args, keys, ids, opts[:block])
+    args << 'COUNT' << count if count
+    args << 'BLOCK' << block.to_i if block
+    args << 'NOACK' if noack
+    _xread(args, keys, ids, block)
   end
 
   # Removes one or multiple entries from the pending entries list of a stream consumer group.
@@ -3233,8 +3267,8 @@ class Redis
         when "get-master-addr-by-name"
           reply
         else
-          if reply.kind_of?(Array)
-            if reply[0].kind_of?(Array)
+          if reply.is_a?(Array)
+            if reply[0].is_a?(Array)
               reply.map(&Hashify)
             else
               Hashify.call(reply)
@@ -3258,12 +3292,17 @@ class Redis
   def cluster(subcommand, *args)
     subcommand = subcommand.to_s.downcase
     block = case subcommand
-            when 'slots'  then HashifyClusterSlots
-            when 'nodes'  then HashifyClusterNodes
-            when 'slaves' then HashifyClusterSlaves
-            when 'info'   then HashifyInfo
-            else Noop
-            end
+    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
@@ -3298,21 +3337,21 @@ class Redis
     return @original_client.connection_info if @cluster_mode
 
     {
-      host:     @original_client.host,
-      port:     @original_client.port,
-      db:       @original_client.db,
-      id:       @original_client.id,
+      host: @original_client.host,
+      port: @original_client.port,
+      db: @original_client.db,
+      id: @original_client.id,
       location: @original_client.location
     }
   end
 
-  def method_missing(command, *args)
+  def method_missing(command, *args) # rubocop:disable Style/MissingRespondToMissing
     synchronize do |client|
       client.call([command] + args)
     end
   end
 
-private
+  private
 
   # Commands returning 1 for true and 0 for false may be executed in a pipeline
   # where the method call will return nil. Propagate the nil instead of falsely
@@ -3384,18 +3423,21 @@ private
     end
   }
 
+  EMPTY_STREAM_RESPONSE = [nil].freeze
+  private_constant :EMPTY_STREAM_RESPONSE
+
   HashifyStreamEntries = lambda { |reply|
-    reply.map do |entry_id, values|
+    reply.compact.map do |entry_id, values|
       [entry_id, values.each_slice(2).to_h]
     end
   }
 
   HashifyStreamPendings = lambda { |reply|
     {
-      'size'         => reply[0],
+      'size' => reply[0],
       'min_entry_id' => reply[1],
       'max_entry_id' => reply[2],
-      'consumers'    => reply[3].nil? ? {} : reply[3].to_h
+      'consumers' => reply[3].nil? ? {} : reply[3].to_h
     }
   }
 
@@ -3404,8 +3446,8 @@ private
       {
         'entry_id' => arr[0],
         'consumer' => arr[1],
-        'elapsed'  => arr[2],
-        'count'    => arr[3]
+        'elapsed' => arr[2],
+        'count' => arr[3]
       }
     end
   }
@@ -3413,15 +3455,15 @@ private
   HashifyClusterNodeInfo = lambda { |str|
     arr = str.split(' ')
     {
-      'node_id'        => arr[0],
-      'ip_port'        => arr[1],
-      'flags'          => arr[2].split(','),
+      'node_id' => arr[0],
+      'ip_port' => arr[1],
+      'flags' => arr[2].split(','),
       'master_node_id' => arr[3],
-      'ping_sent'      => arr[4],
-      'pong_recv'      => arr[5],
-      'config_epoch'   => arr[6],
-      'link_state'     => arr[7],
-      'slots'          => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
+      'ping_sent' => arr[4],
+      'pong_recv' => arr[5],
+      'config_epoch' => arr[6],
+      'link_state' => arr[7],
+      'slots' => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
     }
   }
 
@@ -3432,9 +3474,9 @@ private
       replicas = arr[3..-1].map { |r| { 'ip' => r[0], 'port' => r[1], 'node_id' => r[2] } }
       {
         'start_slot' => first_slot,
-        'end_slot'   => last_slot,
-        'master'     => master,
-        'replicas'   => replicas
+        'end_slot' => last_slot,
+        'master' => master,
+        'replicas' => replicas
       }
     end
   }