async 1.9.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4525bee2a2f58fece634c89881975c3f326ecaaecf4b5495a53f93b6e99360f7
-  data.tar.gz: e23e0f0caa1b383f695aec88aa567bc8daa9028907427ea371579fcd5adf94f6
+  metadata.gz: 82346eddb843773e16f9c2da955116a1418213921a51790050ea72b316a85098
+  data.tar.gz: 6b848d0c50780fc9a1013708aeff0de49858423f79d23039d6b795f6548705c5
 SHA512:
-  metadata.gz: fd2b49c02f4ea805cfe5a3dad3b515adac78cc0edd2190c46f41b3c48460fc5e5d7daa0d3da5803a385552af69c1e557dc43a89f6a13a71e048a1a08c61c3a64
-  data.tar.gz: bb875d2e36bebb80c4850cfa1c4afc938189b2ff559652085cd932659d1363ecc82529bfcedf95197a0b73984821ab49247ef093388131a125efc3e7e9706a98
+  metadata.gz: 4573fa61270cad3f20b436aa322830eb1a08c77533955b58ae7e422b1788aea34db1b829a6c9a4e23faef1cc7a0d8ea40f4a2915e9102dda4ad319d91c3ed3aa
+  data.tar.gz: 516c2056b418feea8e39cec3513a8fc2710be916f5b1d5450a3110e9ae8207dcdb7f7a1a36688a98d081086abcb8eddde6d1766df1b01e98abb0045b44eb964a

data/lib/async.rb

@@ -21,3 +21,10 @@
 require_relative "async/version"
 require_relative "async/logger"
 require_relative "async/reactor"
+
+module Async
+	# Invoke `Reactor.run` with all arguments/block.
+	def self.run(*args, &block)
+		Reactor.run(*args, &block)
+	end
+end

data/lib/async/semaphore.rb

@@ -33,17 +33,39 @@ module Async
 		# The maximum number of tasks that can acquire the semaphore.
 		attr :limit
 		
+		# Is the semaphore currently acquired?
+		def empty?
+			@count.zero?
+		end
+		
 		# Whether trying to acquire this semaphore would block.
 		def blocking?
 			@count >= @limit
 		end
 		
+		# Run an async task. Will wait until the semaphore is ready until spawning and running the task.
+		def async(*args)
+			parent = Task.current
+			
+			wait
+			
+			parent.async do |task|
+				@count += 1
+				
+				begin
+					yield task, *args
+				ensure
+					self.release
+				end
+			end
+		end
+		
 		# Acquire the semaphore, block if we are at the limit.
 		# If no block is provided, you must call release manually.
 		# @yield when the semaphore can be acquired
 		# @return the result of the block if invoked
 		def acquire
-			self.wait while blocking?
+			wait
 			
 			@count += 1
 			
@@ -60,37 +82,21 @@ module Async
 		def release
 			@count -= 1
 			
-			self.signal
-		end
-		
-		# Is anyone waiting?
-		def empty?
-			@waiting.empty?
-		end
-		
-		# Wait on this semaphore.
-		def wait
-			@waiting << Fiber.current
-			Task.yield
-		end
-		
-		# Resume any waiting tasks.
-		def signal(task: Task.current)
-			task.reactor << self if @waiting.any?
-		end
-		
-		# Whether this semaphore has work to do when being resumed.
-		def alive?
-			@waiting.any?
-		end
-		
-		# Resume tasks waiting on the semaphore, up to the maximum to the available limit.
-		def resume
 			available = @waiting.pop(@limit - @count)
 			
 			available.each do |fiber|
 				fiber.resume if fiber.alive?
 			end
 		end
+		
+		private
+		
+		# Wait until the semaphore becomes available.
+		def wait
+			while blocking?
+				@waiting << Fiber.current
+				Task.yield
+			end
+		end
 	end
 end

data/lib/async/version.rb

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

data/spec/async/semaphore_spec.rb

@@ -20,26 +20,113 @@
 
 require 'async/semaphore'
 
+require_relative 'condition_examples'
+
 RSpec.describe Async::Semaphore do
 	include_context Async::RSpec::Reactor
 	
-	it 'should process work in batches' do
-		semaphore = Async::Semaphore.new(4)
-		current, maximum = 0, 0
+	context '#async' do
+		let(:repeats) {40}
+		let(:limit) {4}
 		
-		100.times.map do
-			reactor.async do |task|
-				semaphore.acquire do
+		it 'should process work in batches' do
+			semaphore = Async::Semaphore.new(limit)
+			current, maximum = 0, 0
+			
+			result = repeats.times.map do |i|
+				semaphore.async do |task|
 					current += 1
 					maximum = [current, maximum].max
-					task.sleep(0.01)
+					task.sleep(rand * 0.1)
 					current -= 1
+					
+					i
 				end
-			end
-		end.collect(&:result)
+			end.collect(&:result)
+			
+			# Verify that the maximum number of concurrent tasks was the specificed limit:
+			expect(maximum).to be == limit
+			
+			# Verify that the results were in the correct order:
+			expect(result).to be == (0...repeats).to_a
+		end
 		
-		expect(maximum).to be == 4
+		it 'only allows one task at a time' do
+			semaphore = Async::Semaphore.new(1)
+			order = []
+			
+			3.times.map do |i|
+				semaphore.async do |task|
+					order << i
+					task.sleep(0.1)
+					order << i
+				end
+			end.collect(&:result)
+			
+			expect(order).to be == [0, 0, 1, 1, 2, 2]
+		end
+		
+		it 'allows tasks to execute concurrently' do
+			semaphore = Async::Semaphore.new(3)
+			order = []
+			
+			3.times.map do |i|
+				semaphore.async do |task|
+					order << i
+					task.sleep(0.1)
+					order << i
+				end
+			end.collect(&:result)
+			
+			expect(order).to be == [0, 1, 2, 0, 1, 2]
+		end
 	end
 	
-	it_behaves_like Async::Condition
+	context '#count' do
+		it 'should count number of current acquisitions' do
+			expect(subject.count).to be == 0
+			
+			subject.acquire do
+				expect(subject.count).to be == 1
+			end
+		end
+	end
+	
+	context '#limit' do
+		it 'should have a default limit' do
+			expect(subject.limit).to be == 1
+		end
+	end
+	
+	context '#empty?' do
+		it 'should be empty unless acquired' do
+			expect(subject).to be_empty
+			
+			subject.acquire do
+				expect(subject).to_not be_empty
+			end
+		end
+	end
+	
+	context '#blocking?' do
+		it 'will be blocking when acquired' do
+			expect(subject).to_not be_blocking
+			
+			subject.acquire do
+				expect(subject).to be_blocking
+			end
+		end
+	end
+	
+	context '#acquire/#release' do
+		it 'works when called without block' do
+			subject.acquire
+			
+			expect(subject.count).to be == 1
+			
+			subject.release
+			
+			expect(subject.count).to be == 0
+		end
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Samuel Williams