Aligning implementation with Async 2.x.

Author: ioquatix

lib/async/io/stream.rb

@@ -258,19 +258,20 @@ def fill_read_buffer(size = @block_size)
 				flush
 
 				if @read_buffer.empty?
-					if @io.read(size, @read_buffer)
+					if @io.sysread(size, @read_buffer)
 						# Console.logger.debug(self, name: "read") {@read_buffer.inspect}
 						return true
 					end
 				else
-					if chunk = @io.read(size, @input_buffer)
+					if chunk = @io.sysread(size, @input_buffer)
 						@read_buffer << chunk
 						# Console.logger.debug(self, name: "read") {@read_buffer.inspect}
 
 						return true
 					end
 				end
 
+			rescue EOFError
 				# else for both cases above:
 				@eof = true
 				return false

lib/async/io/tcp_socket.rb

@@ -28,55 +28,21 @@ module Async
 	module IO
 		# Asynchronous TCP socket wrapper.
 		class TCPSocket < IPSocket
-			wraps ::TCPSocket
+			wraps ::TCPSocket, :gets, :puts
 
 			def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
 				if remote_host.is_a? ::TCPSocket
 					super(remote_host)
 				else
-					remote_address = Addrinfo.tcp(remote_host, remote_port)
-					local_address = Addrinfo.tcp(local_host, local_port) if local_host
-					
-					# We do this unusual dance to avoid leaking an "open" socket instance.
-					socket = Socket.connect(remote_address, local_address: local_address)
-					fd = socket.fcntl(Fcntl::F_DUPFD)
-					Console.logger.debug(self) {"Connected to #{remote_address.inspect}: #{fd}"}
-					socket.close
-					
-					super(::TCPSocket.for_fd(fd))
-					
-					# The equivalent blocking operation. Unfortunately there is no trivial way to make this non-blocking.
-					# super(::TCPSocket.new(remote_host, remote_port, local_host, local_port))
+					super(::TCPSocket.new(remote_host, remote_port, local_host, local_port))
 				end
-				
-				@stream = Stream.new(self)
 			end
 
 			class << self
 				alias open new
 			end
 
-			def close
-				@stream.flush
-				super
-			end
-			
 			include Peer
-			
-			attr :stream
-			
-			# The way this buffering works is pretty atrocious.
-			def_delegators :@stream, :gets, :puts
-			
-			def sysread(size, buffer = nil)
-				data = @stream.read_partial(size)
-				
-				if buffer
-					buffer.replace(data)
-				end
-				
-				return data
-			end
 		end
 
 		# Asynchronous TCP server wrappper.

spec/async/io/tcp_socket_spec.rb

@@ -31,7 +31,7 @@
 
 	# Shared port for localhost network tests.
 	let(:server_address) {Async::IO::Address.tcp("localhost", 6788)}
-	let(:data) {"The quick brown fox jumped over the lazy dog."}
+	let(:data) {"The quick brown fox jumped over the lazy dog.\n"}
 
 	describe Async::IO::TCPServer do
 		it_should_behave_like Async::IO::Generic