async-redis 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46c7b31b58959e0fe6165b3c2b506d9948d095477a5c9efd656dbcb590bfbfe1
-  data.tar.gz: 5d1b6ba10c70e35796b3ee7d02d2be2678dbb99c5fec21be5c2a37eb38aeea41
+  metadata.gz: 97fe8ed81d0096bd994cbbd3511fc3acb7c0c4629cfafdac47e5c237137083f1
+  data.tar.gz: c8a5b6a33efb6de45dc7cc2154b694fbd9337a14c485f85f1693bfeabbcc0f79
 SHA512:
-  metadata.gz: 7c117ee7b68fc57780806754c976686bfff540e22e2077b518892fcd863fe9b86b98dbbf69a37dd7b647f7bf6ad7a4fed1e82071db72c8549fb09bf39e79814a
-  data.tar.gz: 95870e075f3528b95a3503fc3d597a8e9fefe9e038d2f9f62448a8cb1b6df9fb2ae67dc24e5dbadd4798b3619f09089f6dbe2f1058d53895f2b2636df952152f
+  metadata.gz: ad448e4900402ef3e974a247c27a6a8fa5bf65d47fda67b46260830ecfb76a185c86a03ff0c38cd18ae1d628a7ce332d6952e26704d357f3858458fe593fb49d
+  data.tar.gz: 83535dc337e792808e6e3033864e393cb075a5d709bd5a8c507577d8b792f0600388f98cd28997c891102c36dc79062c6327004359f51c4677b50bab42eced8a

data/lib/async/redis/client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 # Copyright, 2018, by Huba Nagy.
 # Copyright, 2019, by Mikael Henriksson.
 # Copyright, 2019, by David Ortiz.
@@ -10,28 +10,23 @@
 require_relative 'context/pipeline'
 require_relative 'context/transaction'
 require_relative 'context/subscribe'
+require_relative 'endpoint'
 
-require_relative 'protocol/resp2'
-
-require 'async/io'
-require 'async/io/stream'
+require 'io/endpoint/host_endpoint'
 require 'async/pool/controller'
-
 require 'protocol/redis/methods'
 
+require 'io/stream'
+
 module Async
 	module Redis
 		# Legacy.
 		ServerError = ::Protocol::Redis::ServerError
 		
-		def self.local_endpoint(port: 6379)
-			Async::IO::Endpoint.tcp('localhost', port)
-		end
-		
 		class Client
 			include ::Protocol::Redis::Methods
 			
-			def initialize(endpoint = Redis.local_endpoint, protocol: Protocol::RESP2, **options)
+			def initialize(endpoint = Endpoint.local, protocol: endpoint.protocol, **options)
 				@endpoint = endpoint
 				@protocol = protocol
 				
@@ -121,7 +116,7 @@ module Async
 					# We will manage flushing ourselves:
 					peer.sync = true
 					
-					stream = IO::Stream.new(peer)
+					stream = ::IO::Stream(peer)
 					
 					@protocol.client(stream)
 				end

data/lib/async/redis/context/pipeline.rb

@@ -2,7 +2,7 @@
 
 # Released under the MIT License.
 # Copyright, 2019, by David Ortiz.
-# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2022, by Tim Willard.
 
 require_relative 'generic'
@@ -22,8 +22,8 @@ module Async
 					end
 					
 					# This method just accumulates the commands and their params.
-					def call(command, *arguments)
-						@pipeline.call(command, *arguments)
+					def call(...)
+						@pipeline.call(...)
 						
 						@pipeline.flush(1)
 						
@@ -46,6 +46,15 @@ module Async
 					end
 				end
 				
+				def collect
+					if block_given?
+						flush
+						yield
+					end
+					
+					@count.times.map{read_response}
+				end
+				
 				def sync
 					@sync ||= Sync.new(self)
 				end
@@ -73,15 +82,9 @@ module Async
 					end
 				end
 				
-				def collect
-					yield
-					
-					@count.times.map{read_response}
-				end
-				
 				def close
 					flush
-			  ensure
+				ensure
 					super
 				end
 			end

data/lib/async/redis/endpoint.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'io/endpoint'
+require 'io/endpoint/host_endpoint'
+require 'io/endpoint/ssl_endpoint'
+
+require_relative 'protocol/resp2'
+require_relative 'protocol/authenticated'
+require_relative 'protocol/selected'
+
+module Async
+	module Redis
+		def self.local_endpoint(**options)
+			Endpoint.local(**options)
+		end
+		
+		# Represents a way to connect to a remote Redis server.
+		class Endpoint < ::IO::Endpoint::Generic
+			LOCALHOST = URI.parse("redis://localhost").freeze
+			
+			def self.local(**options)
+				self.new(LOCALHOST, **options)
+			end	
+			
+			SCHEMES = {
+				'redis' => URI::Generic,
+				'rediss' => URI::Generic,
+			}
+			
+			def self.parse(string, endpoint = nil, **options)
+				url = URI.parse(string).normalize
+				
+				return self.new(url, endpoint, **options)
+			end
+			
+			# Construct an endpoint with a specified scheme, hostname, optional path, and options.
+			#
+			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
+			# @parameter hostname [String] The hostname to connect to (or bind to).
+			# @parameter *options [Hash] Additional options, passed to {#initialize}.
+			def self.for(scheme, hostname, credentials: nil, port: nil, database: nil, **options)
+				uri_klass = SCHEMES.fetch(scheme.downcase) do
+					raise ArgumentError, "Unsupported scheme: #{scheme.inspect}"
+				end
+				
+				if database
+					path = "/#{database}"
+				end
+				
+				self.new(
+					uri_klass.new(scheme, credentials&.join(":"), hostname, port, nil, path, nil, nil, nil).normalize,
+					**options
+				)
+			end
+			
+			# Coerce the given object into an endpoint.
+			# @parameter url [String | Endpoint] The URL or endpoint to convert.
+			def self.[](object)
+				if object.is_a?(self)
+					return object
+				else
+					self.parse(object.to_s)
+				end
+			end
+			
+			# Create a new endpoint.
+			#
+			# @parameter url [URI] The URL to connect to.
+			# @parameter endpoint [Endpoint] The underlying endpoint to use.
+			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
+			# @parameter hostname [String] The hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
+			# @parameter port [Integer] The port to bind to, overrides the URL port.
+			def initialize(url, endpoint = nil, **options)
+				super(**options)
+				
+				raise ArgumentError, "URL must be absolute (include scheme, host): #{url}" unless url.absolute?
+				
+				@url = url
+				
+				if endpoint
+					@endpoint = self.build_endpoint(endpoint)
+				else
+					@endpoint = nil
+				end
+			end
+			
+			def to_url
+				url = @url.dup
+				
+				unless default_port?
+					url.port = self.port
+				end
+				
+				return url
+			end
+			
+			def to_s
+				"\#<#{self.class} #{self.to_url} #{@options}>"
+			end
+			
+			def inspect
+				"\#<#{self.class} #{self.to_url} #{@options.inspect}>"
+			end
+			
+			attr :url
+			
+			def address
+				endpoint.address
+			end
+			
+			def secure?
+				['rediss'].include?(self.scheme)
+			end
+			
+			def protocol
+				protocol = @options.fetch(:protocol, Protocol::RESP2)
+				
+				if credentials = self.credentials
+					protocol = Protocol::Authenticated.new(credentials, protocol)
+				end
+				
+				if database = self.database
+					protocol = Protocol::Selected.new(database, protocol)
+				end
+				
+				return protocol
+			end
+			
+			def default_port
+				6379
+			end
+			
+			def default_port?
+				port == default_port
+			end
+			
+			def port
+				@options[:port] || @url.port || default_port
+			end
+			
+			# The hostname is the server we are connecting to:
+			def hostname
+				@options[:hostname] || @url.hostname
+			end
+			
+			def scheme
+				@options[:scheme] || @url.scheme
+			end
+			
+			def database
+				@options[:database] || extract_database(@url.path)
+			end
+			
+			private def extract_database(path)
+				if path =~ /\/(\d+)$/
+					return $1.to_i
+				end
+			end
+			
+			def credentials
+				@options[:credentials] || extract_userinfo(@url.userinfo)
+			end
+			
+			private def extract_userinfo(userinfo)
+				if userinfo
+					credentials = userinfo.split(":").reject(&:empty?)
+					
+					if credentials.any?
+						return credentials
+					end
+				end
+			end
+			
+			def localhost?
+				@url.hostname =~ /^(.*?\.)?localhost\.?$/
+			end
+			
+			# We don't try to validate peer certificates when talking to localhost because they would always be self-signed.
+			def ssl_verify_mode
+				if self.localhost?
+					OpenSSL::SSL::VERIFY_NONE
+				else
+					OpenSSL::SSL::VERIFY_PEER
+				end
+			end
+			
+			def ssl_context
+				@options[:ssl_context] || OpenSSL::SSL::SSLContext.new.tap do |context|
+					context.set_params(
+						verify_mode: self.ssl_verify_mode
+					)
+				end
+			end
+			
+			def build_endpoint(endpoint = nil)
+				endpoint ||= tcp_endpoint
+				
+				if secure?
+					# Wrap it in SSL:
+					return ::IO::Endpoint::SSLEndpoint.new(endpoint,
+						ssl_context: self.ssl_context,
+						hostname: @url.hostname,
+						timeout: self.timeout,
+					)
+				end
+				
+				return endpoint
+			end
+			
+			def endpoint
+				@endpoint ||= build_endpoint
+			end
+			
+			def endpoint=(endpoint)
+				@endpoint = build_endpoint(endpoint)
+			end
+			
+			def bind(*arguments, &block)
+				endpoint.bind(*arguments, &block)
+			end
+			
+			def connect(&block)
+				endpoint.connect(&block)
+			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				self.tcp_endpoint.each do |endpoint|
+					yield self.class.new(@url, endpoint, **@options)
+				end
+			end
+			
+			def key
+				[@url, @options]
+			end
+			
+			def eql? other
+				self.key.eql? other.key
+			end
+			
+			def hash
+				self.key.hash
+			end
+			
+			protected
+			
+			def tcp_options
+				options = @options.dup
+				
+				options.delete(:scheme)
+				options.delete(:port)
+				options.delete(:hostname)
+				options.delete(:ssl_context)
+				options.delete(:protocol)
+				
+				return options
+			end
+			
+			def tcp_endpoint
+				::IO::Endpoint.tcp(self.hostname, port, **tcp_options)
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/authenticated.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Authenticated
+				# Authentication has failed for some reason.
+				class AuthenticationError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter credentials [Array] The credentials to use for authentication.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(credentials, protocol = Async::Redis::Protocol::RESP2)
+					@credentials = credentials
+					@protocol = protocol
+				end
+				
+				attr :credentials
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["AUTH", *@credentials])
+					response = client.read_response
+					
+					if response != "OK"
+						raise AuthenticationError, "Could not authenticate: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/resp2.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require 'protocol/redis'
 
@@ -15,7 +15,7 @@ module Async
 					end
 					
 					def viable?
-						@stream.connected?
+						@stream.readable?
 					end
 					
 					def reusable?

data/lib/async/redis/protocol/selected.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Selected
+				# Authentication has failed for some reason.
+				class SelectionError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter index [Integer] The database index to select.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(index, protocol = Async::Redis::Protocol::RESP2)
+					@index = index
+					@protocol = protocol
+				end
+				
+				attr :index
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["SELECT", @index])
+					response = client.read_response
+					
+					if response != "OK"
+						raise SelectionError, "Could not select database: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

data/lib/async/redis/sentinels.rb

@@ -2,91 +2,100 @@
 
 # Released under the MIT License.
 # Copyright, 2020, by David Ortiz.
-# Copyright, 2023, by Samuel Williams.
+# Copyright, 2023-2024, by Samuel Williams.
+
+require 'io/stream'
 
 module Async
 	module Redis
 		class SentinelsClient < Client
 			def initialize(master_name, sentinels, role = :master, protocol = Protocol::RESP2, **options)
 				@master_name = master_name
+				
 				@sentinel_endpoints = sentinels.map do |sentinel|
-					Async::IO::Endpoint.tcp(sentinel[:host], sentinel[:port])
+					::IO::Endpoint.tcp(sentinel[:host], sentinel[:port])
 				end
+				
 				@role = role
-
 				@protocol = protocol
 				@pool = connect(**options)
 			end
-
+			
 			private
-
+			
 			# Override the parent method. The only difference is that this one needs
 			# to resolve the master/slave address.
 			def connect(**options)
 				Async::Pool::Controller.wrap(**options) do
 					endpoint = resolve_address
 					peer = endpoint.connect
-					stream = IO::Stream.new(peer)
-
+					stream = ::IO::Stream(peer)
+					
 					@protocol.client(stream)
 				end
 			end
-
+			
 			def resolve_address
-				address = case @role
-									when :master then resolve_master
-									when :slave then resolve_slave
-									else raise ArgumentError, "Unknown instance role #{@role}"
-									end
-
+				case @role
+				when :master
+					resolve_master
+				when :slave
+					resolve_slave
+				else
+					raise ArgumentError, "Unknown instance role #{@role}"
+				end => address
+				
 				address or raise RuntimeError, "Unable to fetch #{@role} via Sentinel."
 			end
-
+			
 			def resolve_master
 				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint)
-
+					client = Client.new(sentinel_endpoint, protocol: @protocol)
+					
 					begin
 						address = client.call('sentinel', 'get-master-addr-by-name', @master_name)
 					rescue Errno::ECONNREFUSED
 						next
 					end
-
-					return Async::IO::Endpoint.tcp(address[0], address[1]) if address
+					
+					return ::IO::Endpoint.tcp(address[0], address[1]) if address
 				end
-
+				
 				nil
 			end
-
+			
 			def resolve_slave
 				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint)
-
+					client = Client.new(sentinel_endpoint, protocol: @protocol)
+					
 					begin
 						reply = client.call('sentinel', 'slaves', @master_name)
 					rescue Errno::ECONNREFUSED
 						next
 					end
-
+					
 					slaves = available_slaves(reply)
 					next if slaves.empty?
-
+					
 					slave = select_slave(slaves)
-					return Async::IO::Endpoint.tcp(slave['ip'], slave['port'])
+					return ::IO::Endpoint.tcp(slave['ip'], slave['port'])
 				end
-
+				
 				nil
 			end
-
-			def available_slaves(slaves_cmd_reply)
+			
+			def available_slaves(reply)
 				# The reply is an array with the format: [field1, value1, field2,
 				# value2, etc.].
 				# When a slave is marked as down by the sentinel, the "flags" field
 				# (comma-separated array) contains the "s_down" value.
-				slaves_cmd_reply.map { |s| s.each_slice(2).to_h }
-						            .reject { |s| s.fetch('flags').split(',').include?('s_down') }
+				slaves = reply.map{|fields| fields.each_slice(2).to_h}
+				
+				slaves.reject do |slave|
+					slave['flags'].split(',').include?('s_down')
+				end
 			end
-
+			
 			def select_slave(available_slaves)
 				available_slaves.sample
 			end

data/lib/async/redis/version.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 module Async
 	module Redis
-		VERSION = "0.8.0"
+		VERSION = "0.9.0"
 	end
 end

data/license.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright, 2018-2023, by Samuel Williams.  
+Copyright, 2018-2024, by Samuel Williams.  
 Copyright, 2018, by Huba Nagy.  
 Copyright, 2019-2020, by David Ortiz.  
 Copyright, 2019, by Pierre Montelle.  

data/readme.md

@@ -1,111 +1,14 @@
 # Async::Redis
 
-An asynchronous client for Redis including TLS. Support for streaming requests and responses. Built on top of [async](https://github.com/socketry/async) and [async-io](https://github.com/socketry/async-io).
+An asynchronous client for Redis including TLS. Support for streaming requests and responses. Built on top of [async](https://github.com/socketry/async).
 
 [![Development Status](https://github.com/socketry/async-redis/workflows/Test/badge.svg)](https://github.com/socketry/async-redis/actions?workflow=Test)
 
-## Installation
-
-``` shell
-$ bundle add async-redis
-```
-
 ## Usage
 
-### Basic Local Connection
-
-``` ruby
-require 'async/redis'
-
-endpoint = Async::Redis.local_endpoint
-client = Async::Redis::Client.new(endpoint)
-
-Async do
-	pp client.info
-ensure
-	client.close
-end
-```
-
-### Connecting to Redis SSL Endpoint
-
-This example demonstrates parsing an environment variable with a `redis://` or SSL `rediss://` scheme, and demonstrates how you can specify SSL parameters on the SSLContext object.
-
-``` ruby
-require 'async/redis'
-
-def make_redis_endpoint(uri)
-	tcp_endpoint = Async::IO::Endpoint.tcp(uri.hostname, uri.port)
-	case uri.scheme
-	when 'redis'
-		tcp_endpoint
-	when 'rediss'
-		ssl_context = OpenSSL::SSL::SSLContext.new
-		ssl_context.set_params(
-			ca_file: "/path/to/ca.crt",
-			cert: OpenSSL::X509::Certificate.new(File.read("client.crt")),
-			key: OpenSSL::PKey::RSA.new(File.read("client.key")),
-		)
-		Async::IO::SSLEndpoint.new(tcp_endpoint, ssl_context: ssl_context)
-	else
-		raise ArgumentError
-	end
-end
-
-endpoint = make_redis_endpoint(URI(ENV['REDIS_URL']))
-client = Async::Redis::Client.new(endpoint)
-
-# ...
-```
+Please see the [project documentation](https://socketry.github.io/async-redis/) for more details.
 
-### Variables
-
-``` ruby
-require 'async'
-require 'async/redis'
-
-endpoint = Async::Redis.local_endpoint
-client = Async::Redis::Client.new(endpoint)
-
-Async do
-	client.set('X', 10)
-	pp client.get('X')
-ensure
-	client.close
-end
-```
-
-### Subscriptions
-
-``` ruby
-require 'async'
-require 'async/redis'
-
-endpoint = Async::Redis.local_endpoint
-client = Async::Redis::Client.new(endpoint)
-
-Async do |task|
-	condition = Async::Condition.new
-	
-	publisher = task.async do
-		condition.wait
-		
-		client.publish 'status.frontend', 'good'
-	end
-	
-	subscriber = task.async do
-		client.subscribe 'status.frontend' do |context|
-			condition.signal # We are waiting for messages.
-			
-			type, name, message = context.listen
-			
-			pp type, name, message
-		end
-	end
-ensure
-	client.close
-end
-```
+  - [Getting Started](https://socketry.github.io/async-redis/guides/getting-started/index) - This guide explains how to use the `async-redis` gem to connect to a Redis server and perform basic operations.
 
 ## Contributing
 
@@ -116,3 +19,11 @@ We welcome contributions to this project.
 3.  Commit your changes (`git commit -am 'Add some feature'`).
 4.  Push to the branch (`git push origin my-new-feature`).
 5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-redis
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -48,70 +48,78 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-06-13 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: async-pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: async-io
+  name: io-endpoint
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: async-pool
+  name: io-stream
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: protocol-redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
 description:
 email:
 executables: []
@@ -124,8 +132,11 @@ files:
 - lib/async/redis/context/pipeline.rb
 - lib/async/redis/context/subscribe.rb
 - lib/async/redis/context/transaction.rb
+- lib/async/redis/endpoint.rb
 - lib/async/redis/key.rb
+- lib/async/redis/protocol/authenticated.rb
 - lib/async/redis/protocol/resp2.rb
+- lib/async/redis/protocol/selected.rb
 - lib/async/redis/sentinels.rb
 - lib/async/redis/version.rb
 - license.md
@@ -133,7 +144,9 @@ files:
 homepage: https://github.com/socketry/async-redis
 licenses:
 - MIT
-metadata: {}
+metadata:
+  documentation_uri: https://socketry.github.io/async-redis/
+  source_code_uri: https://github.com/socketry/async-redis.git
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -142,14 +155,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A Redis client library.