async-io 1.22.0 → 1.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 368fe5eb02962730d8f47e3ab180913aa922085eb554cc2e430b8c15113e8f33
-  data.tar.gz: '09c5660537d3a7ce792bdf89674e79d0e40391346788c27808d14edbde1dfb13'
+  metadata.gz: b15a84835cd91c8d303fb774bcfab585180115153fab3006f0e2e179d9d06a91
+  data.tar.gz: 89d3f2c2c676234ce38c494d582502a78b7ff4f2a19a9eaa926dcdf95c45d770
 SHA512:
-  metadata.gz: 27929ee0118185c0dadb8216ce88f5d4296633481215d0c3865396b56e5c9d73f63bd8b6d6f01db5e641a3eb6e78209746b36bf0e91b17cb9e7d8550819d8a37
-  data.tar.gz: 35c33f0d712a94d7468c69aaa178139e756a3fcb1e56daf78671a2f347a790b141172ea6a3d993d4640da017d6f12624e1f10124225d0c4a877d2b39351b0b6f
+  metadata.gz: 42716527198f1cc5228b6c714cd43dd7ec8174aeab1a899db158e6e44c13067e8cc2c705048a0c00384334b19c5b9fe56e0c220cc676a1a190f8e0c6c9034a8b
+  data.tar.gz: '01831255a14a052f6a2fc04973d6a64002edbb31885ea8683ef0c84f104a4a74abd3a06ccc75f28115150bd6892456a9733af16e66280685ebe63dfedae83b26'

data/examples/issues/pipes.rb

@@ -0,0 +1,32 @@
+# wat.rb
+require 'async'
+require_relative '../../lib/async/io'
+require 'digest/sha1'
+require 'securerandom'
+
+Async.run do |task|
+	r, w = IO.pipe.map { |io| Async::IO.try_convert(io) }
+
+	task.async do |subtask|
+		s = Digest::SHA1.new
+		l = 0
+		100.times do
+			bytes = SecureRandom.bytes(4000)
+			s << bytes
+			w << bytes
+			l += bytes.bytesize
+		end
+		w.close
+		p [:write, l, s.hexdigest]
+	end
+	
+	task.async do |subtask|
+		s = Digest::SHA1.new
+		l = 0
+		while b = r.read(4096)
+			s << b
+			l += b.bytesize
+		end
+		p [:read, l, s.hexdigest]
+	end
+end

data/lib/async/io/generic.rb

@@ -23,6 +23,10 @@ require 'forwardable'
 
 module Async
 	module IO
+		# The default block size for IO buffers.
+		# BLOCK_SIZE = ENV.fetch('BLOCK_SIZE', 1024*16).to_i
+		BLOCK_SIZE = 1024*8
+		
 		# Convert a Ruby ::IO object to a wrapped instance:
 		def self.try_convert(io, &block)
 			if wrapper_class = Generic::WRAPPERS[io.class]
@@ -42,17 +46,20 @@ module Async
 				# @!macro [attach] wrap_blocking_method
 				#   @method $1
 				#   Invokes `$2` on the underlying {io}. If the operation would block, the current task is paused until the operation can succeed, at which point it's resumed and the operation is completed.
-				def wrap_blocking_method(new_name, method_name, invert: true)
-					define_method(new_name) do |*args|
-						async_send(method_name, *args)
+				def wrap_blocking_method(new_name, method_name, invert: true, &block)
+					if block_given?
+						define_method(new_name, &block)
+					else
+						define_method(new_name) do |*args|
+							async_send(method_name, *args)
+						end
 					end
 					
 					if invert
-						# We define the original _nonblock method to call the async variant. We ignore options.
-						# define_method(method_name) do |*args, **options|
-						# 	self.__send__(new_name, *args)
-						# end
-						def_delegators :@io, method_name
+						# We wrap the original _nonblock method, ignoring options.
+						define_method(method_name) do |*args, exception: false|
+							async_send(method_name, *args)
+						end
 					end
 				end
 				
@@ -85,17 +92,77 @@ module Async
 			
 			wraps ::IO, :external_encoding, :internal_encoding, :autoclose?, :autoclose=, :pid, :stat, :binmode, :flush, :set_encoding, :to_io, :to_i, :reopen, :fileno, :fsync, :fdatasync, :sync, :sync=, :tell, :seek, :rewind, :pos, :pos=, :eof, :eof?, :close_on_exec?, :close_on_exec=, :closed?, :close_read, :close_write, :isatty, :tty?, :binmode?, :sysseek, :advise, :ioctl, :fcntl, :nread, :ready?, :pread, :pwrite, :pathconf
 			
+			# Read the specified number of bytes from the input stream. This is fast path.
 			# @example
-			#   data = io.read(512)
-			wrap_blocking_method :read, :read_nonblock
-			alias sysread read
-			alias readpartial read
+			#   data = io.sysread(512)
+			wrap_blocking_method :sysread, :read_nonblock
+			
+			# Read `length` bytes of data from the underlying I/O. If length is unspecified, read everything.
+			def read(length = nil, buffer = nil)
+				if buffer
+					buffer.clear
+				else
+					buffer = String.new
+				end
+				
+				if length
+					return "" if length <= 0
+					
+					# Fast path:
+					if buffer = self.sysread(length, buffer)
+						
+						# Slow path:
+						while buffer.bytesize < length
+							# Slow path:
+							if chunk = self.sysread(length - buffer.bytesize)
+								buffer << chunk
+							else
+								break
+							end
+						end
+						
+						return buffer
+					else
+						return nil
+					end
+				else
+					buffer = self.sysread(BLOCK_SIZE, buffer)
+					
+					while chunk = self.sysread(BLOCK_SIZE)
+						buffer << chunk
+					end
+					
+					return buffer
+				end
+			end
 			
+			# Write entire buffer to output stream. This is fast path.
 			# @example
-			#   io.write("Hello World")
-			wrap_blocking_method :write, :write_nonblock
-			alias syswrite write
-			alias << write
+			#   io.syswrite("Hello World")
+			wrap_blocking_method :syswrite, :write_nonblock
+			
+			alias readpartial read_nonblock
+			
+			def write(buffer)
+				# Fast path:
+				written = self.syswrite(buffer)
+				remaining = buffer.bytesize - written
+				
+				while remaining > 0
+					# Slow path:
+					length = self.syswrite(buffer.byteslice(written, remaining))
+					
+					remaining -= length
+					written += length
+				end
+				
+				return written
+			end
+			
+			def << buffer
+				write(buffer)
+				return self
+			end
 			
 			def dup
 				super.tap do |copy|

data/lib/async/io/socket.rb

@@ -58,7 +58,7 @@ module Async
 				# On Darwin, sometimes occurs when the connection is not yet fully formed. Empirically, TCP_NODELAY is enabled despite this result.
 			rescue Errno::EOPNOTSUPP
 				# Some platforms may simply not support the operation.
-				Async.logger.warn(self) {"Unable to set sync=#{value}!"}
+				# Async.logger.warn(self) {"Unable to set sync=#{value}!"}
 			end
 			
 			def sync

data/lib/async/io/ssl_endpoint.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'endpoint'
+require_relative 'host_endpoint'
 require_relative 'ssl_socket'
 
 module Async

data/lib/async/io/ssl_socket.rb

@@ -33,9 +33,6 @@ module Async
 			wrap_blocking_method :accept, :accept_nonblock
 			wrap_blocking_method :connect, :connect_nonblock
 			
-			alias syswrite write
-			alias sysread read
-			
 			def self.connect(socket, context, hostname = nil, &block)
 				client = self.new(socket, context)
 				
@@ -62,14 +59,6 @@ module Async
 				end
 			end
 			
-			def local_address
-				@io.to_io.local_address
-			end
-			
-			def remote_address
-				@io.to_io.remote_address
-			end
-			
 			include Peer
 			
 			def initialize(socket, context)
@@ -90,6 +79,27 @@ module Async
 					super(io, socket.reactor)
 				end
 			end
+			
+			def local_address
+				@io.to_io.local_address
+			end
+			
+			def remote_address
+				@io.to_io.remote_address
+			end
+			
+			def close_write
+				self.shutdown(Socket::SHUT_WR)
+			end
+			
+			def close_read
+				self.shutdown(Socket::SHUT_RD)
+			end
+			
+			def shutdown(how)
+				@io.flush
+				@io.to_io.shutdown(how)
+			end
 		end
 		
 		# We reimplement this from scratch because the native implementation doesn't expose the underlying server/context that we need to implement non-blocking accept.

data/lib/async/io/stream.rb

@@ -24,9 +24,7 @@ require_relative 'generic'
 module Async
 	module IO
 		class Stream
-			# The default block size for IO buffers.
-			# BLOCK_SIZE = ENV.fetch('BLOCK_SIZE', 1024*16).to_i
-			BLOCK_SIZE = 1024*8
+			BLOCK_SIZE = IO::BLOCK_SIZE
 			
 			def initialize(io, block_size: BLOCK_SIZE, sync: true)
 				@io = io
@@ -72,13 +70,29 @@ module Async
 			def read_partial(size = nil)
 				return '' if size == 0
 				
-				if @read_buffer.empty? and !@eof
-					fill_read_buffer
+				unless @eof
+					if size and @read_buffer.bytesize < size
+						fill_read_buffer(size > @block_size ? size : @block_size)
+					elsif @read_buffer.empty?
+						fill_read_buffer
+					end
 				end
 				
 				return consume_read_buffer(size)
 			end
 			
+			def read_exactly(size, exception: EOFError)
+				if buffer = read(size)
+					if buffer.bytesize != size
+						raise exception, "could not read enough data"
+					end
+					
+					return buffer
+				end
+				
+				raise exception, "encountered eof while reading data"
+			end
+			
 			alias readpartial read_partial
 			
 			# Efficiently read data from the stream until encountering pattern.
@@ -115,12 +129,12 @@ module Async
 			# @return the number of bytes appended to the buffer.
 			def write(string)
 				if @write_buffer.empty? and string.bytesize >= @block_size
-					syswrite(string)
+					@io.write(string)
 				else
 					@write_buffer << string
 					
 					if @write_buffer.size >= @block_size
-						syswrite(@write_buffer)
+						@io.write(@write_buffer)
 						@write_buffer.clear
 					end
 				end
@@ -138,7 +152,7 @@ module Async
 			# Flushes buffered data to the stream.
 			def flush
 				unless @write_buffer.empty?
-					syswrite(@write_buffer)
+					@io.write(@write_buffer)
 					@write_buffer.clear
 				end
 			end
@@ -207,9 +221,9 @@ module Async
 			
 			# Fills the buffer from the underlying stream.
 			def fill_read_buffer(size = @block_size)
-				if @read_buffer.empty? and @io.read(size, @read_buffer)
+				if @read_buffer.empty? and @io.read_nonblock(size, @read_buffer, exception: false)
 					return true
-				elsif chunk = @io.read(size, @input_buffer)
+				elsif chunk = @io.read_nonblock(size, @input_buffer, exception: false)
 					@read_buffer << chunk
 					return true
 				else
@@ -245,28 +259,6 @@ module Async
 				
 				return result
 			end
-			
-			# Write a buffer to the underlying stream.
-			# @param buffer [String] The string to write, any encoding is okay.
-			def syswrite(buffer)
-				remaining = buffer.bytesize
-				
-				# Fast path:
-				written = @io.write(buffer)
-				return if written == remaining
-				
-				# Slow path:
-				remaining -= written
-				
-				while remaining > 0
-					wrote = @io.write(buffer.byteslice(written, remaining))
-					
-					remaining -= wrote
-					written += wrote
-				end
-				
-				return written
-			end
 		end
 	end
 end

data/lib/async/io/tcp_socket.rb

@@ -28,33 +28,7 @@ module Async
 		class TCPSocket < IPSocket
 			wraps ::TCPSocket
 			
-			class StreamWrapper
-				def initialize(io)
-					@io = io
-				end
-				
-				def sync= value
-					@io.sync = value
-				end
-				
-				def close
-					@io.close
-				end
-				
-				def read(*args)
-					@io.sysread(*args)
-				end
-				
-				def write(*args)
-					@io.syswrite(*args)
-				end
-				
-				def flush
-					@io.flush
-				end
-			end
-			
-			def initialize(remote_host, remote_port = nil, local_host = nil, local_port = 0)
+			def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
 				if remote_host.is_a? ::TCPSocket
 					super(remote_host)
 				else
@@ -73,33 +47,33 @@ module Async
 					# super(::TCPSocket.new(remote_host, remote_port, local_host, local_port))
 				end
 				
-				@buffer = Stream.new(StreamWrapper.new(self))
+				@stream = Stream.new(self)
 			end
 			
 			class << self
 				alias open new
 			end
 			
-			include Peer
+			def close
+				@stream.flush
+				super
+			end
 			
-			attr :buffer
+			include Peer
 			
-			def_delegators :@buffer, :gets, :puts, :flush
+			attr :stream
 			
-			def write(*)
-				@buffer.flush
-				
-				super
-			end
+			# The way this buffering works is pretty atrocious.
+			def_delegators :@stream, :gets, :puts
 			
-			def read(size, outbuf = nil)
-				buffer = @buffer.read_partial(size)
+			def sysread(size, buffer = nil)
+				data = @stream.read_partial(size)
 				
-				if outbuf
-					outbuf.replace(buffer)
+				if buffer
+					buffer.replace(data)
 				end
 				
-				return buffer
+				return data
 			end
 		end
 		

data/lib/async/io/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module IO
-		VERSION = "1.22.0"
+		VERSION = "1.23.0"
 	end
 end

data/spec/async/io/echo_spec.rb

@@ -44,8 +44,9 @@ RSpec.describe "echo client/server" do
 		Async do |task|
 			Async::IO::Socket.connect(server_address) do |peer|
 				result = peer.write(data)
+				peer.close_write
 				
-				message = peer.read(512)
+				message = peer.read(data.bytesize)
 				
 				responses << message
 			end

data/spec/async/io/generic_examples.rb

@@ -22,3 +22,31 @@ RSpec.shared_examples Async::IO::Generic do |ignore_methods|
 	# 	end
 	# end
 end
+
+RSpec.shared_examples Async::IO do
+	let(:data) {"Hello World!"}
+	
+	it "should read data" do
+		io.write(data)
+		expect(subject.read(data.bytesize)).to be == data
+	end
+	
+	it "should read less than available data" do
+		io.write(data)
+		expect(subject.read(1)).to be == data[0]
+	end
+	
+	it "should read all available data" do
+		io.write(data)
+		io.close_write
+		
+		expect(subject.read(data.bytesize * 2)).to be == data
+	end
+	
+	it "should read all available data" do
+		io.write(data)
+		io.close_write
+		
+		expect(subject.read).to be == data
+	end
+end

data/spec/async/io/generic_spec.rb

@@ -43,17 +43,16 @@ RSpec.describe Async::IO::Generic do
 		
 		output_task = reactor.async do
 			received = input.read(1024)
+			input.close
 		end
 		
 		reactor.async do
 			output.write(message)
+			output.close
 		end
 		
 		output_task.wait
 		expect(received).to be == message
-		
-		input.close
-		output.close
 	end
 	
 	describe '#wait' do

data/spec/async/io/socket/tcp_spec.rb

@@ -47,6 +47,7 @@ RSpec.describe Async::IO::Socket do
 			reactor.async do
 				Async::IO::Socket.connect(server_address) do |client|
 					client.write(data)
+					client.close_write
 					
 					expect(client.read(512)).to be == data
 				end
@@ -59,6 +60,7 @@ RSpec.describe Async::IO::Socket do
 			reactor.async do |task|
 				Async::IO::Socket.connect(server_address, local_address: local_address) do |client|
 					client.write(data)
+					client.close_write
 					
 					expect(client.read(512)).to be == data
 				end
@@ -69,6 +71,7 @@ RSpec.describe Async::IO::Socket do
 			reactor.async do |task|
 				Async::IO::Socket.connect(server_address) do |client|
 					client.write(data)
+					client.close_write
 					
 					expect(client.read(512)).to be == data
 				end
@@ -84,6 +87,7 @@ RSpec.describe Async::IO::Socket do
 				
 				reactor.async do
 					socket.write(data)
+					socket.close_write
 					
 					expect(socket.read(512)).to be == data
 					

data/spec/async/io/socket_spec.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require 'async/io/socket'
+require 'async/io/address'
 
 require_relative 'generic_examples'
 
@@ -124,6 +125,21 @@ RSpec.describe Async::IO::Socket do
 			s2.close
 		end
 	end
+	
+	context '.pipe' do
+		let(:sockets) do
+			@sockets = described_class.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+		end
+		
+		after do
+			@sockets&.each(&:close)
+		end
+		
+		let(:io) {sockets.first}
+		subject {sockets.last}
+		
+		it_should_behave_like Async::IO
+	end
 end
 
 RSpec.describe Async::IO::IPSocket do

data/spec/async/io/ssl_server_spec.rb

@@ -52,6 +52,7 @@ RSpec.describe Async::IO::SSLServer do
 			reactor.async do
 				client_endpoint.connect do |client|
 					client.write(data)
+					client.close_write
 					
 					expect(client.read(512)).to be == data
 				end
@@ -91,6 +92,7 @@ RSpec.describe Async::IO::SSLServer do
 			reactor.async do
 				valid_client_endpoint.connect do |client|
 					client.write(data)
+					client.close_write
 					
 					expect(client.read(512)).to be == data
 				end

data/spec/async/io/ssl_socket_spec.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/io/ssl_socket'
+require 'async/io/ssl_endpoint'
 
 require 'async/rspec/ssl'
 require_relative 'generic_examples'
@@ -69,6 +69,7 @@ RSpec.describe Async::IO::SSLSocket do
 						expect(client.timeout).to be == 10
 						
 						client.write(data)
+						client.close_write
 						
 						expect(client.read(512)).to be == data
 					end

data/spec/async/io/stream_context.rb

@@ -0,0 +1,28 @@
+# Copyright, 2019, 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/rspec/buffer'
+require 'async/io/stream'
+
+RSpec.shared_context Async::IO::Stream do
+	include_context Async::RSpec::Buffer
+	subject {described_class.new(buffer)}
+	let(:io) {subject.io}
+end

data/spec/async/io/stream_spec.rb

@@ -18,203 +18,251 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'async/io/stream'
-require 'async/rspec/buffer'
+require 'async/io/socket'
+
+require_relative 'generic_examples'
+require_relative 'stream_context'
 
 RSpec.describe Async::IO::Stream do
-	include_context Async::RSpec::Buffer
-	include_context Async::RSpec::Memory
-	include_context Async::RSpec::Reactor
-	
-	let!(:stream) {Async::IO::Stream.new(buffer)}
-	let(:io) {stream.io}
+	# This constant is part of the public interface, but was renamed to `Async::IO::BLOCK_SIZE`.
+	describe "::BLOCK_SIZE" do
+		it "should exist and be reasonable" do
+			expect(Async::IO::Stream::BLOCK_SIZE).to be_between(1024, 1024*32)
+		end
+	end
 	
-	describe '#close_read' do
-		let(:sockets) {@sockets = Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)}
-		let!(:stream) {Async::IO::Stream.new(sockets.last)}
-		after(:each) {@sockets&.each(&:close)}
+	context "socket I/O" do
+		let(:sockets) do
+			@sockets = Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+		end
 		
-		it "can close the reading end of the stream" do
-			stream.close_read
-			
-			expect do
-				stream.read
-			end.to raise_error(IOError, /not opened for reading/)
+		after do
+			@sockets&.each(&:close)
 		end
 		
-		it "can close the writing end of the stream" do
-			stream.close_write
+		let(:io) {sockets.first}
+		subject {described_class.new(sockets.last)}
+		
+		it_should_behave_like Async::IO
+		
+		describe '#close_read' do
+			let(:sockets) do
+				@sockets = Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+			end
 			
-			expect do
-				stream.write("Oh no!")
-				stream.flush
-			end.to raise_error(IOError, /not opened for writing/)
-		end
-	end
-	
-	describe '#read' do
-		it "should read everything" do
-			io.write "Hello World"
-			io.seek(0)
+			after do
+				@sockets&.each(&:close)
+			end
+			
+			subject {described_class.new(sockets.last)}
 			
-			expect(io).to receive(:read).and_call_original.twice
+			it "can close the reading end of the stream" do
+				expect(subject.io).to receive(:close_read).and_call_original
+				
+				subject.close_read
+				
+				# Ruby <= 2.4 raises an exception even with exception: false
+				# expect(stream.read).to be_nil
+			end
 			
-			expect(stream.read).to be == "Hello World"
-			expect(stream).to be_eof
+			it "can close the writing end of the stream" do
+				expect(subject.io).to receive(:close_write).and_call_original
+				
+				subject.write("Oh yes!")
+				subject.close_write
+				
+				expect do
+					subject.write("Oh no!")
+					subject.flush
+				end.to raise_error(IOError, /not opened for writing/)
+			end
 		end
 		
-		it "should read only the amount requested" do
-			io.write "Hello World"
-			io.seek(0)
-			
-			expect(io).to receive(:read).and_call_original.twice
-			
-			expect(stream.read(4)).to be == "Hell"
-			expect(stream).to_not be_eof
+		describe '#read_exactly' do
+			it "can read several bytes" do
+				io.write("hello\nworld\n")
+				
+				expect(subject.read_exactly(4)).to be == 'hell'
+			end
 			
-			expect(stream.read(20)).to be == "o World"
-			expect(stream).to be_eof
+			it "can raise exception if io is eof" do
+				io.close
+				
+				expect do
+					subject.read_exactly(4)
+				end.to raise_error(EOFError)
+			end
 		end
+	end
+	
+	context "buffered I/O" do
+		include_context Async::IO::Stream
+		include_context Async::RSpec::Memory
+		include_context Async::RSpec::Reactor
 		
-		context "with large content" do
-			it "allocates expected amount of bytes" do
-				io.write("." * 16*1024)
+		describe '#read' do
+			it "should read everything" do
+				io.write "Hello World"
 				io.seek(0)
 				
-				buffer = nil
+				expect(subject.io).to receive(:read_nonblock).and_call_original.twice
 				
-				expect do
-					# The read buffer is already allocated, and it will be resized to fit the incoming data. It will be swapped with an empty buffer.
-					buffer = stream.read(16*1024)
-				end.to limit_allocations.of(String, count: 1, size: 0)
+				expect(subject.read).to be == "Hello World"
+				expect(subject).to be_eof
+			end
+		
+			it "should read only the amount requested" do
+				io.write "Hello World"
+				io.seek(0)
 				
-				expect(buffer.size).to be == 16*1024
+				expect(subject.io).to receive(:read_nonblock).and_call_original.twice
 				
-				io.close
+				expect(subject.read_partial(4)).to be == "Hell"
+				expect(subject).to_not be_eof
+				
+				expect(subject.read_partial(20)).to be == "o World"
+				expect(subject).to be_eof
+			end
+		
+			context "with large content" do
+				it "allocates expected amount of bytes" do
+					io.write("." * 16*1024)
+					io.seek(0)
+					
+					buffer = nil
+					
+					expect do
+						# The read buffer is already allocated, and it will be resized to fit the incoming data. It will be swapped with an empty buffer.
+						buffer = subject.read(16*1024)
+					end.to limit_allocations.of(String, count: 1, size: 0)
+					
+					expect(buffer.size).to be == 16*1024
+				end
 			end
-		end
-	end
-	
-	describe '#read_until' do
-		it "can read a line" do
-			io.write("hello\nworld\n")
-			io.seek(0)
-			
-			expect(stream.read_until("\n")).to be == 'hello'
-			expect(stream.read_until("\n")).to be == 'world'
-			expect(stream.read_until("\n")).to be_nil
 		end
 		
-		context "with 1-byte block size" do
-			let!(:stream) {Async::IO::Stream.new(buffer, block_size: 1)}
-			
-			it "can read a line with a multi-byte pattern" do
-				io.write("hello\r\nworld\r\n")
+		describe '#read_until' do
+			it "can read a line" do
+				io.write("hello\nworld\n")
 				io.seek(0)
 				
-				expect(stream.read_until("\r\n")).to be == 'hello'
-				expect(stream.read_until("\r\n")).to be == 'world'
-				expect(stream.read_until("\r\n")).to be_nil
+				expect(subject.read_until("\n")).to be == 'hello'
+				expect(subject.read_until("\n")).to be == 'world'
+				expect(subject.read_until("\n")).to be_nil
 			end
-		end
 		
-		context "with large content" do
-			it "allocates expected amount of bytes" do
-				expect do
-					stream.read_until("b")
-				end.to limit_allocations.of(String, size: 0, count: 1)
+			context "with 1-byte block size" do
+				subject! {Async::IO::Stream.new(buffer, block_size: 1)}
+				
+				it "can read a line with a multi-byte pattern" do
+					io.write("hello\r\nworld\r\n")
+					io.seek(0)
+					
+					expect(subject.read_until("\r\n")).to be == 'hello'
+					expect(subject.read_until("\r\n")).to be == 'world'
+					expect(subject.read_until("\r\n")).to be_nil
+				end
 			end
-		end
-	end
-	
-	describe '#flush' do
-		it "should not call write if write buffer is empty" do
-			expect(io).to_not receive(:write)
 			
-			stream.flush
+			context "with large content" do
+				it "allocates expected amount of bytes" do
+					subject
+					
+					expect do
+						subject.read_until("b")
+					end.to limit_allocations.of(String, size: 0, count: 1)
+				end
+			end
 		end
 		
-		it "should flush underlying data when it exceeds block size" do
-			expect(io).to receive(:write).and_call_original.once
-			
-			stream.block_size.times do
-				stream.write("!")
+		describe '#flush' do
+			it "should not call write if write buffer is empty" do
+				expect(subject.io).to_not receive(:write)
+				
+				subject.flush
 			end
-		end
-	end
-	
-	describe '#read_partial' do
-		before(:each) do
-			io.write "Hello World!" * 1024
-			io.seek(0)
-		end
 		
-		it "should avoid calling read" do
-			expect(io).to receive(:read).and_call_original.once
-			
-			expect(stream.read_partial(12)).to be == "Hello World!"
+			it "should flush underlying data when it exceeds block size" do
+				expect(subject.io).to receive(:write).and_call_original.once
+				
+				subject.block_size.times do
+					subject.write("!")
+				end
+			end
 		end
 		
-		context "with large content" do
-			it "allocates only the amount required" do
-				expect do
-					stream.read(4*1024)
-				end.to limit_allocations.of(String, count: 2, size: 4*1024+1)
+		describe '#read_partial' do
+			before(:each) do
+				io.write("Hello World!" * 1024)
+				io.seek(0)
 			end
 			
-			it "allocates exact number of bytes being read" do
-				expect do
-					stream.read(16*1024)
-				end.to limit_allocations.of(String, count: 1, size: 0)
+			it "should avoid calling read" do
+				expect(subject.io).to receive(:read_nonblock).and_call_original.once
+				
+				expect(subject.read_partial(12)).to be == "Hello World!"
 			end
 			
-			it "allocates expected amount of bytes" do
-				buffer = nil
+			context "with large content" do
+				it "allocates only the amount required" do
+					expect do
+						subject.read(4*1024)
+					end.to limit_allocations.of(String, count: 2, size: 4*1024+1)
+				end
 				
-				expect do
-					buffer = stream.read_partial
-				end.to limit_allocations.of(String, count: 1)
+				it "allocates exact number of bytes being read" do
+					expect do
+						subject.read_partial(16*1024)
+					end.to limit_allocations.of(String, count: 1, size: 0)
+				end
 				
-				expect(buffer.size).to be == stream.block_size
+				it "allocates expected amount of bytes" do
+					buffer = nil
+					
+					expect do
+						buffer = subject.read_partial
+					end.to limit_allocations.of(String, count: 1)
+					
+					expect(buffer.size).to be == subject.block_size
+				end
 			end
 		end
-	end
-	
-	describe '#write' do
-		it "should read one line" do
-			expect(io).to receive(:write).and_call_original.once
-			
-			stream.write "Hello World\n"
-			stream.flush
-			
-			io.seek(0)
-			
-			expect(stream.read).to be == "Hello World\n"
+		
+		describe '#write' do
+			it "should read one line" do
+				expect(subject.io).to receive(:write).and_call_original.once
+				
+				subject.write "Hello World\n"
+				subject.flush
+				
+				io.seek(0)
+				expect(subject.read).to be == "Hello World\n"
+			end
 		end
-	end
-	
-	describe '#eof' do
-		it "should terminate stream" do
-			expect do
-				stream.eof!
-			end.to raise_exception(EOFError)
-			
-			expect(stream).to be_eof
+		
+		describe '#eof' do
+			it "should terminate subject" do
+				expect do
+					subject.eof!
+				end.to raise_exception(EOFError)
+				
+				expect(subject).to be_eof
+			end
 		end
-	end
-	
-	describe '#close' do
-		it 'can be closed even if underlying io is closed' do
-			io.close
-			
-			expect(stream.io).to be_closed
-			
-			# Put some data in the write buffer
-			stream.write "."
-			
-			expect do
-				stream.close
-			end.to_not raise_exception
+		
+		describe '#close' do
+			it 'can be closed even if underlying io is closed' do
+				io.close
+				
+				expect(subject.io).to be_closed
+				
+				# Put some data in the write buffer
+				subject.write "."
+				
+				expect do
+					subject.close
+				end.to_not raise_exception
+			end
 		end
 	end
 end

data/spec/async/io/tcp_socket_spec.rb

@@ -22,7 +22,7 @@ require 'async/io/tcp_socket'
 
 require_relative 'generic_examples'
 
-RSpec.describe Async::IO::TCPSocket do
+RSpec.describe Async::IO::TCPSocket, timeout: 1 do
 	include_context Async::RSpec::Reactor
 	
 	it_should_behave_like Async::IO::Generic
@@ -44,6 +44,7 @@ RSpec.describe Async::IO::TCPSocket do
 				
 				data = peer.gets
 				peer.puts(data)
+				peer.flush
 				
 				peer.close
 				server.close
@@ -52,15 +53,16 @@ RSpec.describe Async::IO::TCPSocket do
 		
 		let(:client) {Async::IO::TCPSocket.new("localhost", 6788)}
 		
-		it "can read into outbuf" do
+		it "can read into output buffer" do
 			client.puts("Hello World")
+			client.flush
 			
-			outbuf = String.new
+			buffer = String.new
 			# 20 is bigger than echo response...
-			data = client.read(20, outbuf)
+			data = client.read(20, buffer)
 			
-			expect(outbuf).to_not be_empty
-			expect(outbuf).to be == data
+			expect(buffer).to_not be_empty
+			expect(buffer).to be == data
 			
 			client.close
 			server_task.wait
@@ -69,6 +71,8 @@ RSpec.describe Async::IO::TCPSocket do
 		it "should start server and send data" do
 			# Accept a single incoming connection and then finish.
 			client.puts(data)
+			client.flush
+			
 			expect(client.gets).to be == data
 			
 			client.close

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-io
 version: !ruby/object:Gem::Version
-  version: 1.22.0
+  version: 1.23.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-30 00:00:00.000000000 Z
+date: 2019-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -130,6 +130,7 @@ files:
 - examples/chat/client.rb
 - examples/chat/server.rb
 - examples/issues/broken_ssl.rb
+- examples/issues/pipes.rb
 - examples/millions/client.rb
 - examples/millions/server.rb
 - examples/udp/client.rb
@@ -176,6 +177,7 @@ files:
 - spec/async/io/ssl_server_spec.rb
 - spec/async/io/ssl_socket_spec.rb
 - spec/async/io/standard_spec.rb
+- spec/async/io/stream_context.rb
 - spec/async/io/stream_spec.rb
 - spec/async/io/tcp_socket_spec.rb
 - spec/async/io/trap_spec.rb
@@ -204,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Provides support for asynchonous TCP, UDP, UNIX and SSL sockets.
@@ -226,6 +228,7 @@ test_files:
 - spec/async/io/ssl_server_spec.rb
 - spec/async/io/ssl_socket_spec.rb
 - spec/async/io/standard_spec.rb
+- spec/async/io/stream_context.rb
 - spec/async/io/stream_spec.rb
 - spec/async/io/tcp_socket_spec.rb
 - spec/async/io/trap_spec.rb