protocol-redis 0.4.0 → 0.6.0

data/{tasks/methods.trenni → lib/protocol/redis/methods/pubsub.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyright, 2018, by Huba Nagy.
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,23 +24,14 @@
 module Protocol
 	module Redis
 		module Methods
-			module #{self[:module_name]}
-<?r
-			first = true
-			self[:group_commands].each do |command, command_spec|
-				method_name = command.to_s.downcase.split(/[\s\-_]+/).join('_')
-				
-				unless first
-?>
-				
-<?r			end ?>
-				def #{method_name}(*arguments)
-					call(#{command.to_s.dump}, *arguments)
+			module Pubsub
+				# Post a message to a channel.
+				# @see https://redis.io/commands/publish
+				# @param channel [String]
+				# @param message [String]
+				def publish(channel, message)
+					call('PUBLISH', channel, message)
 				end
-<?r
-				first = false
-			end
-?>
 			end
 		end
 	end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Protocol
+	module Redis
+		module Methods
+			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]
+				# @param 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]
+				def evalsha(*arguments)
+					call("EVALSHA", *arguments)
+				end
+				
+				# Set the debug mode for executed scripts. O(1).
+				# @see https://redis.io/commands/script debug
+				# @param mode [Enum]
+				def script_debug(*arguments)
+					call("SCRIPT DEBUG", *arguments)
+				end
+				
+				# Check existence of scripts in the script cache. O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
+				# @see https://redis.io/commands/script exists
+				# @param sha1 [String]
+				def script_exists(*arguments)
+					call("SCRIPT EXISTS", *arguments)
+				end
+				
+				# Remove all the scripts from the script cache. O(N) with N being the number of scripts in cache.
+				# @see https://redis.io/commands/script flush
+				def script_flush(*arguments)
+					call("SCRIPT FLUSH", *arguments)
+				end
+				
+				# Kill the script currently in execution. O(1).
+				# @see https://redis.io/commands/script kill
+				def script_kill(*arguments)
+					call("SCRIPT KILL", *arguments)
+				end
+				
+				# Load the specified Lua script into the script cache. O(N) with N being the length in bytes of the script body.
+				# @see https://redis.io/commands/script load
+				# @param script [String]
+				def script_load(*arguments)
+					call("SCRIPT LOAD", *arguments)
+				end
+			end
+		end
+	end
+end

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

@@ -31,7 +31,7 @@ module Protocol
 				def info
 					metadata = {}
 					
-					call('INFO').each_line(Protocol::CRLF) do |line|
+					call('INFO').each_line(Redis::Connection::CRLF) do |line|
 						key, value = line.split(':')
 						
 						if value
@@ -46,7 +46,7 @@ module Protocol
 				# @see https://redis.io/commands/flushdb
 				# @param async [Enum]
 				def flushdb!
-					return call('FLUSHDB')
+					call('FLUSHDB')
 				end
 			end
 		end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Protocol
+	module Redis
+		module Methods
+			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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				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]
+				def sscan(*arguments)
+					call("SSCAN", *arguments)
+				end
+			end
+		end
+	end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # Copyright, 2020, by Dimitry Chopey.
-# Copyright, 2020, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -25,6 +25,22 @@ module Protocol
 	module Redis
 		module Methods
 			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]
+				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]
+				def bzpopmax(*keys, timeout: 0)
+					call("BZPOPMAX", *keys, timeout: 0)
+				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]
@@ -41,20 +57,95 @@ module Protocol
 					arguments = ["ZADD", key]
 					
 					if update == true
-						arguments << "XX"
+						arguments.push("XX")
 					elsif update == false
-						arguments << "NX"
+						arguments.push("NX")
 					end
 					
-					arguments << "CH" if change
-					arguments << "INCR" if increment
+					arguments.push("CH") if change
+					arguments.push("INCR") if increment
 					
-					arguments << score << member
-					arguments.concat(others)
+					arguments.push(score, member)
+					arguments.push(*others)
 					
 					call(*arguments)
 				end
-
+				
+				# Get the number of members in a sorted set. O(1).
+				# @see https://redis.io/commands/zcard
+				# @param 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]
+				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]
+				def zincrby(key, increment, member)
+					call("ZINCRBY", key, amount, 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.
+				def zinterstore(destination, keys, weights = nil, aggregate: nil)
+					arguments = []
+					
+					if weights
+						if weights.size != keys.size
+							raise ArgumentError, "#{weights.size} weights given for #{keys.size} keys!"
+						end
+						
+						arguments.push("WEIGHTS")
+						arguments.concat(weights)
+					end
+					
+					if aggregate
+						arguments.push("AGGREGATE", aggregate)
+					end
+					
+					call("ZINTERSTORE", destination, keys.size, *keys, *arguments)
+				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]
+				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]
+				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]
+				def zpopmin(key, count = 1)
+					call("ZPOPMIN", key, count = 1)
+				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]
@@ -64,11 +155,65 @@ module Protocol
 				def zrange(key, start, stop, with_scores: false)
 					arguments = [start, stop]
 					
-					arguments << "WITHSCORES" if with_scores
+					arguments.push("WITHSCORES") if with_scores
 					
 					call("ZRANGE", key, *arguments)
 				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.
+				def zrangebylex(key, min, max, limit: nil)
+					if limit
+						arguments = ["LIMIT", *limit]
+					end
+					
+					call("ZRANGEBYLEX", key, min, max, *arguments)
+				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]
+				def zrevrangebylex(key, min, max, limit: nil)
+					if limit
+						arguments = ["LIMIT", *limit]
+					end
+					
+					call("ZREVRANGEBYLEX", key, min, max, *arguments)
+				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.
+				#
+				# @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
+					
+					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]
+				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]
@@ -76,6 +221,105 @@ module Protocol
 				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]
+				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]
+				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]
+				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]
+				def zrevrange(key, min, max, with_scores: false)
+					arguments = [min, max]
+					
+					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]
+				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
+					
+					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]
+				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]
+				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]
+				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]
+				def zscan(key, cursor = 0, match: nil, count: nil)
+					arguments = [key, cursor]
+					
+					if match
+						arguments.push("MATCH", match)
+					end
+					
+					if count
+						arguments.push("COUNT", count)
+					end
+					
+					call("ZSCAN", *arguments)
+				end
 			end
 		end
 	end