protocol-rack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 336b02d7bf414f258948e6b3c865ff4ede58f534d6d883b9115d6e958fc40716
+  data.tar.gz: a83c9865d89da8d67873c7b91ddee8ae07e4eaf57191854834c12c0c0a7aee6a
+SHA512:
+  metadata.gz: 696e7b6094fdc826d28b5e13a05069fab7bcdb090e65add3c515a57ea3a452af43fd87b68ca22c2ad7869d73d065247c5f48656abfb0523ae66a451dcba026d3
+  data.tar.gz: 6d3143e5bea719225288bbb74e74d924c1f405a89ff358cea1679c71c5ec680a43b64ebf6bc8862b5ee6cf890f0241ab5fafddedf0c80a9c3b132574ca3d7fc9

data/lib/protocol/rack/adapter/generic.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, 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.
+
+require 'console'
+
+require_relative '../constants'
+require_relative '../input'
+require_relative '../response'
+
+module Protocol
+	module Rack
+		module Adapter
+			class Generic
+				def self.wrap(app)
+					self.new(app)
+				end
+				
+				# Initialize the rack adaptor middleware.
+				# @parameter app [Object] The rack middleware.
+				def initialize(app)
+					@app = app
+					
+					raise ArgumentError, "App must be callable!" unless @app.respond_to?(:call)
+				end
+				
+				def logger
+					Console.logger
+				end
+
+				# Unwrap raw HTTP headers into the CGI-style expected by Rack middleware.
+				#
+				# Rack separates multiple headers with the same key, into a single field with multiple lines.
+				#
+				# @parameter headers [Protocol::HTTP::Headers] The raw HTTP request headers.
+				# @parameter env [Hash] The rack request `env`.
+				def unwrap_headers(headers, env)
+					headers.each do |key, value|
+						http_key = "HTTP_#{key.upcase.tr('-', '_')}"
+						
+						if current_value = env[http_key]
+							env[http_key] = "#{current_value};#{value}"
+						else
+							env[http_key] = value
+						end
+					end
+				end
+				
+				# Process the incoming request into a valid rack `env`.
+				#
+				# - Set the `env['CONTENT_TYPE']` and `env['CONTENT_LENGTH']` based on the incoming request body. 
+				# - Set the `env['HTTP_HOST']` header to the request authority.
+				# - Set the `env['HTTP_X_FORWARDED_PROTO']` header to the request scheme.
+				# - Set `env['REMOTE_ADDR']` to the request remote adress.
+				#
+				# @parameter request [Protocol::HTTP::Request] The incoming request.
+				# @parameter env [Hash] The rack `env`.
+				def unwrap_request(request, env)
+					if content_type = request.headers.delete('content-type')
+						env[CGI::CONTENT_TYPE] = content_type
+					end
+					
+					# In some situations we don't know the content length, e.g. when using chunked encoding, or when decompressing the body.
+					if body = request.body and length = body.length
+						env[CGI::CONTENT_LENGTH] = length.to_s
+					end
+					
+					self.unwrap_headers(request.headers, env)
+					
+					# HTTP/2 prefers `:authority` over `host`, so we do this for backwards compatibility.
+					env[CGI::HTTP_HOST] ||= request.authority
+								
+					if request.respond_to?(:remote_address)
+						if remote_address = request.remote_address
+							env[CGI::REMOTE_ADDR] = remote_address.ip_address if remote_address.ip?
+						end
+					end
+				end
+				
+				# Build a rack `env` from the incoming request and apply it to the rack middleware.
+				#
+				# @parameter request [Protocol::HTTP::Request] The incoming request.
+				def call(request)
+					env = self.make_environment(request)
+					
+					status, headers, body = @app.call(env)
+					
+					return Response.wrap(status, headers, body, request)
+				rescue => exception
+					Console.logger.error(self) {exception}
+					
+					body&.close if body.respond_to?(:close)
+
+					return failure_response(exception)
+				end
+				
+				private
+
+				# Generate a suitable response for the given exception.
+				# @parameter exception [Exception]
+				# @returns [Protocol::HTTP::Response]
+				def failure_response(exception)
+					Protocol::HTTP::Response.for_exception(exception)
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/adapter/rack2.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, 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.
+
+require 'console'
+
+require_relative 'generic'
+require_relative '../rewindable'
+
+module Protocol
+	module Rack
+		module Adapter
+			class Rack2	< Generic
+				RACK_VERSION = 'rack.version'
+				RACK_MULTITHREAD = 'rack.multithread'
+				RACK_MULTIPROCESS = 'rack.multiprocess'
+				RACK_RUN_ONCE = 'rack.run_once'
+				
+				RACK_IS_HIJACK = 'rack.hijack?'
+				RACK_HIJACK = 'rack.hijack'
+				
+				def self.wrap(app)
+					Rewindable.new(self.new(app))
+				end
+				
+				def make_environment(request)
+					request_path, query_string = request.path.split('?', 2)
+					server_name, server_port = (request.authority || '').split(':', 2)
+					
+					env = {
+						RACK_VERSION => [2, 0],
+						RACK_MULTITHREAD => false,
+						RACK_MULTIPROCESS => true,
+						RACK_RUN_ONCE => false,
+						
+						PROTOCOL_HTTP_REQUEST => request,
+						
+						RACK_INPUT => Input.new(request.body),
+						RACK_ERRORS => $stderr,
+						RACK_LOGGER => self.logger,
+
+						# The request protocol, either from the upgrade header or the HTTP/2 pseudo header of the same name.
+						RACK_PROTOCOL => request.protocol,
+						
+						# The HTTP request method, such as “GET” or “POST”. This cannot ever be an empty string, and so is always required.
+						CGI::REQUEST_METHOD => request.method,
+						
+						# The initial portion of the request URL's “path” that corresponds to the application object, so that the application knows its virtual “location”. This may be an empty string, if the application corresponds to the “root” of the server.
+						CGI::SCRIPT_NAME => '',
+						
+						# The remainder of the request URL's “path”, designating the virtual “location” of the request's target within the application. This may be an empty string, if the request URL targets the application root and does not have a trailing slash. This value may be percent-encoded when originating from a URL.
+						CGI::PATH_INFO => request_path,
+						CGI::REQUEST_PATH => request_path,
+						CGI::REQUEST_URI => request.path,
+
+						# The portion of the request URL that follows the ?, if any. May be empty, but is always required!
+						CGI::QUERY_STRING => query_string || '',
+						
+						# The server protocol (e.g. HTTP/1.1):
+						CGI::SERVER_PROTOCOL => request.version,
+						
+						# The request scheme:
+						RACK_URL_SCHEME => request.scheme,
+						
+						# I'm not sure what sane defaults should be here:
+						CGI::SERVER_NAME => server_name,
+						CGI::SERVER_PORT => server_port,
+					}
+					
+					self.unwrap_request(request, env)
+					
+					return env
+				end
+				
+				def self.make_response(env, response)
+					# These interfaces should be largely compatible:
+					headers = response.headers.to_h
+					if protocol = response.protocol
+						headers['rack.protocol'] = protocol
+					end
+					
+					if body = response.body and body.stream?
+						if env[RACK_IS_HIJACK]
+							headers[RACK_HIJACK] = body
+							body = []
+						end
+					end
+					  
+					[response.status, headers, body]
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/adapter/rack3.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, 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.
+
+require 'console'
+
+require_relative 'generic'
+
+module Protocol
+	module Rack
+		module Adapter
+			class Rack3 < Generic
+				def self.wrap(app)
+					self.new(app)
+				end
+				
+				def make_environment(request)
+					request_path, query_string = request.path.split('?', 2)
+					server_name, server_port = (request.authority || '').split(':', 2)
+					
+					env = {
+						PROTOCOL_HTTP_REQUEST => request,
+						
+						RACK_INPUT => Input.new(request.body),
+						RACK_ERRORS => $stderr,
+						RACK_LOGGER => self.logger,
+
+						# The request protocol, either from the upgrade header or the HTTP/2 pseudo header of the same name.
+						RACK_PROTOCOL => request.protocol,
+						
+						# The HTTP request method, such as “GET” or “POST”. This cannot ever be an empty string, and so is always required.
+						CGI::REQUEST_METHOD => request.method,
+						
+						# The initial portion of the request URL's “path” that corresponds to the application object, so that the application knows its virtual “location”. This may be an empty string, if the application corresponds to the “root” of the server.
+						CGI::SCRIPT_NAME => '',
+						
+						# The remainder of the request URL's “path”, designating the virtual “location” of the request's target within the application. This may be an empty string, if the request URL targets the application root and does not have a trailing slash. This value may be percent-encoded when originating from a URL.
+						CGI::PATH_INFO => request_path,
+						CGI::REQUEST_PATH => request_path,
+						CGI::REQUEST_URI => request.path,
+
+						# The portion of the request URL that follows the ?, if any. May be empty, but is always required!
+						CGI::QUERY_STRING => query_string || '',
+						
+						# The server protocol (e.g. HTTP/1.1):
+						CGI::SERVER_PROTOCOL => request.version,
+						
+						# The request scheme:
+						RACK_URL_SCHEME => request.scheme,
+						
+						# I'm not sure what sane defaults should be here:
+						CGI::SERVER_NAME => server_name,
+						CGI::SERVER_PORT => server_port,
+					}
+					
+					self.unwrap_request(request, env)
+					
+					return env
+				end
+				
+				def self.make_response(env, response)
+					# These interfaces should be largely compatible:
+					headers = response.headers.to_h
+					if protocol = response.protocol
+						headers['rack.protocol'] = protocol
+					end
+					
+					if body = response.body and body.stream?
+						# Force streaming response:
+						body = proc{|stream| body.call(stream)}
+					end
+					  
+					[response.status, headers, body]
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/adapter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, 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.
+
+require_relative 'adapter/rack2'
+require_relative 'adapter/rack3'
+
+module Protocol
+	module Rack
+		module Adapter
+			if ::Rack::RELEASE >= "3"
+				IMPLEMENTATION = Rack3
+			else
+				IMPLEMENTATION = Rack2
+			end
+			
+			def self.new(app)
+				IMPLEMENTATION.wrap(app)
+			end
+			
+			def self.make_response(env, response)
+				IMPLEMENTATION.make_response(env, response)
+			end
+		end
+	end
+end

data/lib/protocol/rack/body/enumerable.rb

@@ -0,0 +1,119 @@
+# 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.
+
+require 'protocol/http/body/readable'
+require 'protocol/http/body/file'
+
+module Protocol
+	module Rack
+		module Body
+			# Wraps the rack response body.
+			#
+			# The `rack` body must respond to `each` and must only yield `String` values. If the body responds to `close`, it will be called after iteration.
+			class Enumerable < ::Protocol::HTTP::Body::Readable
+				CONTENT_LENGTH = 'content-length'.freeze
+				
+				# Wraps an array into a buffered body.
+				# @parameter body [Object] The `rack` response body.
+				def self.wrap(body, length = nil)
+					if body.is_a?(Array)
+						length ||= body.sum(&:bytesize)
+						return self.new(body, length)
+					else
+						return self.new(body, length)
+					end
+				end
+				
+				# Initialize the output wrapper.
+				# @parameter body [Object] The rack response body.
+				# @parameter length [Integer] The rack response length.
+				def initialize(body, length)
+					@length = length
+					@body = body
+					
+					@chunks = nil
+				end
+				
+				# The rack response body.
+				attr :body
+				
+				# The content length of the rack response body.
+				attr :length
+				
+				# Whether the body is empty.
+				def empty?
+					@length == 0 or (@body.respond_to?(:empty?) and @body.empty?)
+				end
+				
+				# Whether the body can be read immediately.
+				def ready?
+					body.is_a?(Array) or body.respond_to?(:to_ary)
+				end
+				
+				# Close the response body.
+				def close(error = nil)
+					if @body and @body.respond_to?(:close)
+						@body.close
+					end
+					
+					@body = nil
+					@chunks = nil
+					
+					super
+				end
+				
+				# Enumerate the response body.
+				# @yields {|chunk| ...}
+				# 	@parameter chunk [String]
+				def each(&block)
+					@body.each(&block)
+				ensure
+					self.close($!)
+				end
+				
+				def stream?
+					!@body.respond_to?(:each)
+				end
+
+				def call(stream)
+					@body.call(stream)
+				ensure
+					self.close($!)
+				end
+
+				# Read the next chunk from the response body.
+				# @returns [String | Nil]
+				def read
+					@chunks ||= @body.to_enum(:each)
+					
+					return @chunks.next
+				rescue StopIteration
+					return nil
+				end
+				
+				def inspect
+					"\#<#{self.class} length=#{@length.inspect} body=#{@body.class}>"
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/body/input_wrapper.rb

@@ -0,0 +1,59 @@
+# 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.
+
+require 'protocol/http/body/readable'
+require 'protocol/http/body/stream'
+
+module Protocol
+	module Rack
+		module Body
+			# Used for wrapping a generic `rack.input` object into a readable body.
+			class InputWrapper < Protocol::HTTP::Body::Readable
+				BLOCK_SIZE = 1024*4
+				
+				def initialize(io, block_size: BLOCK_SIZE)
+					@io = io
+					@block_size = block_size
+					
+					super()
+				end
+				
+				def close(error = nil)
+					if @io
+						@io.close
+						@io = nil
+					end
+				end
+				
+				# def join
+				# 	@io.read.tap do |buffer|
+				# 		buffer.force_encoding(Encoding::BINARY)
+				# 	end
+				# end
+				
+				def read
+					@io&.read(@block_size)
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/body/streaming.rb

@@ -0,0 +1,72 @@
+# 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.
+
+require 'protocol/http/body/readable'
+require 'protocol/http/body/stream'
+
+module Protocol
+	module Rack
+		module Body
+			# Wraps a streaming response body into a compatible Protocol::HTTP body.
+			class Streaming < ::Protocol::HTTP::Body::Readable
+				def initialize(block, input = nil)
+					@block = block
+					@input = input
+				end
+				
+				attr :block
+
+				def each(&block)
+					stream = ::Protocol::HTTP::Body::Stream.new(@input, Output.new(block))
+					
+					@block.call(stream)
+				end
+
+				def stream?
+					true
+				end
+
+				def call(stream)
+					@block.call(stream)
+				end
+				
+				class Output
+					def initialize(block)
+						@block = block
+					end
+					
+					def write(chunk)
+						@block.call(chunk)
+					end
+					
+					def close
+						@block = nil
+					end
+					
+					def empty?
+						true
+					end
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/body.rb

@@ -0,0 +1,58 @@
+# 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.
+
+require_relative 'body/streaming'
+require_relative 'body/enumerable'
+
+module Protocol
+	module Rack
+		module Body
+			CONTENT_LENGTH = 'content-length'
+			
+			def self.wrap(status, headers, body, input = nil)
+				# In no circumstance do we want this header propagating out:
+				if length = headers.delete(CONTENT_LENGTH)
+					# We don't really trust the user to provide the right length to the transport.
+					length = Integer(length)
+				end
+
+				# If we have an Async::HTTP body, we return it directly:
+				if body.is_a?(::Protocol::HTTP::Body::Readable)
+					return body
+				elsif status == 200 and body.respond_to?(:to_path)
+					begin
+						# Don't mangle partial responses (206)
+						return ::Protocol::HTTP::Body::File.open(body.to_path).tap do
+							body.close if body.respond_to?(:close) # Close the original body.
+						end
+					rescue Errno::ENOENT
+						# If the file is not available, ignore.
+					end
+				elsif body.respond_to?(:each)
+					body = Body::Enumerable.wrap(body, length)
+				else
+					body = Body::Streaming.new(body, input)
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/constants.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Copyright, 2017, 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.
+
+require 'rack'
+
+require_relative 'input'
+require_relative 'response'
+
+require 'console'
+
+module Protocol
+	module Rack
+		# Used for injecting the raw request in the the rack environment.
+		PROTOCOL_HTTP_REQUEST = "protocol.http.request"
+		
+		# CGI keys <https://tools.ietf.org/html/rfc3875#section-4.1>:
+		module CGI
+			HTTP_HOST = 'HTTP_HOST'
+			PATH_INFO = 'PATH_INFO'
+			REQUEST_METHOD = 'REQUEST_METHOD'
+			REQUEST_PATH = 'REQUEST_PATH'
+			REQUEST_URI = 'REQUEST_URI'
+			SCRIPT_NAME = 'SCRIPT_NAME'
+			QUERY_STRING = 'QUERY_STRING'
+			SERVER_PROTOCOL = 'SERVER_PROTOCOL'
+			SERVER_NAME = 'SERVER_NAME'
+			SERVER_PORT = 'SERVER_PORT'
+			REMOTE_ADDR = 'REMOTE_ADDR'
+			CONTENT_TYPE = 'CONTENT_TYPE'
+			CONTENT_LENGTH = 'CONTENT_LENGTH'
+			
+			# Header constants:
+			HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO'
+		end
+		
+		# Rack environment variables:
+		RACK_ERRORS = 'rack.errors'
+		RACK_LOGGER = 'rack.logger'
+		RACK_INPUT = 'rack.input'
+		RACK_URL_SCHEME = 'rack.url_scheme'
+		RACK_PROTOCOL = 'rack.protocol'
+	end
+end

data/lib/protocol/rack/input.rb

@@ -0,0 +1,125 @@
+# 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.
+
+require 'async/io/buffer'
+require 'protocol/http/body/stream'
+
+module Protocol
+	module Rack
+		# Wraps a streaming input body into the interface required by `rack.input`.
+		#
+		# The input stream is an `IO`-like object which contains the raw HTTP POST data. When applicable, its external encoding must be `ASCII-8BIT` and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to `gets`, `each`, `read` and `rewind`.
+		#
+		# This implementation is not always rewindable, to avoid buffering the input when handling large uploads. See {Rewindable} for more details.
+		class Input
+			# Initialize the input wrapper.
+			# @parameter body [Protocol::HTTP::Body::Readable]
+			def initialize(body)
+				@body = body
+				
+				# Will hold remaining data in `#read`.
+				@buffer = nil
+			end
+			
+			# The input body.
+			# @attribute [Protocol::HTTP::Body::Readable]
+			attr :body
+			
+			# Enumerate chunks of the request body.
+			# @yields {|chunk| ...}
+			# 	@parameter chunk [String]
+			def each(&block)
+				return to_enum unless block_given?
+				
+				while chunk = gets
+					yield chunk
+				end
+			end
+			
+			include Protocol::HTTP::Body::Stream::Reader
+			
+			# Read the next chunk of data from the input stream.
+			#
+			# `gets` must be called without arguments and return a `String`, or `nil` when the input stream has no more data.
+			#
+			# @returns [String | Nil] The next chunk from the body.
+			def gets
+				if @buffer.nil?
+					return read_next
+				else
+					buffer = @buffer
+					@buffer = nil
+					return buffer
+				end
+			end
+			
+			# Close the input and output bodies.
+			def close(error = nil)
+				if @body
+					@body.close(error)
+					@body = nil
+				end
+				
+				return nil
+			end
+			
+			# Rewind the input stream back to the start.
+			#
+			# `rewind` must be called without arguments. It rewinds the input stream back to the beginning. It must not raise Errno::ESPIPE: that is, it may not be a pipe or a socket. Therefore, handler developers must buffer the input data into some rewindable object if the underlying input stream is not rewindable.
+			#
+			# @returns [Boolean] Whether the body could be rewound.
+			def rewind
+				if @body and @body.respond_to?(:rewind)
+					# If the body is not rewindable, this will fail.
+					@body.rewind
+					@buffer = nil
+					@finished = false
+					
+					return true
+				end
+				
+				return false
+			end
+			
+			# Whether the stream has been closed.
+			def closed?
+				@body.nil?
+			end
+			
+			# Whether there are any output chunks remaining?
+			def empty?
+				@output.empty?
+			end
+			
+			private
+			
+			def read_next
+				if @body
+					@body.read
+				else
+					@body = nil
+					raise IOError, "Stream is not readable, input has been closed!"
+				end
+			end
+		end
+	end
+end

data/lib/protocol/rack/request.rb

@@ -0,0 +1,72 @@
+# 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.
+
+require 'protocol/http/request'
+
+require_relative 'body/input_wrapper'
+
+module Protocol
+	module Rack
+		class Request < ::Protocol::HTTP::Request
+			def self.[](env)
+				env['protocol.http.request'] ||= new(env)
+			end
+
+			def initialize(env)
+				@env = env
+
+				super(
+					@env['rack.url_scheme'],
+					@env['HTTP_HOST'],
+					@env['REQUEST_METHOD'],
+					@env['PATH_INFO'],
+					@env['SERVER_PROTOCOL'],
+					self.class.headers(@env),
+					Body::InputWrapper.new(@env['rack.input']),
+					self.class.protocol(@env)
+				)
+			end
+
+			HTTP_UPGRADE = 'HTTP_UPGRADE'
+
+			def self.protocol(env)
+				if protocols = env['rack.protocol']
+					return Array(protocols)
+				elsif protocols = env[HTTP_UPGRADE]
+					return protocols.split(/\s*,\s*/)
+				end
+			end
+
+			def self.headers(env)
+				headers = ::Protocol::HTTP::Headers.new
+				env.each do |key, value|			
+					if key.start_with?('HTTP_')
+						next if key == 'HTTP_HOST'
+						headers[key[5..-1].gsub('_', '-').downcase] = value
+					end
+				end
+
+				return headers
+			end
+		end
+	end
+end

data/lib/protocol/rack/response.rb

@@ -0,0 +1,118 @@
+# 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.
+
+require_relative 'body'
+require_relative 'constants'
+# require 'time'
+
+require 'protocol/http/response'
+require 'protocol/http/headers'
+
+module Protocol
+	module Rack
+		# A wrapper for a `Rack` response.
+		#
+		# A Rack response consisting of `[status, headers, body]` includes various rack-specific elements, including:
+		#
+		# - A `headers['rack.hijack']` callback which bypasses normal response handling.
+		# - Potentially invalid content length.
+		# - Potentially invalid body when processing a `HEAD` request.
+		# - Newline-separated header values.
+		# - Other `rack.` specific header key/value pairs.
+		#
+		# This wrapper takes those issues into account and adapts the rack response tuple into a {Protocol::HTTP::Response}.
+		class Response < ::Protocol::HTTP::Response
+			# HTTP hop headers which *should* not be passed through the proxy.
+			HOP_HEADERS = [
+				'connection',
+				'keep-alive',
+				'public',
+				'proxy-authenticate',
+				'transfer-encoding',
+				'upgrade',
+			]
+			
+			# Process the rack response headers into into a {Protocol::HTTP::Headers} instance, along with any extra `rack.` metadata.
+			# @returns [Tuple(Protocol::HTTP::Headers, Hash)]
+			def self.wrap_headers(fields)
+				headers = ::Protocol::HTTP::Headers.new
+				meta = {}
+				
+				fields.each do |key, value|
+					key = key.downcase
+					
+					if key.start_with?('rack.')
+						meta[key] = value
+					elsif value.is_a?(Array)
+						value.each do |value|
+							headers[key] = value
+						end
+					else
+						headers[key] = value
+					end
+				end
+				
+				return headers, meta
+			end
+			
+			# Wrap a rack response.
+			# @parameter status [Integer] The rack response status.
+			# @parameter headers [Duck(:each)] The rack response headers.
+			# @parameter body [Duck(:each, :close) | Nil] The rack response body.
+			# @parameter request [Protocol::HTTP::Request] The original request.
+			def self.wrap(status, headers, body, request = nil)
+				headers, meta = wrap_headers(headers)
+
+				ignored = headers.extract(HOP_HEADERS)
+				unless ignored.empty?
+					Console.logger.warn(self, "Ignoring protocol-level headers: #{ignored.inspect}")
+				end
+
+				body = Body.wrap(status, headers, body, request&.body)
+
+				if request&.head?
+					# I thought about doing this in Output.wrap, but decided the semantics are too tricky. Specifically, the various ways a rack response body can be wrapped, and the need to invoke #close at the right point.
+					body = ::Protocol::HTTP::Body::Head.for(body)
+				end
+				
+				protocol = meta[RACK_PROTOCOL]
+				
+				# https://tools.ietf.org/html/rfc7231#section-7.4.2
+				# headers.add('server', "falcon/#{Falcon::VERSION}")
+				
+				# https://tools.ietf.org/html/rfc7231#section-7.1.1.2
+				# headers.add('date', Time.now.httpdate)
+				
+				return self.new(status, headers, body, protocol)
+			end
+			
+			# Initialize the response wrapper.
+			# @parameter status [Integer] The response status.
+			# @parameter headers [Protocol::HTTP::Headers] The response headers.
+			# @parameter body [Protocol::HTTP::Body] The response body.
+			# @parameter protocol [String] The response protocol for upgraded requests.
+			def initialize(status, headers, body, protocol = nil)
+				super(nil, status, headers, body, protocol)
+			end
+		end
+	end
+end

data/lib/protocol/rack/rewindable.rb

@@ -0,0 +1,79 @@
+# 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.
+
+require 'protocol/http/body/rewindable'
+require 'protocol/http/middleware'
+
+module Protocol
+	module Rack
+		# Content-type driven input buffering, specific to the needs of `rack`.
+		class Rewindable < ::Protocol::HTTP::Middleware
+			# Media types that require buffering.
+			BUFFERED_MEDIA_TYPES = %r{
+				application/x-www-form-urlencoded|
+				multipart/form-data|
+				multipart/related|
+				multipart/mixed
+			}x
+			
+			POST = 'POST'
+			
+			# Initialize the rewindable middleware.
+			# @parameter app [Protocol::HTTP::Middleware] The middleware to wrap.
+			def initialize(app)
+				super(app)
+			end
+			
+			# Determine whether the request needs a rewindable body.
+			# @parameter request [Protocol::HTTP::Request]
+			# @returns [Boolean]
+			def needs_rewind?(request)
+				content_type = request.headers['content-type']
+				
+				if request.method == POST and content_type.nil?
+					return true
+				end
+				
+				if BUFFERED_MEDIA_TYPES =~ content_type
+					return true
+				end
+				
+				return false
+			end
+			
+			def make_environment(request)
+				@delegate.make_environment(request)
+			end
+			
+			# Wrap the request body in a rewindable buffer if required.
+			# @parameter request [Protocol::HTTP::Request]
+			# @returns [Protocol::HTTP::Response] the response.
+			def call(request)
+				if body = request.body and needs_rewind?(request)
+					request.body = Protocol::HTTP::Body::Rewindable.new(body)
+				end
+				
+				return super
+			end
+		end
+	end
+end

data/lib/protocol/rack/version.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Copyright, 2022, 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 Rack
+		VERSION = "0.1.0"
+	end
+end

data/lib/protocol/rack.rb

@@ -0,0 +1,26 @@
+# 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.
+
+require_relative 'rack/version'
+require_relative 'rack/adapter'
+require_relative 'rack/request'
+require_relative 'rack/response'

data.tar.gz.sig

@@ -0,0 +1 @@
+-#Ϡ�|���n���8������a���nOKצ�7�/z�9�ı5�f�f��Q�����=Ø�H�e6&R==����T*EMJ��\:���xm�+P$Tx0����X�F�'�B����l�,����+�h���9��cm��2����#��uYX}?�����q����z����������P�7vyX�5��B���ɰCȢ�E�7��9!ZZv�S3T�q��7�+�҂,���=R��"�F��zAlh�e���S���k���-˜�.&�};H��R�Y-(�F�֝:�������B��M�I����/��QA��Ŵ��گ"��Q`�r�h���ȸ�N��q(�S'y�Y�P!��^!���𷞇'd�

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: protocol-rack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 2022-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: protocol-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.4
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/protocol/rack.rb
+- lib/protocol/rack/adapter.rb
+- lib/protocol/rack/adapter/generic.rb
+- lib/protocol/rack/adapter/rack2.rb
+- lib/protocol/rack/adapter/rack3.rb
+- lib/protocol/rack/body.rb
+- lib/protocol/rack/body/enumerable.rb
+- lib/protocol/rack/body/input_wrapper.rb
+- lib/protocol/rack/body/streaming.rb
+- lib/protocol/rack/constants.rb
+- lib/protocol/rack/input.rb
+- lib/protocol/rack/request.rb
+- lib/protocol/rack/response.rb
+- lib/protocol/rack/rewindable.rb
+- lib/protocol/rack/version.rb
+homepage: https://github.com/socketry/protocol-rack
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: An implementation of the Rack protocol/specification.
+test_files: []