protocol-redis 0.8.1 → 0.10.0

data/lib/protocol/redis/methods/hashes.rb

@@ -1,186 +1,187 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2023, by Troex Nevelin.
 # Copyright, 2023, by Nick Burwell.
 
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis hashes.
 			module Hashes
 				# Get the number of fields in a hash. O(1).
-				# @see https://redis.io/commands/hlen
-				# @param key [Key]
-				# @return [Integer]
+				# See <https://redis.io/commands/hlen> for more details.
+				# @parameter key [Key]
+				# @returns [Integer]
 				def hlen(key)
-					call('HLEN', key)
+					call("HLEN", key)
 				end
 				
 				# Set the string value of a hash field. O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
-				# @see https://redis.io/commands/hset
-				# @param key [Key]
-				# @return [Integer] if new field added returns "1" otherwise "0"
+				# See <https://redis.io/commands/hset> for more details.
+				# @parameter key [Key]
+				# @returns [Integer] if new field added returns "1" otherwise "0"
 				def hset(key, field, value)
-					call('HSET', key, field, value)
+					call("HSET", key, field, value)
 				end
 				
 				# Set the value of a hash field, only if the field does not exist. O(1).
-				# @see https://redis.io/commands/hsetnx
-				# @param key [Key]
-				# @param field [String]
-				# @param value [String]
-				# @return [Boolean] "true" if new field added, "false" otherwise
+				# See <https://redis.io/commands/hsetnx> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @parameter value [String]
+				# @returns [Boolean] "true" if new field added, "false" otherwise
 				def hsetnx(key, field, value)
-					call('HSETNX', key, field, value) > 0
+					call("HSETNX", key, field, value) > 0
 				end
 				
 				# Set multiple hash fields to multiple values. O(N) where N is the number of fields being set.
-				# @see https://redis.io/commands/hmset
-				# @param key [Key]
-				# @return [String] default: "OK"
+				# See <https://redis.io/commands/hmset> for more details.
+				# @parameter key [Key]
+				# @returns [String] default: "OK"
 				def hmset(key, *attrs)
-					call('HMSET', key, *attrs)
+					call("HMSET", key, *attrs)
 				end
-
+				
 				# Set multiple hash fields to multiple values, by providing a hash
 				#
 				# @example
 				#   redis.mapped_hmset("hash", { "f1" => "v1", "f2" => "v2" })
 				#     # => "OK"
 				#
-				# @param key [Key]
-				# @param hash [Hash] a non-empty hash with fields mapping to values
-				# @return [String] default: "OK"
+				# @parameter key [Key]
+				# @parameter hash [Hash] a non-empty hash with fields mapping to values
+				# @returns [String] default: "OK"
 				#
-				# @see #hmset
+				# See <#hmset> for more details.
 				def mapped_hmset(key, hash)
 					hmset(key, *hash.flatten)
 				end
 				
 				# Get the value of a hash field. O(1).
-				# @see https://redis.io/commands/hget
-				# @param key [Key]
-				# @param field [String]
-				# @return [String, Null]
+				# See <https://redis.io/commands/hget> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @returns [String, Null]
 				def hget(key, field)
-					call('HGET', key, field)
+					call("HGET", key, field)
 				end
 				
 				# Get the values of all the given hash fields. O(N) where N is the number of fields being requested.
-				# @see https://redis.io/commands/hmget
-				# @param key [Key]
-				# @param fields [Array<String>] array of fields
-				# @return [Array]
+				# See <https://redis.io/commands/hmget> for more details.
+				# @parameter key [Key]
+				# @parameter fields [Array(String)] array of fields
+				# @returns [Array]
 				def hmget(key, *fields)
-					call('HMGET', key, *fields)
+					call("HMGET", key, *fields)
 				end
-
+				
 				# Get the values of all the given hash fields and return as array
 				#
 				# @example
 				#   redis.mapped_hmget("hash", "f1", "f2")
 				#     # => { "f1" => "v1", "f2" => "v2" }
 				#
-				# @param key [Key]
-				# @param fields [Array<String>] array of fields
-				# @return [Hash] a hash mapping the specified fields to their values
+				# @parameter key [Key]
+				# @parameter fields [Array(String)] array of fields
+				# @returns [Hash] a hash mapping the specified fields to their values
 				#
-				# @see #hmget
+				# See <#hmget> for more details.
 				def mapped_hmget(key, *fields)
 					reply = hmget(key, *fields)
 					Hash[fields.zip(reply)]
 				end
-
+				
 				# Delete one or more hash fields. O(N) where N is the number of fields to be removed.
-				# @see https://redis.io/commands/hdel
-				# @param key [Key]
-				# @param field [String]
-				# @return [Integer] number of deleted fields
+				# See <https://redis.io/commands/hdel> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @returns [Integer] number of deleted fields
 				def hdel(key, *fields)
-					call('HDEL', key, *fields)
+					call("HDEL", key, *fields)
 				end
 				
 				# Determine if a hash field exists. O(1).
-				# @see https://redis.io/commands/hexists
-				# @param key [Key]
-				# @param field [String]
-				# @return [Boolean]
+				# See <https://redis.io/commands/hexists> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @returns [Boolean]
 				def hexists(key, field)
-					call('HEXISTS', key, field) > 0
+					call("HEXISTS", key, field) > 0
 				end
 				
 				# Increment the integer value of a hash field by the given number. O(1).
-				# @see https://redis.io/commands/hincrby
-				# @param key [Key]
-				# @param field [String]
-				# @param increment [Integer]
-				# @return [Integer] field value after increment
+				# See <https://redis.io/commands/hincrby> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @parameter increment [Integer]
+				# @returns [Integer] field value after increment
 				def hincrby(key, field, increment)
-					call('HINCRBY', key, field, increment)
+					call("HINCRBY", key, field, increment)
 				end
 				
 				# Increment the float value of a hash field by the given amount. O(1).
-				# @see https://redis.io/commands/hincrbyfloat
-				# @param key [Key]
-				# @param field [String]
-				# @param increment [Double]
-				# @return [Float] field value after increment
+				# See <https://redis.io/commands/hincrbyfloat> for more details.
+				# @parameter key [Key]
+				# @parameter field [String]
+				# @parameter increment [Double]
+				# @returns [Float] field value after increment
 				def hincrbyfloat(key, field, increment)
-					Float(call('HINCRBYFLOAT', key, field, increment))
+					Float(call("HINCRBYFLOAT", key, field, increment))
 				end
 				
 				# Get all the fields in a hash. O(N) where N is the size of the hash.
-				# @see https://redis.io/commands/hkeys
-				# @param key [Key]
-				# @return [Array]
+				# See <https://redis.io/commands/hkeys> for more details.
+				# @parameter key [Key]
+				# @returns [Array]
 				def hkeys(key)
-					call('HKEYS', key)
+					call("HKEYS", key)
 				end
 				
 				# Get all the values in a hash. O(N) where N is the size of the hash.
-				# @see https://redis.io/commands/hvals
-				# @param key [Key]
-				# @return [Array]
+				# See <https://redis.io/commands/hvals> for more details.
+				# @parameter key [Key]
+				# @returns [Array]
 				def hvals(key)
-					call('HVALS', key)
+					call("HVALS", key)
 				end
 				
 				# Get all the fields and values in a hash. O(N) where N is the size of the hash.
-				# @see https://redis.io/commands/hgetall
-				# @param key [Key]
-				# @return [Hash]
+				# See <https://redis.io/commands/hgetall> for more details.
+				# @parameter key [Key]
+				# @returns [Hash]
 				def hgetall(key)
-					call('HGETALL', key).each_slice(2).to_h
+					call("HGETALL", key).each_slice(2).to_h
 				end
-
+				
 				# Iterates fields of Hash types and their associated values. O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
-				# @see https://redis.io/commands/hscan/
-				# @param cursor [Cursor]
-				# @return [Hash]
+				# See <https://redis.io/commands/hscan/> for more details.
+				# @parameter cursor [Cursor]
+				# @returns [Hash]
 				def hscan(key, cursor = "0", match: nil, count: nil)
 					arguments = [key, cursor]
-
+					
 					if match
 						arguments.append("MATCH", match)
 					end
-
+					
 					if count
 						arguments.append("COUNT", count)
 					end
-
+					
 					call("HSCAN", *arguments)
 				end
 				
 				# Iterate over each field and the value of the hash, using HSCAN.
 				def hscan_each(key, cursor = "0", match: nil, count: nil, &block)
 					return enum_for(:hscan_each, key, cursor, match: match, count: count) unless block_given?
-
+					
 					while true
 						cursor, data = hscan(key, cursor, match: match, count: count)
-
+						
 						data.each_slice(2, &block)
-
+						
 						break if cursor == "0"
 					end
 				end

data/lib/protocol/redis/methods/lists.rb

@@ -7,74 +7,75 @@
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis lists.
 			module Lists
 				# Remove and get the first element in a list, or block until one is available. O(1).
-				# @see https://redis.io/commands/blpop
-				# @param key [Key]
-				# @param timeout [Integer]
+				# See <https://redis.io/commands/blpop> for more details.
+				# @parameter key [Key]
+				# @parameter timeout [Integer]
 				def blpop(*keys, timeout: 0)
-					call('BLPOP', *keys, timeout)
+					call("BLPOP", *keys, timeout)
 				end
 				
 				# Remove and get the last element in a list, or block until one is available. O(1).
-				# @see https://redis.io/commands/brpop
-				# @param key [Key]
-				# @param timeout [Integer]
+				# See <https://redis.io/commands/brpop> for more details.
+				# @parameter key [Key]
+				# @parameter timeout [Integer]
 				def brpop(*keys, timeout: 0)
-					call('BRPOP', *keys, timeout)
+					call("BRPOP", *keys, timeout)
 				end
 				
 				# Pop an element from a list, push it to another list and return it; or block until one is available. O(1).
-				# @see https://redis.io/commands/brpoplpush
-				# @param source [Key]
-				# @param destination [Key]
-				# @param timeout [Integer]
+				# See <https://redis.io/commands/brpoplpush> for more details.
+				# @parameter source [Key]
+				# @parameter destination [Key]
+				# @parameter timeout [Integer]
 				def brpoplpush(source, destination, timeout)
-					call('BRPOPLPUSH', source, destination, timeout)
+					call("BRPOPLPUSH", source, destination, timeout)
 				end
 				
 				# Get an element from a list by its index. O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
-				# @see https://redis.io/commands/lindex
-				# @param key [Key]
-				# @param index [Integer]
+				# See <https://redis.io/commands/lindex> for more details.
+				# @parameter key [Key]
+				# @parameter index [Integer]
 				def lindex(key, index)
-					call('LINDEX', key, index)
+					call("LINDEX", key, index)
 				end
 				
 				# Insert an element before or after another element in a list. O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
-				# @see https://redis.io/commands/linsert
-				# @param key [Key]
-				# @param where [Enum]
-				# @param pivot [String]
-				# @param element [String]
+				# See <https://redis.io/commands/linsert> for more details.
+				# @parameter key [Key]
+				# @parameter where [Enum]
+				# @parameter pivot [String]
+				# @parameter element [String]
 				def linsert(key, position=:before, index, value)
 					if position == :before
-						offset = 'BEFORE'
+						offset = "BEFORE"
 					else
-						offset = 'AFTER'
+						offset = "AFTER"
 					end
 					
-					call('LINSERT', key, offset, index, value)
+					call("LINSERT", key, offset, index, value)
 				end
 				
 				# Get the length of a list. O(1).
-				# @see https://redis.io/commands/llen
-				# @param key [Key]
+				# See <https://redis.io/commands/llen> for more details.
+				# @parameter key [Key]
 				def llen(key)
-					call('LLEN', key)
+					call("LLEN", key)
 				end
 				
 				# Remove and get the first element in a list. O(1).
-				# @see https://redis.io/commands/lpop
-				# @param key [Key]
+				# See <https://redis.io/commands/lpop> for more details.
+				# @parameter key [Key]
 				def lpop(key)
-					call('LPOP', key)
+					call("LPOP", key)
 				end
 				
 				# Prepend one or multiple elements to a list. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
-				# @see https://redis.io/commands/lpush
-				# @param key [Key]
-				# @param element [String]
+				# See <https://redis.io/commands/lpush> for more details.
+				# @parameter key [Key]
+				# @parameter element [String]
 				def lpush(key, value, *values)
 					case value
 					when Array
@@ -83,74 +84,74 @@ module Protocol
 						values = [value] + values
 					end
 					
-					call('LPUSH', key, *values)
+					call("LPUSH", key, *values)
 				end
 				
 				# Prepend an element to a list, only if the list exists. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
-				# @see https://redis.io/commands/lpushx
-				# @param key [Key]
-				# @param element [String]
+				# See <https://redis.io/commands/lpushx> for more details.
+				# @parameter key [Key]
+				# @parameter element [String]
 				def lpushx(key, value)
-					call('LPUSHX', key, value)
+					call("LPUSHX", key, value)
 				end
 				
 				# Get a range of elements from a list. O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
-				# @see https://redis.io/commands/lrange
-				# @param key [Key]
-				# @param start [Integer]
-				# @param stop [Integer]
+				# See <https://redis.io/commands/lrange> for more details.
+				# @parameter key [Key]
+				# @parameter start [Integer]
+				# @parameter stop [Integer]
 				def lrange(key, start, stop)
-					call('LRANGE', key, start, stop)
+					call("LRANGE", key, start, stop)
 				end
 				
 				# Remove elements from a list. O(N+M) where N is the length of the list and M is the number of elements removed.
-				# @see https://redis.io/commands/lrem
-				# @param key [Key]
-				# @param count [Integer]
-				# @param element [String]
+				# See <https://redis.io/commands/lrem> for more details.
+				# @parameter key [Key]
+				# @parameter count [Integer]
+				# @parameter element [String]
 				def lrem(key, count, value)
-					call('LREM', key, count, value)
+					call("LREM", key, count, value)
 				end
 				
 				# Set the value of an element in a list by its index. O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
-				# @see https://redis.io/commands/lset
-				# @param key [Key]
-				# @param index [Integer]
-				# @param element [String]
+				# See <https://redis.io/commands/lset> for more details.
+				# @parameter key [Key]
+				# @parameter index [Integer]
+				# @parameter element [String]
 				def lset(key, index, values)
-					call('LSET', key, index, values)
+					call("LSET", key, index, values)
 				end
 				
 				# Trim a list to the specified range. O(N) where N is the number of elements to be removed by the operation.
-				# @see https://redis.io/commands/ltrim
-				# @param key [Key]
-				# @param start [Integer]
-				# @param stop [Integer]
+				# See <https://redis.io/commands/ltrim> for more details.
+				# @parameter key [Key]
+				# @parameter start [Integer]
+				# @parameter stop [Integer]
 				def ltrim(key, start, stop)
-					call('LTRIM', key, start, stop)
+					call("LTRIM", key, start, stop)
 				end
 				
 				# Remove and get the last element in a list. O(1).
-				# @see https://redis.io/commands/rpop
-				# @param key [Key]
+				# See <https://redis.io/commands/rpop> for more details.
+				# @parameter key [Key]
 				def rpop(key)
-					call('RPOP', key)
+					call("RPOP", key)
 				end
 				
 				# Remove the last element in a list, prepend it to another list and return it. O(1).
-				# @see https://redis.io/commands/rpoplpush
-				# @param source [Key]
-				# @param destination [Key]
+				# See <https://redis.io/commands/rpoplpush> for more details.
+				# @parameter source [Key]
+				# @parameter destination [Key]
 				def rpoplpush(source, destination=nil)
 					destination = source if destination.nil?
 					
-					call('RPOPLPUSH', source, destination)
+					call("RPOPLPUSH", source, destination)
 				end
 				
 				# Append one or multiple elements to a list. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
-				# @see https://redis.io/commands/rpush
-				# @param key [Key]
-				# @param element [String]
+				# See <https://redis.io/commands/rpush> for more details.
+				# @parameter key [Key]
+				# @parameter element [String]
 				def rpush(key, value, *values)
 					case value
 					when Array
@@ -159,15 +160,15 @@ module Protocol
 						values = [value] + values
 					end
 					
-					call('RPUSH', key, *values)
+					call("RPUSH", key, *values)
 				end
 				
 				# Append an element to a list, only if the list exists. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
-				# @see https://redis.io/commands/rpushx
-				# @param key [Key]
-				# @param element [String]
+				# See <https://redis.io/commands/rpushx> for more details.
+				# @parameter key [Key]
+				# @parameter element [String]
 				def rpushx(key, value)
-					call('RPUSHX', key, value)
+					call("RPUSHX", key, value)
 				end
 			end
 		end

data/lib/protocol/redis/methods/pubsub.rb

@@ -6,13 +6,14 @@
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis Pub/Sub.
 			module Pubsub
 				# Post a message to a channel.
-				# @see https://redis.io/commands/publish
-				# @param channel [String]
-				# @param message [String]
+				# See <https://redis.io/commands/publish> for more details.
+				# @parameter channel [String]
+				# @parameter message [String]
 				def publish(channel, message)
-					call('PUBLISH', channel, message)
+					call("PUBLISH", channel, message)
 				end
 			end
 		end

data/lib/protocol/redis/methods/scripting.rb

@@ -7,31 +7,32 @@
 module Protocol
 	module Redis
 		module Methods
+			# Mehtods for managing Redis scripting.
 			module Scripting
 				# Execute a Lua script server side. Depends on the script that is executed.
-				# @see https://redis.io/commands/eval
-				# @param script [String]
-				# @param numkeys [Integer]
-				# @param key [Key] Multiple keys are supported, as long as the same number of values are also provided
-				# @param arg [String]
+				# See <https://redis.io/commands/eval> for more details.
+				# @parameter script [String]
+				# @parameter numkeys [Integer]
+				# @parameter key [Key] Multiple keys are supported, as long as the same number of values are also provided
+				# @parameter arg [String]
 				def eval(*arguments)
 					call("EVAL", *arguments)
 				end
 				
 				# Execute a Lua script server side. Depends on the script that is executed.
-				# @see https://redis.io/commands/evalsha
-				# @param sha1 [String]
-				# @param numkeys [Integer]
-				# @param key [Key]
-				# @param arg [String]
+				# See <https://redis.io/commands/evalsha> for more details.
+				# @parameter sha1 [String]
+				# @parameter numkeys [Integer]
+				# @parameter key [Key]
+				# @parameter arg [String]
 				def evalsha(*arguments)
 					call("EVALSHA", *arguments)
 				end
 				
 				# Execute script management commands
-				# @see https://redis.io/commands/script/
-				# @param subcommand [String] e.g. `debug`, `exists`, `flush`, `load`, `kill`
-				# @param [Array<String>] args depends on the subcommand provided
+				# See <https://redis.io/commands/script/> for more details.
+				# @parameter subcommand [String] e.g. `debug`, `exists`, `flush`, `load`, `kill`
+				# @parameter [Array(String)] arguments depends on the subcommand provided
 				def script(subcommand, *arguments)
 					call("SCRIPT", subcommand.to_s, *arguments)
 				end

data/lib/protocol/redis/methods/server.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2020, by David Ortiz.
 
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis servers.
 			module Server
 				# Get information and statistics about the server.
-				# @see https://redis.io/commands/info
-				# @param section [String]
+				# See <https://redis.io/commands/info> for more details.
+				# @parameter section [String]
 				def info
 					metadata = {}
 					
-					call('INFO').each_line(Redis::Connection::CRLF) do |line|
-						key, value = line.split(':')
+					call("INFO").each_line(Redis::Connection::CRLF) do |line|
+						key, value = line.split(":")
 						
 						if value
 							metadata[key.to_sym] = value.chomp!
@@ -25,11 +26,30 @@ module Protocol
 					return metadata
 				end
 				
+				# Get the client information for the current connection.
+				# See <https://redis.io/commands/client-info> for more details.
+				# @returns [Hash] A hash containing client metadata.
+				def client_info
+					metadata = {}
+					
+					call("CLIENT", "INFO").split(/\s+/).each do |pair|
+						key, value = pair.split("=")
+						
+						if value
+							metadata[key.to_sym] = value
+						else
+							metadata[key.to_sym] = nil
+						end
+					end
+					
+					return metadata
+				end
+				
 				# Remove all keys from the current database.
-				# @see https://redis.io/commands/flushdb
-				# @param async [Enum]
+				# See <https://redis.io/commands/flushdb> for more details.
+				# @parameter async [Enum]
 				def flushdb!
-					call('FLUSHDB')
+					call("FLUSHDB")
 				end
 			end
 		end