build-graph 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2660012c78eab9ed19ce99d5ba59be689e5a25f86c3dc376d8ea11ac86290275
-  data.tar.gz: bbae16e2bfaa322b26e521a319ce2431d636e263ee42685706c893e02011eebf
+  metadata.gz: b6ca9917fd8c609a63c0608a797010e9df257a64709c0129c91a49847759cc35
+  data.tar.gz: e1f7c0aa6231782ad4767a982c657323f128455200dd324a1ce4149fdf912563
 SHA512:
-  metadata.gz: da7be812b70a047264c5950de7ee69d4b82d5ec06ec2fd5ef636b68ecad77dcb8271ab82dfe4f749571db5c11dfe00295ebf235a15605a4483db103d8bae1f3d
-  data.tar.gz: 1e0fe54dde3ac23a375884e8bc1a8abb0635d7bcf0a8e21864e6dde9d2a144549612f119cfd6e089f2a6c8a2e51fe7bd76f6c1db753b00a8fffb3602c5d0c259
+  metadata.gz: 75a5812081eda17786f4a8c3abbda92b187f4b57ccbd130c6a76a8ea034836f22e5bb42d15f8e6634d4e1a5449953eaa144cc69add30889658b97bd7c0b45958
+  data.tar.gz: ccdee7f9215f75f6489455bad14ab71644030a622047fedafcaf55c76c712cb587ef5c44aee322f51b1c49703aef22be93083f1caf66d874cb2f794c6ede5e04

data/lib/build/graph/node.rb

@@ -89,7 +89,7 @@ module Build
 			end
 			
 			def inspect
-				"#<#{self.class} #{@inputs.inspect} => #{@outputs.inspect} by #{@process.inspect}>"
+				"#<#{self.class} #{@inputs.inspect} => #{@outputs.inspect} by #{@process}>"
 			end
 			
 			def self.top(inputs = Files::Paths::NONE, outputs = :inherit, **options, &block)

data/lib/build/graph/task.rb

@@ -42,12 +42,14 @@ module Build
 				@walker.tasks[node] = self
 				
 				@node = node
+				@fiber = nil
 				
 				@error = nil
 				
 				@children = []
 				
 				@state = nil
+				@annotation = nil
 				
 				@inputs_failed = false
 			end
@@ -58,6 +60,8 @@ module Build
 			attr :children
 			attr :state
 			
+			attr :annotation
+			
 			# The error, if the execution of the node fails.
 			attr :error
 			
@@ -75,6 +79,10 @@ module Build
 				# Inforn the walker a new task is being generated for this node:
 				@walker.enter(self)
 				
+				if @fiber
+					raise RuntimeError, "Task is already running!"
+				end
+				
 				@fiber = Fiber.new do
 					# If all inputs were good, we can update the node.
 					if wait_for_inputs?
@@ -96,6 +104,8 @@ module Build
 					@state ||= :complete
 					
 					@walker.exit(self)
+					
+					@fiber = nil
 				end
 				
 				# Schedule the work, hopefully synchronously:
@@ -124,7 +134,11 @@ module Build
 			# Returns true if the outputs of the task are out of date w.r.t. the inputs.
 			# Currently, does not take into account if the input is a glob and files have been added.
 			def dirty?
-				@outputs.dirty?(@inputs)
+				if @outputs
+					@outputs.dirty?(@inputs)
+				else
+					true
+				end
 			end
 			
 			def changed!
@@ -157,12 +171,15 @@ module Build
 				if @node.inherit_outputs?
 					@outputs = Files::State.new(self.children_outputs)
 				else
+					@annotation = "update outputs"
 					# After the task has finished, we update the output states:
 					@outputs.update!
 				end
 			end
 			
 			def fail!(error)
+				@annotation = "failed"
+				
 				if logger = @walker.logger
 					logger.error("Task #{self} failed: #{error}")
 					logger.debug(error) if error.kind_of?(Exception)
@@ -174,12 +191,15 @@ module Build
 			
 			# Returns false if any input failed.
 			def wait_for_inputs?
+				@annotation = "wait for inputs"
 				# Wait on any inputs, returns whether any inputs failed:
 				@walker.wait_on_paths(self, @inputs)
 			end
 			
 			# Returns false if any child failed.
 			def wait_for_children?
+				@annotation = "wait for children"
+				
 				@walker.wait_for_children(self, @children)
 			end
 		end

data/lib/build/graph/version.rb

@@ -20,6 +20,6 @@
 
 module Build
 	module Graph
-		VERSION = "1.2.0"
+		VERSION = "1.2.1"
 	end
 end

data/lib/build/graph/walker.rb

@@ -86,7 +86,7 @@ module Build
 			def call(node, parent_task = nil)
 				# We try to fetch the task if it has already been invoked, otherwise we create a new task.
 				@tasks.fetch(node) do
-					@logger.debug{"Update: #{node} #{parent_task.inspect}"}
+					@logger.debug{"Update: #{node} #{parent_task.class}"}
 					
 					# This method should add the node
 					@update.call(self, node, parent_task)
@@ -108,23 +108,25 @@ module Build
 				edge = Edge.new
 				
 				paths = paths.collect(&:to_s)
-				@logger.debug{"Task #{task} is waiting on paths #{paths}"}
 				
 				paths.each do |path|
 					# Is there a task generating this output?
 					if outputs = @outputs[path]
+						@logger.debug{"Task #{task} is waiting on path #{path}"}
+						
 						# When the output is ready, trigger this edge:
 						outputs << edge
 						edge.increment!
+					elsif !File.exist?(path)
+						raise RuntimeError, "File #{path} is not being generated by any active task!"
+						# What should we do about paths which haven't been registered as outputs?
+						# Either they exist - or they don't.
+						# If they exist, it means they are probably static inputs of the build graph.
+						# If they don't, it might be an error, or it might be deliberate.
 					end
-					
-					# What should we do about paths which haven't been registered as outputs?
-					# Either they exist - or they don't.
-					# If they exist, it means they are probably static inputs of the build graph.
-					# If they don't, it might be an error, or it might be deliberate.
 				end
 				
-				failed = paths.any?{|path| @failed_outputs.include? path}
+				failed = paths.any?{|path| @failed_outputs.include?(path)}
 				
 				return edge.wait && !failed
 			end
@@ -167,7 +169,8 @@ module Build
 					@logger.debug{"Task will generate outputs: #{outputs.to_a.collect(&:to_s).inspect}"}
 					
 					outputs.each do |path|
-						@outputs[path.to_s] = []
+						# Tasks which have children tasks may list the same output twice. This is not a bug.
+						@outputs[path.to_s] ||= []
 					end
 				end
 			end
@@ -197,6 +200,7 @@ module Build
 					end
 					
 					if edges = @outputs.delete(path)
+						# @logger.debug "\tUpdating #{edges.count} edges..."
 						edges.each{|edge| edge.traverse(task)}
 					end
 				end

data/spec/build/graph/graph_spec.rb

@@ -21,158 +21,154 @@
 
 require_relative 'process_graph'
 
-module Build::Graph::GraphSpec
-	include ProcessGraph
+RSpec.describe Build::Graph do
+	let(:group) {Process::Group.new}
 	
-	RSpec.describe Build::Graph do
-		let(:group) {Process::Group.new}
+	let(:logger) {Logger.new($stderr).tap{|logger| logger.level = Logger::DEBUG}}
+	
+	it "shouldn't update mtime" do
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		listing_output = Build::Files::Paths.directory(__dir__, ["listing.txt"])
 		
-		let(:logger) {Logger.new($stderr).tap{|logger| logger.level = Logger::DEBUG}}
+		FileUtils.rm_f listing_output.to_a
 		
-		it "shouldn't update mtime" do
-			test_glob = Glob.new(__dir__, "*.rb")
-			listing_output = Paths.directory(__dir__, ["listing.txt"])
-			
-			FileUtils.rm_f listing_output.to_a
-			
-			walker = Walker.for(ProcessTask, group)
-			
-			top = ProcessNode.top do
-				process test_glob, listing_output do
-					run("ls", "-la", *inputs, :out => outputs.first.for_writing)
-				end
-			end
-			
-			group.wait do
-				walker.update(top)
-			end
-			
-			first_modified_time = listing_output.first.modified_time
-			
-			group.wait do
-				walker.update(top)
-			end
-			
-			# The output file shouldn't have been changed because already exists and the input files haven't changed either:
-			second_modified_time = listing_output.first.modified_time
-			
-			# The granularity of mtime on some systems is a bit weird:
-			expect(second_modified_time.to_f).to be_within(0.001).of(first_modified_time.to_f)
-			
-			FileUtils.rm_f listing_output.to_a
-			walker.monitor.update(listing_output.roots)
-			
-			# The granularity of modification times isn't that great, so we use >= below.
-			# sleep 1
-			
-			group.wait do
-				walker.update(top)
+		walker = Build::Graph::Walker.for(ProcessTask, group)
+		
+		top = ProcessNode.top do
+			process test_glob, listing_output do
+				run("ls", "-la", *inputs, :out => outputs.first.for_writing)
 			end
-			
-			expect(listing_output.first.modified_time).to be >= first_modified_time
-			
-			FileUtils.rm_f listing_output.to_a
 		end
 		
-		it "should compile program and respond to changes in source code" do
-			program_root = Path.join(__dir__, "program")
-			code_glob = Glob.new(program_root, "*.cpp")
-			program_path = Path.join(program_root, "dictionary-sort")
-			
-			walker = Walker.for(ProcessTask, group)
-			
-			#FileUtils.touch(code_glob.first)
-			
-			top = ProcessNode.top do
-				process code_glob, program_path do
-					object_files = inputs.with(extension: ".o") do |input_path, output_path|
-						depfile_path = input_path + ".d"
-						
-						dependencies = Paths.new(input_path)
-						
-						if File.exist? depfile_path
-							depfile = Build::Makefile.load_file(depfile_path)
-							
-							dependencies = depfile[output_path] || dependencies
-						end
+		group.wait do
+			walker.update(top)
+		end
+		
+		first_modified_time = listing_output.first.modified_time
+		
+		group.wait do
+			walker.update(top)
+		end
+		
+		# The output file shouldn't have been changed because already exists and the input files haven't changed either:
+		second_modified_time = listing_output.first.modified_time
+		
+		# The granularity of mtime on some systems is a bit weird:
+		expect(second_modified_time.to_f).to be_within(0.001).of(first_modified_time.to_f)
+		
+		FileUtils.rm_f listing_output.to_a
+		walker.monitor.update(listing_output.roots)
+		
+		# The granularity of modification times isn't that great, so we use >= below.
+		# sleep 1
+		
+		group.wait do
+			walker.update(top)
+		end
+		
+		expect(listing_output.first.modified_time).to be >= first_modified_time
+		
+		FileUtils.rm_f listing_output.to_a
+	end
+	
+	it "should compile program and respond to changes in source code" do
+		program_root = Build::Files::Path.join(__dir__, "program")
+		code_glob = Build::Files::Glob.new(program_root, "*.cpp")
+		program_path = Build::Files::Path.join(program_root, "dictionary-sort")
+		
+		walker = Build::Graph::Walker.for(ProcessTask, group)
+		
+		#FileUtils.touch(code_glob.first)
+		
+		top = ProcessNode.top do
+			process code_glob, program_path do
+				object_files = inputs.with(extension: ".o") do |input_path, output_path|
+					depfile_path = input_path + ".d"
+					
+					dependencies = Build::Files::Paths.new(input_path)
+					
+					if File.exist? depfile_path
+						depfile = Build::Makefile.load_file(depfile_path)
 						
-						process dependencies, output_path do
-							run("clang++", "-MMD", "-O3",
-								"-o", output_path.shortest_path(input_path.root),
-								"-c", input_path.relative_path, "-std=c++11",
-								chdir: input_path.root
-							)
-						end
+						dependencies = depfile[output_path] || dependencies
 					end
 					
-					process object_files, program_path do
-						run("clang++", "-O3", "-o", program_path, *object_files.to_a, "-lm", "-pthread")
+					process dependencies, output_path do
+						run("clang++", "-MMD", "-O3",
+							"-o", output_path.shortest_path(input_path.root),
+							"-c", input_path.relative_path, "-std=c++11",
+							chdir: input_path.root
+						)
 					end
 				end
 				
-				process program_path do
-					run("./" + program_path.relative_path, chdir: program_path.root)
+				process object_files, program_path do
+					run("clang++", "-O3", "-o", program_path, *object_files.to_a, "-lm", "-pthread")
 				end
 			end
 			
-			group.wait do
-				walker.update(top)
+			process program_path do
+				run("./" + program_path.relative_path, chdir: program_path.root)
 			end
-			
-			expect(program_path).to be_exist
-			expect(code_glob.first.modified_time).to be <= program_path.modified_time
 		end
 		
-		it "should copy files incrementally" do
-			program_root = Path.join(__dir__, "program")
-			files = Glob.new(program_root, "*.cpp")
-			destination = Path.new(__dir__) + "tmp"
-			
-			walker = Walker.for(ProcessTask, group)
+		group.wait do
+			walker.update(top)
+		end
+		
+		expect(program_path).to be_exist
+		expect(code_glob.first.modified_time).to be <= program_path.modified_time
+	end
+	
+	it "should copy files incrementally" do
+		program_root = Build::Files::Path.join(__dir__, "program")
+		files = Build::Files::Glob.new(program_root, "*.cpp")
+		destination = Build::Files::Path.new(__dir__) + "tmp"
+		
+		walker = Build::Graph::Walker.for(ProcessTask, group)
+		
+		top = ProcessNode.top files do
+			mkpath destination
 			
-			top = ProcessNode.top files do
-				mkpath destination
+			inputs.each do |source_path|
+				destination_path = source_path.rebase(destination)
 				
-				inputs.each do |source_path|
-					destination_path = source_path.rebase(destination)
-					
-					process source_path, destination_path do
-						$stderr.puts "Copying #{inputs.first} -> #{outputs.first}"
-						install inputs.first, outputs.first
-					end
+				process source_path, destination_path do
+					$stderr.puts "Copying #{inputs.first} -> #{outputs.first}"
+					install inputs.first, outputs.first
 				end
 			end
+		end
+		
+		mutex = Mutex.new
+		files_deleted = false
+		
+		thread = Thread.new do
+			sleep 1
 			
-			mutex = Mutex.new
-			files_deleted = false
-			
-			thread = Thread.new do
-				sleep 1
+			mutex.synchronize do
+				destination.glob("*.cpp").delete
 				
-				mutex.synchronize do
-					destination.glob("*.cpp").delete
-					
-					files_deleted = true
-				end
+				files_deleted = true
 			end
-			
-			walker.run do
-				mutex.synchronize do
-					group.wait do
-						walker.update(top)
-					end
+		end
+		
+		walker.run do
+			mutex.synchronize do
+				group.wait do
+					walker.update(top)
 				end
-				
-				break if files_deleted
 			end
 			
-			thread.join
-			
-			expect(destination).to be_exist
-			# This line failed, may still be a race condition:
-			expect(destination.glob("*.cpp").count).to be == 2
-			
-			destination.delete
+			break if files_deleted
 		end
+		
+		thread.join
+		
+		expect(destination).to be_exist
+		# This line failed, may still be a race condition:
+		expect(destination.glob("*.cpp").count).to be == 2
+		
+		destination.delete
 	end
 end

data/spec/build/graph/inherit_spec.rb

@@ -23,34 +23,29 @@ require 'build/graph/walker'
 require 'build/graph/task'
 require 'build/files'
 
-module Build::Graph::InheritSpec
-	include Build::Graph
-	include Build::Files
-	
-	RSpec.describe Build::Graph::Walker do
-		it "should inherit children outputs", :focus do
-			test_glob = Glob.new(__dir__, "*.rb")
-			listing_output = Paths.directory(__dir__, ["listing.txt"])
+RSpec.describe Build::Graph::Walker do
+	it "should inherit children outputs", :focus do
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		listing_output = Build::Files::Paths.directory(__dir__, ["listing.txt"])
+		
+		node_a = Build::Graph::Node.new(Build::Files::Paths::NONE, :inherit, "a")
+		node_b = Build::Graph::Node.new(test_glob, listing_output, "b")
+		
+		walker = Build::Graph::Walker.new do |walker, node|
+			task = Build::Graph::Task.new(walker, node)
 			
-			node_a = Node.new(Paths::NONE, :inherit, "a")
-			node_b = Node.new(test_glob, listing_output, "b")
-			
-			walker = Walker.new do |walker, node|
-				task = Task.new(walker, node)
-				
-				task.visit do
-					if node.process == 'a'
-						task.invoke(node_b)
-					end
+			task.visit do
+				if node.process == 'a'
+					task.invoke(node_b)
 				end
 			end
-			
-			walker.update([node_a])
-			
-			task_a = walker.tasks[node_a]
-			task_b = walker.tasks[node_b]
-			
-			expect(task_a.outputs.to_a).to be == task_b.outputs.to_a
 		end
+		
+		walker.update([node_a])
+		
+		task_a = walker.tasks[node_a]
+		task_b = walker.tasks[node_b]
+		
+		expect(task_a.outputs.to_a).to be == task_b.outputs.to_a
 	end
 end

data/spec/build/graph/process_graph.rb

@@ -3,79 +3,74 @@ require 'process/group'
 require 'build/files'
 require 'build/graph'
 
-module ProcessGraph
-	include Build::Graph
-	include Build::Files
-
-	class ProcessNode < Node
-		def initialize(inputs, outputs, block, title: nil)
-			super(inputs, outputs, block.source_location)
-			
-			if title
-				@title = title
-			else
-				@title = self.process
-			end
-			
-			@block = block
-		end
+class ProcessNode < Build::Graph::Node
+	def initialize(inputs, outputs, block, title: nil)
+		super(inputs, outputs, block.source_location)
 		
-		def evaluate(context)
-			context.instance_eval(&@block)
+		if title
+			@title = title
+		else
+			@title = self.process
 		end
 		
-		attr :title
+		@block = block
+	end
+	
+	def evaluate(context)
+		context.instance_eval(&@block)
 	end
+	
+	attr :title
+end
 
-	class ProcessTask < Task
-		def initialize(walker, node, group)
-			super(walker, node)
-			
-			@group = group
-		end
-		
-		def process(inputs, outputs = :inherit, **options, &block)
-			inputs = Build::Files::List.coerce(inputs)
-			outputs = Build::Files::List.coerce(outputs) unless outputs.kind_of? Symbol
-			
-			node = ProcessNode.new(inputs, outputs, block, **options)
-			
-			self.invoke(node)
-		end
+class ProcessTask < Build::Graph::Task
+	def initialize(walker, node, group)
+		super(walker, node)
 		
-		def wet?
-			@node.dirty?
-		end
+		@group = group
+	end
+	
+	def process(inputs, outputs = :inherit, **options, &block)
+		inputs = Build::Files::List.coerce(inputs)
+		outputs = Build::Files::List.coerce(outputs) unless outputs.kind_of? Symbol
 		
-		def run(*arguments)
-			if wet?
-				puts "\t[run] #{arguments.join(' ')}"
-				status = @group.spawn(*arguments)
-				
-				if status != 0
-					raise CommandError.new(status)
-				end
-			end
-		end
+		node = ProcessNode.new(inputs, outputs, block, **options)
 		
-		def mkpath(*args)
-			return unless wet?
+		self.invoke(node)
+	end
+	
+	def wet?
+		@node.dirty?
+	end
+	
+	def run(*arguments)
+		if wet?
+			puts "\t[run] #{arguments.join(' ')}"
+			status = @group.spawn(*arguments)
 			
-			FileUtils.mkpath(*args)
+			if status != 0
+				raise CommandError.new(status)
+			end
 		end
+	end
+	
+	def mkpath(*args)
+		return unless wet?
 		
-		def install(*args)
-			return unless wet?
-			
-			FileUtils.install(*args)
-		end
+		FileUtils.mkpath(*args)
+	end
+	
+	def install(*args)
+		return unless wet?
 		
-		# This function is called to finish the invocation of the task within the graph.
-		# There are two possible ways this function can generally proceed.
-		# 1/ The node this task is running for is clean, and thus no actual processing needs to take place, but children should probably be executed.
-		# 2/ The node this task is running for is dirty, and the execution of commands should work as expected.
-		def update
-			@node.evaluate(self)
-		end
+		FileUtils.install(*args)
+	end
+	
+	# This function is called to finish the invocation of the task within the graph.
+	# There are two possible ways this function can generally proceed.
+	# 1/ The node this task is running for is clean, and thus no actual processing needs to take place, but children should probably be executed.
+	# 2/ The node this task is running for is dirty, and the execution of commands should work as expected.
+	def update
+		@node.evaluate(self)
 	end
 end

data/spec/build/graph/task_spec.rb

@@ -24,43 +24,38 @@ require 'build/graph/walker'
 require 'build/graph/task'
 require 'build/files/glob'
 
-module Build::Graph::TaskSpec
-	include Build::Graph
-	include Build::Files
-	
-	RSpec.describe Build::Graph::Task do
-		it "should wait for children" do
-			node_a = Node.new(Paths::NONE, Paths::NONE, "a")
-			node_b = Node.new(Paths::NONE, Paths::NONE, "b")
+RSpec.describe Build::Graph::Task do
+	it "should wait for children" do
+		node_a = Build::Graph::Node.new(Build::Files::Paths::NONE, Build::Files::Paths::NONE, "a")
+		node_b = Build::Graph::Node.new(Build::Files::Paths::NONE, Build::Files::Paths::NONE, "b")
+		
+		nodes = Set.new([node_a])
+		
+		sequence = []
+		
+		# A walker runs repeatedly, updating tasks which have been marked as dirty.
+		walker = Build::Graph::Walker.new do |walker, node|
+			task = Build::Graph::Task.new(walker, node)
 			
-			nodes = Set.new([node_a])
-			
-			sequence = []
-			
-			# A walker runs repeatedly, updating tasks which have been marked as dirty.
-			walker = Walker.new do |walker, node|
-				task = Task.new(walker, node)
+			task.visit do
+				sequence << node.process.upcase
 				
-				task.visit do
-					sequence << node.process.upcase
-					
-					if node.process == 'a'
-						# This will invoke node_b concurrently, but as it is a child, task.visit won't finish until node_b is done.
-						task.invoke(node_b)
-					end
+				if node.process == 'a'
+					# This will invoke node_b concurrently, but as it is a child, task.visit won't finish until node_b is done.
+					task.invoke(node_b)
 				end
-				
-				sequence << node.process
 			end
 			
-			walker.update(nodes)
-			
-			expect(walker.tasks.count).to be == 2
-			expect(walker.failed_tasks.count).to be == 0
-			
-			task_b = walker.tasks[node_b]
-			expect(walker.tasks[node_a].children).to be == [task_b]
-			expect(sequence).to be == ['A', 'B', 'b', 'a']
+			sequence << node.process
 		end
+		
+		walker.update(nodes)
+		
+		expect(walker.tasks.count).to be == 2
+		expect(walker.failed_tasks.count).to be == 0
+		
+		task_b = walker.tasks[node_b]
+		expect(walker.tasks[node_a].children).to be == [task_b]
+		expect(sequence).to be == ['A', 'B', 'b', 'a']
 	end
 end

data/spec/build/graph/walker_spec.rb

@@ -24,68 +24,102 @@ require 'build/graph/walker'
 require 'build/graph/task'
 require 'build/files/glob'
 
-module Build::Graph::WalkerSpec
-	include Build::Graph
-	include Build::Files
+RSpec.describe Build::Graph::Walker do
+	let(:logger) {Logger.new($stderr).tap{|logger| logger.level = Logger::DEBUG}}
 	
-	RSpec.describe Build::Graph::Walker do
-		let(:logger) {Logger.new($stderr).tap{|logger| logger.level = Logger::DEBUG}}
+	it "can generate the same output from multiple tasks" do
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		listing_output = Build::Files::Paths.directory(__dir__, ["listing.txt"])
 		
-		it "should be unique" do
-			test_glob = Glob.new(__dir__, "*.rb")
-			listing_output = Paths.directory(__dir__, ["listing.txt"])
-			
-			node_a = Node.new(test_glob, listing_output, "a")
-			node_b = Node.new(listing_output, Paths::NONE, "b")
-			
-			sequence = []
+		node_a = Build::Graph::Node.new(test_glob, listing_output, "a")
+		node_b = Build::Graph::Node.new(Build::Files::Paths::NONE, listing_output, "b")
+		
+		sequence = []
+		
+		# A walker runs repeatedly, updating tasks which have been marked as dirty.
+		walker = Build::Graph::Walker.new(logger: logger) do |walker, node|
+			task = Build::Graph::Task.new(walker, node)
 			
-			# A walker runs repeatedly, updating tasks which have been marked as dirty.
-			walker = Walker.new do |walker, node|
-				task = Task.new(walker, node)
+			task.visit do
+				if node.process == "a"
+					task.invoke(node_b)
+				end
 				
-				task.visit do
-					sequence << node.process
+				node.outputs.each do |output|
+					output.touch
 				end
+				sequence << node.process
 			end
-			
-			walker.update([node_a, node_b])
-			
-			expect(walker.tasks.count).to be == 2
-			expect(walker.failed_tasks.count).to be == 0
-			expect(sequence).to be == ['a', 'b']
 		end
 		
-		it "should cascade failure" do
-			test_glob = Glob.new(__dir__, "*.rb")
-			listing_output = Paths.directory(__dir__, ["listing.txt"])
-			summary_output = Paths.directory(__dir__, ["summary.txt"])
-			
-			node_a = Node.new(test_glob, listing_output, "a")
-			node_b = Node.new(listing_output, summary_output, "b")
+		edge = double()
+		walker.outputs[listing_output.first.to_s] ||= [edge]
+		expect(edge).to receive(:traverse)
+		
+		walker.update([node_a, node_a])
+		
+		expect(walker.tasks.count).to be == 2
+		expect(walker.failed_tasks.count).to be == 0
+		expect(sequence).to be == ['b', 'a']
+	end
+	
+	it "should be unique" do
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		listing_output = Build::Files::Paths.directory(__dir__, ["listing.txt"])
+		
+		node_a = Build::Graph::Node.new(test_glob, listing_output, "a")
+		node_b = Build::Graph::Node.new(listing_output, Build::Files::Paths::NONE, "b")
+		
+		sequence = []
+		
+		# A walker runs repeatedly, updating tasks which have been marked as dirty.
+		walker = Build::Graph::Walker.new(logger: logger) do |walker, node|
+			task = Build::Graph::Task.new(walker, node)
 			
-			# A walker runs repeatedly, updating tasks which have been marked as dirty.
-			walker = Walker.new do |walker, node|
-				task = Task.new(walker, node)
-				
-				task.visit do
-					if node.process == 'a'
-						raise TransientError.new('Test Failure')
-					end
+			task.visit do
+				node.outputs.each do |output|
+					output.touch
 				end
+				sequence << node.process
 			end
+		end
+		
+		walker.update([node_a, node_b])
+		
+		expect(walker.tasks.count).to be == 2
+		expect(walker.failed_tasks.count).to be == 0
+		expect(sequence).to be == ['a', 'b']
+	end
+	
+	it "should cascade failure" do
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		listing_output = Build::Files::Paths.directory(__dir__, ["listing.txt"])
+		summary_output = Build::Files::Paths.directory(__dir__, ["summary.txt"])
+		
+		node_a = Build::Graph::Node.new(test_glob, listing_output, "a")
+		node_b = Build::Graph::Node.new(listing_output, summary_output, "b")
+		
+		# A walker runs repeatedly, updating tasks which have been marked as dirty.
+		walker = Build::Graph::Walker.new do |walker, node|
+			task = Build::Graph::Task.new(walker, node)
 			
-			walker.update([node_a, node_b])
-			
-			expect(walker.tasks.count).to be == 2
-			expect(walker.failed_tasks.count).to be == 2
-			expect(listing_output).to be_intersect walker.failed_outputs
-			expect(summary_output).to be_intersect walker.failed_outputs
-			
-			walker.clear_failed
-			
-			expect(walker.tasks.count).to be == 0
-			expect(walker.failed_tasks.count).to be == 0
+			task.visit do
+				if node.process == 'a'
+					raise Build::Graph::TransientError.new('Test Failure')
+				end
+			end
 		end
+		
+		walker.update([node_a, node_b])
+		
+		expect(walker.tasks.count).to be == 2
+		expect(walker.failed_tasks.count).to be == 2
+		expect(listing_output).to be_intersect walker.failed_outputs
+		expect(summary_output).to be_intersect walker.failed_outputs
+		
+		walker.clear_failed
+		
+		expect(walker.tasks.count).to be == 0
+		expect(walker.failed_tasks.count).to be == 0
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: build-graph
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Samuel Williams