async 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e540efd83cb7c67cb1c2b1a07008b33d67af97ce
-  data.tar.gz: e10155ef52e5fc2d37da808e654e58a1b9b56286
+  metadata.gz: 2fbc8a7a4d1987be4082ebae4b613319a95e936f
+  data.tar.gz: a6eb19cd5a9485c3de75d4498e7f96b0f0755334
 SHA512:
-  metadata.gz: 7853ec9aa1967b5375b956f6d4e2ddaa6370f8c992afb6fdd73a8a1b792a17697d90b60fcd215c1e8a77928135c41226aeac16e0e94de242ef5e9f3c2560261c
-  data.tar.gz: 6d49f738de6c79bc363ef541549e040a8e98b74049fc346aca922560d98787df64217b148d9291b541b5ccf5e80d6cb9d90ff04cbba5fe91a061d754d579ebe7
+  metadata.gz: 9f53412d28ed692ca27c059371ea97bca9a7424e6dc37ad3b97e910c8031d475388de304030a8004cce54712712c59915071bff1fd281892a1ed96fb7bedbe14
+  data.tar.gz: 6d2691f41bdd26610261269e8c15ef210696f15dba391119437758e604ac524fb0d65c871bdcc164babd6570b3c8fbea2784b4d3cd57ef9f4d6e6ced48552f67

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 group :development do
 	gem 'pry'
 	gem 'guard-rspec'
+	gem 'guard-yard'
 	
 	gem 'yard'
 end

data/Guardfile

@@ -8,3 +8,7 @@ guard :rspec, cmd: "bundle exec rspec" do
 	watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
 	watch("spec/spec_helper.rb") { "spec" }
 end
+
+guard 'yard', :port => '8808' do
+	watch(%r{^lib/(.+)\.rb$})
+end

data/lib/async/condition.rb

@@ -20,25 +20,34 @@
 
 require 'fiber'
 require 'forwardable'
-
 require_relative 'node'
 
 module Async
+	# A synchronization primative, which allows fibers to wait until a particular condition is triggered.
 	class Condition
 		def initialize
 			@waiting = []
 		end
 		
+		# Queue up the current fiber and wait on yielding the task.
+		# @return [Object]
 		def wait
 			@waiting << Fiber.current
 			
 			Task.yield
 		end
 		
-		def signal(value)
+		# Signal to a given task that it should resume operations.
+		# @param value The value to return to the waiting fibers.
+		# @see Task.yield which is responsible for handling value.
+		# @return [void]
+		def signal(value = nil)
+			# TODO: Should we hot-swap @waiting - so that tasks can wait on this condition again?
 			while task = @waiting.pop
 				task.resume(value)
 			end
+			
+			return nil
 		end
 	end
 end

data/lib/async/io.rb

@@ -29,27 +29,21 @@ module Async
 		
 		WRAPPERS = {}
 		
+		# Return the wrapper for a given native IO instance.
 		def self.[] instance
 			WRAPPERS[instance.class]
 		end
 		
 		class << self
-			if RUBY_VERSION >= "2.3"
-				def wrap_blocking_method(new_name, method_name)
-					# puts "#{self}\##{$1} -> #{method_name}"
+			# @!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, &block)
+				if block_given?
+					define_method(new_name, &block)
+				else
 					define_method(new_name) do |*args|
-						async do
-							@io.__send__(method_name, *args, exception: false)
-						end
-					end
-				end
-			else
-				def wrap_blocking_method(new_name, method_name)
-					# puts "#{self}\##{$1} -> #{method_name}"
-					define_method(new_name) do |*args|
-						async do
-							@io.__send__(method_name, *args)
-						end
+						async_send(method_name, *args)
 					end
 				end
 			end
@@ -57,9 +51,9 @@ module Async
 			def wraps(klass, *additional_methods)
 				WRAPPERS[klass] = self
 				
-				klass.instance_methods(false).grep(/(.*)_nonblock/) do |method_name|
-					wrap_blocking_method($1, method_name)
-				end
+				# klass.instance_methods(false).grep(/(.*)_nonblock/) do |method_name|
+				# 	wrap_blocking_method($1, method_name)
+				# end
 				
 				def_delegators :@io, *(additional_methods - instance_methods(false))
 			end
@@ -67,8 +61,30 @@ module Async
 		
 		wraps ::IO
 		
+		# @example
+		#   data = io.read(512)
+		wrap_blocking_method :read, :read_nonblock
+		
+		# @example
+		#   io.write("Hello World")
+		wrap_blocking_method :write, :write_nonblock
+		
 		protected
 		
+		if RUBY_VERSION >= "2.3"
+			def async_send(*args)
+				async do
+					@io.__send__(*args, exception: false)
+				end
+			end
+		else
+			def async_send(*args)
+				async do
+					@io.__send__(*args)
+				end
+			end
+		end
+		
 		def async
 			while true
 				begin

data/lib/async/logger.rb

@@ -21,9 +21,12 @@
 require 'logger'
 
 module Async
+	# The Async Logger class.
 	class << self
+		# @attr logger [Logger] the global logger instance used by `Async`.
 		attr :logger
-		
+	
+		# Set the default log level based on `$DEBUG` and `$VERBOSE`.
 		def default_log_level
 			if $DEBUG
 				Logger::DEBUG
@@ -34,6 +37,7 @@ module Async
 			end
 		end
 	end
-	
+
+	# Create the logger instance.
 	@logger = Logger.new($stderr, level: default_log_level)
 end

data/lib/async/node.rb

@@ -21,7 +21,10 @@
 require 'set'
 
 module Async
+	# Represents a node in a tree, used for nested {Task} instances.
 	class Node
+		# Create a new node in the tree.
+		# @param parent [Node, nil] This node will attach to the given parent.
 		def initialize(parent = nil)
 			@children = Set.new
 			@parent = nil
@@ -31,10 +34,15 @@ module Async
 			end
 		end
 		
+		# @attr parent [Node, nil]
 		attr :parent
+		
+		# @attr children [Set<Node>]
 		attr :children
 		
-		# Attach this node to an existing parent.
+		# Change the parent of this node.
+		# @param parent [Node, nil] the parent to attach to, or nil to detach.
+		# @return [self]
 		def parent=(parent)
 			return if @parent.equal?(parent)
 			
@@ -47,12 +55,19 @@ module Async
 				@parent = parent
 				@parent.children << self
 			end
+			
+			return self
 		end
-		
+	
+		# Whether the node can be consumed safely. By default, checks if the
+		# children set is empty.
+		# @return [Boolean]	
 		def finished?
 			@children.empty?
 		end
-		
+	
+		# If the node has a parent, and is {finished?}, then remove this node from
+		# the parent.
 		def consume
 			if @parent && finished?
 				@parent.reap(self)
@@ -60,7 +75,9 @@ module Async
 				@parent = nil
 			end
 		end
-		
+	
+		# Remove a given child node.
+		# @param child [Node] 
 		def reap(child)
 			@children.delete(child)
 		end

data/lib/async/reactor.rb

@@ -27,12 +27,21 @@ require 'timers'
 require 'forwardable'
 
 module Async
+	# Raised if a timeout occurs on a specific Fiber. Handled gracefully by {Task}.
 	class TimeoutError < RuntimeError
 	end
-	
+
+	# An asynchronous, cooperatively scheduled event reactor.
 	class Reactor < Node
 		extend Forwardable
 		
+		# The preferred method to invoke asynchronous behavior.
+		#
+		# - When invoked within an existing reactor task, it will run the given block
+		# asynchronously. Will return the task once it has been scheduled.
+		# - When invoked at the top level, will create and run a reactor, and invoke
+		# the block as an asynchronous task. Will block until the reactor finishes
+		# running.
 		def self.run(*args, &block)
 			if current = Task.current?
 				reactor = current.reactor
@@ -50,7 +59,8 @@ module Async
 				return reactor
 			end
 		end
-		
+	
+		# @param wrappers [Hash] A mapping for wrapping pre-existing IO objects.
 		def initialize(wrappers: IO)
 			super(nil)
 			
@@ -61,22 +71,29 @@ module Async
 			
 			@stopped = true
 		end
-		
+	
+		# @attr wrappers [Object] 
 		attr :wrappers
+		# @attr stopped [Boolean] 
 		attr :stopped
 		
 		def_delegators :@timers, :every, :after
-		
+	
+		# Wrap a given IO object and associate it with a specific task.
+		# @param io The `IO` instance to wrap.
+		# @param task [Task] The task which manages the wrapper.
+		# @return [Wrapper]
 		def wrap(io, task)
 			@wrappers[io].new(io, task)
 		end
-		
+	
 		def with(io, &block)
 			async do |task|
 				task.with(io, &block)
 			end
 		end
-		
+
+		# @return [Task]	
 		def async(*ios, &block)
 			task = Task.new(ios, self, &block)
 			
@@ -96,11 +113,18 @@ module Async
 		def register(*args)
 			@selector.register(*args)
 		end
-		
+	
+		# Stop the reactor at the earliest convenience.
+		# @return [void]
 		def stop
-			@stopped = true
+			unless @stopped
+				@stopped = true
+				@selector.wakeup
+			end
 		end
-		
+	
+		# Run the reactor until either all tasks complete or {#stop} is invoked.
+		# Proxies arguments to {#async} immediately before entering the loop.
 		def run(*args, &block)
 			raise RuntimeError, 'Reactor has been closed' if @selector.nil?
 			
@@ -129,7 +153,7 @@ module Async
 					monitors.each do |monitor|
 						if fiber = monitor.value
 							# Async.logger.debug "Resuming task #{task} due to IO..."
-							fiber.resume
+							fiber.resume # if fiber.alive?
 						end
 					end
 				end
@@ -141,7 +165,9 @@ module Async
 			Async.logger.debug{@children.collect{|child| [child.to_s, child.alive?]}.inspect}
 			@stopped = true
 		end
-		
+	
+		# Close each of the children tasts and selector.
+		# @return [void]
 		def close
 			@children.each(&:stop)
 			
@@ -149,10 +175,14 @@ module Async
 			@selector = nil
 		end
 		
+		# Check if the selector has been closed.
+		# @return [Boolean]
 		def closed?
 			@selector.nil?
 		end
-		
+	
+		# Put the calling fiber to sleep for a given ammount of time.
+		# @param duration [Numeric] The time in seconds, to sleep for.
 		def sleep(duration)
 			task = Fiber.current
 			
@@ -167,6 +197,10 @@ module Async
 			timer.cancel if timer
 		end
 		
+		# Invoke the block, but after the timeout, raise {TimeoutError} in any
+		# currenly blocking operation.
+		# @param duration [Integer] The time in seconds, in which the task should 
+		#   complete.
 		def timeout(duration)
 			backtrace = caller
 			task = Fiber.current

data/lib/async/socket.rb

@@ -26,23 +26,81 @@ module Async
 	class BasicSocket < IO
 		wraps ::BasicSocket
 		
-		# We provide non-blocking send:
-		alias send sendmsg
+		wrap_blocking_method :recv, :recv_nonblock
+		wrap_blocking_method :recvmsg, :recvmsg_nonblock
+		
+		wrap_blocking_method :recvfrom, :recvfrom_nonblock
+		
+		wrap_blocking_method :send, :sendmsg_nonblock
+		wrap_blocking_method :sendmsg, :sendmsg_nonblock
 	end
 	
 	class Socket < BasicSocket
 		wraps ::Socket
 		
-		module Connect
-			def connect(*args)
-				begin
-					super
-				rescue Errno::EISCONN
+		wrap_blocking_method :accept, :accept_nonblock
+		
+		wrap_blocking_method :connect, :connect_nonblock do |*args|
+			begin
+				async_send(:connect_nonblock, *args)
+			rescue Errno::EISCONN
+				# We are now connected.
+			end
+		end
+		
+		# Establish a connection to a given `remote_address`.
+		# @example
+		#  socket = Async::Socket.connect(Addrinfo.tcp("8.8.8.8", 53))
+		# @param remote_address [Addrinfo] The remote address to connect to.
+		# @param local_address [Addrinfo] The local address to bind to before connecting.
+		# @option protcol [Integer] The socket protocol to use.
+		def self.connect(remote_address, local_address = nil, protocol: 0, task: Task.current)
+			socket = ::Socket.new(remote_address.afamily, remote_address.socktype, protocol)
+			
+			if local_address
+				socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
+				socket.bind(local_address) if local_address
+			end
+			
+			if block_given?
+				task.with(socket) do |wrapper|
+					wrapper.connect(remote_address.to_sockaddr)
+					
+					yield wrapper
 				end
+			else
+				task.bind(socket).connect(remote_address.to_sockaddr)
+				
+				return socket
+			end
+		end
+		
+		# Bind to a local address.
+		# @example
+		#  socket = Async::Socket.bind(Addrinfo.tcp("0.0.0.0", 9090))
+		# @param local_address [Addrinfo] The local address to bind to.
+		# @option protcol [Integer] The socket protocol to use.
+		def self.bind(local_address, backlog: nil, protocol: 0, task: Task.current, &block)
+			socket = ::Socket.new(local_address.afamily, local_address.socktype, protocol)
+			
+			socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
+			socket.bind(local_address)
+			
+			socket.listen(backlog) if backlog
+			
+			if block_given?
+				task.with(socket, &block)
+			else
+				return socket
 			end
 		end
 		
-		prepend Connect
+		# Bind to a local address and accept connections in a loop.
+		def self.accept(*args, task: Task.current, &block)
+			bind(*args, task: task) do |wrapper|
+				task.with(*wrapper.accept, &block) while true
+			end
+		end
 	end
 	
 	class IPSocket < BasicSocket

data/lib/async/task.rb

@@ -25,12 +25,21 @@ require_relative 'node'
 require_relative 'condition'
 
 module Async
+	# Raised when a task is explicitly stopped.
 	class Interrupt < Exception
 	end
-	
+
+	# A task represents the state associated with the execution of an asynchronous
+	# block.
 	class Task < Node
 		extend Forwardable
-		
+	
+		# Yield the unerlying `result` for the task. If the result
+		# is an Exception, then that result will be raised an its
+		# exception.
+		# @return [Object] result of the task
+		# @raise [Exception] if the result is an exception
+		# @yield [result] result of the task if a block if given.
 		def self.yield
 			if block_given?
 				result = yield
@@ -44,7 +53,11 @@ module Async
 				return result
 			end
 		end
-		
+	
+		# Create a new task.
+		# @param ios [Array] an array of `IO` objects such as `TCPServer`, `Socket`, etc.
+		# @param reactor [Async::Reactor] 
+		# @return [void]
 		def initialize(ios, reactor)
 			if parent = Task.current?
 				super(parent)
@@ -85,25 +98,34 @@ module Async
 			end
 		end
 		
+		# Show the current status of the task as a string.
+		# @todo (picat) Add test for this method?	
 		def to_s
 			"#{super}[#{@status}]"
 		end
-		
+	
+		# @attr ios [Array<IO>] All wrappers associated with this task.
 		attr :ios
 		
+		# @attr ios [Reactor] The reactor the task was created within.
 		attr :reactor
 		def_delegators :@reactor, :timeout, :sleep
 		
+		# @attr fiber [Fiber] The fiber which is being used for the execution of this task.
 		attr :fiber
 		def_delegators :@fiber, :alive?
 		
+		# @attr status [Symbol] The status of the execution of the fiber, one of `:running`, `:complete`, `:interrupted`, or `:failed`.
 		attr :status
-		attr :result
 		
+		# Resume the execution of the task.
 		def run
 			@fiber.resume
 		end
-		
+	
+		# Retrieve the current result of the task. Will cause the caller to wait until result is available.
+		# @raise [RuntimeError] if the task's fiber is the current fiber.
+		# @return [Object]
 		def result
 			raise RuntimeError.new("Cannot wait on own fiber") if Fiber.current.equal?(@fiber)
 			
@@ -116,7 +138,9 @@ module Async
 		end
 		
 		alias wait result
-		
+	
+		# Stop the task and all of its children.
+		# @return [void]
 		def stop
 			@children.each(&:stop)
 			
@@ -125,47 +149,67 @@ module Async
 				@fiber.resume(exception)
 			end
 		end
-		
-		def with(io)
+	
+		# Provide a wrapper to an IO object with a Reactor.
+		# @yield [Async::Wrapper] a wrapped object.
+		def with(io, *args)
 			wrapper = @reactor.wrap(io, self)
-			
-			yield wrapper
+			yield wrapper, *args
 		ensure
-			wrapper.close
-			io.close
+			wrapper.close if wrapper
+			io.close if io
 		end
 		
+		# Wrap and bind the given object to the reactor.
+		# @param io the native object to bind to this task.
+		# @return [Wrapper] The wrapped object.
 		def bind(io)
-			@ios[io.fileno] ||= reactor.wrap(io, self)
+			@ios[io.fileno] ||= @reactor.wrap(io, self)
 		end
 		
+		# Register a given IO with given interests to be able to monitor it.
+		# @param io [IO] a native io object.
+		# @param interests [Symbol] One of `:r`, `:w` or `:rw`.
+		# @return [NIO::Monitor]
 		def register(io, interests)
 			@reactor.register(io, interests)
 		end
-		
+	
+		# Lookup the {Task} for the current fiber. Raise `RuntimeError` if none is available.
+		# @return [Async::Task]
+		# @raise [RuntimeError] if task was not {set!} for the current fiber.
 		def self.current
 			Thread.current[:async_task] or raise RuntimeError, "No async task available!"
 		end
-		
+
+			
+		# Check if there is a task defined for the current fiber.
+		# @return [Async::Task, nil]
 		def self.current?
 			Thread.current[:async_task]
 		end
-		
+	
+		# Check if the task is running.
+		# @return [Boolean]
 		def running?
 			@status == :running
 		end
 		
 		# Whether we can remove this node from the reactor graph.
+		# @return [Boolean]
 		def finished?
 			super && @status != :running
 		end
 		
+		# Close all bound IO objects.
 		def close
 			@ios.each_value(&:close)
-			@ios = []
+			@ios = nil
 			
+			# Attempt to remove this node from the task tree.
 			consume
 			
+			# If this task was being used as a future, signal completion here:
 			if @condition
 				@condition.signal(@result)
 			end
@@ -173,6 +217,7 @@ module Async
 		
 		private
 		
+		# Set the current fiber's `:async_task` to this task.
 		def set!
 			# This is actually fiber-local:
 			Thread.current[:async_task] = self

data/lib/async/tcp_socket.rb

@@ -21,34 +21,15 @@
 require_relative 'socket'
 
 module Async
-	# Asynchronous TCP socket/client.
+	# Asynchronous TCP socket wrapper.
 	class TCPSocket < IPSocket
 		wraps ::TCPSocket
-		
-		def self.connect(remote_address, remote_port, local_address = nil, local_port = nil, task: Task.current, &block)
-			# This may block if remote_address is a hostname
-			remote = Addrinfo.tcp(remote_address, remote_port)
-			
-			socket = ::Socket.new(remote.afamily, ::Socket::SOCK_STREAM, 0)
-			socket.bind Addrinfo.tcp(local_address, local_port) if local_address
-			
-			if block_given?
-				task.with(socket) do |wrapper|
-					wrapper.connect(remote.to_sockaddr)
-					
-					yield wrapper
-				end
-			else
-				task.bind(socket).connect(remote.to_sockaddr)
-				
-				return socket
-			end
-		end
 	end
 	
-	# Asynchronous TCP server
+	# Asynchronous TCP server wrappper.
 	class TCPServer < TCPSocket
 		wraps ::TCPServer
+		
+		wrap_blocking_method :accept, :accept_nonblock
 	end
 end
-

data/lib/async/udp_socket.rb

@@ -21,10 +21,14 @@
 require_relative 'socket'
 
 module Async
-	# Asynchronous UDP socket.
+	# Asynchronous UDP socket wrapper.
 	class UDPSocket < IPSocket
+		wraps ::UDPSocket
+		
 		# We pass `send` through directly, but in theory it might block. Internally, it uses sendto.
-		wraps ::UDPSocket, :send
+		def_delegators :@io, :send
+		
+		wrap_blocking_method :recvfrom, :recvfrom_nonblock
 	end
 end
 

data/lib/async/unix_socket.rb

@@ -21,7 +21,13 @@
 require_relative 'socket'
 
 module Async
-	module UNIXSocket < BasicSocket
+	class UNIXServer < BasicSocket
+		wraps ::UNIXServer
+		
+		wrap_blocking_method :accept, :accept_nonblock
+	end
+	
+	class UNIXSocket < BasicSocket
 		wraps ::UNIXSocket
 	end
 end

data/lib/async/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Async
-	VERSION = "0.12.0"
+	VERSION = "0.13.0"
 end

data/lib/async/wrapper.rb

@@ -21,47 +21,61 @@
 module Async
 	# Represents an asynchronous IO within a reactor.
 	class Wrapper
+		# @param io the native object to wrap.
+		# @param task [Task] the task that is managing this wrapper.
 		def initialize(io, task)
 			@io = io
 			@task = task
 			@monitor = nil
 		end
 		
+		# The underlying native `io`.
 		attr :io
-		attr :task
 		
-		def monitor(interests)
-			unless @monitor
-				@monitor = @task.register(@io, interests)
-			else
-				@monitor.interests = interests
-			end
-			
-			@monitor.value = Fiber.current
-			
-			yield
-			
-		ensure
-			@monitor.value = nil if @monitor
-		end
+		# The task this wrapper is associated with.
+		attr :task
 		
+		# Wait for the io to become readable.
 		def wait_readable
 			wait_any(:r)
 		end
 		
+		# Wait for the io to become writable.
 		def wait_writable
 			wait_any(:w)
 		end
 		
+		# Wait fo the io to become either readable or writable.
+		# @param interests [:r | :w | :rw] what events to wait for.
 		def wait_any(interests = :rw)
 			monitor(interests) do
 				Task.yield
 			end
 		end
 		
+		# Close the monitor.
 		def close
 			@monitor.close if @monitor
 			@monitor = nil
 		end
+		
+		private
+		
+		# Monitor the io for the given events
+		# @param interests [:r | :w | :rw] what events to wait for.
+		def monitor(interests)
+			unless @monitor
+				@monitor = @task.register(@io, interests)
+			else
+				@monitor.interests = interests
+			end
+			
+			@monitor.value = Fiber.current
+			
+			yield
+			
+		ensure
+			@monitor.value = nil if @monitor
+		end
 	end
 end

data/{lib/async/ssl_socket.rb → spec/async/condition_spec.rb}

@@ -18,13 +18,24 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'io'
+require 'async/condition'
 
-require 'openssl'
-
-module Async
-	# This might be better in a nested module?
-	class SSLSocket < IO
-		wraps OpenSSL::SSL::SSLSocket
+RSpec.describe Async::Condition do
+	include_context 'reactor'
+	
+	it 'should continue after condition is signalled' do
+		task = reactor.async do
+			subject.wait
+			#puts "Got #{value}"
+		end
+		
+		expect(task.status).to be :running
+		
+		# This will cause the task to exit:
+		subject.signal
+		
+		expect(task.status).to be :complete
+		
+		task.stop
 	end
 end

data/spec/async/tcp_socket_spec.rb

@@ -19,57 +19,47 @@
 # THE SOFTWARE.
 
 RSpec.describe Async::Reactor do
+	include_context "closes all io"
+	
 	# Shared port for localhost network tests.
-	let(:port) {6779}
+	let(:server_address) {Addrinfo.tcp("localhost", 6779)}
+	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
-	def run_echo_server
+	around(:each) do |example|
 		# Accept a single incoming connection and then finish.
-		subject.async(server) do |server, task|
-			task.with(server.accept) do |peer|
-				data = peer.read(512)
-				peer.write(data)
+		subject.async do |task|
+			Async::Socket.bind(server_address, backlog: 128) do |server|
+				task.with(*server.accept) do |peer, address|
+					data = peer.read(512)
+					peer.write(data)
+				end
 			end
 		end
 		
-		yield
+		result = example.run
 		
-		subject.run
+		return result if result.is_a? Exception
 		
-		server.close
+		subject.run
 	end
 	
 	describe 'basic tcp server' do
-		# These may block:
-		let(:server) {TCPServer.new("localhost", port)}
-		let(:client) {TCPSocket.new("localhost", port)}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
 		it "should start server and send data" do
-			run_echo_server do
-				subject.with(client) do |client|
+			subject.async do
+				Async::Socket.connect(server_address) do |client|
 					client.write(data)
 					expect(client.read(512)).to be == data
 				end
 			end
-			
-			expect(client).to be_closed
 		end
 	end
 	
 	describe 'non-blocking tcp connect' do
-		# These may block:
-		let(:server) {TCPServer.new("localhost", port)}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
 		it "should start server and send data" do
-			run_echo_server do
-				subject.async do |task|
-					Async::TCPSocket.connect("localhost", port) do |client|
-						client.write(data)
-						expect(client.read(512)).to be == data
-					end
+			subject.async do |task|
+				Async::Socket.connect(server_address) do |client|
+					client.write(data)
+					expect(client.read(512)).to be == data
 				end
 			end
 		end
@@ -77,42 +67,39 @@ RSpec.describe Async::Reactor do
 		it "can connect socket and read/write in a different task" do
 			socket = nil
 			
-			run_echo_server do
-				subject.async do |task|
-					socket = Async::TCPSocket.connect("localhost", port)
-					
-					# Stop the reactor once the connection was made.
-					subject.stop
-				end
-			
-				subject.run
-				
-				expect(socket).to_not be_nil
+			subject.async do |task|
+				socket = Async::Socket.connect(server_address)
 				
-				subject.async(socket) do |client|
-					client.write(data)
-					expect(client.read(512)).to be == data
-				end
-				
-				subject.run
+				# Stop the reactor once the connection was made.
+				subject.stop
 			end
+		
+			subject.run
+			
+			expect(socket).to_not be_nil
+			
+			subject.async(socket) do |client|
+				client.write(data)
+				expect(client.read(512)).to be == data
+			end
+			
+			subject.run
 		end
 		
 		it "can't use a socket in nested tasks" do
-			socket = nil
-			
-			run_echo_server do
-				subject.async do |task|
-					socket = Async::TCPSocket.connect("localhost", port)
-					
-					# I'm not sure if this is the right behaviour or not. Without a significant amont of work, async sockets are tied to the task that creates them.
-					expect do
-						subject.async(socket) do |client|
-							client.write(data)
-							expect(client.read(512)).to be == data
-						end
-					end.to raise_error(ArgumentError, /already registered with selector/)
-				end
+			subject.async do |task|
+				socket = Async::Socket.connect(server_address)
+				
+				# I'm not sure if this is the right behaviour or not. Without a significant amont of work, async sockets are tied to the task that creates them.
+				expect do
+					subject.async(socket) do |client|
+						client.write(data)
+						expect(client.read(512)).to be == data
+					end
+				end.to raise_error(ArgumentError, /already registered with selector/)
+				
+				# We need to explicitly close the socket, since we explicitly opened it.
+				socket.close
 			end
 		end
 	end

data/spec/async/udp_socket_spec.rb

@@ -19,35 +19,50 @@
 # THE SOFTWARE.
 
 RSpec.describe Async::Reactor do
+	include_context "closes all io"
+	
 	# Shared port for localhost network tests.
-	let(:port) {6778}
+	let(:server_address) {Addrinfo.udp("127.0.0.1", 6778)}
+	let(:data) {"The quick brown fox jumped over the lazy dog."}
 	
 	describe 'basic udp server' do
-		# These may block:
-		let(:server) {UDPSocket.new.tap{|socket| socket.bind("localhost", port)}}
-		let(:client) {UDPSocket.new}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
-		after(:each) do
-			server.close
+		it "should echo data back to peer" do
+			subject.async do
+				Async::Socket.bind(server_address) do |server|
+					packet, address = server.recvfrom(512)
+					
+					server.send(packet, 0, address)
+				end
+			end
+			
+			subject.async do
+				Async::Socket.connect(server_address) do |client|
+					client.send(data)
+					response = client.recv(512)
+					
+					expect(response).to be == data
+				end
+			end
+			
+			subject.run
 		end
 		
-		it "should echo data back to peer" do
-			subject.async(server) do |server, task|
-				packet, (_, remote_port, remote_host) = server.recvfrom(512)
-				
-				subject.async do
-					server.send(packet, 0, remote_host, remote_port)
+		it "should use unconnected socket" do
+			subject.async do
+				Async::Socket.bind(server_address) do |server|
+					packet, address = server.recvfrom(512)
+					
+					server.send(packet, 0, address)
 				end
 			end
 			
-			subject.async(client) do |client|
-				client.send(data, 0, "localhost", port)
-				
-				response, _ = client.recvfrom(512)
-				
-				expect(response).to be == data
+			subject.async do |task|
+				task.with(UDPSocket.new(server_address.afamily)) do |client|
+					client.send(data, 0, server_address)
+					response, address = client.recvfrom(512)
+					
+					expect(response).to be == data
+				end
 			end
 			
 			subject.run

data/spec/async/unix_socket_spec.rb

@@ -0,0 +1,53 @@
+# Copyright, 2017, 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/unix_socket'
+
+RSpec.describe Async::Reactor do
+	include_context "closes all io"
+	
+	let(:path) {File.join(__dir__, "unix-socket")}
+	let(:data) {"The quick brown fox jumped over the lazy dog."}
+	
+	before(:each) do
+		FileUtils.rm_f path
+	end
+	
+	describe 'basic unix socket' do
+		it "should echo data back to peer" do
+			subject.async do |task|
+				task.with(UNIXServer.new(path)) do |server|
+					task.with(server.accept) do |peer|
+						peer.send(peer.recv(512))
+					end
+				end
+			end
+			
+			subject.with(UNIXSocket.new(path)) do |socket|
+				socket.send(data)
+				response = socket.recv(512)
+				
+				expect(response).to be == data
+			end
+			
+			subject.run
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -21,14 +21,38 @@ require "async"
 require "async/tcp_socket"
 require "async/udp_socket"
 
+RSpec.shared_context "closes all io" do
+	def current_ios(gc: GC.start)
+		all_ios = ObjectSpace.each_object(IO).to_a.sort_by(&:object_id)
+		
+		# We are not interested in ios that have been closed already:
+		return all_ios.reject{|io| io.closed?}
+	end
+	
+	# We use around(:each) because it's the highest priority.
+	around(:each) do |example|
+		@system_ios = current_ios
+		
+		result = example.run
+		
+		expect(current_ios).to be == @system_ios
+		
+		result
+	end
+end
+
 RSpec.shared_context "reactor" do
 	let(:reactor) {Async::Task.current.reactor}
 	
 	around(:each) do |example|
 		Async::Reactor.run do
-			example.run
+			result = example.run
+			
+			return result if result.is_a? Exception
 		end
 	end
+	
+	include_context "closes all io"
 end
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -107,6 +107,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - Gemfile
 - Guardfile
 - README.md
@@ -121,19 +122,20 @@ files:
 - lib/async/node.rb
 - lib/async/reactor.rb
 - lib/async/socket.rb
-- lib/async/ssl_socket.rb
 - lib/async/task.rb
 - lib/async/tcp_socket.rb
 - lib/async/udp_socket.rb
 - lib/async/unix_socket.rb
 - lib/async/version.rb
 - lib/async/wrapper.rb
+- spec/async/condition_spec.rb
 - spec/async/node_spec.rb
 - spec/async/reactor/nested_spec.rb
 - spec/async/reactor_spec.rb
 - spec/async/task_spec.rb
 - spec/async/tcp_socket_spec.rb
 - spec/async/udp_socket_spec.rb
+- spec/async/unix_socket_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/socketry/async
 licenses:
@@ -160,10 +162,12 @@ signing_key:
 specification_version: 4
 summary: Async is an asynchronous I/O framework based on nio4r.
 test_files:
+- spec/async/condition_spec.rb
 - spec/async/node_spec.rb
 - spec/async/reactor/nested_spec.rb
 - spec/async/reactor_spec.rb
 - spec/async/task_spec.rb
 - spec/async/tcp_socket_spec.rb
 - spec/async/udp_socket_spec.rb
+- spec/async/unix_socket_spec.rb
 - spec/spec_helper.rb