protocol-redis 0.8.1 → 0.10.0

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

@@ -4,82 +4,83 @@
 # Copyright, 2019-2023, by Samuel Williams.
 # Copyright, 2021, by Troex Nevelin.
 
-require 'date'
+require "date"
 
 module Protocol
 	module Redis
 		module Methods
+			# Methods for interacting with Redis keys.
 			module Generic
 				# Delete a key. O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
-				# @see https://redis.io/commands/del
-				# @param key [Key]
+				# See <https://redis.io/commands/del> for more details.
+				# @parameter key [Key]
 				def del(*keys)
 					if keys.any?
-						call('DEL', *keys)
+						call("DEL", *keys)
 					end
 				end
 				
 				# Return a serialized version of the value stored at the specified key. O(1) to access the key and additional O(N*M) to serialized it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).
-				# @see https://redis.io/commands/dump
-				# @param key [Key]
+				# See <https://redis.io/commands/dump> for more details.
+				# @parameter key [Key]
 				def dump(key)
-					call('DUMP', key)
+					call("DUMP", key)
 				end
 				
 				# Determine if a key exists. O(1).
-				# @see https://redis.io/commands/exists
-				# @param key [Key]
-				# @return [Integer]
+				# See <https://redis.io/commands/exists> for more details.
+				# @parameter key [Key]
+				# @returns [Integer]
 				def exists(key, *keys)
-					call('EXISTS', key, *keys)
+					call("EXISTS", key, *keys)
 				end
 				
 				# Boolean oversion of `exists`
-				# @param key [Key]
-				# @return [Boolean]
+				# @parameter key [Key]
+				# @returns [Boolean]
 				def exists?(key, *keys)
 					exists(key, *keys) > 0
 				end
 				
 				# Set a key's time to live in seconds. O(1).
-				# @see https://redis.io/commands/expire
-				# @param key [Key]
-				# @param seconds [Integer]
+				# See <https://redis.io/commands/expire> for more details.
+				# @parameter key [Key]
+				# @parameter seconds [Integer]
 				def expire(key, seconds)
-					call('EXPIRE', key, seconds)
+					call("EXPIRE", key, seconds)
 				end
 				
 				# Set the expiration for a key as a UNIX timestamp. O(1).
-				# @see https://redis.io/commands/expireat
-				# @param key [Key]
-				# @param timestamp [Posix time]
+				# See <https://redis.io/commands/expireat> for more details.
+				# @parameter key [Key]
+				# @parameter timestamp [Posix time]
 				def expireat(key, time)
 					case time
 					when DateTime, Time, Date
-						timestamp = time.strftime('%s').to_i
+						timestamp = time.strftime("%s").to_i
 					else
 						timestamp = time
 					end
 					
-					call('EXPIREAT', key, timestamp)
+					call("EXPIREAT", key, timestamp)
 				end
 				
 				# Find all keys matching the given pattern. O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
-				# @see https://redis.io/commands/keys
-				# @param pattern [Pattern]
+				# See <https://redis.io/commands/keys> for more details.
+				# @parameter pattern [Pattern]
 				def keys(pattern)
-					call('KEYS', pattern)
+					call("KEYS", pattern)
 				end
 				
 				# Atomically transfer a key from a Redis instance to another one. This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
-				# @see https://redis.io/commands/migrate
-				# @param host [String]
-				# @param port [String]
-				# @param key [Enum]
-				# @param destination-db [Integer]
-				# @param timeout [Integer]
-				# @param copy [Enum]
-				# @param replace [Enum]
+				# See <https://redis.io/commands/migrate> for more details.
+				# @parameter host [String]
+				# @parameter port [String]
+				# @parameter key [Enum]
+				# @parameter destination-db [Integer]
+				# @parameter timeout [Integer]
+				# @parameter copy [Enum]
+				# @parameter replace [Enum]
 				def migrate(host, port, destination = 0, keys:, timeout: 0, copy: false, replace: false, auth: nil)
 					raise ArgumentError, "Must provide keys" if keys.empty?
 					
@@ -113,94 +114,94 @@ module Protocol
 				end
 				
 				# Move a key to another database. O(1).
-				# @see https://redis.io/commands/move
-				# @param key [Key]
-				# @param db [Integer]
+				# See <https://redis.io/commands/move> for more details.
+				# @parameter key [Key]
+				# @parameter db [Integer]
 				def move(key, db)
-					call('MOVE', key, db)
+					call("MOVE", key, db)
 				end
 				
 				# Inspect the internals of Redis objects. O(1) for all the currently implemented subcommands.
-				# @see https://redis.io/commands/object
-				# @param subcommand [String]
-				# @param arguments [String]
+				# See <https://redis.io/commands/object> for more details.
+				# @parameter subcommand [String]
+				# @parameter arguments [String]
 				def object(subcommand, *arguments)
-					call('OBJECT', subcommand, *arguments)
+					call("OBJECT", subcommand, *arguments)
 				end
 				
 				# Remove the expiration from a key. O(1).
-				# @see https://redis.io/commands/persist
-				# @param key [Key]
+				# See <https://redis.io/commands/persist> for more details.
+				# @parameter key [Key]
 				def persist(key)
-					call('PERSIST', key)
+					call("PERSIST", key)
 				end
 				
 				# Set a key's time to live in milliseconds. O(1).
-				# @see https://redis.io/commands/pexpire
-				# @param key [Key]
-				# @param milliseconds [Integer]
+				# See <https://redis.io/commands/pexpire> for more details.
+				# @parameter key [Key]
+				# @parameter milliseconds [Integer]
 				def pexpire(key, milliseconds)
-					call('PEXPIRE', milliseconds)
+					call("PEXPIRE", key, milliseconds)
 				end
 				
 				# Set the expiration for a key as a UNIX timestamp specified in milliseconds. O(1).
-				# @see https://redis.io/commands/pexpireat
-				# @param key [Key]
-				# @param milliseconds-timestamp [Posix time]
+				# See <https://redis.io/commands/pexpireat> for more details.
+				# @parameter key [Key]
+				# @parameter milliseconds-timestamp [Posix time]
 				def pexpireat(key, time)
-					case time.class
+					case time
 					when DateTime, Time, Date 
-						timestamp =  time.strftime('%Q').to_i
+						timestamp = (time.to_f * 1000).to_i
 					else
 						timestamp = time
 					end
 					
-					call('PEXPIREAT', key, timestamp)
+					call("PEXPIREAT", key, timestamp)
 				end
 				
 				# Get the time to live for a key in milliseconds. O(1).
-				# @see https://redis.io/commands/pttl
-				# @param key [Key]
+				# See <https://redis.io/commands/pttl> for more details.
+				# @parameter key [Key]
 				def pttl(key)
-					call('PTTL', key)
+					call("PTTL", key)
 				end
 				
 				# Return a random key from the keyspace. O(1).
-				# @see https://redis.io/commands/randomkey
+				# See <https://redis.io/commands/randomkey> for more details.
 				def randomkey
-					call('RANDOMKEY')
+					call("RANDOMKEY")
 				end
 				
 				# Rename a key. O(1).
-				# @see https://redis.io/commands/rename
-				# @param key [Key]
-				# @param newkey [Key]
+				# See <https://redis.io/commands/rename> for more details.
+				# @parameter key [Key]
+				# @parameter newkey [Key]
 				def rename(key, new_key)
-					call('RENAME', key, new_key)
+					call("RENAME", key, new_key)
 				end
 				
 				# Rename a key, only if the new key does not exist. O(1).
-				# @see https://redis.io/commands/renamenx
-				# @param key [Key]
-				# @param newkey [Key]
+				# See <https://redis.io/commands/renamenx> for more details.
+				# @parameter key [Key]
+				# @parameter newkey [Key]
 				def renamenx(key, new_key)
-					call('RENAMENX', key, new_key)
+					call("RENAMENX", key, new_key)
 				end
 				
 				# Create a key using the provided serialized value, previously obtained using DUMP. O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).
-				# @see https://redis.io/commands/restore
-				# @param key [Key]
-				# @param ttl [Integer]
-				# @param serialized-value [String]
-				# @param replace [Enum]
-				# @param absttl [Enum]
+				# See <https://redis.io/commands/restore> for more details.
+				# @parameter key [Key]
+				# @parameter ttl [Integer]
+				# @parameter serialized-value [String]
+				# @parameter replace [Enum]
+				# @parameter absttl [Enum]
 				def restore(key, serialized_value, ttl=0)
-					call('RESTORE', key, ttl, serialized_value)
+					call("RESTORE", key, ttl, serialized_value)
 				end
 				
 				# Incrementally iterate the keys space. 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/scan
-				# @param cursor [Integer]
+				# See <https://redis.io/commands/scan> for more details.
+				# @parameter cursor [Integer]
 				def scan(cursor, match: nil, count: nil, type: nil)
 					arguments = [cursor]
 					
@@ -220,11 +221,11 @@ module Protocol
 				end
 				
 				# Sort the elements in a list, set or sorted set. O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is currently O(N) as there is a copy step that will be avoided in next releases.
-				# @see https://redis.io/commands/sort
-				# @param key [Key]
-				# @param order [Enum]
-				# @param sorting [Enum]
-				def sort(key, by: nil, offset: nil, count: nil, get: nil, order: 'ASC', alpha: false, store: nil)
+				# See <https://redis.io/commands/sort> for more details.
+				# @parameter key [Key]
+				# @parameter order [Enum]
+				# @parameter sorting [Enum]
+				def sort(key, by: nil, offset: nil, count: nil, get: nil, order: "ASC", alpha: false, store: nil)
 					arguments = []
 					
 					if by
@@ -251,42 +252,42 @@ module Protocol
 						arguments.append("STORE", store)
 					end
 					
-					call('SORT', *arguments)
+					call("SORT", key, *arguments)
 				end
 				
 				# Alters the last access time of a key(s). Returns the number of existing keys specified. O(N) where N is the number of keys that will be touched.
-				# @see https://redis.io/commands/touch
-				# @param key [Key]
+				# See <https://redis.io/commands/touch> for more details.
+				# @parameter key [Key]
 				def touch(key, *keys)
-					call('TOUCH', key, *keys)
+					call("TOUCH", key, *keys)
 				end
 				
 				# Get the time to live for a key. O(1).
-				# @see https://redis.io/commands/ttl
-				# @param key [Key]
+				# See <https://redis.io/commands/ttl> for more details.
+				# @parameter key [Key]
 				def ttl(key)
-					call('TTL', key)
+					call("TTL", key)
 				end
 				
 				# Determine the type stored at key. O(1).
-				# @see https://redis.io/commands/type
-				# @param key [Key]
+				# See <https://redis.io/commands/type> for more details.
+				# @parameter key [Key]
 				def type(key)
-					call('TYPE', key)
+					call("TYPE", key)
 				end
 				
 				# Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking. O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
-				# @see https://redis.io/commands/unlink
-				# @param key [Key]
+				# See <https://redis.io/commands/unlink> for more details.
+				# @parameter key [Key]
 				def unlink(key)
-					call('UNLINK', key)
+					call("UNLINK", key)
 				end
-					
+				
 				# Wait for the synchronous replication of all the write commands sent in the context of the current connection. O(1).
-				# @see https://redis.io/commands/wait
-				# @param numreplicas [Integer]
-				# @param timeout [Integer]
-				def wait(newreplicas, timeout = 0)
+				# See <https://redis.io/commands/wait> for more details.
+				# @parameter numreplicas [Integer]
+				# @parameter timeout [Integer]
+				def wait(numreplicas, timeout = 0)
 					call("WAIT", numreplicas, timeout)
 				end
 			end

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

@@ -6,54 +6,55 @@
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis geospatial indexes.
 			module Geospatial
 				# Add one or more geospatial items in the geospatial index represented using a sorted set. O(log(N)) for each item added, where N is the number of elements in the sorted set.
-				# @see https://redis.io/commands/geoadd
-				# @param key [Key]
+				# See <https://redis.io/commands/geoadd> for more details.
+				# @parameter key [Key]
 				def geoadd(key, longitude, latitude, member, *arguments)
-					call("GEOADD", longitude, latitude, member, *arguments)
+					call("GEOADD", key, longitude, latitude, member, *arguments)
 				end
 				
 				# Returns members of a geospatial index as standard geohash strings. O(log(N)) for each member requested, where N is the number of elements in the sorted set.
-				# @see https://redis.io/commands/geohash
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/geohash> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def geohash(key, member, *members)
 					call("GEOHASH", key, member, *members)
 				end
 				
 				# Returns longitude and latitude of members of a geospatial index. O(log(N)) for each member requested, where N is the number of elements in the sorted set.
-				# @see https://redis.io/commands/geopos
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/geopos> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def geopos(key, member, *members)
 					call("GEOPOS", key, member, *members)
 				end
 				
 				# Returns the distance between two members of a geospatial index. O(log(N)).
-				# @see https://redis.io/commands/geodist
-				# @param key [Key]
-				# @param member1 [String]
-				# @param member2 [String]
-				# @param unit [Enum] Distance scale to use, one of "m" (meters), "km" (kilometers), "mi" (miles) or "ft" (feet).
+				# See <https://redis.io/commands/geodist> for more details.
+				# @parameter key [Key]
+				# @parameter member1 [String]
+				# @parameter member2 [String]
+				# @parameter unit [Enum] Distance scale to use, one of "m" (meters), "km" (kilometers), "mi" (miles) or "ft" (feet).
 				def geodist(key, from, to, unit = "m")
 					call("GEODIST", key, from, to, unit)
 				end
 				
 				# Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point. O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
-				# @see https://redis.io/commands/georadius
-				# @param key [Key]
-				# @param longitude [Double]
-				# @param latitude [Double]
-				# @param radius [Double]
-				# @param unit [Enum]
-				# @param count [Integer] Limit the number of results to at most this many.
-				# @param order [Symbol] `:ASC` Sort returned items from the nearest to the farthest, relative to the center. `:DESC` Sort returned items from the farthest to the nearest, relative to the center.
-				# @param with_coordinates [Boolean] Also return the longitude,latitude coordinates of the matching items.
-				# @param with_distance [Boolean] Also return the distance of the returned items from the specified center. The distance is returned in the same unit as the unit specified as the radius argument of the command.
-				# @param with_hash [Boolean] Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
-				# @param store [Key]
-				# @param store_distance [Key]
+				# See <https://redis.io/commands/georadius> for more details.
+				# @parameter key [Key]
+				# @parameter longitude [Double]
+				# @parameter latitude [Double]
+				# @parameter radius [Double]
+				# @parameter unit [Enum]
+				# @parameter count [Integer] Limit the number of results to at most this many.
+				# @parameter order [Symbol] `:ASC` Sort returned items from the nearest to the farthest, relative to the center. `:DESC` Sort returned items from the farthest to the nearest, relative to the center.
+				# @parameter with_coordinates [Boolean] Also return the longitude,latitude coordinates of the matching items.
+				# @parameter with_distance [Boolean] Also return the distance of the returned items from the specified center. The distance is returned in the same unit as the unit specified as the radius argument of the command.
+				# @parameter with_hash [Boolean] Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
+				# @parameter store [Key]
+				# @parameter store_distance [Key]
 				def georadius(key, longitude, latitude, radius, unit = "m", with_coordinates: false, with_distance: false, with_hash: false, count: nil, order: nil, store: nil, store_distance: nil)
 					arguments = [key, longitude, latitude, radius, unit]
 					
@@ -85,7 +86,7 @@ module Protocol
 					end
 					
 					if store_distance
-						arguments.append("STOREDIST", storedist)
+						arguments.append("STOREDIST", store_distance)
 						readonly = false
 					end
 					
@@ -98,18 +99,18 @@ module Protocol
 				end
 				
 				# Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member. O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
-				# @see https://redis.io/commands/georadiusbymember
-				# @param key [Key]
-				# @param member [String]
-				# @param radius [Double]
-				# @param unit [Enum]
-				# @param count [Integer] Limit the number of results to at most this many.
-				# @param order [Symbol] `:ASC` Sort returned items from the nearest to the farthest, relative to the center. `:DESC` Sort returned items from the farthest to the nearest, relative to the center.
-				# @param with_coordinates [Boolean] Also return the longitude,latitude coordinates of the matching items.
-				# @param with_distance [Boolean] Also return the distance of the returned items from the specified center. The distance is returned in the same unit as the unit specified as the radius argument of the command.
-				# @param with_hash [Boolean] Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
-				# @param store [Key]
-				# @param store_distance [Key]
+				# See <https://redis.io/commands/georadiusbymember> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
+				# @parameter radius [Double]
+				# @parameter unit [Enum]
+				# @parameter count [Integer] Limit the number of results to at most this many.
+				# @parameter order [Symbol] `:ASC` Sort returned items from the nearest to the farthest, relative to the center. `:DESC` Sort returned items from the farthest to the nearest, relative to the center.
+				# @parameter with_coordinates [Boolean] Also return the longitude,latitude coordinates of the matching items.
+				# @parameter with_distance [Boolean] Also return the distance of the returned items from the specified center. The distance is returned in the same unit as the unit specified as the radius argument of the command.
+				# @parameter with_hash [Boolean] Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
+				# @parameter store [Key]
+				# @parameter store_distance [Key]
 				def georadiusbymember(key, member, radius, unit = "m", with_coordinates: false, with_distance: false, with_hash: false, count: nil, order: nil, store: nil, store_distance: nil)
 					arguments = [key, member, radius, unit]
 					
@@ -133,14 +134,6 @@ module Protocol
 						arguments.append(order)
 					end
 					
-					if store
-						arguments.append("STORE", store)
-					end
-					
-					if store_distance
-						arguments.append("STOREDIST", storedist)
-					end
-					
 					readonly = true
 					
 					if store
@@ -149,7 +142,7 @@ module Protocol
 					end
 					
 					if store_distance
-						arguments.append("STOREDIST", storedist)
+						arguments.append("STOREDIST", store_distance)
 						readonly = false
 					end