Expand stream interface to support gets/puts.

Author: ioquatix

lib/protocol/http/body/stream.rb

@@ -11,6 +11,8 @@ module HTTP
 		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
@@ -55,7 +57,7 @@ def read(length = nil, buffer = nil)
 
 							# 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)
 
@@ -102,7 +104,7 @@ def readpartial(length)
 						read_partial(length) or raise EOFError, "End of file reached!"
 					end
 
-					def read_nonblock(length, buffer = nil)
+					def read_nonblock(length, buffer = nil, exception: nil)
 						@buffer ||= read_next
 						chunk = nil
 
@@ -127,6 +129,40 @@ def read_nonblock(length, buffer = nil)
 
 						return buffer
 					end
+					
+					# Efficiently read data from the stream until encountering pattern.
+					# @parameter pattern [String] The pattern to match.
+					# @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.
+					def gets(separator = NEWLINE, **options)
+						read_until(separator, **options)
+					end
 				end
 
 				include Reader
@@ -148,6 +184,16 @@ def <<(buffer)
 					write(buffer)
 				end
 
+				def puts(*arguments, separator: NEWLINE)
+					buffer = ::String.new
+					
+					arguments.each do |argument|
+						buffer << argument << separator
+					end
+					
+					write(buffer)
+				end
+				
 				def flush
 				end
 

test/protocol/http/body/reader.rb

@@ -7,6 +7,8 @@
 require 'protocol/http/body/reader'
 require 'protocol/http/body/buffered'
 
+require 'tempfile'
+
 class TestReader
 	include Protocol::HTTP::Body::Reader
 
@@ -35,22 +37,26 @@ def initialize(body)
 	end
 
 	with '#save' do
-		let(:path) { File.expand_path('reader_spec.txt', __dir__) }
-		
 		it 'saves to the provided filename' do
-			reader.save(path)
-			expect(File.read(path)).to be == 'thequickbrownfox'
+			Tempfile.create do |file|
+				reader.save(file.path)
+				expect(File.read(file.path)).to be == 'thequickbrownfox'
+			end
 		end
 
 		it 'saves by truncating an existing file if it exists' do
-			File.write(path, 'hello' * 100)
-			reader.save(path)
-			expect(File.read(path)).to be == 'thequickbrownfox'
+			Tempfile.create do |file|
+				File.write(file.path, 'hello' * 100)
+				reader.save(file.path)
+				expect(File.read(file.path)).to be == 'thequickbrownfox'
+			end
 		end
 
 		it 'mirrors the interface of File.open' do
-			reader.save(path, 'w')
-			expect(File.read(path)).to be == 'thequickbrownfox'
+			Tempfile.create do |file|
+				reader.save(file.path, 'w')
+				expect(File.read(file.path)).to be == 'thequickbrownfox'
+			end
 		end
 	end
 end

test/protocol/http/body/stream.rb

@@ -131,6 +131,29 @@
 		end
 	end
 
+	with '#read_until' do
+		it "can read until a pattern is encountered" do
+			expect(stream.read_until("o")).to be == "Hello"
+			expect(stream.read_until("d")).to be == "World"
+		end
+	end
+	
+	with '#gets' do
+		let(:input) {Protocol::HTTP::Body::Buffered.new(["Hello\nWorld\n"])}
+		
+		it "can read lines" do
+			expect(stream.gets).to be == "Hello\n"
+			expect(stream.gets).to be == "World\n"
+			expect(stream.gets).to be == nil
+		end
+		
+		it "can read lines and chomp separators" do
+			expect(stream.gets(chomp: true)).to be == "Hello"
+			expect(stream.gets(chomp: true)).to be == "World"
+			expect(stream.gets(chomp: true)).to be == nil
+		end
+	end
+	
 	with '#close_read' do
 		it "should close the input" do
 			stream.read(1)
@@ -166,6 +189,15 @@
 		end
 	end
 
+	with '#puts' do
+		it "should write lines to the output" do
+			stream.puts("Hello", "World")
+			stream.puts("Goodbye")
+			
+			expect(output.chunks).to be == ["Hello\nWorld\n", "Goodbye\n"]
+		end
+	end
+	
 	with '#close_write' do
 		it "should close the input" do
 			stream.close_write