protocol-redis 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9a0af74e1d169a5d9f8b712a1211deb9c2ab510c969043073e685b5a4d4a99a
-  data.tar.gz: 7961d5412651f7969160e5b3844be5ab7db064b5b1f2ff6833ca17e12cc42233
+  metadata.gz: e43c648ff264ee29a69f92fc31f9c82435adccc55e47030268d2f82c74334974
+  data.tar.gz: afec0aedb9963f4a48d2f4f2c9ba63079b376f8bb120bf7d78cb6e993d94c267
 SHA512:
-  metadata.gz: 6fdf6ab96249d724ea77949cd073cb581f8ad58b96e3d54058e5f2e466ae2de7a947f327b44367a38d65939c2b8d8ed7a72f3e24a408f15871d25c35e45f271a
-  data.tar.gz: 27ca946edfed62633623d6876a04cdd36da92b95fbf0e21d5086b493580b1988d4d1a68e9f3ff1f99c1e9da4bc71b812688941b10d799c6dd6060a107c24427a
+  metadata.gz: 2356a25989896ad34bfa432627e9967cd1695898df66107e975ede10e70c8bd5f3a2cbac4c1a136fcff317306823917800106c02b6b719c4d2352176b9182234
+  data.tar.gz: 5616240fd409f903c2f52e99e5ee3c8e0792b81bc933dcfab1366c56bf9ce1dfed0cdc9780f0440aae079205f25b6274eab235635573d1ff78b9cb24ce340c1d

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

@@ -32,7 +32,7 @@ module Protocol
 				# @param key [Key]
 				def del(*keys)
 					if keys.any?
-						return call('DEL', *keys)
+						call('DEL', *keys)
 					end
 				end
 				
@@ -40,14 +40,14 @@ module Protocol
 				# @see https://redis.io/commands/dump
 				# @param key [Key]
 				def dump(key)
-					return call('DUMP', key)
+					call('DUMP', key)
 				end
 				
 				# Determine if a key exists. O(1).
 				# @see https://redis.io/commands/exists
 				# @param key [Key]
 				def exists(key, *keys)
-					return call('EXISTS', key, *keys)
+					call('EXISTS', key, *keys)
 				end
 				
 				# Set a key's time to live in seconds. O(1).
@@ -55,7 +55,7 @@ module Protocol
 				# @param key [Key]
 				# @param seconds [Integer]
 				def expire(key, seconds)
-					return call('EXPIRE', key, seconds)
+					call('EXPIRE', key, seconds)
 				end
 				
 				# Set the expiration for a key as a UNIX timestamp. O(1).
@@ -70,14 +70,14 @@ module Protocol
 						timestamp = time
 					end
 					
-					return 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]
 				def keys(pattern)
-					return 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.
@@ -118,7 +118,7 @@ module Protocol
 						arguments.append("KEYS", *keys)
 					end
 					
-					return call("MIGRATE", *arguments)
+					call("MIGRATE", *arguments)
 				end
 				
 				# Move a key to another database. O(1).
@@ -126,7 +126,7 @@ module Protocol
 				# @param key [Key]
 				# @param db [Integer]
 				def move(key, db)
-					return call('MOVE', key, db)
+					call('MOVE', key, db)
 				end
 				
 				# Inspect the internals of Redis objects. O(1) for all the currently implemented subcommands.
@@ -141,7 +141,7 @@ module Protocol
 				# @see https://redis.io/commands/persist
 				# @param key [Key]
 				def persist(key)
-					return call('PERSIST', key)
+					call('PERSIST', key)
 				end
 				
 				# Set a key's time to live in milliseconds. O(1).
@@ -149,7 +149,7 @@ module Protocol
 				# @param key [Key]
 				# @param milliseconds [Integer]
 				def pexpire(key, milliseconds)
-					return call('PEXPIRE', milliseconds)
+					call('PEXPIRE', milliseconds)
 				end
 				
 				# Set the expiration for a key as a UNIX timestamp specified in milliseconds. O(1).
@@ -164,20 +164,20 @@ module Protocol
 						timestamp = time
 					end
 					
-					return 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]
 				def pttl(key)
-					return call('PTTL', key)
+					call('PTTL', key)
 				end
 				
 				# Return a random key from the keyspace. O(1).
 				# @see https://redis.io/commands/randomkey
 				def randomkey
-					return call('RANDOMKEY')
+					call('RANDOMKEY')
 				end
 				
 				# Rename a key. O(1).
@@ -185,7 +185,7 @@ module Protocol
 				# @param key [Key]
 				# @param newkey [Key]
 				def rename(key, new_key)
-					return call('RENAME', key, new_key)
+					call('RENAME', key, new_key)
 				end
 				
 				# Rename a key, only if the new key does not exist. O(1).
@@ -193,7 +193,7 @@ module Protocol
 				# @param key [Key]
 				# @param newkey [Key]
 				def renamenx(key, new_key)
-					return 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)).
@@ -204,7 +204,7 @@ module Protocol
 				# @param replace [Enum]
 				# @param absttl [Enum]
 				def restore(key, serialized_value, ttl=0)
-					return 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.
@@ -225,7 +225,7 @@ module Protocol
 						arguments.append("TYPE", type)
 					end
 					
-					return call("SCAN", *arguments)
+					call("SCAN", *arguments)
 				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.
@@ -260,35 +260,35 @@ module Protocol
 						arguments.append("STORE", store)
 					end
 					
-					return call('SORT', *arguments)
+					call('SORT', *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]
 				def touch(key, *keys)
-					return 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]
 				def ttl(key)
-					return call('TTL', key)
+					call('TTL', key)
 				end
 				
 				# Determine the type stored at key. O(1).
 				# @see https://redis.io/commands/type
 				# @param key [Key]
 				def type(key)
-					return 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]
 				def unlink(key)
-					return 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).
@@ -296,7 +296,7 @@ module Protocol
 				# @param numreplicas [Integer]
 				# @param timeout [Integer]
 				def wait(newreplicas, timeout = 0)
-					return call("WAIT", numreplicas, timeout)
+					call("WAIT", numreplicas, timeout)
 				end
 			end
 		end

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

@@ -28,14 +28,14 @@ module Protocol
 				# @see https://redis.io/commands/hlen
 				# @param key [Key]
 				def hlen(key)
-					return call('HLEN', key)
+					call('HLEN', key)
 				end
 				
 				# Set the string value of a hash field. O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
 				# @see https://redis.io/commands/hset
 				# @param key [Key]
 				def hset(key, field, value)
-					return call('HSET', key, field, value)
+					call('HSET', key, field, value)
 				end
 				
 				# Set the value of a hash field, only if the field does not exist. O(1).
@@ -44,14 +44,14 @@ module Protocol
 				# @param field [String]
 				# @param value [String]
 				def hsetnx(key, field, value)
-					return call('HSETNX', key, field, value)
+					call('HSETNX', key, field, value)
 				end
 				
 				# Set multiple hash fields to multiple values. O(N) where N is the number of fields being set.
 				# @see https://redis.io/commands/hmset
 				# @param key [Key]
 				def hmset(key, *attrs)
-					return call('HMSET', key, *attrs)
+					call('HMSET', key, *attrs)
 				end
 				
 				# Get the value of a hash field. O(1).
@@ -59,7 +59,7 @@ module Protocol
 				# @param key [Key]
 				# @param field [String]
 				def hget(key, field)
-					return call('HGET', key, field)
+					call('HGET', key, field)
 				end
 				
 				# Get the values of all the given hash fields. O(N) where N is the number of fields being requested.
@@ -67,7 +67,7 @@ module Protocol
 				# @param key [Key]
 				# @param field [String]
 				def hmget(key, *fields, &blk)
-					return call('HMGET', key, *fields, &blk)
+					call('HMGET', key, *fields, &blk)
 				end
 				
 				# Delete one or more hash fields. O(N) where N is the number of fields to be removed.
@@ -75,7 +75,7 @@ module Protocol
 				# @param key [Key]
 				# @param field [String]
 				def hdel(key, *fields)
-					return call('HDEL', key, *fields)
+					call('HDEL', key, *fields)
 				end
 				
 				# Determine if a hash field exists. O(1).
@@ -83,7 +83,7 @@ module Protocol
 				# @param key [Key]
 				# @param field [String]
 				def hexists(key, field)
-					return call('HEXISTS', key, field)
+					call('HEXISTS', key, field)
 				end
 				
 				# Increment the integer value of a hash field by the given number. O(1).
@@ -92,7 +92,7 @@ module Protocol
 				# @param field [String]
 				# @param increment [Integer]
 				def hincrby(key, field, increment)
-					return call('HINCRBY', key, field, increment)
+					call('HINCRBY', key, field, increment)
 				end
 				
 				# Increment the float value of a hash field by the given amount. O(1).
@@ -101,28 +101,28 @@ module Protocol
 				# @param field [String]
 				# @param increment [Double]
 				def hincrbyfloat(key, field, increment)
-					return call('HINCRBYFLOAT', key, field, increment)
+					call('HINCRBYFLOAT', key, field, increment)
 				end
 				
 				# Get all the fields in a hash. O(N) where N is the size of the hash.
 				# @see https://redis.io/commands/hkeys
 				# @param key [Key]
 				def hkeys(key)
-					return call('HKEYS', key)
+					call('HKEYS', key)
 				end
 				
 				# Get all the values in a hash. O(N) where N is the size of the hash.
 				# @see https://redis.io/commands/hvals
 				# @param key [Key]
 				def hvals(key)
-					return call('HVALS', key)
+					call('HVALS', key)
 				end
 				
 				# Get all the fields and values in a hash. O(N) where N is the size of the hash.
 				# @see https://redis.io/commands/hgetall
 				# @param key [Key]
 				def hgetall(key)
-					return call('HGETALL', key)
+					call('HGETALL', key)
 				end
 			end
 		end

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

@@ -30,7 +30,7 @@ module Protocol
 				# @param key [Key]
 				# @param timeout [Integer]
 				def blpop(*keys, timeout: 0)
-					return call('BLPOP', *keys, timeout)
+					call('BLPOP', *keys, timeout)
 				end
 				
 				# Remove and get the last element in a list, or block until one is available. O(1).
@@ -38,7 +38,7 @@ module Protocol
 				# @param key [Key]
 				# @param timeout [Integer]
 				def brpop(*keys, timeout: 0)
-					return call('BRPOP', *keys, timeout)
+					call('BRPOP', *keys, timeout)
 				end
 				
 				# Pop an element from a list, push it to another list and return it; or block until one is available. O(1).
@@ -47,7 +47,7 @@ module Protocol
 				# @param destination [Key]
 				# @param timeout [Integer]
 				def brpoplpush(source, destination, timeout)
-					return call('BRPOPLPUSH', source, destination, timeout)
+					call('BRPOPLPUSH', source, destination, timeout)
 				end
 				
 				# Get an element from a list by its index. O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
@@ -55,7 +55,7 @@ module Protocol
 				# @param key [Key]
 				# @param index [Integer]
 				def lindex(key, index)
-					return call('LINDEX', key, index)
+					call('LINDEX', key, index)
 				end
 				
 				# Insert an element before or after another element in a list. O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
@@ -71,21 +71,21 @@ module Protocol
 						offset = 'AFTER'
 					end
 					
-					return call('LINSERT', key, offset, index, value)
+					call('LINSERT', key, offset, index, value)
 				end
 				
 				# Get the length of a list. O(1).
 				# @see https://redis.io/commands/llen
 				# @param key [Key]
 				def llen(key)
-					return call('LLEN', key)
+					call('LLEN', key)
 				end
 				
 				# Remove and get the first element in a list. O(1).
 				# @see https://redis.io/commands/lpop
 				# @param key [Key]
 				def lpop(key)
-					return call('LPOP', key)
+					call('LPOP', key)
 				end
 				
 				# Prepend one or multiple elements to a list. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
@@ -100,7 +100,7 @@ module Protocol
 						values = [value] + values
 					end
 					
-					return call('LPUSH', key, *values)
+					call('LPUSH', key, *values)
 				end
 				
 				# Prepend an element to a list, only if the list exists. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
@@ -108,7 +108,7 @@ module Protocol
 				# @param key [Key]
 				# @param element [String]
 				def lpushx(key, value)
-					return call('LPUSHX', key, value)
+					call('LPUSHX', key, value)
 				end
 				
 				# Get a range of elements from a list. O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
@@ -117,7 +117,7 @@ module Protocol
 				# @param start [Integer]
 				# @param stop [Integer]
 				def lrange(key, start, stop)
-					return call('LRANGE', key, start, stop)
+					call('LRANGE', key, start, stop)
 				end
 				
 				# Remove elements from a list. O(N+M) where N is the length of the list and M is the number of elements removed.
@@ -126,7 +126,7 @@ module Protocol
 				# @param count [Integer]
 				# @param element [String]
 				def lrem(key, count, value)
-					return call('LREM', key, count, value)
+					call('LREM', key, count, value)
 				end
 				
 				# Set the value of an element in a list by its index. O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
@@ -135,7 +135,7 @@ module Protocol
 				# @param index [Integer]
 				# @param element [String]
 				def lset(key, index, values)
-					return call('LSET', key, index, values)
+					call('LSET', key, index, values)
 				end
 				
 				# Trim a list to the specified range. O(N) where N is the number of elements to be removed by the operation.
@@ -144,14 +144,14 @@ module Protocol
 				# @param start [Integer]
 				# @param stop [Integer]
 				def ltrim(key, start, stop)
-					return call('LTRIM', key, start, stop)
+					call('LTRIM', key, start, stop)
 				end
 				
 				# Remove and get the last element in a list. O(1).
 				# @see https://redis.io/commands/rpop
 				# @param key [Key]
 				def rpop(key)
-					return call('RPOP', key)
+					call('RPOP', key)
 				end
 				
 				# Remove the last element in a list, prepend it to another list and return it. O(1).
@@ -161,7 +161,7 @@ module Protocol
 				def rpoplpush(source, destination=nil)
 					destination = source if destination.nil?
 					
-					return call('RPOPLPUSH', source, destination)
+					call('RPOPLPUSH', source, destination)
 				end
 				
 				# Append one or multiple elements to a list. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
@@ -176,7 +176,7 @@ module Protocol
 						values = [value] + values
 					end
 					
-					return call('RPUSH', key, *values)
+					call('RPUSH', key, *values)
 				end
 				
 				# Append an element to a list, only if the list exists. O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
@@ -184,7 +184,7 @@ module Protocol
 				# @param key [Key]
 				# @param element [String]
 				def rpushx(key, value)
-					return call('RPUSHX', key, value)
+					call('RPUSHX', key, value)
 				end
 			end
 		end

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

@@ -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/strings.rb

@@ -137,7 +137,7 @@ module Protocol
 				# @param milliseconds [Integer]
 				# @param value [String]
 				def psetex(key, milliseconds, value)
-					return set key, value, milliseconds: milliseconds
+					call('PSETEX', key, milliseconds, value)
 				end
 
 				# Set the string value of a key. O(1).
@@ -163,7 +163,7 @@ module Protocol
 						arguments << "NX"
 					end
 
-					return call('SET', key, value, *arguments)
+					call('SET', key, value, *arguments)
 				end
 
 				# Sets or clears the bit at offset in the string value stored at key. O(1).
@@ -172,7 +172,7 @@ module Protocol
 				# @param offset [Integer]
 				# @param value [Integer]
 				def setbit(key, offset, value)
-					return call('SETBIT', key, offset, value)
+					call('SETBIT', key, offset, value)
 				end
 
 				# Set the value and expiration of a key. O(1).
@@ -181,7 +181,7 @@ module Protocol
 				# @param seconds [Integer]
 				# @param value [String]
 				def setex(key, seconds, value)
-					return set key, value, seconds: seconds
+					call('SETEX', key, seconds, value)
 				end
 
 				# Set the value of a key, only if the key does not exist. O(1).
@@ -189,7 +189,7 @@ module Protocol
 				# @param key [Key]
 				# @param value [String]
 				def setnx(key, value)
-					return set key, value, condition: :nx
+					call('SETNX', key, value)
 				end
 
 				# Overwrite part of a string at key starting at the specified offset. O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
@@ -198,14 +198,14 @@ module Protocol
 				# @param offset [Integer]
 				# @param value [String]
 				def setrange(key, offset, value)
-					return call('SETRANGE', key, offset, value)
+					call('SETRANGE', key, offset, value)
 				end
 
 				# Get the length of the value stored in a key. O(1).
 				# @see https://redis.io/commands/strlen
 				# @param key [Key]
 				def strlen(key)
-					return call('STRLEN', key)
+					call('STRLEN', key)
 				end
 			end
 		end

data/lib/protocol/redis/version.rb

@@ -22,6 +22,6 @@
 
 module Protocol
 	module Redis
-		VERSION = "0.4.0"
+		VERSION = "0.4.1"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-redis
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Samuel Williams