Use redis-client call_v interface

Saves splatting commands all the time

Author: byroot

lib/redis.rb

@@ -156,19 +156,19 @@ def synchronize
 
   def send_command(command, &block)
     @monitor.synchronize do
-      @client.call(command, &block)
+      @client.call_v(command, &block)
     end
   end
 
   def send_blocking_command(command, timeout, &block)
     @monitor.synchronize do
-      @client.blocking_call(timeout, command, &block)
+      @client.blocking_call_v(timeout, command, &block)
     end
   end
 
   def _subscription(method, timeout, channels, block)
     if @subscription_client
-      return @subscription_client.call([method] + channels)
+      return @subscription_client.call_v([method] + channels)
     end
 
     begin

lib/redis/client.rb

@@ -65,8 +65,12 @@ def password
       config.password
     end
 
-    def call(command, &block)
-      super(*command, &block)
+    undef_method :call
+    undef_method :call_once
+    undef_method :blocking_call
+
+    def call_v(command, &block)
+      super(command, &block)
     rescue ::RedisClient::Error => error
       raise ERROR_MAPPING.fetch(error.class), error.message, error.backtrace
     end
@@ -83,9 +87,9 @@ def pipelined
       raise ERROR_MAPPING.fetch(error.class), error.message, error.backtrace
     end
 
-    def blocking_call(timeout, command, &block)
+    def blocking_call_v(timeout, command, &block)
       timeout += self.timeout if timeout && timeout > 0
-      super(timeout, *command, &block)
+      super(timeout, command, &block)
     rescue ::RedisClient::Error => error
       raise ERROR_MAPPING.fetch(error.class), error.message, error.backtrace
     end

lib/redis/cluster.rb

@@ -244,7 +244,7 @@ def _scan(command, &block)
 
       command[1] = raw_cursor.to_s
 
-      result_cursor, result_keys = client.call(command, &block)
+      result_cursor, result_keys = client.call_v(command, &block)
       result_cursor = Integer(result_cursor)
 
       if result_cursor == 0

lib/redis/commands/connection.rb

@@ -42,7 +42,7 @@ def select(db)
       # @return [String] `OK`
       def quit
         synchronize do |client|
-          client.call([:quit])
+          client.call_v([:quit])
         rescue ConnectionError
         ensure
           client.close

lib/redis/commands/server.rb

@@ -120,7 +120,7 @@ def lastsave
       def monitor
         synchronize do |client|
           client = client.pubsub
-          client.call([:monitor])
+          client.call_v([:monitor])
           loop do
             yield client.next_event
           end
@@ -138,7 +138,7 @@ def save
       def shutdown
         synchronize do |client|
           client.disable_reconnection do
-            client.call([:shutdown])
+            client.call_v([:shutdown])
           rescue ConnectionError
             # This means Redis has probably exited.
             nil
@@ -157,11 +157,9 @@ def slaveof(host, port)
       # @param [Integer] length maximum number of entries to return
       # @return [Array<String>, Integer, String] depends on subcommand
       def slowlog(subcommand, length = nil)
-        synchronize do |client|
-          args = [:slowlog, subcommand]
-          args << length if length
-          client.call args
-        end
+        args = [:slowlog, subcommand]
+        args << length if length
+        send_command(args)
       end
 
       # Internal command used for replication.

lib/redis/commands/streams.rb

@@ -21,15 +21,12 @@ module Streams
       # @return [Array<Hash>] information of the consumers if subcommand is `consumers`
       def xinfo(subcommand, key, group = nil)
         args = [:xinfo, subcommand, key, group].compact
-        synchronize do |client|
-          client.call(args) do |reply|
-            case subcommand.to_s.downcase
-            when 'stream'              then Hashify.call(reply)
-            when 'groups', 'consumers' then reply.map { |arr| Hashify.call(arr) }
-            else reply
-            end
-          end
+        block = case subcommand.to_s.downcase
+        when 'stream'              then Hashify
+        when 'groups', 'consumers' then proc { |r| r.map(&Hashify) }
         end
+
+        send_command(args, &block)
       end
 
       # Add new entry to the stream.
@@ -113,7 +110,7 @@ def xdel(key, *ids)
       def xrange(key, start = '-', range_end = '+', count: nil)
         args = [:xrange, key, start, range_end]
         args.concat(['COUNT', count]) if count
-        synchronize { |client| client.call(args, &HashifyStreamEntries) }
+        send_command(args, &HashifyStreamEntries)
       end
 
       # Fetches entries of the stream in descending order.

lib/redis/commands/transactions.rb

@@ -60,7 +60,7 @@ def multi
       # @see #multi
       def watch(*keys)
         synchronize do |client|
-          res = client.call([:watch, *keys])
+          res = client.call_v([:watch] + keys)
 
           if block_given?
             begin

lib/redis/pipeline.rb

@@ -23,7 +23,7 @@ def multi
       size = @futures.size
       yield transaction
       multi_future = MultiFuture.new(@futures[size..-1])
-      @pipeline.call(:exec) do |result|
+      @pipeline.call_v([:exec]) do |result|
         multi_future._set(result)
       end
       @futures << multi_future
@@ -38,7 +38,7 @@ def synchronize
 
     def send_command(command, &block)
       future = Future.new(command, block)
-      @pipeline.call(*command) do |result|
+      @pipeline.call_v(command) do |result|
         future._set(result)
       end
       @futures << future
@@ -47,7 +47,7 @@ def send_command(command, &block)
 
     def send_blocking_command(command, timeout, &block)
       future = Future.new(command, block)
-      @pipeline.blocking_call(timeout, *command) do |result|
+      @pipeline.blocking_call_v(timeout, command) do |result|
         future._set(result)
       end
       @futures << future

lib/redis/subscribe.rb

@@ -6,8 +6,8 @@ def initialize(client)
       @client = client
     end
 
-    def call(command)
-      @client.call(command)
+    def call_v(command)
+      @client.call_v(command)
     end
 
     def subscribe(*channels, &block)
@@ -27,19 +27,19 @@ def psubscribe_with_timeout(timeout, *channels, &block)
     end
 
     def unsubscribe(*channels)
-      call([:unsubscribe, *channels])
+      call_v([:unsubscribe, *channels])
     end
 
     def punsubscribe(*channels)
-      call([:punsubscribe, *channels])
+      call_v([:punsubscribe, *channels])
     end
 
     protected
 
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
-      @client.call([start, *channels])
+      @client.call_v([start, *channels])
       while event = @client.next_event(timeout)
         if event.is_a?(::RedisClient::CommandError)
           raise Client::ERROR_MAPPING.fetch(event.class), event.message

test/redis/internals_test.rb

@@ -196,15 +196,15 @@ def close_on_connection(seq, &block)
 
   def test_retry_on_write_error_by_default
     close_on_connection([0]) do |redis|
-      assert_equal "1", redis._client.call(["x" * 128 * 1024])
+      assert_equal "1", redis._client.call_v(["x" * 128 * 1024])
     end
   end
 
   def test_dont_retry_on_write_error_when_wrapped_in_without_reconnect
     close_on_connection([0]) do |redis|
       assert_raises Redis::ConnectionError do
         redis.without_reconnect do
-          redis._client.call(["x" * 128 * 1024])
+          redis._client.call_v(["x" * 128 * 1024])
         end
       end
     end