fix

Author: supercaracal

lib/redis_client/cluster.rb

@@ -62,30 +62,37 @@ def blocking_call_v(timeout, command, &block)
     end
 
     def scan(*args, **kwargs, &block)
-      raise ArgumentError, 'block required' unless block
+      return to_enum(__callee__, *args, **kwargs) unless block_given?
 
+      command = @command_builder.generate(['SCAN', ZERO_CURSOR_FOR_SCAN] + args, kwargs)
       seed = Random.new_seed
-      cursor = ZERO_CURSOR_FOR_SCAN
       loop do
-        cursor, keys = router.scan('SCAN', cursor, *args, seed: seed, **kwargs)
+        cursor, keys = router.scan(command, seed: seed)
+        command[1] = cursor
         keys.each(&block)
         break if cursor == ZERO_CURSOR_FOR_SCAN
       end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = router.assign_node(['SSCAN', key])
-      router.try_delegate(node, :sscan, key, *args, **kwargs, &block)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['SSCAN', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 1, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = router.assign_node(['HSCAN', key])
-      router.try_delegate(node, :hscan, key, *args, **kwargs, &block)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['HSCAN', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 2, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = router.assign_node(['ZSCAN', key])
-      router.try_delegate(node, :zscan, key, *args, **kwargs, &block)
+      return to_enum(__callee__, key, *args, **kwargs) unless block_given?
+
+      command = @command_builder.generate(['ZSCAN', key, ZERO_CURSOR_FOR_SCAN] + args, kwargs)
+      router.scan_single_key(command, arity: 2, &block)
     end
 
     def pipelined(exception: true)

lib/redis_client/cluster/router.rb

@@ -104,12 +104,6 @@ def try_send(node, method, command, args, retry_count: 3, &block)
         end
       end
 
-      def try_delegate(node, method, *args, retry_count: 3, **kwargs, &block)
-        handle_redirection(node, nil, retry_count: retry_count) do |on_node|
-          on_node.public_send(method, *args, **kwargs, &block)
-        end
-      end
-
       def handle_redirection(node, command, retry_count:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         yield node
       rescue ::RedisClient::CircuitBreaker::OpenCircuitError
@@ -153,9 +147,7 @@ def handle_redirection(node, command, retry_count:) # rubocop:disable Metrics/Ab
         raise
       end
 
-      def scan(*command, seed: nil, **kwargs) # rubocop:disable Metrics/AbcSize
-        command = @command_builder.generate(command, kwargs)
-
+      def scan(command, seed: nil) # rubocop:disable Metrics/AbcSize
         command[1] = ZERO_CURSOR_FOR_SCAN if command.size == 1
         input_cursor = Integer(command[1])
 
@@ -180,6 +172,19 @@ def scan(*command, seed: nil, **kwargs) # rubocop:disable Metrics/AbcSize
         raise
       end
 
+      def scan_single_key(command, arity:, &block)
+        node = assign_node(command)
+
+        handle_redirection(node, nil, retry_count: 3) do |on_node|
+          loop do
+            cursor, values = on_node.call_v(command)
+            command[2] = cursor
+            arity < 2 ? values.each(&block) : values.each_slice(arity, &block)
+            break if cursor == ZERO_CURSOR_FOR_SCAN
+          end
+        end
+      end
+
       def assign_node(command)
         handle_node_reload_error do
           node_key = find_node_key(command)

test/redis_client/test_cluster.rb

@@ -92,8 +92,6 @@ def test_blocking_call
       end
 
       def test_scan
-        assert_raises(ArgumentError) { @client.scan }
-
         10.times { |i| @client.call('SET', "key#{i}", i) }
         wait_for_replication
         want = (0..9).map { |i| "key#{i}" }
@@ -117,9 +115,9 @@ def test_hscan
         10.times do |i|
           10.times { |j| @client.call('HSET', "key#{i}", "field#{j}", j) }
           wait_for_replication
-          want = (0..9).map { |j| "field#{j}" }
+          want = (0..9).map { |j| ["field#{j}", j.to_s] }
           got = []
-          @client.hscan("key#{i}", 'COUNT', '5') { |field| got << field }
+          @client.hscan("key#{i}", 'COUNT', '5') { |pair| got << pair }
           assert_equal(want, got.sort)
         end
       end
@@ -128,9 +126,9 @@ def test_zscan
         10.times do |i|
           10.times { |j| @client.call('ZADD', "key#{i}", j, "member#{j}") }
           wait_for_replication
-          want = (0..9).map { |j| "member#{j}" }
+          want = (0..9).map { |j| ["member#{j}", j.to_s] }
           got = []
-          @client.zscan("key#{i}", 'COUNT', '5') { |member| got << member }
+          @client.zscan("key#{i}", 'COUNT', '5') { |pair| got << pair }
           assert_equal(want, got.sort)
         end
       end