protocol-http 0.22.9 → 0.23.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b1672fc86e8bbe321f648e200205314ee472f9b01c326882f089e149b584f11
-  data.tar.gz: acbe42e8d8af4b50d018325b0204cec345ed161fbb7eba0583a512ce65c0a713
+  metadata.gz: e75d177999c829771f7425826d9780247d787ae7a145bd6d90db46466c485b6d
+  data.tar.gz: 63bb4af0ed06afe86f513b3c78606fe87d7beec9f38c95d2c1dafe0eb1fa69dc
 SHA512:
-  metadata.gz: 1cda8cf0c22f5d9a01a308cc83f2b80209bc3ad98ec84c5082d0846e6835224bb6c2ef9f9cc25b12eaa542f77000fa13c7cc9d2aba2107ba362e737c13ef90a0
-  data.tar.gz: 4fcd1417896726bce8019ea8fc5ebdbd92f07484611855c4cc04b0ba1a59deb18a79dd1d0c4b8978b7ec48c3c27376b09f3d75cd33728d4d5474093a08699694
+  metadata.gz: db0297861b7a15bdbe274410952604bf7b8fdb6e981439b2fc42bad0453d71104dbc87c9268b4ba45d5b6f905777cbf2e0065a0c4c6ae3e895b2bc33c34bb679
+  data.tar.gz: c411551f450228472f3010b34bf4069416bbcfb05d9408d2d9d0d058bbb960afb468b66a193c43848b27cb2e1181bc56292b4f2f3171665351a9fca17f1b3fb6

data/lib/protocol/http/body/buffered.rb

@@ -56,7 +56,6 @@ module Protocol
 					@length = length
 					
 					@index = 0
-					@digest = nil
 				end
 				
 				attr :chunks
@@ -87,7 +86,6 @@ module Protocol
 				end
 				
 				def write(chunk)
-					@digest&.update(chunk)
 					@chunks << chunk
 				end
 				

data/lib/protocol/http/body/stream.rb

@@ -41,99 +41,104 @@ module Protocol
 				attr :input
 				attr :output
 				
-				# rack.hijack_io must respond to:
-				# read, write, read_nonblock, write_nonblock, flush, close, close_read, close_write, closed?
-				
-				# read behaves like IO#read. Its signature is read([length, [buffer]]). If given, length must be a non-negative Integer (>= 0) or nil, and buffer must be a String and may not be nil. If length is given and not nil, then this method reads at most length bytes from the input stream. If length is not given or nil, then this method reads all data until EOF. When EOF is reached, this method returns nil if length is given and not nil, or “” if length is not given or is nil. If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
-				# @param length [Integer] the amount of data to read
-				# @param buffer [String] the buffer which will receive the data
-				# @return a buffer containing the data
-				def read(length = nil, buffer = nil)
-					return '' if length == 0
+				# This provides a read-only interface for data, which is surprisingly tricky to implement correctly.
+				module Reader
+					# rack.hijack_io must respond to:
+					# read, write, read_nonblock, write_nonblock, flush, close, close_read, close_write, closed?
 					
-					buffer ||= Async::IO::Buffer.new
+					# read behaves like IO#read. Its signature is read([length, [buffer]]). If given, length must be a non-negative Integer (>= 0) or nil, and buffer must be a String and may not be nil. If length is given and not nil, then this method reads at most length bytes from the input stream. If length is not given or nil, then this method reads all data until EOF. When EOF is reached, this method returns nil if length is given and not nil, or “” if length is not given or is nil. If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
+					# @param length [Integer] the amount of data to read
+					# @param buffer [String] the buffer which will receive the data
+					# @return a buffer containing the data
+					def read(length = nil, buffer = nil)
+						return '' if length == 0
+						
+						buffer ||= Async::IO::Buffer.new
 
-					# Take any previously buffered data and replace it into the given buffer.
-					if @buffer
-						buffer.replace(@buffer)
-						@buffer = nil
-					end
-					
-					if length
-						while buffer.bytesize < length and chunk = read_next
-							buffer << chunk
+						# Take any previously buffered data and replace it into the given buffer.
+						if @buffer
+							buffer.replace(@buffer)
+							@buffer = nil
 						end
 						
-						# This ensures the subsequent `slice!` works correctly.
-						buffer.force_encoding(Encoding::BINARY)
+						if length
+							while buffer.bytesize < length and chunk = read_next
+								buffer << chunk
+							end
+							
+							# This ensures the subsequent `slice!` works correctly.
+							buffer.force_encoding(Encoding::BINARY)
 
-						# This will be at least one copy:
-						@buffer = buffer.byteslice(length, buffer.bytesize)
-						
-						# This should be zero-copy:
-						buffer.slice!(length)
-						
-						if buffer.empty?
-							return nil
+							# This will be at least one copy:
+							@buffer = buffer.byteslice(length, buffer.bytesize)
+							
+							# This should be zero-copy:
+							buffer.slice!(length, buffer.bytesize)
+							
+							if buffer.empty?
+								return nil
+							else
+								return buffer
+							end
 						else
+							while chunk = read_next
+								buffer << chunk
+							end
+							
 							return buffer
 						end
-					else
-						while chunk = read_next
-							buffer << chunk
+					end
+					
+					# Read at most `length` bytes from the stream. Will avoid reading from the underlying stream if possible.
+					def read_partial(length = nil)
+						if @buffer
+							buffer = @buffer
+							@buffer = nil
+						else
+							buffer = read_next
+						end
+						
+						if buffer and length
+							if buffer.bytesize > length
+								# This ensures the subsequent `slice!` works correctly.
+								buffer.force_encoding(Encoding::BINARY)
+
+								@buffer = buffer.byteslice(length, buffer.bytesize)
+								buffer.slice!(length, buffer.bytesize)
+							end
 						end
 						
 						return buffer
 					end
-				end
-				
-				# Read at most `length` bytes from the stream. Will avoid reading from the underlying stream if possible.
-				def read_partial(length = nil)
-					if @buffer
-						buffer = @buffer
-						@buffer = nil
-					else
-						buffer = read_next
-					end
 					
-					if buffer and length
-						if buffer.bytesize > length
-							# This ensures the subsequent `slice!` works correctly.
-							buffer.force_encoding(Encoding::BINARY)
-
-							@buffer = buffer.byteslice(length, buffer.bytesize)
-							buffer.slice!(length)
+					def read_nonblock(length, buffer = nil)
+						@buffer ||= read_next
+						chunk = nil
+						
+						unless @buffer
+							buffer&.clear
+							return
+						end
+						
+						if @buffer.bytesize > length
+							chunk = @buffer.byteslice(0, length)
+							@buffer = @buffer.byteslice(length, @buffer.bytesize)
+						else
+							chunk = @buffer
+							@buffer = nil
 						end
+						
+						if buffer
+							buffer.replace(chunk)
+						else
+							buffer = chunk
+						end
+						
+						return buffer
 					end
-					
-					return buffer
 				end
 				
-				def read_nonblock(length, buffer = nil)
-					@buffer ||= read_next
-					chunk = nil
-					
-					unless @buffer
-						buffer&.clear
-						return
-					end
-					
-					if @buffer.bytesize > length
-						chunk = @buffer.byteslice(0, length)
-						@buffer = @buffer.byteslice(length, @buffer.bytesize)
-					else
-						chunk = @buffer
-						@buffer = nil
-					end
-					
-					if buffer
-						buffer.replace(chunk)
-					else
-						buffer = chunk
-					end
-					
-					return buffer
-				end
+				include Reader
 				
 				def write(buffer)
 					if @output

data/lib/protocol/http/headers.rb

@@ -340,11 +340,11 @@ module Protocol
 					return self
 				end
 				
-				# @yield [String, String] header key (lower case) and value (as string).
+				# @yields [String, String] header key (lower case string) and value (as string).
 				def each(&block)
 					@all.each do |headers|
 						headers.each do |key, value|
-							yield key.downcase, value.to_s
+							yield key.to_s.downcase, value.to_s
 						end
 					end
 				end

data/lib/protocol/http/request.rb

@@ -39,13 +39,28 @@ module Protocol
 				@protocol = protocol
 			end
 			
+			# The request scheme, usually one of "http" or "https".
 			attr_accessor :scheme
+
+			# The request authority, usually a hostname and port number.
 			attr_accessor :authority
+
+			# The request method, usually one of "GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT" or "OPTIONS".
 			attr_accessor :method
+
+			# The request path, usually a path and query string.
 			attr_accessor :path
+
+			# The request version, usually "http/1.0", "http/1.1", "h2", or "h3".
 			attr_accessor :version
+
+			# The request headers, contains metadata associated with the request such as the user agent, accept (content type), accept-language, etc.
 			attr_accessor :headers
+
+			# The request body, an instance of Protocol::HTTP::Body::Readable or similar.
 			attr_accessor :body
+
+			# The request protocol, usually empty, but occasionally "websocket" or "webtransport", can be either single value `String` or multi-value `Array` of `String` instances. In HTTP/1, it is used to request a connection upgrade, and in HTTP/2 it is used to indicate a specfic protocol for the stream.
 			attr_accessor :protocol
 			
 			# Send the request to the given connection.

data/lib/protocol/http/version.rb

@@ -22,6 +22,6 @@
 
 module Protocol
 	module HTTP
-		VERSION = "0.22.9"
+		VERSION = "0.23.3"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http
 version: !ruby/object:Gem::Version
-  version: 0.22.9
+  version: 0.23.3
 platform: ruby
 authors:
 - Samuel Williams
@@ -41,7 +41,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2022-08-07 00:00:00.000000000 Z
+date: 2022-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler