process-group 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28a68aa53cd296412dd77cdca5a9c8b000269439
-  data.tar.gz: 49777327e43bbddda6e17a2b13776227693d115d
+  metadata.gz: 98b4baed52fa9d14e546993096a2e68ca5e2550e
+  data.tar.gz: 630111d7484ecdc7e850c48afc3c437767f3695b
 SHA512:
-  metadata.gz: 508765b5658d4fbb032c7f43f36a5a9c26e4fbbfc379295398d3ac08e9da12bab9440cb9002bd052d9eaaba5abbbd9ee970f8a290ceaab144ad682e53e95ebfb
-  data.tar.gz: 0f7d655bd81259b92c757342ff71aee743209e33dbb3c1a71e4b4facd0c4dac5de706a01735c4afd964feb6b52429e8d6b07e706db992408a7da81f599b5a4e9
+  metadata.gz: 57f6dcf3d08a2b85315633c630cca1ace63bfcf678db80882125c1c72773e4377e85503677a58f6d0dfd7917404d3e9085da8de7f09d4c250838f33192fcee2a
+  data.tar.gz: 29f4993f4ded486db893cad0855a6c4af59d4f89ded8f638d99459d4188917c4b9156135f97b98c968e147cb8d31bfb5c7ec1026e37e505a825a78db115fd508

data/.travis.yml

@@ -9,6 +9,8 @@ rvm:
   - rbx-2
 env: COVERAGE=true
 matrix:
+  fast_finish: true
   allow_failures:
+    - rvm: "ruby-head"
     - rvm: "rbx-2"
 

data/README.md

@@ -12,86 +12,105 @@
 
 Add this line to your application's Gemfile:
 
-    gem 'process-group'
+	gem 'process-group'
 
 And then execute:
 
-    $ bundle
+	$ bundle
 
 Or install it yourself as:
 
-    $ gem install process-group
+	$ gem install process-group
 
 ## Usage
 
 The simplest concurrent usage is as follows:
 
 	# Create a new process group:
-	group = Process::Group.new
-	
-	# Run the command (non-blocking):
-	group.run("sleep 1") do |exit_status|
-		# Running in a separate fiber, will execute this code once the process completes:
-		puts "Command finished with status: #{exit_status}"
+	Process::Group.wait do |group|
+		# Run the command (non-blocking):
+		group.run("sleep 1") do |exit_status|
+			# Running in a separate fiber, will execute this code once the process completes:
+			puts "Command finished with status: #{exit_status}"
+		end
+		
+		# Do something else here:
+		sleep(1)
+		
+		# Wait for all processes in group to finish.
 	end
-	
-	# Do something else here:
-	sleep(1)
-	
-	# Wait for all processes in group to finish:
-	group.wait
 
-The `group.wait` call is an explicit synchronisation point, and if it completes successfully, all processes/fibers have finished successfully. If an error is raised in a fiber, it will be passed back out through `group.wait` and this is the only failure condition. Even if this occurs, all children processes are guaranteed to be cleaned up.
+The `group.wait` call is an explicit synchronization point, and if it completes successfully, all processes/fibers have finished successfully. If an error is raised in a fiber, it will be passed back out through `group.wait` and this is the only failure condition. Even if this occurs, all children processes are guaranteed to be cleaned up.
 
 ### Explicit Fibers
 
 Items within a single fiber will execute sequentially. Processes (e.g. via `Group#spawn`) will run concurrently in multiple fibers.
 
-	group = Process::Group.new
+	Process::Group.wait do |group|
+		# Explicity manage concurrency in this fiber:
+		Fiber.new do
+			# These processes will be run sequentially:
+			group.spawn("sleep 1")
+			group.spawn("sleep 1")
+		end.resume
 	
-	# Explicity manage concurrency in this fiber:
-	Fiber.new do
-		# These processes will be run sequentially:
-		group.spawn("sleep 1")
-		group.spawn("sleep 1")
-	end.resume
-	
-	# Implicitly run this task concurrently as the above fiber:
-	group.run("sleep 2")
-	
-	# Wait for fiber to complete:
-	group.wait
+		# Implicitly run this task concurrently as the above fiber:
+		group.run("sleep 2")
+	end
 
 `Group#spawn` is theoretically identical to `Process#spawn` except the processes are run concurrently if possible.
 
-### Specify Options
+### Explicit Wait
 
-You can specify options to `Group#run` and `Group#spawn` just like `Process::spawn`:
+The recommended approach to use process group is to call `Process::Group.wait` with a block which invokes tasks. This block is wrapped in appropriate `rescue Interrupt` and `ensure` blocks which guarantee that the process group is cleaned up:
+
+	Process::Group.wait do |group|
+		group.run("sleep 10")
+	end
+
+It is also possible to invoke this machinery and reuse the process group simply by instantiating the group and calling wait explicitly:
 
 	group = Process::Group.new
 	
-	env = {'FOO' => 'BAR'}
+	group.wait do
+		group.run("sleep 10")
+	end
+
+It is also possible to queue tasks for execution outside the wait block. But by design, it's only possible to execute tasks within the wait block. Tasks added outside a wait block will be queued up for execution when `#wait` is invoked:
+
+	group = Process::Group.new
 	
-	# Arguments are essentially the same as Process::spawn.
-	group.run(env, "sleep 1", chdir: "/tmp")
+	group.run("sleep 10")
 	
+	# Run command here:
 	group.wait
 
+### Specify Options
+
+You can specify options to `Group#run` and `Group#spawn` just like `Process::spawn`:
+
+	Process::Group.wait do |group|
+		env = {'FOO' => 'BAR'}
+		
+		# Arguments are essentially the same as Process::spawn.
+		group.run(env, "sleep 1", chdir: "/tmp")
+	end
+
 ### Process Limit
 
-The process group can be used as a way to spawn multiple processes, but sometimes you'd like to limit the number of parallel processes to something relating to the number of processors in the system. A number of options exist.
+The process group can be used as a way to spawn multiple processes, but sometimes you'd like to limit the number of parallel processes to something relating to the number of processors in the system. By default, there is no limit on the number of processes running concurrently.
 
 	# 'facter' gem - found a bit slow to initialise, but most widely supported.
 	require 'facter'
 	group = Process::Group.new(limit: Facter.processorcount)
-	
+
 	# 'system' gem - found very fast, less wide support (but nothing really important).
 	require 'system'
 	group = Process::Group.new(limit: System::CPU.count)
-	
+
 	# hardcoded - set to n (8 < n < 32) and let the OS scheduler worry about it.
 	group = Process::Group.new(limit: 32)
-	
+
 	# unlimited - default.
 	group = Process::Group.new
 
@@ -101,7 +120,7 @@ It is possible to send a signal (kill) to the entire process group:
 
 	group.kill(:TERM)
 
-If there are no running processes, this is a no-op (rather than an error).
+If there are no running processes, this is a no-op (rather than an error). [Proper handling of SIGINT/SIGQUIT](http://www.cons.org/cracauer/sigint.html) explains how to use signals correctly.
 
 #### Handling Interrupts
 

data/lib/process/group.rb

@@ -23,6 +23,12 @@ require 'fiber'
 module Process
 	# A group of tasks which can be run asynchrnously using fibers. Someone must call Group#wait to ensure that all fibers eventually resume.
 	class Group
+		def self.wait(**options, &block)
+			group = Group.new(options)
+			
+			group.wait(&block)
+		end
+		
 		# Executes a command using Process.spawn with the given arguments and options.
 		class Command
 			def initialize(arguments, options, fiber = Fiber.current)
@@ -88,6 +94,9 @@ module Process
 			@fiber = nil
 		
 			@pgid = nil
+			
+			# Whether we can actively schedule tasks or not:
+			@waiting = false
 		end
 		
 		# A table of currently running processes.
@@ -102,16 +111,20 @@ module Process
 			
 			-@pgid
 		end
-
+		
+		def queued?
+			@queue.size > 0
+		end
+		
 		# Are there processes currently running?
 		def running?
 			@running.size > 0
 		end
-
+		
 		# Run a process in a new fiber, arguments have same meaning as Process#spawn.
-		def run(*arguments)
+		def run(*arguments, **options)
 			Fiber.new do
-				exit_status = self.spawn(*arguments)
+				exit_status = self.spawn(*arguments, **options)
 				
 				yield exit_status if block_given?
 			end.resume
@@ -141,20 +154,26 @@ module Process
 			not available?
 		end
 		
-		# Wait for all running and queued processes to finish.
+		# Wait for all running and queued processes to finish. If you provide a block, it will be invoked before waiting, but within canonical signal handling machinery.
 		def wait
 			raise ArgumentError.new("Cannot call Process::Group#wait from child process!") unless @pid == Process.pid
 			
-			while running?
-				process, status = wait_one
-				
-				schedule!
+			waiting do
+				yield(self) if block_given?
 				
-				process.resume(status)
+				while running?
+					process, status = wait_one
+					
+					schedule!
+					
+					process.resume(status)
+				end
 			end
 			
 			# No processes, process group is no longer valid:
 			@pgid = nil
+			
+			return self
 		rescue Interrupt
 			# If the user interrupts the wait, interrupt the process group and wait for them to finish:
 			self.kill(:INT)
@@ -182,13 +201,33 @@ module Process
 			end
 		end
 		
+		def to_s
+			"#<#{self.class} running=#{@running.size} queued=#{@queue.count} limit=#{@limit} pgid=#{@pgid}>"
+		end
+		
 		private
 		
+		# The waiting loop, schedule any outstanding tasks:
+		def waiting
+			@waiting = true
+			
+			# Schedule any queued tasks:
+			schedule!
+			
+			yield
+		ensure
+			@waiting = false
+		end
+		
+		def waiting?
+			@waiting
+		end
+		
 		# Append a process to the queue and schedule it for execution if possible.
 		def append!(process)
 			@queue << process
 			
-			schedule!
+			schedule! if waiting?
 			
 			Fiber.yield
 		end
@@ -214,6 +253,9 @@ module Process
 		# Wait for all children to exit but without resuming any controlling fibers.
 		def wait_all
 			wait_one while running?
+			
+			# Clear any queued tasks:
+			@queue.clear
 		end
 		
 		# Wait for one process, should only be called when a child process has finished, otherwise would block.

data/lib/process/group/version.rb

@@ -20,6 +20,6 @@
 
 module Process
 	class Group
-		VERSION = "1.0.1"
+		VERSION = "1.1.0"
 	end
 end

data/spec/process/group/fork_spec.rb

@@ -20,46 +20,41 @@
 
 require 'process/group'
 
-module Process::Group::ForkSpec
-	describe Process::Group do
-		it "should fork and write to pipe" do
-			group = Process::Group.new
-		
-			input, output = IO.pipe
-		
-			Fiber.new do
-				result = group.fork do
-					output.puts "Hello World"
-				
-					exit(1)
-				end
-				
-				expect(result.exitstatus).to be == 1
-			end.resume
-		
+RSpec.describe Process::Group do
+	it "should fork and write to pipe" do
+		input, output = IO.pipe
+	
+		Fiber.new do
+			result = subject.fork do
+				output.puts "Hello World"
+			
+				exit(1)
+			end
+			
+			# We need to close output so that input.read will encounter end of stream.
 			output.close
-		
-			group.wait
-		
-			expect(input.read).to be == "Hello World\n"
-		end
-		
-		it "should not throw interrupt from fork" do
-			group = Process::Group.new
-		
-			Fiber.new do
-				result = group.fork do
-					# Don't print out a backtrace when Ruby invariably exits due to the execption below:
-					$stderr.reopen('/dev/null', 'w')
-					
-					raise Interrupt
-				end
 			
-				expect(result.exitstatus).not_to be == 0
-			end.resume
+			expect(result.exitstatus).to be == 1
+		end.resume
 		
-			# Shouldn't raise any errors:
-			group.wait
-		end
+		subject.wait
+		
+		expect(input.read).to be == "Hello World\n"
+	end
+	
+	it "should not throw interrupt from fork" do
+		Fiber.new do
+			result = subject.fork do
+				# Don't print out a backtrace when Ruby invariably exits due to the execption below:
+				$stderr.reopen('/dev/null', 'w')
+				
+				raise Interrupt
+			end
+		
+			expect(result.exitstatus).not_to be == 0
+		end.resume
+	
+		# Shouldn't raise any errors:
+		subject.wait
 	end
-end
+end

data/spec/process/group/interrupt_spec.rb

@@ -20,131 +20,127 @@
 
 require 'process/group'
 
-module Process::Group::InterruptSpec
-	describe Process::Group do
-		it "should raise interrupt exception" do
-			group = Process::Group.new
-			checkpoint = ""
+RSpec.describe Process::Group do
+	it "should raise interrupt exception" do
+		checkpoint = ""
 		
-			Fiber.new do
-				checkpoint += 'X'
-			
-				result = group.fork { sleep 0.1 }
-			
-				expect(result).to be == 0
-			
-				checkpoint += 'Y'
-			
-				# Simulate the user pressing Ctrl-C after 0.5 seconds:
-				raise Interrupt
-			end.resume
-		
-			Fiber.new do
-				checkpoint += 'A'
-			
-				# This never returns:
-				result = group.fork { sleep 0.2 }
-			
-				checkpoint += 'B'
-			end.resume
-		
-			expect(group).to receive(:kill).with(:INT).once
-			expect(group).to receive(:kill).with(:TERM).once
-			
-			expect do
-				group.wait
-			end.to raise_error(Interrupt)
-			
-			expect(checkpoint).to be == 'XAY'
-		end
+		Fiber.new do
+			checkpoint += 'X'
 		
-		it "should raise an exception" do
-			group = Process::Group.new
-			checkpoint = ""
+			result = subject.fork { sleep 0.1 }
 		
-			Fiber.new do
-				checkpoint += 'X'
-			
-				result = group.fork { sleep 0.1 }
-				expect(result).to be == 0
-			
-				checkpoint += 'Y'
-			
-				# Raises a RuntimeError
-				fail "Error"
-			end.resume
+			expect(result).to be == 0
 		
-			Fiber.new do
-				checkpoint += 'A'
-			
-				# This never returns:
-				result = group.fork { sleep 0.2 }
-			
-				checkpoint += 'B'
-			end.resume
+			checkpoint += 'Y'
 		
-			expect do
-				expect(group).to receive(:kill).with(:TERM).once
+			# Simulate the user pressing Ctrl-C after a short time:
+			raise Interrupt
+		end.resume
+	
+		Fiber.new do
+			checkpoint += 'A'
 			
-				group.wait
-			end.to raise_error(RuntimeError)
-		
-			expect(checkpoint).to be == 'XAY'
-		end
-		
-		class Timeout < StandardError
-		end
+			# This never returns:
+			result = subject.fork do
+				# We do this to exit immediately.. otherwise Ruby will print a backtrace and that's a bit confusing.
+				trap(:INT) { exit!(0) }
+				sleep(0.2)
+			end
+		
+			checkpoint += 'B'
+		end.resume
 	
-		it "should pass back out exceptions" do
-			group = Process::Group.new
-			checkpoint = ""
-		
-			Fiber.new do
-				# Wait for 2 seconds, let other processes run:
-				group.fork { sleep 2 }
-				checkpoint += 'A'
-				#puts "Finished waiting #1..."
-		
-				# If no other processes are running, we are done:
-				Fiber.yield unless group.running?
-				checkpoint += 'B'
-				#puts "Sending SIGINT..."
+		expect(subject).to receive(:kill).with(:INT).once.and_call_original
+		expect(subject).to receive(:kill).with(:TERM).once.and_call_original
 		
-				# Send SIGINT to currently running processes:
-				group.kill(:INT)
+		expect do
+			subject.wait
+		end.to raise_error(Interrupt)
 		
-				# Wait for 2 seconds, let other processes run:
-				group.fork { sleep 2 }
-				checkpoint += 'C'
-				#puts "Finished waiting #2..."
+		expect(checkpoint).to be == 'XAY'
+	end
+	
+	it "should raise an exception" do
+		checkpoint = ""
+	
+		Fiber.new do
+			checkpoint += 'X'
 		
-				# If no other processes are running, we are done:
-				Fiber.yield unless group.running?
-				checkpoint += 'D'
-				#puts "Sending SIGTERM..."
+			result = subject.fork { sleep 0.1 }
+			expect(result).to be == 0
 		
-				# Send SIGTERM to currently running processes:
-				group.kill(:TERM)
+			checkpoint += 'Y'
 		
-				# Raise an Timeout exception which is pased back out:
-				raise Timeout
-			end.resume
+			# Raises a RuntimeError
+			fail "Error"
+		end.resume
 	
-			# Run some other long task:
-			group.run("sleep 10")
+		Fiber.new do
+			checkpoint += 'A'
 		
-			start_time = Time.now
+			# This never returns:
+			result = subject.fork { sleep 0.2 }
 		
-			# Wait for fiber to complete:
-			expect do
-				group.wait
-				checkpoint += 'E'
-			end.not_to raise_error
-		
-			end_time = Time.now
+			checkpoint += 'B'
+		end.resume
+	
+		expect do
+			expect(subject).to receive(:kill).with(:TERM).once
 		
-			expect(checkpoint).to be == 'ABCE'
-			expect(end_time - start_time).to be_within(0.2).of 4.0
-		end
+			subject.wait
+		end.to raise_error(RuntimeError)
+	
+		expect(checkpoint).to be == 'XAY'
+	end
+
+	it "should pass back out exceptions" do
+		checkpoint = ""
+	
+		Fiber.new do
+			# Wait for 2 seconds, let other processes run:
+			subject.fork { sleep 2 }
+			checkpoint += 'A'
+			#puts "Finished waiting #1..."
+	
+			# If no other processes are running, we are done:
+			Fiber.yield unless subject.running?
+			checkpoint += 'B'
+			#puts "Sending SIGINT..."
+	
+			# Send SIGINT to currently running processes:
+			subject.kill(:INT)
+	
+			# Wait for 2 seconds, let other processes run:
+			subject.fork { sleep 2 }
+			checkpoint += 'C'
+			#puts "Finished waiting #2..."
+	
+			# If no other processes are running, we are done:
+			Fiber.yield unless subject.running?
+			checkpoint += 'D'
+			#puts "Sending SIGTERM..."
+	
+			# Send SIGTERM to currently running processes:
+			subject.kill(:TERM)
+
+			# Raise an Timeout exception which is pased back out:
+			raise StandardError.new("Should never get here!")
+		end.resume
+
+		# Run some other long task:
+		subject.run("sleep 10")
+	
+		start_time = Time.now
+	
+		# Wait for fiber to complete:
+		expect do
+			subject.wait
+			checkpoint += 'E'
+		end.not_to raise_error
+	
+		end_time = Time.now
+	
+		expect(checkpoint).to be == 'ABCE'
+		expect(end_time - start_time).to be_within(0.2).of 4.0
 	end
 end

data/spec/process/group/io_spec.rb

@@ -20,37 +20,33 @@
 
 require 'process/group'
 
-module Process::Group::IOSpec
-	describe Process::Group do
-		it "should read line on separate thread" do
-			group = Process::Group.new
-		
-			input, output = IO.pipe
-		
-			Fiber.new do
-				result = group.fork do
-					3.times do
-						output.puts "Hello World"
-						sleep 0.1
-					end
-				
-					exit(0)
+RSpec.describe Process::Group do
+	it "should read line on separate thread" do
+		input, output = IO.pipe
+	
+		Fiber.new do
+			result = subject.fork do
+				3.times do
+					output.puts "Hello World"
+					sleep 0.1
 				end
-				
-				expect(result).to be == 0
-			end.resume
-			
-			output.close
 			
-			lines = nil
-			io_thread = Thread.new do
-				lines = input.read
+				exit(0)
 			end
 			
-			group.wait
+			output.close
 			
-			io_thread.join
-			expect(lines).to be == ("Hello World\n" * 3)
+			expect(result).to be == 0
+		end.resume
+		
+		lines = nil
+		io_thread = Thread.new do
+			lines = input.read
 		end
+		
+		subject.wait
+		
+		io_thread.join
+		expect(lines).to be == ("Hello World\n" * 3)
 	end
 end

data/spec/process/group/load_spec.rb

@@ -20,27 +20,23 @@
 
 require 'process/group'
 
-module Process::Group::LoadSpec
-	describe Process::Group do
-		it "should only run a limited number of processes" do
-			group = Process::Group.new(limit: 5)
-			
-			expect(group.available?).to be_truthy
-			expect(group.blocking?).to be_falsey
-			
-			5.times do
-				Fiber.new do
-					result = group.fork do
-						exit(0)
-					end
-					
-					expect(result.exitstatus).to be == 0
-				end.resume
-			end
-			
-			expect(group.blocking?).to be_truthy
-			
-			group.wait
+RSpec.describe Process::Group.new(limit: 5) do
+	it "should only run a limited number of processes" do
+		expect(subject.available?).to be_truthy
+		expect(subject.blocking?).to be_falsey
+		
+		5.times do
+			Fiber.new do
+				result = subject.fork do
+					exit(0)
+				end
+				
+				expect(result.exitstatus).to be == 0
+			end.resume
+		end
+		
+		subject.wait do
+			expect(subject.blocking?).to be_truthy
 		end
 	end
 end

data/spec/process/group/process_spec.rb

@@ -18,40 +18,38 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module Process::Group::ProcessSpec
-	describe Process do
-		it "default fork exit status should be 0" do
-			pid = fork do
-			end
-			
-			Process.waitpid(pid)
-			
-			expect($?.exitstatus).to be == 0
+RSpec.describe Process do
+	it "default fork exit status should be 0" do
+		pid = fork do
+		end
+		
+		Process.waitpid(pid)
+		
+		expect($?.exitstatus).to be == 0
+	end
+	
+	it "should fork and return exit status correctly" do
+		pid = fork do
+			exit(1)
 		end
 		
-		it "should fork and return exit status correctly" do
+		Process.waitpid(pid)
+		
+		expect($?.exitstatus).to be == 1
+	end
+	
+	# This is currently broken on Rubinius.
+	it "should be okay to use fork within a fiber" do
+		pid = nil
+		
+		Fiber.new do
 			pid = fork do
-				exit(1)
+				exit(2)
 			end
-			
-			Process.waitpid(pid)
-			
-			expect($?.exitstatus).to be == 1
-		end
+		end.resume
 		
-		# This is currently broken on Rubinius.
-		it "should be okay to use fork within a fiber" do
-			pid = nil
-			
-			Fiber.new do
-				pid = fork do
-					exit(2)
-				end
-			end.resume
-			
-			Process.waitpid(pid)
-			
-			expect($?.exitstatus).to be == 2
-		end
+		Process.waitpid(pid)
+		
+		expect($?.exitstatus).to be == 2
 	end
-end
+end

data/spec/process/group/spawn_spec.rb

@@ -20,90 +20,80 @@
 
 require 'process/group'
 
-module Process::Group::SpawnSpec
-	describe Process::Group do
-		it "should execute fibers concurrently" do
-			group = Process::Group.new
-			
-			start_time = Time.now
-			
-			Fiber.new do
-				result = group.fork { sleep 1.0 }
-				
-				expect(result).to be == 0
-			end.resume
-			
-			Fiber.new do
-				result = group.fork { sleep 2.0 }
-				
-				expect(result).to be == 0
-			end.resume
-			
-			group.wait
-			
-			end_time = Time.now
-			
-			# Check that the execution time was roughly 2 seconds:
-			expect(end_time - start_time).to be_within(0.1).of(2.0)
-		end
-		
-		it "should kill commands" do
-			group = Process::Group.new
+RSpec.describe Process::Group do
+	it "should execute fibers concurrently" do
+		start_time = Time.now
 		
-			start_time = Time.now
-		
-			group.run("sleep 1") do |exit_status|
-				expect(exit_status).to_not be 0
-			end
-		
-			group.run("sleep 2") do |exit_status|
-				expect(exit_status).to_not be 0
-			end
+		Fiber.new do
+			result = subject.fork { sleep 1.0 }
+			
+			expect(result).to be == 0
+		end.resume
 		
-			group.kill(:KILL)
+		Fiber.new do
+			result = subject.fork { sleep 2.0 }
+			
+			expect(result).to be == 0
+		end.resume
 		
-			group.wait
+		subject.wait
 		
-			end_time = Time.now
+		end_time = Time.now
 		
-			# Check that processes killed almost immediately:
-			expect(end_time - start_time).to be < 0.2
+		# Check that the execution time was roughly 2 seconds:
+		expect(end_time - start_time).to be_within(0.1).of(2.0)
+	end
+	
+	it "should kill commands" do
+		start_time = Time.now
+	
+		subject.run("sleep 1") do |exit_status|
+			expect(exit_status).to_not be 0
 		end
-		
-		it "should pass environment to child process" do
-			group = Process::Group.new
-		
-			env = {'FOO' => 'BAR'}
-		
-			# Make a pipe to receive output from child process:
-			input, output = IO.pipe
-		
-			group.run(env, "echo $FOO", out: output) do |exit_status|
-				output.close
-			end
-		
-			group.wait
-		
-			expect(input.read).to be == "BAR\n"
+	
+		subject.run("sleep 2") do |exit_status|
+			expect(exit_status).to_not be 0
 		end
-		
-		it "should yield exit status" do
-			group = Process::Group.new
-		
-			start_time = Time.now
-		
-			group.run("sleep 1")
-		
-			group.run("sleep 1") do |exit_status|
-				expect(exit_status).to be == 0
-			end
-		
-			group.wait
-		
-			end_time = Time.now
-		
-			# Check that the execution time was roughly 1 second:
-			expect(end_time - start_time).to be_within(0.1).of(1.0)
+	
+		subject.wait do
+			subject.kill(:KILL)
+		end
+	
+		end_time = Time.now
+	
+		# Check that processes killed almost immediately:
+		expect(end_time - start_time).to be < 0.2
+	end
+	
+	it "should pass environment to child process" do
+		env = {'FOO' => 'BAR'}
+	
+		# Make a pipe to receive output from child process:
+		input, output = IO.pipe
+	
+		subject.run(env, "echo $FOO", out: output) do |exit_status|
+			output.close
+		end
+	
+		subject.wait
+	
+		expect(input.read).to be == "BAR\n"
+	end
+	
+	it "should yield exit status" do
+		start_time = Time.now
+	
+		subject.run("sleep 1")
+	
+		subject.run("sleep 1") do |exit_status|
+			expect(exit_status).to be == 0
 		end
+	
+		subject.wait
+	
+		end_time = Time.now
+	
+		# Check that the execution time was roughly 1 second:
+		expect(end_time - start_time).to be_within(0.1).of(1.0)
 	end
 end

data/spec/process/group/wait_spec.rb

@@ -0,0 +1,85 @@
+# Copyright, 2012, 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 'process/group'
+
+RSpec.describe Process::Group do
+	it "should invoke child task normally" do
+		start_time = Time.now
+		
+		child_exit_status = nil
+		
+		subject.wait do
+			subject.run("exit 0") do |exit_status|
+				child_exit_status = exit_status
+			end
+		end
+		
+		expect(child_exit_status).to be == 0
+	end
+	
+	it "should kill child task if process is interrupted" do
+		start_time = Time.now
+		
+		child_exit_status = nil
+		
+		expect do
+			subject.wait do
+				subject.run("sleep 10") do |exit_status|
+					child_exit_status = exit_status
+				end
+				
+				# Simulate the parent (controlling) process receiving an interrupt.
+				raise Interrupt
+			end
+		end.to raise_error(Interrupt)
+		
+		expect(child_exit_status).to_not be == 0
+	end
+	
+	it "should propagate Interrupt" do
+		expect(Process::Group).to receive(:new).once.and_call_original
+		
+		expect do
+			Process::Group.wait do |group|
+				raise Interrupt
+			end
+		end.to raise_error(Interrupt)
+	end
+	
+	it "should clear queue after wait" do
+		subject.limit = 1
+		
+		subject.run("sleep 10")
+		subject.run("sleep 10")
+		
+		expect(subject.running?).to be_falsey
+		expect(subject.queued?).to be_truthy
+		
+		expect do
+			subject.wait do
+				raise Interrupt
+			end
+		end.to raise_error(Interrupt)
+		
+		expect(subject.running?).to be_falsey
+		expect(subject.queued?).to be_falsey
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: process-group
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-09 00:00:00.000000000 Z
+date: 2016-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,7 @@ files:
 - spec/process/group/load_spec.rb
 - spec/process/group/process_spec.rb
 - spec/process/group/spawn_spec.rb
+- spec/process/group/wait_spec.rb
 homepage: https://github.com/ioquatix/process-group
 licenses:
 - MIT
@@ -98,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Run processes concurrently in separate fibers with predictable behaviour.
@@ -109,3 +110,4 @@ test_files:
 - spec/process/group/load_spec.rb
 - spec/process/group/process_spec.rb
 - spec/process/group/spawn_spec.rb
+- spec/process/group/wait_spec.rb