build-graph 0.0.1

data/lib/build/system/state.rb

@@ -0,0 +1,218 @@
+# Copyright, 2014, 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 Build
+	module System
+		# Represents a specific file on disk with a specific mtime.
+		class FileTime
+			include Comparable
+		
+			def initialize(path, time)
+				@path = path
+				@time = time
+			end
+		
+			attr :path
+			attr :time
+		
+			def <=> other
+				@time <=> other.time
+			end
+		end
+	
+		class State
+			def initialize(files)
+				raise ArgumentError.new("Invalid files list: #{files}") unless Files::List === files
+			
+				@files = files
+		
+				@times = {}
+			
+				update!
+			end
+	
+			attr :files
+	
+			attr :added
+			attr :removed
+			attr :changed
+			attr :missing
+		
+			attr :times
+		
+			def update!
+				last_times = @times
+				@times = {}
+			
+				@added = []
+				@removed = []
+				@changed = []
+				@missing = []
+			
+				file_times = []
+			
+				@files.each do |path|
+					if File.exist?(path)
+						modified_time = File.mtime(path)
+					
+						if last_time = last_times.delete(path)
+							# Path was valid last update:
+							if modified_time != last_time
+								@changed << path
+							end
+						else
+							# Path didn't exist before:
+							@added << path
+						end
+					
+						@times[path] = modified_time
+					
+						unless File.directory?(path)
+							file_times << FileTime.new(path, modified_time)
+						end
+					else
+						@missing << path
+					end
+				end
+			
+				@removed = last_times.keys
+			
+				@oldest_time = file_times.min
+				@newest_time = file_times.max
+			
+				return @added.size > 0 || @changed.size > 0 || @removed.size > 0
+			end
+		
+			attr :oldest_time
+			attr :newest_time
+		
+			attr :missing
+		
+			def missing?
+				!@missing.empty?
+			end
+		
+			# Outputs is a list of full paths and must not include any patterns/globs.
+			def intersects?(outputs)
+				@files.intersects?(outputs)
+			end
+		
+			def empty?
+				@files.to_a.empty?
+			end
+		end
+	
+		class IOState
+			def initialize(inputs, outputs)
+				@input_state = State.new(inputs)
+				@output_state = State.new(outputs)
+			end
+		
+			attr :input_state
+			attr :output_state
+		
+			# Output is dirty if files are missing or if latest input is older than any output.
+			def dirty?
+				if @output_state.missing?
+					# puts "Output file missing: #{output_state.missing.inspect}"
+				
+					return true
+				end
+			
+				# If there are no inputs, we are always clean as long as outputs exist:
+				# if @input_state.empty?
+				#	return false
+				# end
+			
+				oldest_output_time = @output_state.oldest_time
+				newest_input_time = @input_state.newest_time
+			
+				if newest_input_time and oldest_output_time
+					# if newest_input_time > oldest_output_time
+					#	puts "Out of date file: #{newest_input_time.inspect} > #{oldest_output_time.inspect}"
+					# end
+				
+					return newest_input_time > oldest_output_time
+				end
+			
+				# puts "Missing file dates: #{newest_input_time.inspect} < #{oldest_output_time.inspect}"
+			
+				return true
+			end
+		
+			def fresh?
+				not dirty?
+			end
+		
+			def files
+				@input_state.files + @output_state.files
+			end
+		
+			def added
+				@input_state.added + @output_state.added
+			end
+		
+			def removed
+				@input_state.removed + @output_state.removed
+			end
+		
+			def changed
+				@input_state.changed + @output_state.changed
+			end
+		
+			def update!
+				input_changed = @input_state.update!
+				output_changed = @output_state.update!
+			
+				input_changed or output_changed
+			end
+		
+			def intersects?(outputs)
+				@input_state.intersects?(outputs) or @output_state.intersects?(outputs)
+			end
+		end
+	
+		class Handle
+			def initialize(monitor, files, &block)
+				@monitor = monitor
+				@state = State.new(files)
+				@on_changed = block
+			end
+		
+			attr :monitor
+		
+			def commit!
+				@state.update!
+			end
+		
+			def directories
+				@state.files.roots
+			end
+		
+			def remove!
+				monitor.delete(self)
+			end
+		
+			def changed!
+				@on_changed.call(@state) if @state.update!
+			end
+		end
+	end
+end

data/lib/build/version.rb

@@ -0,0 +1,3 @@
+module Build
+	VERSION = "0.0.1"
+end

data/lib/build/walker.rb

@@ -0,0 +1,175 @@
+
+require 'set'
+
+require 'build/error'
+
+module Build
+	# A walker walks over a graph and applies a task to each node.
+	class Walker
+		def initialize(graph, &task)
+			@graph = graph
+			@task = task
+			
+			@count = 0
+			
+			@outputs = {}
+			@dirty = Set.new
+			
+			# Generate a list of dirty outputs, possibly a subset, if the build graph might generate additional nodes:
+			@graph.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
+		end
+		
+		attr :graph
+		attr :output
+		
+		attr_accessor :count
+		
+		attr :dirty
+		attr :parents
+		
+		def task(*arguments)
+			@task.call(self, *arguments)
+		end
+		
+		def wait_on_paths(paths)
+			edge = Edge.new
+			failed = false
+			
+			paths.each do |path|
+				if @outputs.include? path
+					@outputs[path] << edge
+					
+					edge.increment!
+				end
+				
+				if !failed and @failed.include?(path)
+					failed = true
+				end
+			end
+			
+			edge.wait || failed
+		end
+		
+		def wait_for_nodes(children)
+			edge = Edge.new
+			
+			children.each do |child|
+				if @dirty.include?(child)
+					edge.increment!
+					
+					@parents[child] ||= []
+					@parents[child] << edge
+				end
+			end
+			
+			edge.wait
+		end
+		
+		def exit(node)
+			@dirty.delete(node)
+			
+			# Fail outputs if the node failed:
+			@failed += node.outputs if node.failed?
+			
+			# Clean the node's outputs:
+			node.outputs.each do |path|
+				if edges = @outputs.delete(path)
+					edges.each{|edge| edge.traverse(node)}
+				end
+			end
+		
+			# Trigger the parent nodes:
+			if parents = @parents.delete(node)
+				parents.each{|edge| edge.traverse(node)}
+			end
+		end
+	end
+	
+	# A task is a specific process and scope applied to a graph node.
+	class Task
+		def initialize(graph, walker, node)
+			@graph = graph
+			@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
+		
+		# 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
+					#self.instance_eval(&update)
+					yield
+				rescue TransientError => error
+					$stderr.puts Rainbow("Error: #{error.inspect}").red
+					@error = error
+				end
+			end
+			
+			wait_for_children
+		end
+		
+		def exit
+			if @error || any_child_failed? || any_inputs_failed?
+				@node.fail!
+			elsif @pool
+				@node.clean!
+			end
+			
+			@walker.exit(@node)
+			
+			@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
+		end
+	end
+end

data/test/test_files.rb

@@ -0,0 +1,63 @@
+# 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 'test/unit'
+
+require 'build/files'
+
+class TestFiles < Test::Unit::TestCase
+	def test_inclusion
+		# Glob all test files:
+		glob = Build::Files::Glob.new(__dir__, "*.rb")
+		
+		assert glob.count > 0
+		
+		# Should include this file:
+		assert glob.include?(__FILE__)
+		
+		# Glob should intersect self:
+		assert glob.intersects?(glob)
+	end
+	
+	def test_composites
+		lib = File.join(__dir__, "../lib")
+		
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		lib_glob = Build::Files::Glob.new(lib, "*.rb")
+		
+		both = test_glob + lib_glob
+		
+		# List#roots is the generic accessor for Lists
+		assert both.roots.include? test_glob.root
+		
+		# The composite should include both:
+		assert both.include?(__FILE__)
+	end
+	
+	def test_roots
+		test_glob = Build::Files::Glob.new(__dir__, "*.rb")
+		
+		# Despite returning a String:
+		assert test_glob.first.kind_of? String
+		
+		# We actually return a subclass which includes the root portion:
+		assert_equal __dir__, test_glob.first.root
+	end
+end