build-graph 0.3.6 → 0.3.7

data/lib/build/graph/version.rb

@@ -20,6 +20,6 @@
 
 module Build
 	module Graph
-		VERSION = "0.3.6"
+		VERSION = "0.3.7"
 	end
 end

data/lib/build/graph/walker.rb

@@ -20,195 +20,169 @@
 
 require 'set'
 
+require_relative 'task'
+require_relative 'node'
+require_relative 'edge'
 require_relative 'error'
 
 module Build
 	module Graph
 		# A walker walks over a graph and applies a task to each node.
 		class Walker
-			def initialize(controller, &task)
-				@controller = controller
-				@task = task
+			def initialize(&block)
+				# Node -> Task mapping.
+				@tasks = {}
 				
-				# The number of nodes we have touched:
-				@count = 0
+				@update = block
 				
 				@outputs = {}
-				@dirty = Set.new
-			
-				# Generate a list of dirty outputs, possibly a subset, if the build graph might generate additional nodes:
-				@controller.nodes.each do |key, node|
-					# For a given child, a list of any parents waiting on it.
-					if node.dirty?
-						@dirty << node
-						
-						@outputs[node] = []
-						
-						node.outputs.each do |output|
-							@outputs[output] = []
-						end
-					end
-				end
-			
+				
 				@parents = {}
-			
+				
 				# Failed output paths:
-				@failed = Set.new
+				@failed_tasks = []
+				@failed_outputs = Set.new
 				
-				# The number of failed nodes:
-				@failures = 0
+				@monitor = Files::Monitor.new
 			end
 			
-			attr :controller
-			attr :task
+			attr :tasks # {Node => Task}
 			
 			attr :outputs
 			
-			attr_accessor :count
+			attr :failed_tasks
+			attr :failed_outputs
+			
+			attr :count
 			attr :dirty
 			
 			attr :parents
 			
-			# A list of outputs which have failed to generate:
-			attr :failed
+			attr :monitor
 			
-			def failed?
-				@failures > 0
+			def update(nodes)
+				Array(nodes).each do |node|
+					@update.call(self, node)
+				end
 			end
 			
-			def task(*arguments)
-				@task.call(self, *arguments)
+			def call(node)
+				# We try to fetch the task if it has already been invoked, otherwise we create a new task.
+				@tasks.fetch(node) do
+					@update.call(self, node)
+					
+					# This should now be defined:
+					@tasks[node]
+				end
+			end
+			
+			def failed?
+				@failed_tasks.size > 0
 			end
 			
 			def wait_on_paths(paths)
+				# If there are no paths, we are done:
+				return true if paths.count == 0
+				
+				# We create a new directed hyper-graph edge which waits for all paths to be ready (or failed):
 				edge = Edge.new
-				failed = false
-			
+				
+				paths = paths.collect(&:to_s)
+				
 				paths.each do |path|
-					if @outputs.include? path
-						@outputs[path] << edge
-					
+					# Is there a task generating this output?
+					if outputs = @outputs[path]
+						# When the output is ready, trigger this edge:
+						outputs << edge
 						edge.increment!
 					end
-				
-					if !failed and @failed.include?(path)
-						failed = true
-					end
 				end
-			
-				edge.wait || failed
+				
+				failed = paths.any?{|path| @failed_outputs.include? path}
+				
+				return edge.wait && !failed
 			end
-		
-			def wait_for_nodes(children)
-				edge = Edge.new
 			
+			# A parent task only completes once all it's children are complete.
+			def wait_for_children(parent, children)
+				# Consider only incomplete/failed children:
+				children = children.select{|child| !child.complete?}
+				
+				# If there are no children like this, then done:
+				return true if children.size == 0
+				
+				# Otherwise, construct an edge to track state changes:
+				edge = Edge.new
+				
 				children.each do |child|
-					if @dirty.include?(child)
+					if child.failed?
+						edge.skip!(child)
+					else
+						# We are waiting for this child to finish:
 						edge.increment!
-					
-						@parents[child] ||= []
-						@parents[child] << edge
+						
+						@parents[child.node] ||= []
+						@parents[child.node] << edge
 					end
 				end
+				
+				return edge.wait
+			end
 			
-				edge.wait
+			def enter(task)
+				# puts "--> #{task.node.process}"
+				@tasks[task.node] = task
+				
+				# In order to wait on outputs, they must be known before entering the task. This might seem odd, but unless we know outputs are being generated, waiting for them to complete is impossible - unless this was somehow specified ahead of time. The implications of this logic is that all tasks must be sequential in terms of output -> input chaning. This is not a problem in practice.
+				if outputs = task.outputs
+					outputs.each do |path|
+						@outputs[path.to_s] = []
+					end
+				end
 			end
-		
-			def exit(node)
-				@dirty.delete(node)
 			
+			def exit(task)
+				# puts "<-- #{task.node.process}"
+				
 				# Fail outputs if the node failed:
-				if node.failed?
-					@failed += node.outputs
-					@failures += 1
+				if task.failed?
+					@failed_tasks << task
+					
+					if task.outputs
+						@failed_outputs += task.outputs.collect{|path| path.to_s}
+					end
 				end
 				
 				# Clean the node's outputs:
-				node.outputs.each do |path|
+				task.outputs.each do |path|
+					path = path.to_s
+					
 					if edges = @outputs.delete(path)
-						edges.each{|edge| edge.traverse(node)}
+						edges.each{|edge| edge.traverse(task)}
 					end
 				end
-		
-				# Trigger the parent nodes:
-				if parents = @parents.delete(node)
-					parents.each{|edge| edge.traverse(node)}
+				
+				# Notify the parent nodes that the child is done:
+				if parents = @parents.delete(task.node)
+					parents.each{|edge| edge.traverse(task)}
 				end
+				
+				@monitor.add(task)
 			end
-		end
-	
-		# A task is a specific process and scope applied to a graph node.
-		class Task
-			def initialize(controller, walker, node)
-				@controller = controller
-				@node = node
-				@walker = walker
-			
-				# If the execution of the node fails, this is where we save the error:
-				@error = nil
-			
-				@children = []
-			end
-		
-			attr :children
-		
-			def inputs
-				@node.inputs
-			end
-		
-			def outputs
-				@node.outputs
-			end
-		
-			def wet?
-				@node.dirty?
-			end
-		
-			# Derived task should override this function to provide appropriate behaviour.
-			def visit
-				wait_for_inputs
 			
-				# If all inputs were good, we can update the node.
-				unless any_inputs_failed?
-					begin
-						yield
-					rescue TransientError => error
-						$stderr.puts Rainbow("Error: #{error.inspect}").red
-						@error = error
-					end
+			def delete(node)
+				if task = @tasks.delete(node)
+					@monitor.delete(task)
 				end
-			
-				wait_for_children
 			end
-		
-			def exit
-				if @error || any_child_failed? || any_inputs_failed?
-					@node.fail!
-				elsif wet?
-					@node.clean!
-				end
-				
-				@walker.exit(@node)
+			
+			def clear_failed
+				@failed_tasks.each do |task|
+					self.delete(task.node)
+				end if @failed_tasks
 				
-				@walker.count += 1
-			end
-		
-		protected
-			def wait_for_inputs
-				# Wait on any inputs, returns whether any inputs failed:
-				@inputs_failed = @walker.wait_on_paths(@node.inputs)
-			end
-		
-			def wait_for_children
-				@walker.wait_for_nodes(@children)
-			end
-		
-			def any_child_failed?
-				@children.any?{|child| child.failed?}
-			end
-		
-			def any_inputs_failed?
-				@inputs_failed
+				@failed_tasks = []
+				@failed_outputs = Set.new
 			end
 		end
 	end

data/spec/build/graph/graph_spec.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env rspec
 # Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -18,72 +19,45 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'build/graph'
-require 'build/files'
+require 'build/graph/walker'
 require 'build/makefile'
 
 require 'process/group'
 require 'fileutils'
-require 'rainbow'
 
 module Build::Graph::GraphSpec
-	# The graph node is created once, so a graph has a fixed number of nodes, which store per-vertex state and connectivity.
-	class Node < Build::Graph::Node
-		include Build::Files
-		
-		def initialize(controller, inputs = Paths::NONE, outputs = Paths::NONE, &update)
-			@update = update
+	include Build::Graph
+	include Build::Files
+	
+	class ProcessNode < Node
+		def initialize(inputs, outputs, block)
+			super(inputs, outputs, block.source_location)
 			
-			super(controller, inputs, outputs)
-		end
-		
-		def apply!(scope)
-			scope.instance_eval(&@update)
+			@block = block
 		end
 		
-		# This ensures that enclosed nodes are run if they are dirty. The top level node has no inputs or outputs by default, so children who become dirty wouldn't mark it as dirty and thus wouldn't be run.
-		def requires_update?
-			if outputs.count == 0
-				return true
-			else
-				super
-			end
+		def evaluate(context)
+			context.instance_eval(&@block)
 		end
 	end
 	
-	# The task is the context in which a vertex is updated. Because nodes may initially create other nodes, it is also responsible for looking up and creating new nodes.
-	class Task < Build::Graph::Task
-		include Build::Files
-		
-		def initialize(controller, walker, node, group = nil)
-			super(controller, walker, node)
+	class ProcessTask < Task
+		def process(inputs, outputs = :inherit, &block)
+			inputs = Build::Files::List.coerce(inputs)
+			outputs = Build::Files::List.coerce(outputs) unless outputs.kind_of? Symbol
 			
-			@group = group
+			node = ProcessNode.new(inputs, outputs, block)
+			
+			self.invoke(node)
 		end
 		
 		def wet?
-			@group and @node.dirty?
-		end
-		
-		def process(inputs, outputs, &block)
-			inputs = Build::Files::List.coerce(inputs)
-			outputs = Build::Files::List.coerce(outputs)
-			
-			child_node = @controller.nodes.fetch([inputs, outputs]) do |key|
-				@controller.nodes[key] = Node.new(@controller, inputs, outputs, &block)
-			end
-			
-			@children << child_node
-			
-			# State saved in update!
-			child_node.update!(@walker)
-			
-			return child_node
+			@group != nil
 		end
 		
 		def run(*arguments)
 			if wet?
-				puts Rainbow(arguments.join(' ')).blue
+				puts "\t[run] #{arguments.join(' ')}"
 				status = @group.spawn(*arguments)
 				
 				if status != 0
@@ -92,48 +66,17 @@ module Build::Graph::GraphSpec
 			end
 		end
 		
-		def visit
-			super do
-				@node.apply!(self)
-			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(group = nil)
+			@group = group if @node.dirty?
+			
+			@node.evaluate(self)
 		end
 	end
 	
-	# The controller contains all graph nodes and is responsible for executing tasks on the graph. 
-	class Controller < Build::Graph::Controller
-		def initialize(&block)
-			@top = Node.new(self, &block)
-			
-			super()
-		end
-		
-		attr_accessor :top
-		
-		def traverse!(walker)
-			@top.update!(walker)
-		end
-		
-		def build_graph!
-			super do |walker, node|
-				Task.new(self, walker, node)
-			end
-		end
-		
-		def update!
-			group = Process::Group.new
-			
-			walker = super do |walker, node|
-				Task.new(self, walker, node, group)
-			end
-			
-			group.wait
-			
-			return walker
-		end
-	end
-	
-	include Build::Files
-	
 	describe Build::Graph do
 		it "shouldn't update mtime" do
 			test_glob = Glob.new(__dir__, "*.rb")
@@ -141,28 +84,46 @@ module Build::Graph::GraphSpec
 			
 			FileUtils.rm_f listing_output.to_a
 			
-			node = nil
+			group = Process::Group.new
 			
-			controller = Controller.new do
-				node = process test_glob, listing_output do
+			walker = Walker.new do |walker, node|
+				task = ProcessTask.new(walker, node)
+				
+				task.visit do
+					task.update(group)
+				end
+			end
+			
+			top = ProcessNode.top do
+				process test_glob, listing_output do
 					run("ls", "-la", *inputs, :out => outputs.first.for_writing)
 				end
 			end
 			
-			expect(controller.top).to_not be nil
-			expect(node).to_not be nil
+			walker.update(top)
+			group.wait
 			
-			controller.update!
+			first_modified_time = listing_output.first.modified_time
 			
-			mtime = listing_output.first.mtime
+			walker.update(top)
+			group.wait
 			
-			# Ensure the mtime will change even if the granularity of the filesystem is 1 second:
-			sleep(1)
+			# 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
 			
-			controller.update!
+			# 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)
 			
-			# The output file shouldn't have been changed because already exists and the input files haven't changed either:
-			expect(listing_output.first.mtime).to be == mtime
+			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
+			
+			walker.update(top)
+			group.wait
+			
+			expect(listing_output.first.modified_time).to be >= first_modified_time
 			
 			FileUtils.rm_f listing_output.to_a
 		end
@@ -172,9 +133,19 @@ module Build::Graph::GraphSpec
 			code_glob = Glob.new(program_root, "*.cpp")
 			program_path = Path.join(program_root, "dictionary-sort")
 			
-			# FileUtils.touch(code_glob.first)
+			group = Process::Group.new
 			
-			controller = Controller.new do
+			walker = Walker.new do |walker, node|
+				task = ProcessTask.new(walker, node)
+				
+				task.visit do
+					task.update(group)
+				end
+			end
+			
+			#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"
@@ -201,16 +172,16 @@ module Build::Graph::GraphSpec
 					end
 				end
 				
-				process program_path, Paths::NONE do
+				process program_path do
 					run("./" + program_path.relative_path, chdir: program_path.root)
 				end
 			end
 			
-			walker = controller.update!
-			expect(walker).to be_kind_of Build::Graph::Walker
+			walker.update(top)
+			group.wait
 			
 			expect(program_path).to be_exist
-			expect(code_glob.first.mtime).to be <= program_path.mtime
+			expect(code_glob.first.modified_time).to be <= program_path.modified_time
 		end
 	end
 end