teapot 1.0.0.pre.rc9 → 1.0.0.pre.rc10

data/lib/teapot/build.rb

@@ -1,254 +0,0 @@
-# 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 'teapot/rulebook'
-
-require 'build/files'
-require 'build/graph'
-require 'build/makefile'
-
-require 'teapot/name'
-
-require 'graphviz'
-require 'process/group'
-require 'system'
-
-module Teapot
-	module Build
-		Graph = ::Build::Graph
-		Files = ::Build::Files
-		Paths = ::Build::Files::Paths
-		Makefile = ::Build::Makefile
-		
-		class Node < Graph::Node
-			def initialize(controller, rule, arguments, &block)
-				@arguments = arguments
-				@rule = rule
-				
-				@callback = block
-				
-				inputs, outputs = rule.files(arguments)
-				
-				super(controller, inputs, outputs)
-			end
-			
-			attr :arguments
-			attr :rule
-			attr :callback
-			
-			def hash
-				[@rule.name, @arguments].hash
-			end
-			
-			def eql?(other)
-				other.kind_of?(self.class) and @rule.eql?(other.rule) and @arguments.eql?(other.arguments)
-			end
-			
-			def apply!(scope)
-				@rule.apply!(scope, @arguments)
-				
-				if @callback
-					scope.instance_exec(@arguments, &@callback)
-				end
-			end
-			
-			def inspect
-				@rule.name.inspect
-			end
-		end
-		
-		class Top < Graph::Node
-			def initialize(controller, task_class, &update)
-				@update = update
-				@task_class = task_class
-				
-				super(controller, Paths::NONE, Paths::NONE)
-			end
-			
-			attr :task_class
-			
-			def apply!(scope)
-				scope.instance_exec(&@update)
-			end
-			
-			# Top level nodes are always considered dirty. 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?
-				true
-			end
-			
-			def inspect
-				@task_class.name.inspect
-			end
-		end
-		
-		class Task < Graph::Task
-			def initialize(controller, walker, node, group = nil)
-				super(controller, walker, node)
-				
-				@group = group
-				
-				if wet?
-					#@file_system = FileUtils
-					@file_system = FileUtils::Verbose
-				else
-					@file_system = FileUtils::NoWrite
-				end
-			end
-			
-			attr :file_system
-			alias fs file_system
-			
-			def wet?
-				@group && @node.requires_update?
-			end
-			
-			def update(rule, arguments, &block)
-				arguments = rule.normalize(arguments, self)
-				
-				# A sub-graph for a particular build is isolated based on the task class used to instantiate it, so we use this as part of the key.
-				child_node = @controller.nodes.fetch([self.class, rule.name, arguments]) do |key|
-					@controller.nodes[key] = Node.new(@controller, rule, arguments, &block)
-				end
-				
-				@children << child_node
-				
-				child_node.update!(@walker)
-				
-				return child_node.rule.result(arguments)
-			end
-			
-			def run!(*arguments)
-				if wet?
-					puts Rainbow(arguments.join(' ')).blue
-					status = @group.spawn(*arguments)
-					# puts Rainbow("Finished #{arguments.inspect} with status #{status}").blue
-					
-					if status != 0
-						raise Graph::CommandFailure.new(arguments, status)
-					end
-				end
-			end
-			
-			def visit
-				super do
-					@controller.enter(self, @node)
-					@node.apply!(self)
-					@controller.exit(self, @node)
-				end
-			end
-		end
-		
-		class Controller < Graph::Controller
-			def initialize
-				@module = Module.new
-				
-				@top = []
-				
-				yield self
-				
-				@top.freeze
-				
-				@task_class = nil
-				
-				super()
-			end
-			
-			attr :top
-			
-			attr :visualisation
-			
-			# Because we do a depth first traversal, we can capture global state per branch, such as `@task_class`.
-			def traverse!(walker)
-				@top.each do |node|
-					# Capture the task class for each top level node:
-					@task_class = node.task_class
-					
-					node.update!(walker)
-				end
-			end
-			
-			def add_target(target, environment, &block)
-				task_class = Rulebook.for(environment).with(Task, environment: environment, target: target)
-				
-				# Not sure if this is a good idea - makes debugging slightly easier.
-				Object.const_set("TaskClassFor#{Name.from_target(target.name).identifier}_#{self.object_id}", task_class)
-				
-				@top << Top.new(self, task_class, &target.build)
-			end
-			
-			def build_graph!
-				super do |walker, node|
-					@task_class.new(self, walker, node)
-				end
-			end
-			
-			def enter(task, node)
-				return unless @g
-				
-				parent_node = @hierarchy.last
-				
-				task_node = @g.nodes[node] || @g.add_node(node, shape: 'box')
-				
-				if parent_node
-					parent_node.connect(task_node)
-				end
-				
-				node.inputs.map{|path| path.shortest_path(Dir.pwd)}.each do |path|
-					input_node = @g.nodes[path.to_s] || @g.add_node(path.to_s, shape: 'box')
-					input_node.connect(task_node)
-				end
-				
-				@hierarchy << task_node
-			end
-			
-			def exit(task, node)
-				return unless @g
-				
-				@hierarchy.pop
-				
-				task_node = @g.nodes[node] || @g.add_node(node, shape: 'box')
-				
-				node.outputs.map{|path| path.shortest_path(Dir.pwd)}.each do |path|
-					output_node = @g.nodes[path.to_s] || @g.add_node(path.to_s, shape: 'box')
-					output_node.connect(task_node)
-				end
-			end
-			
-			def update!
-				group = Process::Group.new
-				
-				@g = Graphviz::Graph.new('G', rankdir: "LR")
-				@hierarchy = []
-				
-				walker = super do |walker, node|
-					@task_class.new(self, walker, node, group)
-				end
-				
-				group.wait
-				
-				if ENV['BUILD_GRAPH_PDF']
-					Graphviz::output(@g, path: ENV['BUILD_GRAPH_PDF']) rescue nil
-				end
-				
-				return walker
-			end
-		end
-	end
-end

data/lib/teapot/environment/base.rb

@@ -1,62 +0,0 @@
-# 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.
-
-module Teapot
-	# This is the basic environment data structure which is essentially a linked list of hashes. It is primarily used for organising build configurations across a wide range of different sub-systems, e.g. platform configuration, target configuration, local project configuration, etc.
-	class Environment
-		def initialize(parent = nil, values = nil, &block)
-			@values = (values || {}).to_h
-			@parent = parent
-			
-			if block_given?
-				Constructor.new(self).instance_exec(&block)
-			end
-		end
-		
-		def self.hash(**values)
-			self.new(nil, values)
-		end
-		
-		attr :values
-		attr :parent
-		
-		def lookup(name)
-			if @values.include? name
-				self
-			elsif @parent
-				@parent.lookup(name)
-			end
-		end
-		
-		def [] (key)
-			environment = lookup(key)
-			
-			environment ? environment.values[key] : nil
-		end
-		
-		def []= (key, value)
-			@values[key] = value
-		end
-		
-		def to_s
-			"<#{self.class} #{self.values}>"
-		end
-	end
-end

data/lib/teapot/environment/constructor.rb

@@ -1,133 +0,0 @@
-# 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.
-
-module Teapot
-	class Environment
-		Default = Struct.new(:value)
-		Replace = Struct.new(:value)
-		
-		class Define
-			def initialize(klass, &block)
-				@klass = klass
-				@block = block
-			end
-			
-			attr :klass
-			attr :block
-			
-			def to_s
-				"<#{@klass.name} #{@block.source_location.join(':')}>"
-			end
-		end
-		
-		class Constructor
-			def initialize(environment)
-				@environment = environment
-			end
-	
-			def method_missing(name, value = nil, &block)
-				if block_given?
-					@environment[name] = block
-				else
-					@environment[name] = value
-				end
-		
-				name
-			end
-	
-			def [] key
-				@environment[key]
-			end
-	
-			def default(name)
-				@environment[name] = Default.new(@environment[name])
-				
-				return name
-			end
-			
-			def replace(name)
-				@environment[name] = Replace.new(@environment[name])
-				
-				return name
-			end
-			
-			def append(name)
-				@environment[name] = Array(@environment[name])
-				
-				return name
-			end
-			
-			def define(klass, name, &block)
-				abort "#{name} isn't a string when defining #{klass}" unless String === name
-				
-				@environment[name] = Define.new(klass, &block)
-				
-				return name
-			end
-		end
-		
-		def self.combine(*environments)
-			# Flatten the list of environments:
-			environments = environments.collect do |environment|
-				if Environment === environment
-					environment.to_a
-				else
-					environment
-				end
-			end.flatten
-			
-			# Resequence based on order:
-			first = Environment.new(nil, environments.shift)
-			top = first
-			
-			environments.each do |tail|
-				top = Environment.new(top, tail)
-			end
-			
-			return top
-		end
-		
-		def merge(&block)
-			self.class.combine(
-				self,
-				self.class.new(&block)
-			)
-		end
-		
-		# Convert the hierarchy of environments to an array where the parent comes before the child.
-		def to_a
-			flat = []
-			
-			flatten_to_array(flat)
-			
-			return flat
-		end
-		
-		protected
-		
-		def flatten_to_array(array)
-			if @parent
-				@parent.flatten_to_array(array)
-			end
-			
-			array << self
-		end
-	end
-end