protocol-redis 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eaec89c45931d2380b65c26b642dc53cc65b0c2b93251c57fa9831fa8aa654a6
-  data.tar.gz: 87be2b36ea8deeb9eef4ed56f2e833120a8641fa4256feb0decb4f8ee73b4f64
+  metadata.gz: 3a43936672dd294704fcfd56d9e30a0a7a8f3102fc87e6decdced5fe18c5247c
+  data.tar.gz: 1b18d65000b1d45d35b1f5b2ec8dff64672a78e316b2129c58d99c057af18aa6
 SHA512:
-  metadata.gz: 9c4bf2da40ab8a0090e08428a26f2bdf1b02c1c210a805945d8ff001c5836d6bc3710e1889cd192f0f862bd17dfeb1a6c83dec2cae55ee407b216a96edfd9666
-  data.tar.gz: 4a737e454c0fcdd0c2469f9770caa1e6c4bbe309c2a80a15b5a4937462c5628d175ab59390c075b4d2edd07497ff6bd6947396d0239b11859a89c95fb3962f03
+  metadata.gz: 94099bfe814a49a29a26d9eae937c6420a13bc1e0ae1f669dcd39a185581f8ba7ea309cdcc2d7ba53dd28e79fbfad1c4c69bc68302fac5d4a104b163d88e27eb
+  data.tar.gz: e5bd1cbdcb78bf4f2ca031d81b7b3504bea322be315265874cf61d9439ee554ea5fb96552cebf0612d65388379976174b4e35a7b631009286970377ccdd776a7

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:test)
+Dir.glob('tasks/**/*.rake').each{|path| load(path)}
 
-task :default => :test
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/protocol/redis.rb

@@ -1,3 +1,5 @@
+# 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

data/lib/protocol/redis/connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -27,10 +29,16 @@ module Protocol
 			
 			def initialize(stream)
 				@stream = stream
+				
+				# Number of requests sent:
+				@count = 0
 			end
 			
 			attr :stream
 			
+			# @attr [Integer] Number of requests sent.
+			attr :count
+			
 			def close
 				@stream.close
 			end
@@ -51,6 +59,8 @@ module Protocol
 			def write_request(arguments)
 				write_lines("*#{arguments.size}")
 				
+				@count += 1
+				
 				arguments.each do |argument|
 					string = argument.to_s
 					

data/lib/protocol/redis/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2019, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy

data/lib/protocol/redis/methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright, 2019, by Mikael Henriksson. <http://www.mhenrixon.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -18,20 +20,30 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'methods/generic'
+require_relative 'methods/connection'
+require_relative 'methods/server'
+require_relative 'methods/geospatial'
+
+require_relative 'methods/counting'
+
 require_relative 'methods/hashes'
-require_relative 'methods/keys'
 require_relative 'methods/lists'
-require_relative 'methods/server'
 require_relative 'methods/strings'
 
 module Protocol
 	module Redis
 		module Methods
 			def self.included(klass)
+				klass.include Methods::Generic
+				klass.include Methods::Connection
+				klass.include Methods::Server
+				klass.include Methods::Geospatial
+				
+				klass.include Methods::Counting
+				
 				klass.include Methods::Hashes
-				klass.include Methods::Keys
 				klass.include Methods::Lists
-				klass.include Methods::Server
 				klass.include Methods::Strings
 			end
 		end

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

@@ -0,0 +1,56 @@
+# 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 Connection
+				# Authenticate to the server.
+				# @see https://redis.io/commands/auth
+				# @param password [String]
+				def auth(password)
+					call("AUTH", password)
+				end
+				
+				# Echo the given string.
+				# @see https://redis.io/commands/echo
+				# @param message [String]
+				def echo(message)
+					call("ECHO", message)
+				end
+				
+				# Ping the server.
+				# @see https://redis.io/commands/ping
+				# @param message [String]
+				def ping(message)
+					call("PING", message)
+				end
+				
+				# Close the connection.
+				# @see https://redis.io/commands/quit
+				def quit
+					call("QUIT")
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,52 @@
+# 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 Counting
+				# Adds the specified elements to the specified HyperLogLog. O(1) to add every element.
+				# @see https://redis.io/commands/pfadd
+				# @param key [Key]
+				# @param element [String]
+				def pfadd(key, element, *elements)
+					call("PFADD", key, element, *elements)
+				end
+				
+				# Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s). O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.
+				# @see https://redis.io/commands/pfcount
+				# @param key [Key]
+				def pfcount(key, *keys)
+					call("PFCOUNT", key, *keys)
+				end
+				
+				# Merge N different HyperLogLogs into a single one. O(N) to merge N HyperLogLogs, but with high constant times.
+				# @see https://redis.io/commands/pfmerge
+				# @param destkey [Key]
+				# @param sourcekey [Key]
+				def pfmerge(destkey, sourcekey, *sourcekeys)
+					call("PFMERGE", destkey, sourcekey, *sourcekeys)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,304 @@
+# 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
+# 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.
+
+require 'date'
+
+module Protocol
+	module Redis
+		module Methods
+			module Generic
+				# Delete a key. O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
+				# @see https://redis.io/commands/del
+				# @param key [Key]
+				def del(*keys)
+					if keys.any?
+						return call('DEL', *keys)
+					end
+				end
+				
+				# Return a serialized version of the value stored at the specified key. O(1) to access the key and additional O(N*M) to serialized it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1).
+				# @see https://redis.io/commands/dump
+				# @param key [Key]
+				def dump(key)
+					return 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)
+				end
+				
+				# Set a key's time to live in seconds. O(1).
+				# @see https://redis.io/commands/expire
+				# @param key [Key]
+				# @param seconds [Integer]
+				def expire(key, seconds)
+					return call('EXPIRE', key, seconds)
+				end
+				
+				# Set the expiration for a key as a UNIX timestamp. O(1).
+				# @see https://redis.io/commands/expireat
+				# @param key [Key]
+				# @param timestamp [Posix time]
+				def expireat(key, time)
+					case time
+					when DateTime, Time, Date
+						timestamp = time.strftime('%s').to_i
+					else
+						timestamp = time
+					end
+					
+					return 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)
+				end
+				
+				# Atomically transfer a key from a Redis instance to another one. This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
+				# @see https://redis.io/commands/migrate
+				# @param host [String]
+				# @param port [String]
+				# @param key [Enum]
+				# @param destination-db [Integer]
+				# @param timeout [Integer]
+				# @param copy [Enum]
+				# @param replace [Enum]
+				def migrate(host, port, destination = 0, keys:, timeout: 0, copy: false, replace: false, auth: nil)
+					raise ArgumentError, "Must provide keys" if keys.empty?
+					
+					arguments = [host, port]
+					
+					if keys.size == 1
+						arguments.append(*keys)
+					else
+						arguments.append("")
+					end
+					
+					arguments.append(destination, timeout)
+					
+					if copy
+						arguments.append("COPY")
+					end
+					
+					if replace
+						arguments.append("REPLACE")
+					end
+					
+					if auth
+						arguments.append("AUTH", auth)
+					end
+					
+					if keys.size > 1
+						arguments.append("KEYS", *keys)
+					end
+					
+					return call("MIGRATE", *arguments)
+				end
+				
+				# Move a key to another database. O(1).
+				# @see https://redis.io/commands/move
+				# @param key [Key]
+				# @param db [Integer]
+				def move(key, db)
+					return call('MOVE', key, db)
+				end
+				
+				# Inspect the internals of Redis objects. O(1) for all the currently implemented subcommands.
+				# @see https://redis.io/commands/object
+				# @param subcommand [String]
+				# @param arguments [String]
+				def object(subcommand, *arguments)
+					call('OBJECT', subcommand, *arguments)
+				end
+				
+				# Remove the expiration from a key. O(1).
+				# @see https://redis.io/commands/persist
+				# @param key [Key]
+				def persist(key)
+					return call('PERSIST', key)
+				end
+				
+				# Set a key's time to live in milliseconds. O(1).
+				# @see https://redis.io/commands/pexpire
+				# @param key [Key]
+				# @param milliseconds [Integer]
+				def pexpire(key, milliseconds)
+					return call('PEXPIRE', milliseconds)
+				end
+				
+				# Set the expiration for a key as a UNIX timestamp specified in milliseconds. O(1).
+				# @see https://redis.io/commands/pexpireat
+				# @param key [Key]
+				# @param milliseconds-timestamp [Posix time]
+				def pexpireat(key, time)
+					case time.class
+					when DateTime, Time, Date 
+						timestamp =  time.strftime('%Q').to_i
+					else
+						timestamp = time
+					end
+					
+					return 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)
+				end
+				
+				# Return a random key from the keyspace. O(1).
+				# @see https://redis.io/commands/randomkey
+				def randomkey
+					return call('RANDOMKEY')
+				end
+				
+				# Rename a key. O(1).
+				# @see https://redis.io/commands/rename
+				# @param key [Key]
+				# @param newkey [Key]
+				def rename(key, new_key)
+					return call('RENAME', key, new_key)
+				end
+				
+				# Rename a key, only if the new key does not exist. O(1).
+				# @see https://redis.io/commands/renamenx
+				# @param key [Key]
+				# @param newkey [Key]
+				def renamenx(key, new_key)
+					return call('RENAMENX', key, new_key)
+				end
+				
+				# Create a key using the provided serialized value, previously obtained using DUMP. O(1) to create the new key and additional O(N*M) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).
+				# @see https://redis.io/commands/restore
+				# @param key [Key]
+				# @param ttl [Integer]
+				# @param serialized-value [String]
+				# @param replace [Enum]
+				# @param absttl [Enum]
+				def restore(key, serialized_value, ttl=0)
+					return call('RESTORE', key, ttl, serialized_value)
+				end
+				
+				# Incrementally iterate the keys space. O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
+				# @see https://redis.io/commands/scan
+				# @param cursor [Integer]
+				def scan(cursor, match: nil, count: nil, type: nil)
+					arguments = [cursor]
+					
+					if match
+						arguments.append("MATCH", match)
+					end
+					
+					if count
+						arguments.append("COUNT", count)
+					end
+					
+					if type
+						arguments.append("TYPE", type)
+					end
+					
+					return 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.
+				# @see https://redis.io/commands/sort
+				# @param key [Key]
+				# @param order [Enum]
+				# @param sorting [Enum]
+				def sort(key, by: nil, offset: nil, count: nil, get: nil, order: 'ASC', alpha: false, store: nil)
+					arguments = []
+					
+					if by
+						arguments.append("BY", by)
+					end
+					
+					if offset and count
+						arguments.append("LIMIT", offset, count)
+					end
+					
+					get&.each do |pattern|
+						arguments.append("GET", pattern)
+					end
+					
+					if order
+						arguments.append(order)
+					end
+					
+					if alpha
+						arguments.append("ALPHA")
+					end
+					
+					if store
+						arguments.append("STORE", store)
+					end
+					
+					return 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)
+				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)
+				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)
+				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)
+				end
+					
+				# Wait for the synchronous replication of all the write commands sent in the context of the current connection. O(1).
+				# @see https://redis.io/commands/wait
+				# @param numreplicas [Integer]
+				# @param timeout [Integer]
+				def wait(newreplicas, timeout = 0)
+					return call("WAIT", numreplicas, timeout)
+				end
+			end
+		end
+	end
+end