redis 3.3.5 → 4.8.1

data/lib/redis/commands/transactions.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Transactions
+      # Mark the start of a transaction block.
+      #
+      # Passing a block is optional.
+      #
+      # @example With a block
+      #   redis.multi do |multi|
+      #     multi.set("key", "value")
+      #     multi.incr("counter")
+      #   end # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.multi
+      #     # => "OK"
+      #   redis.set("key", "value")
+      #     # => "QUEUED"
+      #   redis.incr("counter")
+      #     # => "QUEUED"
+      #   redis.exec
+      #     # => ["OK", 6]
+      #
+      # @yield [multi] the commands that are called inside this block are cached
+      #   and written to the server upon returning from it
+      # @yieldparam [Redis] multi `self`
+      #
+      # @return [String, Array<...>]
+      #   - when a block is not given, `OK`
+      #   - when a block is given, an array with replies
+      #
+      # @see #watch
+      # @see #unwatch
+      def multi(&block) # :nodoc:
+        if block_given?
+          if block&.arity == 0
+            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
+          end
+
+          synchronize do |prior_client|
+            pipeline = Pipeline::Multi.new(prior_client)
+            pipelined_connection = PipelinedConnection.new(pipeline)
+            yield pipelined_connection
+            prior_client.call_pipeline(pipeline)
+          end
+        else
+          send_command([:multi])
+        end
+      end
+
+      # Watch the given keys to determine execution of the MULTI/EXEC block.
+      #
+      # Using a block is optional, but is necessary for thread-safety.
+      #
+      # An `#unwatch` is automatically issued if an exception is raised within the
+      # block that is a subclass of StandardError and is not a ConnectionError.
+      #
+      # @example With a block
+      #   redis.watch("key") do
+      #     if redis.get("key") == "some value"
+      #       redis.multi do |multi|
+      #         multi.set("key", "other value")
+      #         multi.incr("counter")
+      #       end
+      #     else
+      #       redis.unwatch
+      #     end
+      #   end
+      #     # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.watch("key")
+      #     # => "OK"
+      #
+      # @param [String, Array<String>] keys one or more keys to watch
+      # @return [Object] if using a block, returns the return value of the block
+      # @return [String] if not using a block, returns `OK`
+      #
+      # @see #unwatch
+      # @see #multi
+      def watch(*keys)
+        synchronize do |client|
+          res = client.call([:watch, *keys])
+
+          if block_given?
+            begin
+              yield(self)
+            rescue ConnectionError
+              raise
+            rescue StandardError
+              unwatch
+              raise
+            end
+          else
+            res
+          end
+        end
+      end
+
+      # Forget about all watched keys.
+      #
+      # @return [String] `OK`
+      #
+      # @see #watch
+      # @see #multi
+      def unwatch
+        send_command([:unwatch])
+      end
+
+      # Execute all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [nil, Array<...>]
+      #   - when commands were not executed, `nil`
+      #   - when commands were executed, an array with their replies
+      #
+      # @see #multi
+      # @see #discard
+      def exec
+        send_command([:exec])
+      end
+
+      # Discard all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [String] `"OK"`
+      #
+      # @see #multi
+      # @see #exec
+      def discard
+        send_command([:discard])
+      end
+    end
+  end
+end

data/lib/redis/commands.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "redis/commands/bitmaps"
+require "redis/commands/cluster"
+require "redis/commands/connection"
+require "redis/commands/geo"
+require "redis/commands/hashes"
+require "redis/commands/hyper_log_log"
+require "redis/commands/keys"
+require "redis/commands/lists"
+require "redis/commands/pubsub"
+require "redis/commands/scripting"
+require "redis/commands/server"
+require "redis/commands/sets"
+require "redis/commands/sorted_sets"
+require "redis/commands/streams"
+require "redis/commands/strings"
+require "redis/commands/transactions"
+
+class Redis
+  module Commands
+    include Bitmaps
+    include Cluster
+    include Connection
+    include Geo
+    include Hashes
+    include HyperLogLog
+    include Keys
+    include Lists
+    include Pubsub
+    include Scripting
+    include Server
+    include Sets
+    include SortedSets
+    include Streams
+    include Strings
+    include Transactions
+
+    # 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
+    # returning false.
+    Boolify = lambda { |value|
+      case value
+      when Integer
+        value > 0
+      else
+        value
+      end
+    }
+
+    BoolifySet = lambda { |value|
+      case value
+      when "OK"
+        true
+      when nil
+        false
+      else
+        value
+      end
+    }
+
+    Hashify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_h
+      else
+        value
+      end
+    }
+
+    Pairify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_a
+      else
+        value
+      end
+    }
+
+    Floatify = lambda { |value|
+      case value
+      when "inf"
+        Float::INFINITY
+      when "-inf"
+        -Float::INFINITY
+      when String
+        Float(value)
+      else
+        value
+      end
+    }
+
+    FloatifyPairs = lambda { |value|
+      return value unless value.respond_to?(:each_slice)
+
+      value.each_slice(2).map do |member, score|
+        [member, Floatify.call(score)]
+      end
+    }
+
+    HashifyInfo = lambda { |reply|
+      lines = reply.split("\r\n").grep_v(/^(#|$)/)
+      lines.map! { |line| line.split(':', 2) }
+      lines.compact!
+      lines.to_h
+    }
+
+    HashifyStreams = lambda { |reply|
+      case reply
+      when nil
+        {}
+      else
+        reply.map { |key, entries| [key, HashifyStreamEntries.call(entries)] }.to_h
+      end
+    }
+
+    EMPTY_STREAM_RESPONSE = [nil].freeze
+    private_constant :EMPTY_STREAM_RESPONSE
+
+    HashifyStreamEntries = lambda { |reply|
+      reply.compact.map do |entry_id, values|
+        [entry_id, values&.each_slice(2)&.to_h]
+      end
+    }
+
+    HashifyStreamAutoclaim = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+      }
+    }
+
+    HashifyStreamAutoclaimJustId = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1]
+      }
+    }
+
+    HashifyStreamPendings = lambda { |reply|
+      {
+        'size' => reply[0],
+        'min_entry_id' => reply[1],
+        'max_entry_id' => reply[2],
+        'consumers' => reply[3].nil? ? {} : reply[3].to_h
+      }
+    }
+
+    HashifyStreamPendingDetails = lambda { |reply|
+      reply.map do |arr|
+        {
+          'entry_id' => arr[0],
+          'consumer' => arr[1],
+          'elapsed' => arr[2],
+          'count' => arr[3]
+        }
+      end
+    }
+
+    HashifyClusterNodeInfo = lambda { |str|
+      arr = str.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('-'))
+      }
+    }
+
+    HashifyClusterSlots = lambda { |reply|
+      reply.map do |arr|
+        first_slot, last_slot = arr[0..1]
+        master = { 'ip' => arr[2][0], 'port' => arr[2][1], 'node_id' => arr[2][2] }
+        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
+    }
+
+    HashifyClusterNodes = lambda { |reply|
+      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    HashifyClusterSlaves = lambda { |reply|
+      reply.map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    Noop = ->(reply) { reply }
+
+    # Sends a command to Redis and returns its reply.
+    #
+    # Replies are converted to Ruby objects according to the RESP protocol, so
+    # you can expect a Ruby array, integer or nil when Redis sends one. Higher
+    # level transformations, such as converting an array of pairs into a Ruby
+    # hash, are up to consumers.
+    #
+    # Redis error replies are raised as Ruby exceptions.
+    def call(*command)
+      send_command(command)
+    end
+
+    # Interact with the sentinel command (masters, master, slaves, failover)
+    #
+    # @param [String] subcommand e.g. `masters`, `master`, `slaves`
+    # @param [Array<String>] args depends on subcommand
+    # @return [Array<String>, Hash<String, String>, String] depends on subcommand
+    def sentinel(subcommand, *args)
+      subcommand = subcommand.to_s.downcase
+      send_command([:sentinel, subcommand] + args) do |reply|
+        case subcommand
+        when "get-master-addr-by-name"
+          reply
+        else
+          if reply.is_a?(Array)
+            if reply[0].is_a?(Array)
+              reply.map(&Hashify)
+            else
+              Hashify.call(reply)
+            end
+          else
+            reply
+          end
+        end
+      end
+    end
+
+    private
+
+    def method_missing(*command) # rubocop:disable Style/MissingRespondToMissing
+      send_command(command)
+    end
+  end
+end

data/lib/redis/connection/command_helper.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 class Redis
   module Connection
     module CommandHelper
-
       COMMAND_DELIMITER = "\r\n"
 
       def build_command(args)
@@ -11,11 +12,13 @@ class Redis
           if i.is_a? Array
             i.each do |j|
               j = j.to_s
+              j = j.encoding == Encoding::BINARY ? j : j.b
               command << "$#{j.bytesize}"
               command << j
             end
           else
             i = i.to_s
+            i = i.encoding == Encoding::BINARY ? i : i.b
             command << "$#{i.bytesize}"
             command << i
           end
@@ -28,16 +31,10 @@ class Redis
         command.join(COMMAND_DELIMITER)
       end
 
-    protected
+      protected
 
-      if defined?(Encoding::default_external)
-        def encode(string)
-          string.force_encoding(Encoding::default_external)
-        end
-      else
-        def encode(string)
-          string
-        end
+      def encode(string)
+        string.force_encoding(Encoding.default_external)
       end
     end
   end

data/lib/redis/connection/hiredis.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "redis/connection/registry"
 require "redis/errors"
+
 require "hiredis/connection"
 require "timeout"
 
 class Redis
   module Connection
     class Hiredis
-
       def self.connect(config)
         connection = ::Hiredis::Connection.new
         connect_timeout = (config.fetch(:connect_timeout, 0) * 1_000_000).to_i
@@ -31,7 +33,7 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection&.connected?
       end
 
       def timeout=(timeout)
@@ -57,7 +59,7 @@ class Redis
       rescue Errno::EAGAIN
         raise TimeoutError
       rescue RuntimeError => err
-        raise ProtocolError.new(err.message)
+        raise ProtocolError, err.message
       end
     end
   end

data/lib/redis/connection/registry.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 class Redis
   module Connection
-
     # Store a list of loaded connection drivers in the Connection module.
     # Redis::Client uses the last required driver by default, and will be aware
     # of the loaded connection drivers if the user chooses to override the