build-graph 0.0.1

data/lib/build/graph.rb

@@ -0,0 +1,75 @@
+
+require 'build/system/monitor'
+require 'build/system/pool'
+
+require 'build/error'
+require 'build/node'
+require 'build/walker'
+require 'build/edge'
+
+module Build
+	class Graph < System::Monitor
+		def initialize
+			super
+			
+			@nodes = {}
+			
+			build_graph!
+		end
+		
+		attr :nodes
+		
+		# You need to override this to traverse the top nodes as required:
+		def traverse!(walker)
+			#Array(top).each do |node|
+			#	node.update!(walker)
+			#end
+		end
+		
+		def walk(&block)
+			Walker.new(self, &block)
+		end
+		
+		def build_graph!
+			# We build the graph without doing any actual execution:
+			nodes = []
+			
+			walker = walk do |walker, node|
+				nodes << node
+				
+				yield walker, node
+			end
+			
+			traverse! walker
+			
+			# We should update the status of all nodes in the graph once we've traversed the graph.
+			nodes.each do |node|
+				node.update_status!
+			end
+		end
+		
+		def update_with_log
+			puts Rainbow("*** Graph update traversal ***").green
+			
+			start_time = Time.now
+			
+			walker = update!
+		ensure
+			end_time = Time.now
+			elapsed_time = end_time - start_time
+			
+			$stdout.flush
+			$stderr.puts Rainbow("Graph Update Time: %0.3fs" % elapsed_time).magenta
+		end
+		
+		def update!
+			walker = walk do |walker, node|
+				yield walker, node
+			end
+			
+			traverse! walker
+			
+			return walker
+		end
+	end
+end

data/lib/build/node.rb

@@ -0,0 +1,134 @@
+
+require 'build/system/state'
+
+module Build
+	class Node
+		def initialize(graph, inputs, outputs)
+			@graph = graph
+			
+			@state = System::IOState.new(inputs, outputs)
+			
+			@status = :unknown
+			@fiber = nil
+			
+			# These are immutable - rather than change them, create a new node:
+			@inputs = inputs
+			@outputs = outputs
+			
+			@graph.add(self)
+		end
+		
+		def eql?(other)
+			other.kind_of?(self.class) and @inputs.eql?(other.inputs) and @outputs.eql?(other.outputs)
+		end
+		
+		def hash
+			[@inputs, @outputs].hash
+		end
+		
+		def directories
+			@state.files.roots
+		end
+		
+		def remove!
+			@graph.delete(self)
+		end
+		
+		# It is possible this function is called unnecessarily. The state check confirms whether a change occurred or not.
+		def changed!(outputs = [])
+			# Don't do anything if we are already dirty.
+			return if dirty?
+		
+			if @state.intersects?(outputs) || @state.update!
+				# puts "changed: inputs=#{inputs} #{@inputs.to_a.inspect} -> #{@outputs.to_a.inspect}"
+			
+				# Could possibly use unknown status here.
+				@status = :dirty
+			
+				# If this node changes, we force all other nodes which depend on this node to be dirty.
+				@graph.update(directories, @outputs)
+			end
+		end
+		
+		attr :inputs
+		attr :outputs
+		
+		attr :state
+		attr :status
+		
+		def unknown?
+			@status == :unknown
+		end
+		
+		def dirty?
+			@status == :dirty
+		end
+		
+		def clean?
+			@status == :clean
+		end
+		
+		def clean!
+			@status = :clean
+		end
+		
+		def fail!
+			@status = :failed
+		end
+		
+		def failed?
+			@status == :failed
+		end
+		
+		def updating?
+			@fiber != nil
+		end
+		
+		# If we are in the initial state, we need to check if the outputs are fresh.
+		def update_status!
+			# puts "Update status: #{@inputs.inspect} -> #{@outputs.inspect} (status=#{@status} @fiber=#{@fiber.inspect}) @status=#{@status} @state.fresh?=#{@state.fresh?}"
+			
+			if @status == :unknown
+				# This could be improved - only stale files should be reported, instead we report all.
+				unless @state.fresh?
+					changed!(self.inputs)
+				else
+					@status = :clean
+				end
+			end
+		end
+		
+		def inspect
+			"<#{dirty? ? '*' : ''}inputs=#{inputs.inspect} outputs=#{outputs.inspect} fiber=#{@fiber.inspect} fresh=#{@state.fresh?}>"
+		end
+		
+		def requires_update?
+			not clean?
+		end
+		
+		# Perform some actions to update this node, returns when completed, and the node is no longer dirty.
+		def update!(walker)
+			# puts "Walking #{@inputs.to_a.inspect} -> #{@outputs.to_a.inspect} (dirty=#{dirty?} @fiber=#{@fiber.inspect})"
+			
+			# If a fiber already exists, this node is in the process of updating.
+			if requires_update? and @fiber == nil
+				# puts "Beginning: #{@inputs.to_a.inspect} -> #{@outputs.to_a.inspect}"
+				
+				@fiber = Fiber.new do
+					task = walker.task(self)
+					
+					task.visit
+					
+					# Commit changes:
+					# puts "Committing: #{@inputs.to_a.inspect} -> #{@outputs.to_a.inspect}"
+					@state.update!
+					@fiber = nil
+					
+					task.exit
+				end
+			
+				@fiber.resume
+			end
+		end
+	end
+end

data/lib/build/system/monitor.rb

@@ -0,0 +1,123 @@
+# 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.
+
+require 'set'
+
+require 'build/system/state'
+
+module Build
+	module System
+		class Monitor
+			def initialize
+				@directories = Hash.new { |hash, key| hash[key] = Set.new }
+			
+				@updated = false
+			end
+		
+			attr :updated
+		
+			# Notify the monitor that files in these directories have changed.
+			def update(directories, *args)
+				directories.each do |directory|
+					# directory = File.realpath(directory)
+				
+					@directories[directory].each do |handle|
+						handle.changed!(*args)
+					end
+				end
+			end
+		
+			def roots
+				@directories.keys
+			end
+		
+			def delete(handle)
+				handle.directories.each do |directory|
+					@directories[directory].delete(handle)
+				
+					# Remove the entire record if there are no handles:
+					if @directories[directory].size == 0
+						@directories.delete(directory)
+					
+						@updated = true
+					end
+				end
+			end
+		
+			def track_changes(files, &block)
+				handle = Handle.new(self, files, &block)
+			
+				add(handle)
+			end
+		
+			def add(handle)
+				handle.directories.each do |directory|
+					@directories[directory] << handle
+				
+					# We just added the first handle:
+					if @directories[directory].size == 1
+						# If the handle already existed, this might trigger unnecessarily.
+						@updated = true
+					end
+				end
+			
+				handle
+			end
+		end
+	
+		def self.run_with_fsevent(monitor, options = {}, &block)
+			require 'rb-fsevent'
+		
+			fsevent ||= FSEvent.new
+		
+			catch(:interrupt) do
+				while true
+					fsevent.watch monitor.roots do |directories|
+						monitor.update(directories)
+					
+						yield
+					
+						if monitor.updated
+							fsevent.stop
+						end
+					end
+				
+					fsevent.run
+				end
+			end
+		end
+	
+		def self.run_with_polling(monitor, options = {}, &block)
+			catch(:interrupt) do
+				while true
+					monitor.update(monitor.roots)
+				
+					yield
+				
+					sleep(options[:latency] || 5.0)
+				end
+			end
+		end
+	
+		def self.run(monitor, options = {}, &block)
+			run_with_polling(monitor, options, &block)
+		end
+	end
+end

data/lib/build/system/pool.rb

@@ -0,0 +1,116 @@
+# 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.
+
+require 'rainbow'
+require 'system'
+require 'fiber'
+
+module Build
+	module System
+		# A pool is a group of tasks which can be run asynchrnously using fibers. Someone must call #wait to ensure that all fibers eventuall resume.
+		class Pool
+			def self.processor_count
+				::System::CPU.count
+			end
+	
+			class Command
+				def initialize(arguments, options, fiber = Fiber.current)
+					@arguments = arguments
+					@options = options
+				
+					@fiber = fiber
+				end
+			
+				attr :arguments
+				attr :options
+			
+				def run(options = {})
+					puts Rainbow("Running #{@arguments.inspect} options: #{@options.merge(options).inspect}").blue
+				
+					Process.spawn(*@arguments, @options.merge(options))
+				end
+			
+				def resume(*arguments)
+					@fiber.resume(*arguments)
+				end
+			end
+	
+			def initialize(options = {})
+				@commands = []
+				@limit = options[:limit] || Pool.processor_count
+			
+				@running = {}
+				@fiber = nil
+			
+				@pgid = true
+			end
+		
+			attr :running
+		
+			def run(*arguments)
+				options = Hash === arguments.last ? arguments.pop : {}
+				arguments = arguments.flatten.collect &:to_s
+			
+				@commands << Command.new(arguments, options)
+			
+				schedule!
+			
+				Fiber.yield
+			end
+		
+			def schedule!
+				while @running.size < @limit and @commands.size > 0
+					command = @commands.shift
+				
+					if @running.size == 0
+						pid = command.run(:pgroup => true)
+						@pgid = Process.getpgid(pid)
+					else
+						pid = command.run(:pgroup => @pgid)
+					end
+				
+					@running[pid] = command
+				end
+			end
+	
+			def wait
+				while @running.size > 0
+					# Wait for processes in this group:
+					pid, status = Process.wait2(-@pgid)
+				
+					command = @running.delete(pid)
+				
+					schedule!
+				
+					command.resume(status)
+				end
+			end
+		end
+	
+		module FakePool
+			def self.wait
+			end
+		
+			def self.run(*arguments)
+				0
+			end
+		end
+	end
+end