protocol-redis 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b27fc5c9284df516083590216e58a3a16aa1013c90c86414989b29323f818d7c
-  data.tar.gz: f30c545712ff3f82e8eb7de43c4351acf2fdd468e42fd187db2b759580d33fef
+  metadata.gz: 1be06c92dd3aa593fd22a8e4a437c93d3d74b8cf5308ec7a7721ce48f74d88c5
+  data.tar.gz: eaa6c565377014ffae9c6bcd20b02437f6c83126da57cd12c4d768e54a320c3a
 SHA512:
-  metadata.gz: 4fd00040f3332fa804f1870e4458731fcb3a1275a31bb87cefc6d85fc3036fa4190adc1040bf012f4feeb7655a37b2b5cef0c90ecbced7facc2ce07502556562
-  data.tar.gz: 0a1c2700b7e5655be9822e5166cd433a9c4c4d93f29fa1cea095bca72ce29af065378f25f6fef9d0b832a517af6595c33b08605298f848d562bede903381bb3f
+  metadata.gz: 6f473cf7bacd6bc990bd412c544f6911248c1a392412a0c85201b33dd60706e50f4cf6fe84c10f82d6018e3952733491aee1bb0113058201af250979cc6091da
+  data.tar.gz: 468ddc3e83d7da8165bfebacc1c4860407647c5f8ac66129b0c889742da1da35d97e480cfee2007db172000a685d423840a1fffd81d98a4c9ceb44111486173e

data/.github/workflows/development.yml

@@ -0,0 +1,34 @@
+name: Development
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os:
+          - ubuntu
+          - macos
+        
+        ruby:
+          - 2.4
+          - 2.5
+          - 2.6
+          - 2.7
+        
+        include:
+          - os: 'ubuntu'
+            ruby: '2.6'
+            env: COVERAGE=PartialSummary,Coveralls
+    
+    runs-on: ${{matrix.os}}-latest
+    
+    steps:
+    - uses: actions/checkout@v1
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: ${{matrix.env}} bundle exec rspec

data/README.md

@@ -2,7 +2,7 @@
 
 Implements the RESP2 and [RESP3](https://github.com/antirez/RESP3) Redis protocols.
 
-[![Build Status](https://travis-ci.com/socketry/protocol-redis.svg?branch=master)](https://travis-ci.com/socketry/protocol-redis)
+[![Actions Status](https://github.com/socketry/protocol-redis/workflows/Development/badge.svg)](https://github.com/socketry/protocol-redis/actions?workflow=Development)
 
 ## Installation
 

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/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

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

@@ -0,0 +1,141 @@
+# 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 Streams
+				# Get information on streams and consumer groups. O(N) with N being the number of returned items for the subcommands CONSUMERS and GROUPS. The STREAM subcommand is O(log N) with N being the number of items in the stream.
+				# @see https://redis.io/commands/xinfo
+				# @param help [Enum]
+				def xinfo(*arguments)
+					call("XINFO", *arguments)
+				end
+				
+				# Appends a new entry to a stream. O(1).
+				# @see https://redis.io/commands/xadd
+				# @param key [Key]
+				# @param ID [String]
+				def xadd(*arguments)
+					call("XADD", *arguments)
+				end
+				
+				# Trims the stream to (approximately if '~' is passed) a certain size. O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
+				# @see https://redis.io/commands/xtrim
+				# @param key [Key]
+				# @param strategy [Enum]
+				# @param approx [Enum]
+				# @param count [Integer]
+				def xtrim(*arguments)
+					call("XTRIM", *arguments)
+				end
+				
+				# Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist. O(1) for each single item to delete in the stream, regardless of the stream size.
+				# @see https://redis.io/commands/xdel
+				# @param key [Key]
+				# @param ID [String]
+				def xdel(*arguments)
+					call("XDEL", *arguments)
+				end
+				
+				# Return a range of elements in a stream, with IDs matching the specified IDs interval. O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
+				# @see https://redis.io/commands/xrange
+				# @param key [Key]
+				# @param start [String]
+				# @param end [String]
+				def xrange(*arguments)
+					call("XRANGE", *arguments)
+				end
+				
+				# Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE. O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
+				# @see https://redis.io/commands/xrevrange
+				# @param key [Key]
+				# @param end [String]
+				# @param start [String]
+				def xrevrange(*arguments)
+					call("XREVRANGE", *arguments)
+				end
+				
+				# Return the number of entires in a stream. O(1).
+				# @see https://redis.io/commands/xlen
+				# @param key [Key]
+				def xlen(*arguments)
+					call("XLEN", *arguments)
+				end
+				
+				# Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block. For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.
+				# @see https://redis.io/commands/xread
+				# @param streams [Enum]
+				# @param key [Key]
+				# @param id [String]
+				def xread(*arguments)
+					call("XREAD", *arguments)
+				end
+				
+				# Create, destroy, and manage consumer groups. O(1) for all the subcommands, with the exception of the DESTROY subcommand which takes an additional O(M) time in order to delete the M entries inside the consumer group pending entries list (PEL).
+				# @see https://redis.io/commands/xgroup
+				def xgroup(*arguments)
+					call("XGROUP", *arguments)
+				end
+				
+				# Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block. For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
+				# @see https://redis.io/commands/xreadgroup
+				# @param noack [Enum]
+				# @param streams [Enum]
+				# @param key [Key]
+				# @param ID [String]
+				def xreadgroup(*arguments)
+					call("XREADGROUP", *arguments)
+				end
+				
+				# Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL. O(1) for each message ID processed.
+				# @see https://redis.io/commands/xack
+				# @param key [Key]
+				# @param group [String]
+				# @param ID [String]
+				def xack(*arguments)
+					call("XACK", *arguments)
+				end
+				
+				# Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer. O(log N) with N being the number of messages in the PEL of the consumer group.
+				# @see https://redis.io/commands/xclaim
+				# @param key [Key]
+				# @param group [String]
+				# @param consumer [String]
+				# @param min-idle-time [String]
+				# @param ID [String]
+				def xclaim(*arguments)
+					call("XCLAIM", *arguments)
+				end
+				
+				# Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged. O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). When the command returns just the summary it runs in O(1) time assuming the list of consumers is small, otherwise there is additional O(N) time needed to iterate every consumer.
+				# @see https://redis.io/commands/xpending
+				# @param key [Key]
+				# @param group [String]
+				# @param consumer [String]
+				def xpending(*arguments)
+					call("XPENDING", *arguments)
+				end
+			end
+		end
+	end
+end

data/lib/protocol/redis/version.rb

@@ -22,6 +22,6 @@
 
 module Protocol
 	module Redis
-		VERSION = "0.4.2"
+		VERSION = "0.5.0"
 	end
 end

data/protocol-redis.gemspec

@@ -2,19 +2,18 @@
 require_relative 'lib/protocol/redis/version'
 
 Gem::Specification.new do |spec|
-	spec.name          = "protocol-redis"
-	spec.version       = Protocol::Redis::VERSION
-	spec.authors       = ["Samuel Williams", "Huba Nagy"]
-	spec.email         = ["samuel.williams@oriontransfer.co.nz", "12huba@gmail.com"]
-
-	spec.summary       = "A RESP protocol client/server parser."
-	spec.homepage      = "https://github.com/socketry/protocol-redis"
-
-	spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+	spec.name = "protocol-redis"
+	spec.version = Protocol::Redis::VERSION
+	spec.authors = ["Samuel Williams", "Huba Nagy"]
+	spec.email = ["samuel.williams@oriontransfer.co.nz", "12huba@gmail.com"]
+	
+	spec.summary = "A transport agnostic RESP protocol client/server."
+	spec.homepage = "https://github.com/socketry/protocol-redis"
+	
+	spec.files = `git ls-files -z`.split("\x0").reject do |f|
 		f.match(%r{^(test|spec|features)/})
 	end
 	
-	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 	
 	spec.add_development_dependency "async-http"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-redis
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-11 00:00:00.000000000 Z
+date: 2020-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -118,9 +118,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".editorconfig"
+- ".github/workflows/development.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
@@ -135,8 +135,11 @@ files:
 - lib/protocol/redis/methods/geospatial.rb
 - lib/protocol/redis/methods/hashes.rb
 - lib/protocol/redis/methods/lists.rb
+- lib/protocol/redis/methods/scripting.rb
 - lib/protocol/redis/methods/server.rb
+- lib/protocol/redis/methods/sets.rb
 - lib/protocol/redis/methods/sorted_sets.rb
+- lib/protocol/redis/methods/streams.rb
 - lib/protocol/redis/methods/strings.rb
 - lib/protocol/redis/version.rb
 - protocol-redis.gemspec
@@ -160,8 +163,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: A RESP protocol client/server parser.
+summary: A transport agnostic RESP protocol client/server.
 test_files: []

data/.travis.yml

@@ -1,22 +0,0 @@
-language: ruby
-dist: xenial
-cache: bundler
-
-services:
-  - redis-server
-
-matrix:
-  include:
-    - rvm: 2.5
-    - rvm: 2.6
-    - rvm: 2.7
-    - rvm: 2.6
-      env: COVERAGE=BriefSummary,Coveralls
-    - rvm: ruby-head
-    - rvm: truffleruby
-    - rvm: jruby-head
-      env: JRUBY_OPTS="--debug -X+O"
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: truffleruby
-    - rvm: jruby-head