protocol-redis 0.9.0 → 0.11.0

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

@@ -6,119 +6,120 @@
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis sets.
 			module Sets
 				# Add one or more members to a set. 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/sadd
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/sadd> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def sadd(*arguments)
 					call("SADD", *arguments)
 				end
 				
 				# Get the number of members in a set. O(1).
-				# @see https://redis.io/commands/scard
-				# @param key [Key]
+				# See <https://redis.io/commands/scard> for more details.
+				# @parameter key [Key]
 				def scard(*arguments)
 					call("SCARD", *arguments)
 				end
 				
 				# Subtract multiple sets. O(N) where N is the total number of elements in all given sets.
-				# @see https://redis.io/commands/sdiff
-				# @param key [Key]
+				# See <https://redis.io/commands/sdiff> for more details.
+				# @parameter key [Key]
 				def sdiff(*arguments)
 					call("SDIFF", *arguments)
 				end
 				
 				# Subtract multiple sets and store the resulting set in a key. O(N) where N is the total number of elements in all given sets.
-				# @see https://redis.io/commands/sdiffstore
-				# @param destination [Key]
-				# @param key [Key]
+				# See <https://redis.io/commands/sdiffstore> for more details.
+				# @parameter destination [Key]
+				# @parameter key [Key]
 				def sdiffstore(*arguments)
 					call("SDIFFSTORE", *arguments)
 				end
 				
 				# Intersect multiple sets. O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
-				# @see https://redis.io/commands/sinter
-				# @param key [Key]
+				# See <https://redis.io/commands/sinter> for more details.
+				# @parameter key [Key]
 				def sinter(*arguments)
 					call("SINTER", *arguments)
 				end
 				
 				# Intersect multiple sets and store the resulting set in a key. O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
-				# @see https://redis.io/commands/sinterstore
-				# @param destination [Key]
-				# @param key [Key]
+				# See <https://redis.io/commands/sinterstore> for more details.
+				# @parameter destination [Key]
+				# @parameter key [Key]
 				def sinterstore(*arguments)
 					call("SINTERSTORE", *arguments)
 				end
 				
 				# Determine if a given value is a member of a set. O(1).
-				# @see https://redis.io/commands/sismember
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/sismember> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def sismember(*arguments)
 					call("SISMEMBER", *arguments)
 				end
 				
 				# Get all the members in a set. O(N) where N is the set cardinality.
-				# @see https://redis.io/commands/smembers
-				# @param key [Key]
+				# See <https://redis.io/commands/smembers> for more details.
+				# @parameter key [Key]
 				def smembers(*arguments)
 					call("SMEMBERS", *arguments)
 				end
 				
 				# Move a member from one set to another. O(1).
-				# @see https://redis.io/commands/smove
-				# @param source [Key]
-				# @param destination [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/smove> for more details.
+				# @parameter source [Key]
+				# @parameter destination [Key]
+				# @parameter member [String]
 				def smove(*arguments)
 					call("SMOVE", *arguments)
 				end
 				
 				# Remove and return one or multiple random members from a set. O(1).
-				# @see https://redis.io/commands/spop
-				# @param key [Key]
-				# @param count [Integer]
+				# See <https://redis.io/commands/spop> for more details.
+				# @parameter key [Key]
+				# @parameter count [Integer]
 				def spop(*arguments)
 					call("SPOP", *arguments)
 				end
 				
 				# Get one or multiple random members from a set. Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.
-				# @see https://redis.io/commands/srandmember
-				# @param key [Key]
-				# @param count [Integer]
+				# See <https://redis.io/commands/srandmember> for more details.
+				# @parameter key [Key]
+				# @parameter count [Integer]
 				def srandmember(*arguments)
 					call("SRANDMEMBER", *arguments)
 				end
 				
 				# Remove one or more members from a set. O(N) where N is the number of members to be removed.
-				# @see https://redis.io/commands/srem
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/srem> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def srem(*arguments)
 					call("SREM", *arguments)
 				end
 				
 				# Add multiple sets. O(N) where N is the total number of elements in all given sets.
-				# @see https://redis.io/commands/sunion
-				# @param key [Key]
+				# See <https://redis.io/commands/sunion> for more details.
+				# @parameter key [Key]
 				def sunion(*arguments)
 					call("SUNION", *arguments)
 				end
 				
 				# Add multiple sets and store the resulting set in a key. O(N) where N is the total number of elements in all given sets.
-				# @see https://redis.io/commands/sunionstore
-				# @param destination [Key]
-				# @param key [Key]
+				# See <https://redis.io/commands/sunionstore> for more details.
+				# @parameter destination [Key]
+				# @parameter key [Key]
 				def sunionstore(*arguments)
 					call("SUNIONSTORE", *arguments)
 				end
 				
 				# Incrementally iterate Set elements. 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/sscan
-				# @param key [Key]
-				# @param cursor [Integer]
+				# See <https://redis.io/commands/sscan> for more details.
+				# @parameter key [Key]
+				# @parameter cursor [Integer]
 				def sscan(*arguments)
 					call("SSCAN", *arguments)
 				end

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

@@ -7,34 +7,35 @@
 module Protocol
 	module Redis
 		module Methods
+			# Methods for managing Redis sorted sets.
 			module SortedSets
 				# Remove and return the member with the lowest score from one or more sorted sets, or block until one is available. O(log(N)) with N being the number of elements in the sorted set.
-				# @see https://redis.io/commands/bzpopmin
-				# @param key [Key]
-				# @param timeout [Integer]
+				# See <https://redis.io/commands/bzpopmin> for more details.
+				# @parameter key [Key]
+				# @parameter timeout [Integer]
 				def bzpopmin(*keys, timeout: 0)
 					call("BZPOPMIN", *keys, timeout)
 				end
 				
 				# Remove and return the member with the highest score from one or more sorted sets, or block until one is available. O(log(N)) with N being the number of elements in the sorted set.
-				# @see https://redis.io/commands/bzpopmax
-				# @param key [Key]
-				# @param timeout [Integer]
+				# See <https://redis.io/commands/bzpopmax> for more details.
+				# @parameter key [Key]
+				# @parameter timeout [Integer]
 				def bzpopmax(*keys, timeout: 0)
-					call("BZPOPMAX", *keys, timeout: 0)
+					call("BZPOPMAX", *keys, timeout)
 				end
 				
 				# Add one or more members to a sorted set, or update its score if it already exists. O(log(N)) for each item added, where N is the number of elements in the sorted set.
-				# @see https://redis.io/commands/zadd
-				# @param key [Key]
-				# @param score [Double]
-				# @param member [String]
-				# @param others [Array] an array of `score`, `member` elements.
-				# @param update [Boolean, nil] If true, only update elements that already exist (never add elements). If false, don't update existing elements (only add new elements).
-				# @param change [Boolean] Modify the return value from the number of new elements added,
+				# See <https://redis.io/commands/zadd> for more details.
+				# @parameter key [Key]
+				# @parameter score [Double]
+				# @parameter member [String]
+				# @parameter others [Array] an array of `score`, `member` elements.
+				# @parameter update [Boolean, nil] If true, only update elements that already exist (never add elements). If false, don't update existing elements (only add new elements).
+				# @parameter change [Boolean] Modify the return value from the number of new elements added,
 				#   to the total number of elements changed; changed elements are new elements added
 				#   and elements already existing for which the score was updated.
-				# @param increment [Boolean] When this option is specified ZADD acts like ZINCRBY;
+				# @parameter increment [Boolean] When this option is specified ZADD acts like ZINCRBY;
 				#   only one score-element pair can be specified in this mode.
 				def zadd(key, score, member, *others, update: nil, change: false, increment: false)
 					arguments = ["ZADD", key]
@@ -55,36 +56,36 @@ module Protocol
 				end
 				
 				# Get the number of members in a sorted set. O(1).
-				# @see https://redis.io/commands/zcard
-				# @param key [Key]
+				# See <https://redis.io/commands/zcard> for more details.
+				# @parameter key [Key]
 				def zcard(key)
 					call("ZCARD", key)
 				end
 				
 				# Count the members in a sorted set with scores within the given values. O(log(N)) with N being the number of elements in the sorted set.
-				# @see https://redis.io/commands/zcount
-				# @param key [Key]
-				# @param min [Double]
-				# @param max [Double]
+				# See <https://redis.io/commands/zcount> for more details.
+				# @parameter key [Key]
+				# @parameter min [Double]
+				# @parameter max [Double]
 				def zcount(key, min, max)
 					call("ZCOUNT", key, min, max)
 				end
 				
 				# Increment the score of a member in a sorted set. O(log(N)) where N is the number of elements in the sorted set.
-				# @see https://redis.io/commands/zincrby
-				# @param key [Key]
-				# @param increment [Integer]
-				# @param member [String]
+				# See <https://redis.io/commands/zincrby> for more details.
+				# @parameter key [Key]
+				# @parameter increment [Integer]
+				# @parameter member [String]
 				def zincrby(key, increment, member)
-					call("ZINCRBY", key, amount, member)
+					call("ZINCRBY", key, increment, member)
 				end
 				
 				# Intersect multiple sorted sets and store the resulting sorted set in a new key. O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
-				# @see https://redis.io/commands/zinterstore
-				# @param destination [Key]
-				# @param keys [Array<Key>]
-				# @param weights [Array<Integer>]
-				# @param aggregate [Enum] one of sum, min, max.
+				# See <https://redis.io/commands/zinterstore> for more details.
+				# @parameter destination [Key]
+				# @parameter keys [Array(Key)]
+				# @parameter weights [Array(Integer)]
+				# @parameter aggregate [Enum] one of sum, min, max.
 				def zinterstore(destination, keys, weights = nil, aggregate: nil)
 					arguments = []
 					
@@ -105,36 +106,36 @@ module Protocol
 				end
 				
 				# Count the number of members in a sorted set between a given lexicographical range. O(log(N)) with N being the number of elements in the sorted set.
-				# @see https://redis.io/commands/zlexcount
-				# @param key [Key]
-				# @param min [String]
-				# @param max [String]
+				# See <https://redis.io/commands/zlexcount> for more details.
+				# @parameter key [Key]
+				# @parameter min [String]
+				# @parameter max [String]
 				def zlexcount(key, min, max)
 					call("ZLEXCOUNT", key, min, max)
 				end
 				
 				# Remove and return members with the highest scores in a sorted set. O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
-				# @see https://redis.io/commands/zpopmax
-				# @param key [Key]
-				# @param count [Integer]
+				# See <https://redis.io/commands/zpopmax> for more details.
+				# @parameter key [Key]
+				# @parameter count [Integer]
 				def zpopmax(key, count = 1)
 					call("ZPOPMAX", key, count)
 				end
 				
 				# Remove and return members with the lowest scores in a sorted set. O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
-				# @see https://redis.io/commands/zpopmin
-				# @param key [Key]
-				# @param count [Integer]
+				# See <https://redis.io/commands/zpopmin> for more details.
+				# @parameter key [Key]
+				# @parameter count [Integer]
 				def zpopmin(key, count = 1)
-					call("ZPOPMIN", key, count = 1)
+					call("ZPOPMIN", key, count)
 				end
 				
 				# Return a range of members in a sorted set, by index. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
-				# @see https://redis.io/commands/zrange
-				# @param key [Key]
-				# @param start [Integer]
-				# @param stop [Integer]
-				# @param with_scores [Boolean] Return the scores of the elements together with the elements.
+				# See <https://redis.io/commands/zrange> for more details.
+				# @parameter key [Key]
+				# @parameter start [Integer]
+				# @parameter stop [Integer]
+				# @parameter with_scores [Boolean] Return the scores of the elements together with the elements.
 				def zrange(key, start, stop, with_scores: false)
 					arguments = [start, stop]
 					
@@ -144,11 +145,11 @@ module Protocol
 				end
 				
 				# Return a range of members in a sorted set, by lexicographical range. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
-				# @see https://redis.io/commands/zrangebylex
-				# @param key [Key]
-				# @param min [String]
-				# @param max [String]
-				# @param limit [Tuple<offset, count>] Limit the results to the specified `offset` and `count` items.
+				# See <https://redis.io/commands/zrangebylex> for more details.
+				# @parameter key [Key]
+				# @parameter min [String]
+				# @parameter max [String]
+				# @parameter limit [Tuple(offset, count)] Limit the results to the specified `offset` and `count` items.
 				def zrangebylex(key, min, max, limit: nil)
 					if limit
 						arguments = ["LIMIT", *limit]
@@ -158,10 +159,10 @@ module Protocol
 				end
 				
 				# Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
-				# @see https://redis.io/commands/zrevrangebylex
-				# @param key [Key]
-				# @param max [String]
-				# @param min [String]
+				# See <https://redis.io/commands/zrevrangebylex> for more details.
+				# @parameter key [Key]
+				# @parameter max [String]
+				# @parameter min [String]
 				def zrevrangebylex(key, min, max, limit: nil)
 					if limit
 						arguments = ["LIMIT", *limit]
@@ -171,125 +172,125 @@ module Protocol
 				end
 				
 				# Return a range of members in a sorted set, by score. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
-				# @see https://redis.io/commands/zrangebyscore
-				# @param key [Key]
-				# @param min [Integer]
-				# @param max [Integer]
-				# @param with_scores [Boolean] Return the scores of the elements together with the elements.
-				# @param limit [Tuple<offset, count>] Limit the results to the specified `offset` and `count` items.
+				# See <https://redis.io/commands/zrangebyscore> for more details.
+				# @parameter key [Key]
+				# @parameter min [Integer]
+				# @parameter max [Integer]
+				# @parameter with_scores [Boolean] Return the scores of the elements together with the elements.
+				# @parameter limit [Tuple<offset, count>] Limit the results to the specified `offset` and `count` items.
 				#
 				# @example Retrieve the first 10 members with score `>= 0` and `<= 100`
 				# 	redis.zrangebyscore("zset", "0", "100", limit: [0, 10])
 				def zrangebyscore(key, min, max, with_scores: false, limit: nil)
 					arguments = [min, max]
 					
-					arguments.push('WITHSCORES') if with_scores
-					arguments.push('LIMIT', *limit) if limit
+					arguments.push("WITHSCORES") if with_scores
+					arguments.push("LIMIT", *limit) if limit
 					
-					call('ZRANGEBYSCORE', key, *arguments)
+					call("ZRANGEBYSCORE", key, *arguments)
 				end
 				
 				# Determine the index of a member in a sorted set. O(log(N)).
-				# @see https://redis.io/commands/zrank
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/zrank> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def zrank(key, member)
 					call("ZRANK", key, member)
 				end
 				
 				# Remove one or more members from a sorted set. O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
-				# @see https://redis.io/commands/zrem
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/zrem> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def zrem(key, member)
 					call("ZREM", key, member)
 				end
 				
 				# Remove all members in a sorted set between the given lexicographical range. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
-				# @see https://redis.io/commands/zremrangebylex
-				# @param key [Key]
-				# @param min [String]
-				# @param max [String]
+				# See <https://redis.io/commands/zremrangebylex> for more details.
+				# @parameter key [Key]
+				# @parameter min [String]
+				# @parameter max [String]
 				def zremrangebylex(key, min, max)
 					call("ZREMRANGEBYLEX", key, min, max)
 				end
 				
 				# Remove all members in a sorted set within the given indexes. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
-				# @see https://redis.io/commands/zremrangebyrank
-				# @param key [Key]
-				# @param start [Integer]
-				# @param stop [Integer]
+				# See <https://redis.io/commands/zremrangebyrank> for more details.
+				# @parameter key [Key]
+				# @parameter start [Integer]
+				# @parameter stop [Integer]
 				def zremrangebyrank(key, start, stop)
 					call("ZREMRANGEBYRANK", key, start, stop)
 				end
 				
 				# Remove all members in a sorted set within the given scores. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
-				# @see https://redis.io/commands/zremrangebyscore
-				# @param key [Key]
-				# @param min [Double]
-				# @param max [Double]
+				# See <https://redis.io/commands/zremrangebyscore> for more details.
+				# @parameter key [Key]
+				# @parameter min [Double]
+				# @parameter max [Double]
 				def zremrangebyscore(key, min, max)
 					call("ZREMRANGEBYSCORE", key, min, max)
 				end
 				
 				# Return a range of members in a sorted set, by index, with scores ordered from high to low. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
-				# @see https://redis.io/commands/zrevrange
-				# @param key [Key]
-				# @param start [Integer]
-				# @param stop [Integer]
-				# @param withscores [Enum]
+				# See <https://redis.io/commands/zrevrange> for more details.
+				# @parameter key [Key]
+				# @parameter start [Integer]
+				# @parameter stop [Integer]
+				# @parameter withscores [Enum]
 				def zrevrange(key, min, max, with_scores: false)
 					arguments = [min, max]
 					
-					arguments.push('WITHSCORES') if with_scores
+					arguments.push("WITHSCORES") if with_scores
 					
 					call("ZREVRANGE", key, *arguments)
 				end
 				
 				# Return a range of members in a sorted set, by score, with scores ordered from high to low. O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
-				# @see https://redis.io/commands/zrevrangebyscore
-				# @param key [Key]
-				# @param max [Double]
-				# @param min [Double]
-				# @param withscores [Enum]
+				# See <https://redis.io/commands/zrevrangebyscore> for more details.
+				# @parameter key [Key]
+				# @parameter max [Double]
+				# @parameter min [Double]
+				# @parameter withscores [Enum]
 				def zrevrangebyscore(key, min, max, with_scores: false, limit: nil)
 					arguments = [min, max]
 					
-					arguments.push('WITHSCORES') if with_scores
-					arguments.push('LIMIT', *limit) if limit
+					arguments.push("WITHSCORES") if with_scores
+					arguments.push("LIMIT", *limit) if limit
 					
 					call("ZREVRANGEBYSCORE", key, *arguments)
 				end
 				
 				# Determine the index of a member in a sorted set, with scores ordered from high to low. O(log(N)).
-				# @see https://redis.io/commands/zrevrank
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/zrevrank> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def zrevrank(key, member)
 					call("ZREVRANK", key, member)
 				end
 				
 				# Get the score associated with the given member in a sorted set. O(1).
-				# @see https://redis.io/commands/zscore
-				# @param key [Key]
-				# @param member [String]
+				# See <https://redis.io/commands/zscore> for more details.
+				# @parameter key [Key]
+				# @parameter member [String]
 				def zscore(key, member)
 					call("ZSCORE", key, member)
 				end
 				
 				# Add multiple sorted sets and store the resulting sorted set in a new key. O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
-				# @see https://redis.io/commands/zunionstore
-				# @param destination [Key]
-				# @param numkeys [Integer]
-				# @param key [Key]
+				# See <https://redis.io/commands/zunionstore> for more details.
+				# @parameter destination [Key]
+				# @parameter numkeys [Integer]
+				# @parameter key [Key]
 				def zunionstore(*arguments)
 					call("ZUNIONSTORE", *arguments)
 				end
 				
 				# Incrementally iterate sorted sets elements and associated scores. 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/zscan
-				# @param key [Key]
-				# @param cursor [Integer]
+				# See <https://redis.io/commands/zscan> for more details.
+				# @parameter key [Key]
+				# @parameter cursor [Integer]
 				def zscan(key, cursor = 0, match: nil, count: nil)
 					arguments = [key, cursor]