teapot 0.9.10 → 1.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 878219ed331477566d41ce4f34e5342bd20d3b54
-  data.tar.gz: fb855b6abbc1225ea619a4ba4e17e821a8c37b62
+  metadata.gz: d5f2d266ab25fcae9ab8d5582147d0a74d05d747
+  data.tar.gz: 202f83855d31f83ac023107ef3e123e95af83795
 SHA512:
-  metadata.gz: d12945e3ba6e0aa7debca0ebbe7642e4edad9b412df3d538f0aa7c4c1195afabad9204c5c9954d52d9563d690c0a8918795e0382c8324c55a86be7f1d6e6195d
-  data.tar.gz: b2faf14aa6e156a92e041b082ce790de98425cab5f606f81c0705afea8327f1064540f14d24df84468189f5c6c375ddeef2ab29c5d93df244d730abac09fec08
+  metadata.gz: 4f3c17b8a55d5aab3a5adb1061d518fd45da2bef8a31471b8e7797169345e6a7fec9cb73441d6cf922e1efb16cbdc1fc8f57e8371866c9aa64c2ac019f373f98
+  data.tar.gz: 50318c19defce391b36cd24056d987eeb9f6c9a1f3c61df53ee53dd8e44fd6484b8effa576cf8791467178a77b96c6dd334d073e92eb522094b6512643b552b5

data/.travis.yml

@@ -1,5 +1,8 @@
 language: ruby
 rvm:
-  - "1.9.2"
-  - "1.9.3"
-  - rbx-19mode
+  - "1.9"
+  - "2.0"
+  - "2.1"
+matrix:
+  allow_failures:
+    - rvm: "1.9"

data/README.md

@@ -60,9 +60,8 @@ You need to make sure any basic tools, e.g. compilers, system libraries, are ins
 
 ## Dependency Graph
 
-Dependency analysis is an important part of efficiently building a source tree. A dependency graph constructed from a single output file depends on the set of input files and their associated implicit dependencies (e.g. `#include` directives), and additionally the environment and task that is being performed. Specifically, the environment can specify additional header files, libraries, or other dependent input files and needs to be considered explicitly.
-
-Teapot assumes per-environment dependency graphs and in addition, parts of the dependency graph are generated dynamically. The process of extracting implicit dependencies can be found under `teapot/extractors` and is used extensively in the build graph `teapot/build`.
+- Should packages be built into a shared prefix or should they be built into unique prefixes and joined together either via install or `-L` and `-I`?
+- Should packages expose the tools required to build themselves as dependencies? e.g. should `build-cmake` as required by, say, `OpenCV`, be exposed to all who depend on `OpenCV`? Should there be a mechanism for non-public dependencies, i.e. dependencies which are not exposed to dependants?
 
 ## Contributing
 
@@ -76,7 +75,7 @@ Teapot assumes per-environment dependency graphs and in addition, parts of the d
 
 Released under the MIT license.
 
-Copyright, 2012, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+Copyright, 2012, 2014, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -1,9 +1,6 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new do |t|
-	t.libs << 'test'
-end
+RSpec::Core::RakeTask.new(:spec)
 
-desc "Run tests"
-task :default => :test
+task :default => :spec

data/bin/teapot

@@ -27,7 +27,6 @@ require 'teapot/controller/create'
 require 'teapot/controller/fetch'
 require 'teapot/controller/generate'
 require 'teapot/controller/list'
-require 'teapot/controller/run'
 require 'teapot/controller/visualize'
 
 require 'teapot/repository'
@@ -39,6 +38,8 @@ OPTIONS = Trollop::options do
 	version "teapot v#{Teapot::VERSION}"
 	
 	opt :only, "Only compiled direct dependencies."
+	opt :continuous, "Run the build graph continually.", :type => :boolean
+	
 	opt :in, "Work in the given directory.", :type => :string
 	opt :unlock, "Don't use package lockfile when fetching."
 	
@@ -67,11 +68,7 @@ module Application
 	def self.build(targets = ARGV)
 		make_controller.build(targets)
 	end
-	
-	def self.run(targets = ARGV)
-		make_controller.run(targets)
-	end
-	
+		
 	def self.list(only = ARGV)
 		if only.size > 0
 			make_controller.list(Set.new(only))
@@ -114,7 +111,6 @@ def track_time
 	start_time = Time.now
 	
 	yield
-	
 ensure
 	end_time = Time.now
 	elapsed_time = end_time - start_time

data/lib/teapot/build.rb

@@ -18,34 +18,182 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'teapot/build/targets/directory'
-require 'teapot/build/targets/files'
-require 'teapot/build/targets/library'
-require 'teapot/build/targets/executable'
-require 'teapot/build/targets/application'
-require 'teapot/build/targets/external'
+require 'teapot/rulebook'
+
+require 'build/files'
+require 'build/graph'
+require 'build/makefile'
+
+require 'teapot/name'
+
+require 'process/group'
+require 'system'
 
 module Teapot
 	module Build
-		def self.top(path)
-			Targets::Directory.target(nil, path)
-		end
+		Graph = ::Build::Graph
+		Files = ::Build::Files
+		Paths = ::Build::Files::Paths
+		Makefile = ::Build::Makefile
 		
-		module Helpers
-			def build_directory(root, directory, *args)
-				target = Build.top(root)
+		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
+		end
 		
-				target.add_directory(directory)
+		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
+		end
 		
-				target.execute(:build, *args)
+		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)
+				
+				# 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("Scheduling #{arguments.inspect}").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
+					@node.apply!(self)
+				end
 			end
+		end
 		
-			def build_external(root, directory, *args, &block)
-				target = Build.top(root)
+		class Controller < Graph::Controller
+			def initialize
+				@module = Module.new
+				
+				@top = []
+				
+				yield self
+				
+				@top.freeze
+				
+				@task_class = nil
+				
+				super()
+			end
 			
-				target << Targets::External.new(target, directory, &block)
+			attr :top
+			
+			# 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
 			
-				target.execute(:build, *args)
+			def update!
+				group = Process::Group.new
+				
+				super do |walker, node|
+					@task_class.new(self, walker, node, group)
+				end
+				
+				group.wait
 			end
 		end
 	end

data/lib/teapot/configuration.rb

@@ -25,7 +25,6 @@ require 'yaml/store'
 
 require 'teapot/context'
 require 'teapot/environment'
-require 'teapot/commands'
 
 require 'teapot/definition'
 

data/lib/teapot/context.rb

@@ -21,9 +21,11 @@
 require 'teapot/loader'
 require 'teapot/package'
 
+require 'teapot/rulebook'
+
 module Teapot
-	TEAPOT_FILE = "teapot.rb"
-	DEFAULT_CONFIGURATION_NAME = 'default'
+	TEAPOT_FILE = 'teapot.rb'.freeze
+	DEFAULT_CONFIGURATION_NAME = 'default'.freeze
 
 	class AlreadyDefinedError < StandardError
 		def initialize(definition, previous)
@@ -39,33 +41,23 @@ module Teapot
 
 	class Context
 		def initialize(root, options = {})
-			@root = Pathname(root)
+			@root = Path[root]
 			@options = options
 
 			@targets = {}
 			@generators = {}
 			@configurations = {}
 			@projects = {}
+			@rules = Rulebook.new
 
 			@dependencies = []
 			@selection = Set.new
 
 			@loaded = {}
 
-			# Load the root package:
-			defined = load(root_package)
-
-			# Find the default configuration, if it exists:
-			@default_configuration = defined.default_configuration
-
-			if options[:configuration]
-				@configuration = @configurations[options[:configuration]]
-			else
-				@configuration = @default_configuration
+			unless options[:fake]
+				load_root_package(options)
 			end
-
-			# Materialize the configuration:
-			@configuration.materialize if @configuration
 		end
 
 		attr :root
@@ -78,6 +70,8 @@ module Teapot
 		# All public configurations.
 		attr :configurations
 
+		attr :rules
+
 		# The context's primary configuration.
 		attr :configuration
 
@@ -111,6 +105,7 @@ module Teapot
 			end.compact
 		end
 
+		# Add a definition to the current context.
 		def << definition
 			case definition
 			when Target
@@ -139,6 +134,10 @@ module Teapot
 				@project ||= definition
 
 				@projects[definition.name] = definition
+			when Rule
+				AlreadyDefinedError.check(definition, @rules)
+
+				@rules << definition
 			end
 		end
 
@@ -146,9 +145,9 @@ module Teapot
 			# In certain cases, a package record might be loaded twice. This typically occurs when multiple configurations are loaded in the same context, or if a package has already been loaded (as is typical with the root package).
 			@loaded.fetch(package) do
 				loader = Loader.new(self, package)
-
+				
 				loader.load(TEAPOT_FILE)
-
+				
 				# Load the definitions into the current context:
 				loader.defined.each do |definition|
 					self << definition
@@ -173,12 +172,29 @@ module Teapot
 			
 			return failed_to_load
 		end
-
-		private
-
+		
 		# The root package is a special package which is used to load definitions from a given root path.
 		def root_package
 			@root_package ||= Package.new(@root, "root")
 		end
+		
+		private
+		
+		def load_root_package(options)
+			# Load the root package:
+			defined = load(root_package)
+
+			# Find the default configuration, if it exists:
+			@default_configuration = defined.default_configuration
+
+			if options[:configuration]
+				@configuration = @configurations[options[:configuration]]
+			else
+				@configuration = @default_configuration
+			end
+
+			# Materialize the configuration:
+			@configuration.materialize if @configuration
+		end
 	end
 end

data/lib/teapot/controller/build.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require 'teapot/controller'
+require 'teapot/build'
 
 module Teapot
 	class Controller
@@ -30,16 +31,32 @@ module Teapot
 			if @options[:only]
 				ordered = context.direct_targets(ordered)
 			end
-		
-			ordered.each do |(target, dependency)|
-				if target.respond_to?(:build!) and !@options[:dry]
-					log "Building #{target.name} for dependency #{dependency}...".color(:cyan)
+			
+			controller = Teapot::Build::Controller.new do |controller|
+				ordered.each do |(target, dependency)|
+					environment = target.environment_for_configuration(context.configuration)
 					
-					target.build!(context.configuration)
+					if target.build
+						controller.add_target(target, environment.flatten)
+					end
+				end
+			end
+			
+			controller.run do
+				# The graph has been dirtied because files have changed, traverse and update it:
+				controller.update_with_log
+				
+				# Only run once is asked:
+				unless @options[:continuous]
+					break
+				end
+				
+				if $TEAPOT_DEBUG_GRAPH
+					controller.nodes.each do |key, node|
+						puts "#{node.status} #{node.inspect}"# unless node.clean?
+					end
 				end
 			end
-	
-			log "Completed build successfully.".color(:green)
 			
 			return chain, ordered
 		end

data/lib/teapot/controller/fetch.rb

@@ -28,7 +28,7 @@ module Teapot
 			configuration = context.configuration
 			unresolved = context.unresolved(configuration.packages)
 			tries = 0
-
+			
 			while tries < @options[:maximum_fetch_depth]
 				configuration.packages.each do |package|
 					next if resolved.include? package

data/lib/teapot/controller.rb

@@ -23,6 +23,7 @@ require 'teapot/version'
 
 require 'uri'
 require 'rainbow'
+require 'rainbow/ext/string'
 require 'fileutils'
 
 module Teapot

data/lib/teapot/definition.rb

@@ -37,7 +37,7 @@ module Teapot
 		
 		# The name of the definition:
 		attr :name
-
+		
 		# A textual description of the definition, possibly in markdown format:
 		attr :description, true
 		

data/lib/teapot/dependency.rb

@@ -45,16 +45,12 @@ module Teapot
 			if String === name_or_aliases || Symbol === name_or_aliases
 				name = name_or_aliases
 				
-				if block_given?
-					provisions[name] = Provision.new(block)
-				else
-					provisions[name] = Provision.new(nil)
-				end
+				provisions[name] = Provision.new(block)
 			else
 				aliases = name_or_aliases
 				
 				aliases.each do |name, dependencies|
-					provisions[name] = Alias.new(Array dependencies)
+					provisions[name] = Alias.new(Array(dependencies))
 				end
 			end
 		end

data/lib/teapot/environment/base.rb

@@ -19,10 +19,10 @@
 # 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. The majority of the actual functionality is exposed in the `environment/*.rb` files.
+	# 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 = {}, &block)
-			@values = (values || {}).to_hash
+		def initialize(parent = nil, values = nil, &block)
+			@values = (values || {}).to_h
 			@parent = parent
 			
 			if block_given?
@@ -30,6 +30,10 @@ module Teapot
 			end
 		end
 		
+		def self.hash(**values)
+			self.new(nil, values)
+		end
+		
 		attr :values
 		attr :parent
 		
@@ -51,20 +55,8 @@ module Teapot
 			@values[key] = value
 		end
 		
-		def to_hash
-			@values
-		end
-		
 		def to_s
 			"<#{self.class} #{self.values}>"
 		end
-		
-		def inspect(output = $stdout, indent = "")
-			@values.each do |(key, value)|
-				output.puts "#{indent}#{key}: #{value}"
-			end
-			
-			@parent.inspect(output, indent + "\t") if @parent
-		end
 	end
 end

data/lib/teapot/environment/constructor.rb

@@ -23,6 +23,20 @@ module Teapot
 		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
@@ -44,14 +58,28 @@ module Teapot
 	
 			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
 		

data/lib/teapot/environment/flatten.rb

@@ -18,9 +18,15 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'digest/md5'
+
 module Teapot
 	class Environment
-		def flatten
+		def to_h
+			@values
+		end
+		
+		def to_hash
 			hash = {}
 			
 			# Flatten this chain of environments:
@@ -33,8 +39,43 @@ module Teapot
 			Hash[hash.map{|key, value| [key, evaluator.object_value(value)]}]
 		end
 		
+		def flatten
+			self.class.new(nil, self.to_hash)
+		end
+		
+		def defined
+			@values.select{|name,value| Define === value}
+		end
+		
+		def inspect(output = $stdout, indent = "")
+			@values.each do |(key, value)|
+				output.puts "#{indent}#{key}: #{value}"
+			end
+			
+			@parent.inspect(output, indent + "\t") if @parent
+		end
+		
+		# This should be stable within environments that produce the same results.
+		def checksum
+			digester = Digest::MD5.new
+			
+			checksum_recursively(digester)
+			
+			return digester.hexdigest
+		end
+		
 		protected
 		
+		def checksum_recursively(digester)
+			@values.each do |(key, value)|
+				digester.update(key.to_s)
+				digester.update(value.to_s)
+			end
+			
+			@parent.checksum_recursively(digester) if @parent
+		end
+		
+		# We fold in the ancestors one at a time from oldest to youngest.
 		def flatten_to_hash(hash)
 			if @parent
 				@parent.flatten_to_hash(hash)