redis 4.2.5 → 5.0.7

data/lib/redis/commands/strings.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Strings
+      # Decrement the integer value of a key by one.
+      #
+      # @example
+      #   redis.decr("value")
+      #     # => 4
+      #
+      # @param [String] key
+      # @return [Integer] value after decrementing it
+      def decr(key)
+        send_command([:decr, key])
+      end
+
+      # Decrement the integer value of a key by the given number.
+      #
+      # @example
+      #   redis.decrby("value", 5)
+      #     # => 0
+      #
+      # @param [String] key
+      # @param [Integer] decrement
+      # @return [Integer] value after decrementing it
+      def decrby(key, decrement)
+        send_command([:decrby, key, Integer(decrement)])
+      end
+
+      # Increment the integer value of a key by one.
+      #
+      # @example
+      #   redis.incr("value")
+      #     # => 6
+      #
+      # @param [String] key
+      # @return [Integer] value after incrementing it
+      def incr(key)
+        send_command([:incr, key])
+      end
+
+      # Increment the integer value of a key by the given integer number.
+      #
+      # @example
+      #   redis.incrby("value", 5)
+      #     # => 10
+      #
+      # @param [String] key
+      # @param [Integer] increment
+      # @return [Integer] value after incrementing it
+      def incrby(key, increment)
+        send_command([:incrby, key, Integer(increment)])
+      end
+
+      # Increment the numeric value of a key by the given float number.
+      #
+      # @example
+      #   redis.incrbyfloat("value", 1.23)
+      #     # => 1.23
+      #
+      # @param [String] key
+      # @param [Float] increment
+      # @return [Float] value after incrementing it
+      def incrbyfloat(key, increment)
+        send_command([:incrbyfloat, key, Float(increment)], &Floatify)
+      end
+
+      # Set the string value of a key.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @param [Hash] options
+      #   - `:ex => Integer`: Set the specified expire time, in seconds.
+      #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+      #   - `:exat => Integer` : Set the specified Unix time at which the key will expire, in seconds.
+      #   - `:pxat => Integer` : Set the specified Unix time at which the key will expire, 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.
+      #   - `:get => true`: Return the old string stored at key, or nil if key did not exist.
+      # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true`
+      def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil, get: nil)
+        args = [:set, key, value.to_s]
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
+        args << "NX" if nx
+        args << "XX" if xx
+        args << "KEEPTTL" if keepttl
+        args << "GET" if get
+
+        if nx || xx
+          send_command(args, &BoolifySet)
+        else
+          send_command(args)
+        end
+      end
+
+      # Set the time to live in seconds of a key.
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [String] value
+      # @return [String] `"OK"`
+      def setex(key, ttl, value)
+        send_command([:setex, key, Integer(ttl), value.to_s])
+      end
+
+      # Set the time to live in milliseconds of a key.
+      #
+      # @param [String] key
+      # @param [Integer] ttl
+      # @param [String] value
+      # @return [String] `"OK"`
+      def psetex(key, ttl, value)
+        send_command([:psetex, key, Integer(ttl), value.to_s])
+      end
+
+      # Set the value of a key, only if the key does not exist.
+      #
+      # @param [String] key
+      # @param [String] value
+      # @return [Boolean] whether the key was set or not
+      def setnx(key, value)
+        send_command([:setnx, key, value.to_s], &Boolify)
+      end
+
+      # Set one or more values.
+      #
+      # @example
+      #   redis.mset("key1", "v1", "key2", "v2")
+      #     # => "OK"
+      #
+      # @param [Array<String>] args array of keys and values
+      # @return [String] `"OK"`
+      #
+      # @see #mapped_mset
+      def mset(*args)
+        send_command([:mset] + args)
+      end
+
+      # Set one or more values.
+      #
+      # @example
+      #   redis.mapped_mset({ "f1" => "v1", "f2" => "v2" })
+      #     # => "OK"
+      #
+      # @param [Hash] hash keys mapping to values
+      # @return [String] `"OK"`
+      #
+      # @see #mset
+      def mapped_mset(hash)
+        mset(hash.flatten)
+      end
+
+      # Set one or more values, only if none of the keys exist.
+      #
+      # @example
+      #   redis.msetnx("key1", "v1", "key2", "v2")
+      #     # => true
+      #
+      # @param [Array<String>] args array of keys and values
+      # @return [Boolean] whether or not all values were set
+      #
+      # @see #mapped_msetnx
+      def msetnx(*args)
+        send_command([:msetnx, *args], &Boolify)
+      end
+
+      # Set one or more values, only if none of the keys exist.
+      #
+      # @example
+      #   redis.mapped_msetnx({ "key1" => "v1", "key2" => "v2" })
+      #     # => true
+      #
+      # @param [Hash] hash keys mapping to values
+      # @return [Boolean] whether or not all values were set
+      #
+      # @see #msetnx
+      def mapped_msetnx(hash)
+        msetnx(hash.flatten)
+      end
+
+      # Get the value of a key.
+      #
+      # @param [String] key
+      # @return [String]
+      def get(key)
+        send_command([:get, key])
+      end
+
+      # Get the values of all the given keys.
+      #
+      # @example
+      #   redis.mget("key1", "key2")
+      #     # => ["v1", "v2"]
+      #
+      # @param [Array<String>] keys
+      # @return [Array<String>] an array of values for the specified keys
+      #
+      # @see #mapped_mget
+      def mget(*keys, &blk)
+        keys.flatten!(1)
+        send_command([:mget, *keys], &blk)
+      end
+
+      # Get the values of all the given keys.
+      #
+      # @example
+      #   redis.mapped_mget("key1", "key2")
+      #     # => { "key1" => "v1", "key2" => "v2" }
+      #
+      # @param [Array<String>] keys array of keys
+      # @return [Hash] a hash mapping the specified keys to their values
+      #
+      # @see #mget
+      def mapped_mget(*keys)
+        mget(*keys) do |reply|
+          if reply.is_a?(Array)
+            Hash[keys.zip(reply)]
+          else
+            reply
+          end
+        end
+      end
+
+      # Overwrite part of a string at key starting at the specified offset.
+      #
+      # @param [String] key
+      # @param [Integer] offset byte offset
+      # @param [String] value
+      # @return [Integer] length of the string after it was modified
+      def setrange(key, offset, value)
+        send_command([:setrange, key, Integer(offset), value.to_s])
+      end
+
+      # Get a substring of the string stored at a key.
+      #
+      # @param [String] key
+      # @param [Integer] start zero-based start offset
+      # @param [Integer] stop zero-based end offset. Use -1 for representing
+      #   the end of the string
+      # @return [Integer] `0` or `1`
+      def getrange(key, start, stop)
+        send_command([:getrange, key, Integer(start), Integer(stop)])
+      end
+
+      # Append a value to a key.
+      #
+      # @param [String] key
+      # @param [String] value value to append
+      # @return [Integer] length of the string after appending
+      def append(key, value)
+        send_command([:append, key, value])
+      end
+
+      # Set the string value of a key and return its old value.
+      #
+      # @param [String] key
+      # @param [String] value value to replace the current value with
+      # @return [String] the old value stored in the key, or `nil` if the key
+      #   did not exist
+      def getset(key, value)
+        send_command([:getset, key, value.to_s])
+      end
+
+      # Get the value of key and delete the key. This command is similar to GET,
+      # except for the fact that it also deletes the key on success.
+      #
+      # @param [String] key
+      # @return [String] the old value stored in the key, or `nil` if the key
+      #   did not exist
+      def getdel(key)
+        send_command([:getdel, key])
+      end
+
+      # Get the value of key and optionally set its expiration. GETEX is similar to
+      # GET, but is a write command with additional options. When no options are
+      # provided, GETEX behaves like GET.
+      #
+      # @param [String] key
+      # @param [Hash] options
+      #   - `:ex => Integer`: Set the specified expire time, in seconds.
+      #   - `:px => Integer`: Set the specified expire time, in milliseconds.
+      #   - `:exat => true`: Set the specified Unix time at which the key will
+      #      expire, in seconds.
+      #   - `:pxat => true`: Set the specified Unix time at which the key will
+      #      expire, in milliseconds.
+      #   - `:persist => true`: Remove the time to live associated with the key.
+      # @return [String] The value of key, or nil when key does not exist.
+      def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: false)
+        args = [:getex, key]
+        args << "EX" << Integer(ex) if ex
+        args << "PX" << Integer(px) if px
+        args << "EXAT" << Integer(exat) if exat
+        args << "PXAT" << Integer(pxat) if pxat
+        args << "PERSIST" if persist
+
+        send_command(args)
+      end
+
+      # Get the length of the value stored in a key.
+      #
+      # @param [String] key
+      # @return [Integer] the length of the value stored in the key, or 0
+      #   if the key does not exist
+      def strlen(key)
+        send_command([:strlen, key])
+      end
+    end
+  end
+end

data/lib/redis/commands/transactions.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Transactions
+      # Mark the start of a transaction block.
+      #
+      # @example With a block
+      #   redis.multi do |multi|
+      #     multi.set("key", "value")
+      #     multi.incr("counter")
+      #   end # => ["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 [Array<...>]
+      #   - an array with replies
+      #
+      # @see #watch
+      # @see #unwatch
+      def multi
+        synchronize do |client|
+          client.multi do |raw_transaction|
+            yield MultiConnection.new(raw_transaction)
+          end
+        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_v([: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.
+      #
+      # @return [String] `"OK"`
+      #
+      # @see #multi
+      # @see #exec
+      def discard
+        send_command([:discard])
+      end
+    end
+  end
+end

data/lib/redis/commands.rb

@@ -0,0 +1,237 @@
+# 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|
+      value != 0 unless value.nil?
+    }
+
+    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].compact.map do |entry, values|
+          [entry, values.each_slice(2)&.to_h]
+        end
+      }
+    }
+
+    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