async 1.25.0 → 1.25.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e483e124943c2ca198118249cfd157307afd86a6e9ead4b376be27ffc95b645
-  data.tar.gz: c460b159f280389b26237c41fd20bac56d9e5b2c525f884402f6170b85fd5053
+  metadata.gz: 70efaa49b29fd36596f22f7796c475610955cc63836725b00775f6c1025aa976
+  data.tar.gz: d5e7987bcb581c20b3ac17fba0ef803a61f154ec107b55ad01220c16ae2a32e6
 SHA512:
-  metadata.gz: 482ff867811aa68736b37a50d83e5850f4a1f9a310274b8993898c5577136e7502f5c369a3c9bf4685380b88a71de2ff4ed04fbd92115e8918472522e92786ea
-  data.tar.gz: 37584a2af7140b2a4efa0fb60879e97ddae99879f97b137add7fb62662139300e280a9126cf24f559172ecb7ba1f2a6c21eb77adc317df9ae54f9ddb8378f928
+  metadata.gz: d47987f2b355ab4dff7e06443787190dc8567abe30391b3a0a2dde55efb4592c14af94b42f52cf2b7f6e35d9868bb1f2cfbdd23cb9abddb4c1ba34a97cf0dab9
+  data.tar.gz: 014fa5e68d7fb509f6120cbce6e07f75d6c17c86b8d5dcc93278555c4e11ea27a2a8883ba8193359aeed1ab3d5303d92e30b053cf840aa31c0b4f9b002d7c5d4

data/lib/async/node.rb

@@ -20,49 +20,181 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'set'
-
 module Async
+	# A double linked list.
+	class List
+		def initialize
+			@head = nil
+			@tail = nil
+			@size = 0
+		end
+		
+		attr :size
+		
+		attr_accessor :head
+		attr_accessor :tail
+		
+		# Inserts an item at the end of the list.
+		def insert(item)
+			unless @head
+				@head = item
+				@tail = item
+				
+				# Consistency:
+				item.head = nil
+				item.tail = nil
+			else
+				@tail.tail = item
+				item.head = @tail
+				
+				# Consistency:
+				item.tail = nil
+				
+				@tail = item
+			end
+			
+			@size += 1
+			
+			return self
+		end
+		
+		def delete(item)
+			if @head.equal?(item)
+				@head = @head.tail
+			else
+				item.head.tail = item.tail
+			end
+			
+			if @tail.equal?(item)
+				@tail = @tail.head
+			else
+				item.tail.head = item.head
+			end
+			
+			item.head = nil
+			# Don't do this, because it will break enumeration.
+			# item.tail = nil
+			
+			@size -= 1
+			
+			return self
+		end
+		
+		def each
+			return to_enum unless block_given?
+			
+			item = @head
+			while item
+				yield item
+				item = item.tail
+			end
+		end
+		
+		def include?(needle)
+			self.each do |item|
+				return true if needle.equal?(item)
+			end
+			
+			return false
+		end
+		
+		def first
+			@head
+		end
+		
+		def last
+			@tail
+		end
+		
+		def empty?
+			@head.nil?
+		end
+		
+		def nil?
+			@head.nil?
+		end
+	end
+	
+	private_constant :List
+	
+	class Children < List
+		def initialize
+			super
+			
+			@transient_count = 0
+		end
+		
+		# Does this node have (direct) transient children?
+		def transients?
+			@transient_count > 0
+		end
+		
+		def insert(item)
+			if item.transient?
+				@transient_count += 1
+			end
+			
+			super
+		end
+		
+		def delete(item)
+			if item.transient?
+				@transient_count -= 1
+			end
+			
+			super
+		end
+		
+		def finished?
+			@size == @transient_count
+		end
+	end
+	
 	# 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, annotation: nil, transient: false)
-			@children = nil
 			@parent = nil
-			
-			# The number of transient children:
-			@transients = 0
+			@children = nil
 			
 			@annotation = annotation
 			@object_name = nil
 			
 			@transient = transient
 			
+			@head = nil
+			@tail = nil
+			
 			if parent
-				self.parent = parent
+				parent.add_child(self)
 			end
 		end
 		
+		# You should not directly rely on these pointers but instead use `#children`.
+		# List pointers:
+		attr_accessor :head
+		attr_accessor :tail
+		
 		# @attr parent [Node, nil]
 		attr :parent
 		
-		# @attr children [Set<Node>] Optional list of children.
+		# @attr children [List<Node>] Optional list of children.
 		attr :children
 		
 		# A useful identifier for the current node.
 		attr :annotation
 		
+		# Whether there are children?
+		def children?
+			@children != nil && !@children.empty?
+		end
+		
 		# Is this node transient?
 		def transient?
 			@transient
 		end
 		
-		# Does this node have (direct) transient children?
-		def transients?
-			@transients > 0
-		end
-		
 		def annotate(annotation)
 			if block_given?
 				previous_annotation = @annotation
@@ -95,13 +227,12 @@ module Async
 			return if @parent.equal?(parent)
 			
 			if @parent
-				@parent.reap(self)
+				@parent.delete_child(self)
 				@parent = nil
 			end
 			
 			if parent
-				@parent = parent
-				@parent.add_child(self)
+				parent.add_child(self)
 			end
 			
 			return self
@@ -112,52 +243,42 @@ module Async
 		end
 		
 		protected def add_child child
-			@children ||= Set.new
-			@children << child
-			
-			if child.transient?
-				@transients += 1
-			end
+			@children ||= Children.new
+			@children.insert(child)
+			child.set_parent(self)
+		end
+		
+		protected def delete_child(child)
+			@children.delete(child)
+			child.set_parent(nil)
 		end
 		
 		# Whether the node can be consumed safely. By default, checks if the
 		# children set is empty.
 		# @return [Boolean]
 		def finished?
-			@children.nil? || @children.empty? || (@children.size == @transients)
+			@children.nil? || @children.finished?
 		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)
+			if parent = @parent and finished?
+				parent.delete_child(self)
 				
-				# After reaping self, children are all moved elsewhere.
-				@children = nil
-				@transients = 0
-				
-				@parent.consume
-				@parent = nil
-			end
-		end
-		
-		# Remove a given child node.
-		# @param child [Node]
-		def reap(child)
-			@children.delete(child)
-			
-			if child.transient?
-				@transients -= 1
-			end
-			
-			child.children&.each do |grand_child|
-				if grand_child.finished?
-					grand_child.set_parent(nil)
-				else
-					grand_child.set_parent(self)
-					add_child(grand_child)
+				if @children
+					@children.each do |child|
+						if child.finished?
+							delete_child(child)
+						else
+							parent.add_child(child)
+						end
+					end
+					
+					@children = nil
 				end
+				
+				parent.consume
 			end
 		end
 		

data/lib/async/reactor.rb

@@ -91,11 +91,11 @@ module Async
 		end
 		
 		def to_s
-			"\#<#{self.description} #{@children&.size || 0} children #{stopped? ? 'stopped' : 'running'}>"
+			"\#<#{self.description} #{@children&.size || 0} children (#{stopped? ? 'stopped' : 'running'})>"
 		end
 		
 		def stopped?
-			@children.nil? || @children.empty?
+			@children.nil?
 		end
 		
 		# TODO Remove these in next major release. They are too confusing to use correctly.
@@ -222,9 +222,7 @@ module Async
 			return true
 		end
 		
-		# Run the reactor until either all tasks complete or {#pause} or {#stop} is
-		# invoked. Proxies arguments to {#async} immediately before entering the
-		# loop, if a block is provided.
+		# Run the reactor until all tasks are finished. Proxies arguments to {#async} immediately before entering the loop, if a block is provided.
 		def run(*arguments, &block)
 			raise RuntimeError, 'Reactor has been closed' if @selector.nil?
 			
@@ -239,12 +237,19 @@ module Async
 			logger.debug(self) {"Exiting run-loop because #{$! ? $! : 'finished'}."}
 		end
 		
+		def stop(later = true)
+			@children&.each do |child|
+				# We don't want this process to propagate `Async::Stop` exceptions, so we schedule tasks to stop later.
+				child.stop(later)
+			end
+		end
+		
 		# Stop each of the children tasks and close the selector.
 		# 
 		# @return [void]
 		def close
 			# This is a critical step. Because tasks could be stored as instance variables, and since the reactor is (probably) going out of scope, we need to ensure they are stopped. Otherwise, the tasks will belong to a reactor that will never run again and are not stopped.
-			self.stop
+			self.stop(false)
 			
 			@selector.close
 			@selector = nil
@@ -255,7 +260,7 @@ module Async
 		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)

data/lib/async/version.rb

@@ -21,5 +21,5 @@
 # THE SOFTWARE.
 
 module Async
-	VERSION = "1.25.0"
+	VERSION = "1.25.1"
 end

data/spec/async/node_spec.rb

@@ -35,14 +35,14 @@ RSpec.describe Async::Node do
 			child.parent = nil
 			
 			expect(child.parent).to be_nil
-			expect(subject.children).to be_empty
+			expect(subject.children).to be_nil
 		end
 		
 		it "can consume bottom to top" do
 			child.consume
 			
 			expect(child.parent).to be_nil
-			expect(subject.children).to be_empty
+			expect(subject.children).to be_nil
 		end
 	end
 	
@@ -64,16 +64,34 @@ RSpec.describe Async::Node do
 	end
 	
 	describe '#consume' do
-		let(:middle) {Async::Node.new(subject)}
-		let(:bottom) {Async::Node.new(middle)}
-		
 		it "can't consume middle node" do
+			middle = Async::Node.new(subject)
+			bottom = Async::Node.new(middle)
+			
 			expect(bottom.parent).to be middle
 			
 			middle.consume
 			
 			expect(bottom.parent).to be middle
 		end
+		
+		it "can consume node while enumerating children" do
+			3.times do
+				Async::Node.new(subject)
+			end
+			
+			children = subject.children.each.to_a
+			expect(subject.children.size).to be 3
+			
+			enumerated = []
+			
+			subject.children.each do |child|
+				child.consume
+				enumerated << child
+			end
+			
+			expect(enumerated).to be == children
+		end
 	end
 	
 	describe '#annotate' do
@@ -129,9 +147,9 @@ RSpec.describe Async::Node do
 			
 			# subject -> middle -> child1 (transient)
 			#                   -> child2
-			middle = Async::Node.new(subject)
-			child1 = Async::Node.new(middle, transient: true)
-			child2 = Async::Node.new(middle)
+			middle = Async::Node.new(subject, annotation: "middle")
+			child1 = Async::Node.new(middle, transient: true, annotation: "child1")
+			child2 = Async::Node.new(middle, annotation: "child2")
 			
 			allow(child1).to receive(:finished?).and_return(false)
 			
@@ -169,7 +187,7 @@ RSpec.describe Async::Node do
 			expect(child.parent).to be_nil
 			expect(middle.parent).to be subject
 			expect(subject.children).to include(middle)
-			expect(middle.children).to be_empty
+			expect(middle.children).to be_nil
 		end
 	end
 end

data/spec/async/queue_spec.rb

@@ -109,6 +109,7 @@ RSpec.describe Async::LimitedQueue do
 	it 'should resume waiting tasks in order' do
 		total_resumed = 0
 		total_dequeued = 0
+		
 		Async do |producer|
 			10.times do
 				producer.async do
@@ -117,13 +118,12 @@ RSpec.describe Async::LimitedQueue do
 				end
 			end
 		end
-		Async do |consumer|
-			10.times do
-				subject.dequeue
-				total_dequeued += 1
-
-				expect(total_resumed).to be == total_dequeued
-			end
+		
+		10.times do
+			item = subject.dequeue
+			total_dequeued += 1
+			
+			expect(total_resumed).to be == total_dequeued
 		end
 	end
 end

data/spec/async/reactor_spec.rb

@@ -80,17 +80,37 @@ RSpec.describe Async::Reactor do
 		end
 	end
 	
+	describe '#print_hierarchy' do
+		it "can print hierarchy" do
+			subject.async do |parent|
+				parent.async do |child|
+					child.sleep 1
+				end
+				
+				parent.sleep 1
+			end
+			
+			output = StringIO.new
+			subject.print_hierarchy(output)
+			lines = output.string.lines
+			
+			expect(lines[0]).to be =~ /#<Async::Reactor.*(running)/
+			expect(lines[1]).to be =~ /\t#<Async::Task.*(running)/
+			expect(lines[2]).to be =~ /\t\t#<Async::Task.*(running)/
+		end
+	end
+	
 	describe '#stop' do
 		it "can stop the reactor" do
 			state = nil
 			
-			subject.async do |task|
+			subject.async(annotation: "sleep(10)") do |task|
 				state = :started
 				task.sleep(10)
 				state = :stopped
 			end
 			
-			subject.async do |task|
+			subject.async(annotation: "reactor.stop") do |task|
 				task.sleep(0.1)
 				task.reactor.stop
 			end

data/spec/async/task_spec.rb

@@ -447,6 +447,16 @@ RSpec.describe Async::Task do
 		end
 	end
 	
+	describe '#children' do
+		it "enumerates children in same order they are created" do
+			tasks = 10.times.map do |i|
+				reactor.async(annotation: "Task #{i}") {|task| task.sleep(1)}
+			end
+			
+			expect(reactor.children.each.to_a).to be == tasks
+		end
+	end
+	
 	describe '#to_s' do
 		it "should show running" do
 			apples_task = reactor.async do |task|

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@
 require "covered/rspec"
 
 if RUBY_PLATFORM =~ /darwin/
-	Q = 10
+	Q = 20
 else
 	Q = 1
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 1.25.0
+  version: 1.25.1
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-23 00:00:00.000000000 Z
+date: 2020-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r