async 1.12.0 → 1.13.0

data/spec/async/reactor/nested_spec.rb

@@ -26,9 +26,9 @@ RSpec.describe Async::Reactor do
 			outer_reactor = Async::Task.current.reactor
 			inner_reactor = nil
 			
-			task = described_class.run do |task|
+			described_class.run do |task|
 				inner_reactor = task.reactor
-			end 
+			end
 			
 			expect(outer_reactor).to be_kind_of(described_class)
 			expect(outer_reactor).to be_eql(inner_reactor)
@@ -40,9 +40,9 @@ RSpec.describe Async::Reactor do
 			expect(Async::Task.current?).to be_nil
 			inner_reactor = nil
 			
-			task = described_class.run do |task|
+			described_class.run do |task|
 				inner_reactor = task.reactor
-			end 
+			end
 			
 			expect(inner_reactor).to be_kind_of(described_class)
 		end

data/spec/async/reactor_spec.rb

@@ -75,26 +75,26 @@ RSpec.describe Async::Reactor do
 	end
 	it "can't return" do
 		expect do
-			Async::Reactor.run do |task|
+			Async do |task|
 				return
-			end
-		end.to raise_error(LocalJumpError)
+			end.wait
+		end.to raise_exception(LocalJumpError)
 	end
 	
 	it "is closed after running" do
 		reactor = nil
 		
-		Async::Reactor.run do |task|
+		Async do |task|
 			reactor = task.reactor
 		end
 		
 		expect(reactor).to be_closed
 		
-		expect{reactor.run}.to raise_error(RuntimeError, /closed/)
+		expect{reactor.run}.to raise_exception(RuntimeError, /closed/)
 	end
 	
 	it "should return a task" do
-		result = Async::Reactor.run do |task|
+		result = Async do |task|
 		end
 		
 		expect(result).to be_kind_of(Async::Task)
@@ -153,8 +153,8 @@ RSpec.describe Async::Reactor do
 					task.timeout(0.0, timeout_class) do
 						task.sleep(1.0)
 					end
-				end
-			end.to raise_error(timeout_class)
+				end.wait
+			end.to raise_exception(timeout_class)
 		end
 	end
 	

data/spec/async/task_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Async::Task do
 			task = reactor.async do |task|
 			end
 			
-			expect{task.run}.to raise_error(RuntimeError, /already running/)
+			expect{task.run}.to raise_exception(RuntimeError, /already running/)
 		end
 	end
 	
@@ -54,13 +54,61 @@ RSpec.describe Async::Task do
 				end.wait
 			end.wait
 		end
+		
+		it "can raise exceptions" do
+			expect do
+				reactor.async do |task|
+					raise "boom"
+				end.wait
+			end.to raise_exception RuntimeError, /boom/
+		end
+		
+		it "can raise exception after asynchronous operation" do
+			task = nil
+			
+			expect do
+				task = reactor.async do |task|
+					task.sleep 0.1
+					
+					raise "boom"
+				end
+			end.to_not raise_exception
+			
+			reactor.run do
+				expect do
+					task.wait
+				end.to raise_exception RuntimeError, /boom/
+			end
+		end
+		
+		it "can consume exceptions" do
+			task = nil
+			
+			expect do
+				task = reactor.async(propagate_exceptions: false) do |task|
+					raise "boom"
+				end
+			end.to_not raise_exception
+			
+			expect do
+				task.wait
+			end.to raise_exception RuntimeError, /boom/
+		end
+		
+		it "won't consume non-StandardError exceptions" do
+			expect do
+				reactor.async(propagate_exceptions: false) do |task|
+					raise SignalException.new(:TERM)
+				end
+			end.to raise_exception(SignalException, /TERM/)
+		end
 	end
 	
 	describe '#yield' do
 		it "can yield back to reactor" do
 			state = nil
 			
-			task = reactor.async do |task|
+			reactor.async do |task|
 				state = :started
 				task.yield
 				state = :finished
@@ -90,7 +138,7 @@ RSpec.describe Async::Task do
 		it "should kill direct child" do
 			parent_task = child_task = nil
 			
-			task = reactor.async do |task|
+			reactor.async do |task|
 				parent_task = task
 				reactor.async do |task|
 					child_task = task
@@ -135,7 +183,7 @@ RSpec.describe Async::Task do
 		it "can sleep for the requested duration" do
 			state = nil
 			
-			task = reactor.async do |task|
+			reactor.async do |task|
 				task.sleep(duration)
 				state = :finished
 			end
@@ -152,10 +200,26 @@ RSpec.describe Async::Task do
 	end
 	
 	describe '#timeout' do
+		it "can extend timeout" do
+			reactor.async do |task|
+				task.timeout(0.2) do |timer|
+					task.sleep(0.1)
+					
+					expect(timer.fires_in).to be_within(10).percent_of(0.1)
+					
+					timer.reset
+					
+					expect(timer.fires_in).to be_within(10).percent_of(0.2)
+				end
+			end
+			
+			reactor.run
+		end
+		
 		it "will timeout if execution takes too long" do
 			state = nil
 			
-			task = reactor.async do |task|
+			reactor.async do |task|
 				begin
 					task.timeout(0.01) do
 						state = :started
@@ -175,7 +239,7 @@ RSpec.describe Async::Task do
 		it "won't timeout if execution completes in time" do
 			state = nil
 			
-			task = reactor.async do |task|
+			reactor.async do |task|
 				state = :started
 				task.timeout(0.01) do
 					task.sleep(0.001)
@@ -191,8 +255,6 @@ RSpec.describe Async::Task do
 	
 	describe '#wait' do
 		it "will wait on another task to complete" do
-			result = nil
-			
 			apples_task = reactor.async do |task|
 				task.sleep(0.1)
 				
@@ -205,33 +267,43 @@ RSpec.describe Async::Task do
 				:oranges
 			end
 			
-			fruit_salad_task = reactor.async do |task|
-				result = [apples_task.result, oranges_task.result]
+			fruit_salad = reactor.async do |task|
+				[apples_task.wait, oranges_task.wait]
 			end
 			
 			reactor.run
 			
-			expect(result).to be == [:apples, :oranges]
+			expect(fruit_salad.wait).to be == [:apples, :oranges]
+		end
+		
+		it "will raise exceptions when checking result" do
+			error_task = nil
+			
+			error_task = reactor.async(propagate_exceptions: false) do |task|
+				raise RuntimeError, "brain not provided"
+			end
+			
+			expect do
+				error_task.wait
+			end.to raise_exception(RuntimeError, /brain/)
 		end
 		
-		it "will propagate exceptions" do
+		it "will propagate exceptions after async operation" do
 			error_task = nil
 			
-			error_task = reactor.async do |task|
+			error_task = reactor.async(propagate_exceptions: false) do |task|
 				task.sleep(0.1)
 				
-				raise ArgumentError.new("It simply wasn't good enough")
+				raise "boom"
 			end
 			
 			innocent_task = reactor.async do |task|
-				expect{error_task.result}.to raise_error(ArgumentError, /wasn't good enough/)
+				expect{error_task.wait}.to raise_exception RuntimeError, /boom/
 			end
 			
-			begin
+			expect do
 				reactor.run
-			rescue Exception
-				retry
-			end
+			end.to_not raise_exception
 			
 			expect(error_task).to be_finished
 			expect(innocent_task).to be_finished

data/spec/async/wrapper_spec.rb

@@ -46,7 +46,9 @@ RSpec.describe Async::Wrapper do
 		end
 		
 		it "can timeout if no event occurs" do
-			expect(output.wait_readable(0.1)).to be_falsey
+			expect do
+				output.wait_readable(0.1)
+			end.to raise_exception(Async::TimeoutError)
 		end
 		
 		it "can wait for readability in sequential tasks" do
@@ -66,7 +68,7 @@ RSpec.describe Async::Wrapper do
 			reactor.async do
 				expect do
 					output.wait_readable
-				end.to raise_error(Async::Wrapper::Cancelled)
+				end.to raise_exception(Async::Wrapper::Cancelled)
 			end
 			
 			expect(output.monitor).to_not be_nil
@@ -82,7 +84,7 @@ RSpec.describe Async::Wrapper do
 			reactor.async do
 				expect do
 					input.wait_readable
-				end.to raise_error(Async::Wrapper::Cancelled)
+				end.to raise_exception(Async::Wrapper::Cancelled)
 			end
 			
 			# This reproduces the race condition that can occur if two tasks are resumed in sequence.
@@ -93,14 +95,14 @@ RSpec.describe Async::Wrapper do
 			# Resume task 2:
 			expect do
 				output.resume
-			end.to_not raise_error
+			end.to_not raise_exception
 		end
 		
 		it "can be cancelled" do
 			reactor.async do
 				expect do
 					input.wait_readable
-				end.to raise_error(Async::Wrapper::Cancelled)
+				end.to raise_exception(Async::Wrapper::Cancelled)
 			end
 			
 			expect(input.monitor).to_not be_nil
@@ -121,7 +123,7 @@ RSpec.describe Async::Wrapper do
 			reactor.async do
 				expect do
 					input.wait_readable(1)
-				end.to raise_error(Async::Wrapper::Cancelled)
+				end.to raise_exception(Async::Wrapper::Cancelled)
 			end
 			
 			expect(input.monitor.interests).to be == :r
@@ -140,7 +142,7 @@ RSpec.describe Async::Wrapper do
 			reactor.async do
 				expect do
 					input.wait_readable
-				end.to raise_error(Async::Wrapper::Cancelled)
+				end.to raise_exception(Async::Wrapper::Cancelled)
 			end
 			
 			expect(input.monitor.interests).to be == :r
@@ -148,7 +150,7 @@ RSpec.describe Async::Wrapper do
 			reactor.async do
 				expect do
 					input.wait_readable
-				end.to raise_error(Async::Wrapper::WaitError)
+				end.to raise_exception(Async::Wrapper::WaitError)
 			end
 		end
 	end
@@ -193,7 +195,7 @@ RSpec.describe Async::Wrapper do
 			
 			expect do
 				output.wait_readable
-			end.to raise_error(IOError, /closed stream/)
+			end.to raise_exception(IOError, /closed stream/)
 		end
 	end
 end

data/spec/enumerator_spec.rb

@@ -34,7 +34,7 @@ RSpec.describe Enumerator do
 		# no fiber really used in internal iterator,
 		# but let this test be here for completness
 		ar = nil
-		Async::Reactor.run do |task|
+		Async do |task|
 			ar = enum(task).to_a
 		end
 		expect(ar).to be == [1, 2]
@@ -42,7 +42,7 @@ RSpec.describe Enumerator do
 
 	it "should play well with Enumerator as external iterator", pending: "expected failure" do
 		ar = []
-		Async::Reactor.run do |task|
+		Async do |task|
 			en = enum(task)
 			ar << en.next
 			ar << en.next
@@ -54,15 +54,15 @@ RSpec.describe Enumerator do
 	end
 
 	it "should play well with Enumerator.zip(Enumerator) method", pending: "expected failure" do
-		Async::Reactor.run do |task|
+		Async do |task|
 			ar = [:a, :b, :c, :d].each.zip(enum(task))
 			expect(ar).to be == [[:a, 1], [:b, 2], [:c, nil], [:d, nil]]
-		end
+		end.wait
 	end
 
 	it "should play with explicit Fiber usage", pending: "expected failure" do
 		ar = []
-		Async::Reactor.run do |task|
+		Async do |task|
 			fib = Fiber.new {
 				Fiber.yield 1
 				task.sleep(0.002)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-20 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -131,6 +131,7 @@ files:
 - lib/async/reactor.rb
 - lib/async/semaphore.rb
 - lib/async/task.rb
+- lib/async/terminal.rb
 - lib/async/version.rb
 - lib/async/wrapper.rb
 - logo.png
@@ -171,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.0.beta3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Async is an asynchronous I/O framework based on nio4r.