protocol-http 0.26.8 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20eddc2f7e87cb40659f99174fe456008413fdaf61841c1c366b17ded34a8dc6
-  data.tar.gz: 5f7b795b609e434534d1910aeb84fc7ba77dc46e1157add3e40ea2a053e1ae3c
+  metadata.gz: a38b2bf9deae253c76d1bfeb0b980cc9ea833ce61c2e2b7ecc890ab951c852fe
+  data.tar.gz: de7d4603e6e944e5d05f9b31fe17b4374837128ef6cca687630c7e97fb1ba5f7
 SHA512:
-  metadata.gz: 5b8a17aab9953fcefefea89da1913ce0fa8ce96d27dd91aad38690a21165abf42cf0b46f3f49f4b469c9af5409bffa733b69728acf0f55526b4a6bef8be041be
-  data.tar.gz: 2264dbd29fdbc90a82f37d503c237092f559ec42093be5b57027976aa5c1d6f7019573e8b65a3d7f2d85f7de7de307c2c71e7104be449a2835e086c1ede8fdd9
+  metadata.gz: ad5ea5d1e217f3284560d9b3f3114314618ab3ab330c4717bb374eabd51e5a46fb8ab810f04092cb8a7018a3c102da6d752121a3f4a5ef8fc9ae0b131939c38d
+  data.tar.gz: 63aeea268ae41d87eb6ff8faea81c5db21c6bcda9da8fedf0d583d045cec1e8fea7a64d065096f52b28019998c0a73d4b642dc3537734d2fa986075e6ea55cca

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

@@ -11,6 +11,8 @@ module Protocol
 		module Body
 			# 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.
 			class Stream
+				NEWLINE = "\n"
+				
 				def initialize(input = nil, output = Buffered.new)
 					@input = input
 					@output = output
@@ -28,10 +30,14 @@ module Protocol
 				
 				# 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?
-					
-					# 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.
+					# Read data from the underlying stream.
+					#
+					# If given a non-negative length, it will read at most that many bytes from the stream. If the stream is at EOF, it will return nil.
+					#
+					# If the length is not given, it will read all data until EOF, or return an empty string if the stream is already at EOF.
+					#
+					# 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
@@ -55,7 +61,7 @@ module Protocol
 							
 							# 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)
 							
@@ -76,7 +82,13 @@ module Protocol
 						end
 					end
 					
-					# Read at most `length` bytes from the stream. Will avoid reading from the underlying stream if possible.
+					# Read some bytes from the stream.
+					#
+					# If the length is given, at most length bytes will be read. Otherwise, one chunk of data from the underlying stream will be read.
+					#
+					# Will avoid reading from the underlying stream if there is buffered data available.
+					#
+					# @parameter length [Integer] The maximum number of bytes to read.
 					def read_partial(length = nil)
 						if @buffer
 							buffer = @buffer
@@ -98,11 +110,13 @@ module Protocol
 						return buffer
 					end
 					
+					# Similar to {read_partial} but raises an `EOFError` if the stream is at EOF.
 					def readpartial(length)
 						read_partial(length) or raise EOFError, "End of file reached!"
 					end
 					
-					def read_nonblock(length, buffer = nil)
+					# Read data from the stream without blocking if possible.
+					def read_nonblock(length, buffer = nil, exception: nil)
 						@buffer ||= read_next
 						chunk = nil
 						
@@ -127,10 +141,55 @@ module Protocol
 						
 						return buffer
 					end
+					
+					# Read data from the stream until encountering pattern.
+					#
+					# @parameter pattern [String] The pattern to match.
+					# @parameter offset [Integer] The offset to start searching from.
+					# @parameter chomp [Boolean] Whether to remove the pattern from the returned data.
+					# @returns [String] The contents of the stream up until the pattern, which is consumed but not returned.
+					def read_until(pattern, offset = 0, chomp: false)
+						# We don't want to split on the pattern, so we subtract the size of the pattern.
+						split_offset = pattern.bytesize - 1
+						
+						@buffer ||= read_next
+						return nil if @buffer.nil?
+						
+						until index = @buffer.index(pattern, offset)
+							offset = @buffer.bytesize - split_offset
+							
+							offset = 0 if offset < 0
+							
+							if chunk = read_next
+								@buffer << chunk
+							else
+								return nil
+							end
+						end
+						
+						@buffer.freeze
+						matched = @buffer.byteslice(0, index+(chomp ? 0 : pattern.bytesize))
+						@buffer = @buffer.byteslice(index+pattern.bytesize, @buffer.bytesize)
+						
+						return matched
+					end
+					
+					# Read a single line from the stream.
+					#
+					# @parameter separator [String] The line separator, defaults to `\n`.
+					# @parameter *options [Hash] Additional options, passed to {read_until}.
+					def gets(separator = NEWLINE, **options)
+						read_until(separator, **options)
+					end
 				end
 				
 				include Reader
 				
+				# Write data to the underlying stream.
+				#
+				# @parameter buffer [String] The data to write.
+				# @raises [IOError] If the stream is not writable.
+				# @returns [Integer] The number of bytes written.
 				def write(buffer)
 					if @output
 						@output.write(buffer)
@@ -140,36 +199,68 @@ module Protocol
 					end
 				end
 				
-				def write_nonblock(buffer)
+				# Write data to the stream using {write}.
+				#
+				# Provided for compatibility with IO-like objects.
+				#
+				# @parameter buffer [String] The data to write.
+				# @parameter exception [Boolean] Whether to raise an exception if the write would block, currently ignored.
+				# @returns [Integer] The number of bytes written.
+				def write_nonblock(buffer, exception: nil)
 					write(buffer)
 				end
 				
+				# Write data to the stream using {write}.
 				def <<(buffer)
 					write(buffer)
 				end
 				
+				# Write lines to the stream.
+				#
+				# The current implementation buffers the lines and writes them in a single operation.
+				#
+				# @parameter arguments [Array(String)] The lines to write.
+				# @parameter separator [String] The line separator, defaults to `\n`.
+				def puts(*arguments, separator: NEWLINE)
+					buffer = ::String.new
+					
+					arguments.each do |argument|
+						buffer << argument << separator
+					end
+					
+					write(buffer)
+				end
+				
+				# Flush the output stream.
+				#
+				# This is currently a no-op.
 				def flush
 				end
 				
+				# Close the input body.
 				def close_read
-					@closed_read = true
-					@buffer = nil
-					
-					@input&.close
-					@input = nil
+					if @input
+						@closed_read = true
+						@buffer = nil
+						
+						@input&.close
+						@input = nil
+					end
 				end
 				
-				# close must never be called on the input stream. huh?
+				# Close the output body.
 				def close_write
-					@output&.close
-					@output = nil
+					if @output
+						@output&.close
+						@output = nil
+					end
 				end
 				
 				# Close the input and output bodies.
 				def close(error = nil)
 					self.close_read
 					self.close_write
-
+					
 					return nil
 				ensure
 					@closed = true

data/lib/protocol/http/version.rb

@@ -5,6 +5,6 @@
 
 module Protocol
 	module HTTP
-		VERSION = "0.26.8"
+		VERSION = "0.27.0"
 	end
 end

data/lib/protocol/http.rb

@@ -9,3 +9,10 @@ require_relative 'http/headers'
 require_relative 'http/request'
 require_relative 'http/response'
 require_relative 'http/middleware'
+
+# @namespace
+module Protocol
+	# @namespace
+	module HTTP
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http
 version: !ruby/object:Gem::Version
-  version: 0.26.8
+  version: 0.27.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -47,7 +47,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-07-07 00:00:00.000000000 Z
+date: 2024-07-12 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Provides abstractions to handle HTTP protocols.