async 1.12.0 → 1.13.0

data/lib/async/node.rb

@@ -96,17 +96,17 @@ module Async
 		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?
+			if @parent and finished?
 				@parent.reap(self)
 				@parent.consume
 				@parent = nil
 			end
 		end
-	
+		
 		# Remove a given child node.
 		# @param child [Node]
 		def reap(child)

data/lib/async/queue.rb

@@ -54,6 +54,8 @@ module Async
 			@full = Async::Condition.new
 		end
 		
+		attr :limit
+		
 		# @return [Boolean] Whether trying to enqueue an item would block.
 		def limited?
 			@items.size >= @limit

data/lib/async/reactor.rb

@@ -27,8 +27,8 @@ require 'timers'
 require 'forwardable'
 
 module Async
-	# Raised if a timeout occurs on a specific Fiber. Handled gracefully by {Task}.
-	class TimeoutError < Exception
+	# Raised if a timeout occurs on a specific Fiber. Handled gracefully by `Task`.
+	class TimeoutError < StandardError
 	end
 	
 	# An asynchronous, cooperatively scheduled event reactor.
@@ -89,8 +89,8 @@ module Async
 		#
 		# This is the main entry point for scheduling asynchronus tasks.
 		#
-		# @yield [Task] Executed within the asynchronous task.
-		# @return [Task] The task that was 
+		# @yield [Task] Executed within the task.
+		# @return [Task] The task that was scheduled into the reactor.
 		def async(*args, &block)
 			task = Task.new(self, &block)
 			
@@ -124,6 +124,7 @@ module Async
 		end
 		
 		# Schedule a fiber (or equivalent object) to be resumed on the next loop through the reactor.
+		# @param fiber [#resume] The object to be resumed on the next iteration of the run-loop.
 		def << fiber
 			@ready << fiber
 		end
@@ -146,8 +147,7 @@ module Async
 			
 			@stopped = false
 			
-			# Allow the user to kick of the initial async tasks.
-			initial_task = async(*args, &block) if block_given?
+			initial_task = self.async(*args, &block) if block_given?
 			
 			@timers.wait do |interval|
 				# running used to correctly answer on `finished?`, and to reuse Array object.
@@ -233,7 +233,7 @@ module Async
 		
 		# 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 
+		# @param duration [Numeric] The time in seconds, in which the task should 
 		#   complete.
 		def timeout(duration, exception = TimeoutError)
 			backtrace = caller
@@ -247,7 +247,7 @@ module Async
 				end
 			end
 			
-			yield
+			yield timer
 		ensure
 			timer.cancel if timer
 		end

data/lib/async/task.rb

@@ -28,7 +28,7 @@ module Async
 	# Raised when a task is explicitly stopped.
 	class Stop < Exception
 	end
-
+	
 	# A task represents the state associated with the execution of an asynchronous
 	# block.
 	class Task < Node
@@ -57,41 +57,21 @@ module Async
 		# Create a new task.
 		# @param reactor [Async::Reactor] the reactor this task will run within.
 		# @param parent [Async::Task] the parent task.
-		def initialize(reactor, parent = Task.current?)
+		# @param propagate_exceptions [Boolean] whether exceptions raised in the task will propagate up the reactor stack.
+		def initialize(reactor, parent = Task.current?, &block)
 			super(parent || reactor)
 			
 			@reactor = reactor
 			
 			@status = :initialized
 			@result = nil
-			
 			@finished = nil
 			
-			@fiber = Fiber.new do |*args|
-				set!
-				
-				begin
-					@result = yield(self, *args)
-					@status = :complete
-					# Async.logger.debug("Task #{self} completed normally.")
-				rescue Stop
-					@status = :stop
-					# Async.logger.debug("Task #{self} stopped: #{$!}")
-					Async.logger.debug(self) {$!}
-				rescue Exception => error
-					@result = error
-					@status = :failed
-					Async.logger.debug(self) {$!}
-					raise
-				ensure
-					# Async.logger.debug("Task #{self} closing: #{$!}")
-					finish!
-				end
-			end
+			@fiber = make_fiber(&block)
 		end
 		
 		def to_s
-			"<#{self.description} status=#{@status}>"
+			"<#{self.description} #{@status}>"
 		end
 		
 		# @attr ios [Reactor] The reactor the task was created within.
@@ -107,7 +87,7 @@ module Async
 		attr :fiber
 		def_delegators :@fiber, :alive?
 		
-		# @attr status [Symbol] The status of the execution of the fiber, one of `:running`, `:complete`, `:stopped`, or `:failed`.
+		# @attr status [Symbol] The status of the execution of the fiber, one of `:initialized`, `:running`, `:complete`, `:stopped` or `:failed`.
 		attr :status
 		
 		# Resume the execution of the task.
@@ -130,20 +110,21 @@ module Async
 		
 		# 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)
+		# @return [Object] the final expression/result of the task's block.
+		def wait
+			raise RuntimeError, "Cannot wait on own fiber" if Fiber.current.equal?(@fiber)
 			
 			if running?
 				@finished ||= Condition.new
 				@finished.wait
 			else
-				Task.yield {@result}
+				Task.yield{@result}
 			end
 		end
 		
-		alias wait result
-	
+		# Deprecated.
+		alias result wait
+		
 		# Stop the task and all of its children.
 		# @return [void]
 		def stop
@@ -178,9 +159,58 @@ module Async
 		def finished?
 			super && @status != :running
 		end
-	
+		
+		def failed?
+			@status == :failed
+		end
+		
+		def stopped?
+			@status == :stopped
+		end
+		
 		private
-	
+		
+		# This is a very tricky aspect of tasks to get right. I've modelled it after `Thread` but it's slightly different in that the exception can propagate back up through the reactor. If the user writes code which raises an exception, that exception should always be visible, i.e. cause a failure. If it's not visible, such code fails silently and can be very difficult to debug.
+		# As an explcit choice, the user can start a task which doesn't propagate exceptions. This only applies to `StandardError` and derived tasks. This allows tasks to internally capture their error state which is raised when invoking `Task#result` similar to how `Thread#join` works. This mode makes `Async::Task` behave more like a promise, and you would need to ensure that someone calls `Task#result` otherwise you might miss important errors.
+		def fail!(exception = nil, propagate = true)
+			@status = :failed
+			@result = exception
+			
+			if propagate
+				raise
+			elsif @finished.nil?
+				# If no one has called wait, we log this as an error:
+				Async.logger.error(self) {$!}
+			else
+				Async.logger.debug(self) {$!}
+			end
+		end
+		
+		def stop!
+			@status = :stopped
+		end
+		
+		def make_fiber(&block)
+			Fiber.new do |*args|
+				set!
+				
+				begin
+					@result = yield(self, *args)
+					@status = :complete
+					# Async.logger.debug("Task #{self} completed normally.")
+				rescue Stop
+					stop!
+				rescue StandardError => error
+					fail!(error, false)
+				rescue Exception => exception
+					fail!(exception, true)
+				ensure
+					# Async.logger.debug("Task #{self} closing: #{$!}")
+					finish!
+				end
+			end
+		end
+		
 		# Finish the current task, and all bound bound IO objects.
 		def finish!
 			# Attempt to remove this node from the task tree.

data/lib/async/terminal.rb

@@ -0,0 +1,99 @@
+# 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.
+
+module Async
+	# Styled terminal output. **Internal Use Only**
+	class Terminal
+		module Attributes
+			NORMAL = 0
+			BOLD = 1
+			FAINT = 2
+			ITALIC = 3
+			UNDERLINE = 4
+			BLINK = 5
+			REVERSE = 7
+			HIDDEN = 8
+		end
+		
+		module Colors
+			BLACK = 0
+			RED = 1
+			GREEN = 2
+			YELLOW = 3
+			BLUE = 4
+			MAGENTA = 5
+			CYAN = 6
+			WHITE = 7
+			DEFAULT = 9
+		end
+		
+		def initialize(output)
+			@output = output
+		end
+		
+		def tty?
+			@output.isatty
+		end
+		
+		def color(foreground, background = nil, attributes = nil)
+			return nil unless tty?
+			
+			buffer = String.new
+			
+			buffer << "\e["
+			first = true
+			
+			if attributes
+				buffer << (attributes).to_s
+				first = false
+			end
+			
+			if foreground
+				if !first
+					buffer << ";" 
+				else
+					first = false
+				end
+				
+				buffer << (30 + foreground).to_s
+			end
+			
+			if background
+				if !first
+					buffer << ";" 
+				else
+					first = false
+				end
+				
+				buffer << (40 + background).to_s
+			end
+			
+			buffer << 'm'
+			
+			return buffer
+		end
+		
+		def reset
+			return nil unless tty?
+			
+			return "\e[0m"
+		end
+	end
+end

data/lib/async/version.rb

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

data/lib/async/wrapper.rb

@@ -205,11 +205,7 @@ module Async
 			# If the user requested an explicit timeout for this operation:
 			if duration
 				@reactor.timeout(duration) do
-					begin
-						Task.yield
-					rescue Async::TimeoutError
-						return false
-					end
+					Task.yield
 				end
 			else
 				Task.yield

data/spec/async/condition_examples.rb

@@ -22,7 +22,7 @@ RSpec.shared_examples Async::Condition do
 	it 'can signal waiting task' do
 		state = nil
 		
-		task = reactor.async do
+		reactor.async do
 			state = :waiting
 			subject.wait
 			state = :resumed

data/spec/async/logger_spec.rb

@@ -18,8 +18,52 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+RSpec.describe Async::Logger do
+	let(:output) {StringIO.new}
+	subject{described_class.new(output)}
+	
+	let(:message) {"Hello World"}
+	
+	context "default log level" do
+		it "logs info" do
+			subject.info(message)
+			
+			expect(output.string).to include message
+		end
+		
+		it "doesn't log debug" do
+			subject.debug(message)
+			
+			expect(output.string).to_not include message
+		end
+	end
+	
+	described_class::LEVELS.each do |name, level|
+		it "can log #{name} messages" do
+			subject.level = level
+			subject.log(name, message)
+			
+			expect(output.string).to include message
+		end
+	end
+	
+	describe '#enable' do
+		let(:object) {Async::Node.new}
+		
+		it "can enable specific subjects" do
+			subject.warn!
+			
+			subject.enable(object)
+			expect(subject).to be_enabled(object)
+			
+			subject.debug(object, message)
+			expect(output.string).to include message
+		end
+	end
+end
+
 RSpec.describe Async.logger do
-	describe '::default_log_level' do
+	describe 'default_log_level' do
 		let!(:debug) {$DEBUG}
 		after {$DEBUG = debug}
 		
@@ -30,20 +74,20 @@ RSpec.describe Async.logger do
 			$DEBUG = false
 			$VERBOSE = false
 			
-			expect(Async.default_log_level).to be == Logger::WARN
+			expect(Async.default_log_level).to be == Async::Logger::WARN
 		end
 		
 		it 'should set default log level based on $DEBUG' do
 			$DEBUG = true
 			
-			expect(Async.default_log_level).to be == Logger::DEBUG
+			expect(Async.default_log_level).to be == Async::Logger::DEBUG
 		end
 		
 		it 'should set default log level based on $VERBOSE' do
 			$DEBUG = false
 			$VERBOSE = true
 			
-			expect(Async.default_log_level).to be == Logger::INFO
+			expect(Async.default_log_level).to be == Async::Logger::INFO
 		end
 	end
 end

data/spec/async/performance_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Async::Wrapper do
 	it "should be fast to wait until readable" do
 		Benchmark.ips do |x|
 			x.report('Wrapper#wait_readable') do |repeats|
-				Async::Reactor.run do |task|
+				Async do |task|
 					input = Async::Wrapper.new(pipe.first, task.reactor)
 					output = pipe.last
 					
@@ -25,7 +25,7 @@ RSpec.describe Async::Wrapper do
 			end
 			
 			x.report('Reactor#register') do |repeats|
-				Async::Reactor.run do |task|
+				Async do |task|
 					input = pipe.first
 					monitor = task.reactor.register(input, :r)
 					output = pipe.last