teapot 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 916041044782b5244a6c8b7cb013e4a0e06e27fc
-  data.tar.gz: adc4038ee1c679711ebf9840ad29337834f2e142
+  metadata.gz: 40d564684024a42a0762e51eef5fdcccea99eb81
+  data.tar.gz: 4dcc60428ead96eca66951c50ba891dcd366741f
 SHA512:
-  metadata.gz: 4cbb0611a500ac31c0496a57c425e044466316b1da97d656be13f7e3ec8407663c51fdf6ceef3254db1f0c1502e7f8862b182217f7717a51ac3daac057df2cb5
-  data.tar.gz: bc125462db83ab65e1bf344b83033aeb8e55e2a7b7ca29d766dd2f9d0b362ece8c565cffef3f5e0c7929598f8b01e9d525d00d360aa6e291026389fecc584d58
+  metadata.gz: 39344b2e907c0718480aeb96439bfd509c5bfabdfd8e859ea5185fd573e9b96d42594ecc4644699c7cec9270e771b598c2c381d0bc557905d3b6ed04c2f8836e
+  data.tar.gz: ab69319d540e01679dee8cd9ddfbb45d69fd22d363cc2dce531bc4b34c50fc198e9de35cb287516e2ddb37396ccb2dc9ca829ff7825e6e2497535684cfce015c

data/README.md

@@ -98,19 +98,29 @@ Provided you are using an environment that supports sanitizers, you can test mor
 
 	$ teapot "Test/*" variant-sanitize
 
-### Build Project
-
-We can now build and run unit tests (althoght there aren't any yet):
-
-	$ teapot build Test/MyProject
-	... snip ...
-	[Summary] 0 passed out of 0 total
-
-When you build, you need to specify dependencies. If you haven't specified all dependencies, they will be suggested to you.
+### Run Project
+
+We can now build and run the project executable:
+
+	$ teapot Run/MyProject
+	I'm a little teapot,
+	Short and stout,
+	Here is my handle (one hand on hip),
+	Here is my spout (other arm out with elbow and wrist bent).
+	When I get all steamed up,
+	Hear me shout,
+	Tip me over and pour me out! (lean over toward spout)
+
+	                              ~
+	                   ___^___   __
+	               .- /       \./ /
+	              /  /          _/
+	              \__|         |
+	                  \_______/
 
 The resulting executables and libraries will be framework dependent, but are typically located in:
 
-	$ cd teapot/$PROJECT_NAME/platforms/$PLATFORM_NAME/bin/
+	$ cd teapot/platforms/development/$PLATFORM-debug/bin
 	$ ./$PROJECT_NAME
 
 ### Cloning Project

data/lib/teapot/command/build.rb

@@ -39,24 +39,22 @@ module Teapot
 			many :targets, "Build these targets, or use them to help the dependency resolution process."
 			split :argv, "Arguments passed to child process(es) of build if any."
 			
-			# The targets to build:
-			def dependency_names(context)
+			def invoke(parent)
+				context = parent.context
+				
+				# The targets to build:
 				if @targets.any?
-					@targets
+					selection = context.select(@targets)
 				else
-					context.configuration.targets[:build]
+					selection = context.select(context.configuration.targets[:build])
 				end
-			end
-			
-			def invoke(parent)
-				context = parent.context
 				
-				chain = context.dependency_chain(dependency_names(context), context.configuration)
+				chain = selection.chain
 				
 				ordered = chain.ordered
 				
 				if @options[:only]
-					ordered = context.direct_targets(ordered)
+					ordered = selection.direct_targets(ordered)
 				end
 				
 				controller = ::Build::Controller.new(logger: parent.logger, limit: @options[:limit]) do |controller|
@@ -64,7 +62,7 @@ module Teapot
 						target = resolution.provider
 						
 						if target.build
-							environment = target.environment(context.configuration, chain)
+							environment = target.environment(selection.configuration, chain)
 							
 							controller.add_target(target, environment.flatten, self.argv)
 						end

data/lib/teapot/command/create.rb

@@ -58,9 +58,8 @@ module Teapot
 				Fetch[].invoke(nested)
 				
 				context = nested.context
-				
-				# The targets to build to create the initial project:
-				target_names = context.configuration.targets[:create]
+				selection = context.select
+				target_names =  selection.configuration.targets[:create]
 				
 				if target_names.any?
 					# Generate the initial project files:

data/lib/teapot/command/fetch.rb

@@ -52,38 +52,34 @@ module Teapot
 				logger = parent.logger
 				context = parent.context
 				
-				resolved = Set.new
-				configuration = context.configuration
-				unresolved = context.unresolved(configuration.packages)
+				updated = Set.new
+				selection = context.select
 				
-				while true
-					configuration.packages.each do |package|
-						next if resolved.include? package
-						
-						# If specific packages were listed, limit updates to them.
-						if @packages.nil? || @packages.empty? || @packages.include?(package.name)
-							fetch_package(context, configuration, package, logger, **@options)
-						end
-						
-						# We are done with this package, don't try to process it again:
-						resolved << package
-					end
-				
-					# Resolve any/all imports:
-					configuration.materialize
+				packages = selection.configuration.packages
 				
-					previously_unresolved = unresolved
-					unresolved = context.unresolved(configuration.packages)
+				if @packages.any?
+					packages = packages.slice(@packages)
+				end
 				
-					# No additional packages were resolved, we have reached a fixed point:
-					if previously_unresolved == unresolved || unresolved.count == 0
+				# If no additional packages were resolved, we have reached a fixed point:
+				while packages.any?
+					packages.each do |package|
+						fetch_package(context, selection.configuration, package, logger, **@options)
+					end
+					
+					selection = context.select
+					
+					# If there are no unresolved packages, we are done.
+					if selection.unresolved.empty?
 						break
 					end
+					
+					packages = selection.unresolved
 				end
 			
-				if unresolved.count > 0
+				if selection.unresolved.count > 0
 					logger.error "Could not fetch all packages!".color(:red)
-					unresolved.each do |package|
+					selection.unresolved.each do |package|
 						logger.error "\t#{package}".color(:red)
 					end
 				else

data/lib/teapot/command/list.rb

@@ -35,9 +35,9 @@ module Teapot
 			
 			def invoke(parent)
 				context = parent.context
+				
 				logger = parent.logger
 				
-				# Should this somehow consider context.root_package?
 				context.configuration.packages.each do |package|
 					# The root package is the local package for this context:
 					next unless only == nil or only.include?(package.name)
@@ -45,7 +45,8 @@ module Teapot
 					logger.info "Package #{package.name} (from #{package.path}):".bright
 				
 					begin
-						definitions = context.load(package)
+						script = context.load(package)
+						definitions = script.defined
 					
 						definitions.each do |definition|
 							logger.info "\t#{definition}"
@@ -74,14 +75,12 @@ module Teapot
 									logger.info "\t\t- #{provision}".color(:green)
 								end
 							when Configuration
-								definition.materialize
-							
 								definition.packages.each do |package|
 									logger.info "\t\t- #{package}".color(:green)
 								end
 							
 								definition.imports.select(&:explicit).each do |import|
-									logger.info "\t\t- unmaterialised import #{import.name}".color(:red)
+									logger.info "\t\t- import #{import.name}".color(:red)
 								end
 							end
 						end

data/lib/teapot/command/status.rb

@@ -38,7 +38,6 @@ module Teapot
 				context = parent.context
 				logger = parent.logger
 				
-				# Should this somehow consider context.root_package?
 				context.configuration.packages.each do |package|
 					# The root package is the local package for this context:
 					next unless only == nil or only.include?(package.name)

data/lib/teapot/command/visualize.rb

@@ -43,13 +43,11 @@ module Teapot
 			
 			def invoke(parent)
 				context = parent.context
-				
-				configuration = context.configuration
-
-				chain = context.dependency_chain(dependency_names, context.configuration)
+				selection = context.select(dependency_names)
+				chain = selection.chain
 
 				if dependency_name
-					provider = context.dependencies[dependency_name]
+					provider = selection.dependencies[dependency_name]
 					
 					# TODO The visualisation generated isn't quite right. It's introspecting too much from the packages and not reflecting #ordered and #provisions.
 					chain = chain.partial(provider)

data/lib/teapot/configuration.rb

@@ -35,30 +35,29 @@ module Teapot
 			:import => true
 		}.freeze
 		
-		def initialize(context, package, name, packages = [], options = nil)
+		def initialize(context, package, name, packages = [], **options)
 			super context, package, name
 
-			if options
-				@options = options
-			else
-				@options = DEFAULT_OPTIONS.dup
-			end
+			@options = DEFAULT_OPTIONS.merge(options)
 
 			@packages = IdentitySet.new(packages)
 			@imports = IdentitySet.new
 
 			@visibility = :private
-			
+
 			# A list of named targets for specific purposes:
 			@targets = Hash.new{|hash,key| hash[key] = Array.new}
 		end
 
 		def freeze
+			return if frozen?
+			
 			@options.freeze
 			@packages.freeze
 			@imports.freeze
 			@visibility.freeze
 			
+			@targets.default = [].freeze
 			@targets.freeze
 			
 			super
@@ -88,8 +87,8 @@ module Teapot
 		attr :imports
 
 		# Specifies that this configuration depends on an external package of some sort.
-		def require(name, options = nil)
-			options = options ? @options.merge(options) : @options.dup
+		def require(name, **options)
+			options = @options.merge(options)
 			
 			@packages << Package.new(packages_path + name.to_s, name, options)
 			
@@ -139,100 +138,55 @@ module Teapot
 		end
 
 		def lock_store
-			@lock_store ||= YAML::Store.new(lock_path.to_s)
+			YAML::Store.new(lock_path.to_s)
 		end
 
-		# Load all packages defined by this configuration.
-		def load_all
-			@packages.each do |package|
-				@context.load(package)
-			end
-		end
-		
-		# Conceptually, a configuration belongs to a package. Primarily, a configuration lists dependent packages, but this also includes itself as the dependencies are purely target based, e.g. this configuration has access to any targets exposed by its own package.
-		def top!
-			@packages << @package
+		def to_s
+			"#<#{self.class} #{@name.dump} visibility=#{@visibility}>"
 		end
 
 		# Process all import directives and return a new configuration based on the current configuration. Import directives bring packages and other import directives from the specififed configuration definition.
-		def materialize
-			# Potentially no materialization is required:
-			return false if @imports.count == 0
-			
-			# Avoid loops in the dependency chain:
-			imported = IdentitySet.new
+		def traverse(configurations, imported = IdentitySet.new, &block)
+			yield self # Whatever happens here, should ensure that...
 			
-			# Enumerate all imports and attempt to resolve the packages:
-			begin
-				updated = false
+			@imports.each do |import|
+				# So we don't get into some crazy cycle:
+				next if imported.include?(import)
 				
-				# Before trying to materialize, we should load all possible packages:
-				@packages.each do |package|
-					@context.load(package) rescue nil
-				end
-				
-				imports = @imports
-				@imports = IdentitySet.new
+				# Mark it as being imported:
+				imported << import
 				
-				imports.each do |import|
-					named_configuration = @context.configurations[import.name]
-
-					# So we don't get into some crazy cycle:
-					next if imported.include? import
-					
-					# It would be nice if we could detect cycles and issue an error to the user. However, sometimes the case above is not hit at the point where the cycle begins - it isn't clear at what point the user explicitly created a cycle, and what configuration actually ends up being imported a second time.
-					
-					if named_configuration && named_configuration != self
-						# Mark this as resolved
-						imported << import
-						
-						updated = self.update(named_configuration, import.options) || updated
-					else
-						# It couldn't be resolved and hasn't already been resolved...
-						@imports << import
-					end
+				# ... by here, the configuration is available:
+				if configuration = configurations[import.name]
+					configuration.traverse(configurations, imported, &block)
 				end
-			end while updated
-			
-			return true
+			end
 		end
 		
 		# Merge an external configuration into this configuration. We won't override already defined packages.
-		def update(configuration, options)
-			updated = false
-			
-			configuration.packages.each do |external_package|
+		def merge(configuration)
+			configuration.packages.each do |package|
 				# The top level configuration will override packages that are defined by imported configurations. This is desirable behaviour, as it allows us to flatten the configuration but provide overrides if required.
-				unless @packages.include? external_package
-					options = options.merge(external_package.options)
+				unless @packages.include? package
+					package = Package.new(packages_path + package.name, package.name, @options.merge(package.options))
 					
-					@packages << Package.new(packages_path + external_package.name, external_package.name, options)
+					@packages << package
 					
-					updated = true
+					yield package
 				end
 			end
 			
-			configuration.imports.each do |external_import|
-				unless @imports.include? external_import
-					options = options.merge(external_import.options)
-					
-					@imports << Import.new(external_import.name, external_import.explicit, options)
-					
-					updated = true
+			configuration.imports.each do |import|
+				unless @imports.include? import
+					@imports << Import.new(import.name, import.explicit, @options.merge(import.options))
 				end
 			end
 			
 			configuration.targets.each do |key, value|
 				@targets[key] += value
-				
-				updated = true
 			end
 			
-			return updated
-		end
-		
-		def to_s
-			"#<#{self.class} #{@name.dump} visibility=#{@visibility}>"
+			return self
 		end
 	end
 end

data/lib/teapot/context.rb

@@ -26,9 +26,6 @@ require 'build/text/substitutions'
 require 'build/text/merge'
 
 module Teapot
-	TEAPOT_FILE = 'teapot.rb'.freeze
-	DEFAULT_CONFIGURATION_NAME = 'default'.freeze
-
 	class AlreadyDefinedError < StandardError
 		def initialize(definition, previous)
 			super "Definition #{definition.name} in #{definition.path} has already been defined in #{previous.path}!"
@@ -40,21 +37,124 @@ module Teapot
 			raise self.new(definition, previous) if previous
 		end
 	end
-
-	# A context represents a specific root package instance with a given configuration and all related definitions.
-	# A context is stateful in the sense that package selection is specialized based on #select and #dependency_chain. These parameters are usually set up initially as part of the context setup.
-	class Context
-		def initialize(root, **options)
-			@root = Path[root]
-			@options = options
-
+	
+	# A selection is a specific view of the data exposed by the context at a specific point in time.
+	class Select
+		def initialize(context, configuration, names = [])
+			@context = context
+			@configuration = Configuration.new(context, configuration.package, configuration.name, [], configuration.options)
+			
 			@targets = {}
 			@configurations = {}
 			@projects = {}
 			@rules = Build::Rulebook.new
-
+			
 			@dependencies = []
 			@selection = Set.new
+			@unresolved = Set.new
+			
+			load!(configuration, names)
+			
+			@chain = nil
+		end
+		
+		attr :context
+		attr :configuration
+		
+		attr :targets
+		attr :projects
+		
+		# Alises as defined by Configuration#targets
+		attr :aliases
+		
+		# All public configurations.
+		attr :configurations
+
+		attr :rules
+		
+		attr :dependencies
+		attr :selection
+		attr :unresolved
+		
+		def chain
+			@chain ||= Build::Dependency::Chain.expand(@dependencies, @targets.values, @selection)
+		end
+		
+		def direct_targets(ordered)
+			@dependencies.collect do |dependency|
+				ordered.find{|(package, _)| package.provides? dependency}
+			end.compact
+		end
+		
+		private
+		
+		# Add a definition to the current context.
+		def append definition
+			case definition
+			when Target
+				AlreadyDefinedError.check(definition, @targets)
+				@targets[definition.name] = definition
+			when Configuration
+				# We define configurations in two cases, if they are public, or if they are part of the root package of this context.
+				if definition.public? or definition.package == @context.root_package
+					AlreadyDefinedError.check(definition, @configurations)
+					@configurations[definition.name] = definition
+				end
+			when Project
+				AlreadyDefinedError.check(definition, @projects)
+				@projects[definition.name] = definition
+			when Rule
+				AlreadyDefinedError.check(definition, @rules)
+				@rules << definition
+			end
+		end
+		
+		def load_package!(package)
+			begin
+				script = @context.load(package)
+				
+				# Load the definitions into the current selection:
+				script.defined.each do |definition|
+					append(definition)
+				end
+			rescue NonexistantTeapotError, IncompatibleTeapotError
+				# If the package doesn't exist or the teapot version is too old, it failed:
+				@unresolved << package
+			end
+		end
+		
+		def load!(configuration, names)
+			# Load the root package which makes all the named configurations and targets available.
+			load_package!(@context.root_package)
+			
+			# Load all packages defined by this configuration.
+			configuration.traverse(@configurations) do |configuration|
+				@configuration.merge(configuration) do |package|
+					# puts "Load package: #{package} from #{configuration}"
+					load_package!(package)
+				end
+			end
+			
+			@configuration.freeze
+			
+			names.each do |name|
+				if @targets.key? name
+					@selection << name
+				else
+					@dependencies << name
+				end
+			end
+		end
+	end
+	
+	# A context represents a specific root package instance with a given configuration and all related definitions. A context is stateful in the sense that package selection is specialized based on #select and #dependency_chain. These parameters are usually set up initially as part of the context setup.
+	class Context
+		def initialize(root, **options)
+			@root = Path[root]
+			@options = options
+
+			@configuration = nil
+			@project = nil
 
 			@loaded = {}
 
@@ -64,29 +164,19 @@ module Teapot
 		attr :root
 		attr :options
 
-		attr :targets
-		attr :projects
-
-		# Context metadata
-		attr :metadata
-
-		# All public configurations.
-		attr :configurations
-
-		attr :rules
-
-		# The context's primary configuration.
+		# The primary configuration.
 		attr :configuration
 
-		# The context's primary project.
+		# The primary project.
 		attr :project
 
-		attr :dependencies
-		attr :selection
-
 		def repository
 			@repository ||= Rugged::Repository.new(@root.to_s)
 		end
+		
+		def select(names = [], configuration = @configuration)
+			Select.new(self, configuration, names)
+		end
 
 		def substitutions
 			substitutions = Build::Text::Substitutions.new
@@ -119,92 +209,16 @@ module Teapot
 			return substitutions
 		end
 
-		def select(names)
-			names.each do |name|
-				if @targets.key? name
-					@selection << name
-				else
-					@dependencies << name
-				end
-			end
-		end
-
-		def dependency_chain(dependency_names, configuration = @configuration)
-			configuration.load_all
-			
-			select(dependency_names)
-			
-			Build::Dependency::Chain.expand(@dependencies, @targets.values, @selection)
-		end
-
-		def direct_targets(ordered)
-			@dependencies.collect do |dependency|
-				ordered.find{|(package, _)| package.provides? dependency}
-			end.compact
-		end
-
-		# Add a definition to the current context.
-		def << definition
-			case definition
-			when Target
-				AlreadyDefinedError.check(definition, @targets)
-
-				@targets[definition.name] = definition
-			when Configuration
-				# We define configurations in two cases, if they are public, or if they are part of the root package of this context.
-				if definition.public? or definition.package == @root_package
-					# The root package implicitly defines the default configuration.
-					if definition.name == DEFAULT_CONFIGURATION_NAME
-						raise AlreadyDefinedError.new(definition, root_package)
-					end
-
-					AlreadyDefinedError.check(definition, @configurations)
-
-					@configurations[definition.name] = definition
-				end
-			when Project
-				AlreadyDefinedError.check(definition, @projects)
-
-				@project ||= definition
-
-				@projects[definition.name] = definition
-			when Rule
-				AlreadyDefinedError.check(definition, @rules)
-
-				@rules << definition
-			end
-		end
-
 		def load(package)
-			# 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
-				end
-
-				# Save the definitions per-package:
-				@loaded[package] = loader.defined
+			if loader = @loaded[package]
+				return loader.script unless loader.changed?
 			end
-		end
-
-		def unresolved(packages)
-			failed_to_load = Set.new
 			
-			packages.collect do |package|
-				begin
-					definitions = load(package)
-				rescue NonexistantTeapotError, IncompatibleTeapotError
-					# If the package doesn't exist or the teapot version is too old, it failed:
-					failed_to_load << package
-				end
-			end
+			loader = Loader.new(self, package)
 			
-			return failed_to_load
+			@loaded[package] = loader
+			
+			return loader.script
 		end
 		
 		# The root package is a special package which is used to load definitions from a given root path.
@@ -216,23 +230,20 @@ module Teapot
 		
 		def load_root_package(options)
 			# Load the root package:
-			defined = load(root_package)
+			script = load(root_package)
 
 			# Find the default configuration, if it exists:
-			@default_configuration = defined.default_configuration
-
 			if configuration_name = options[:configuration]
 				@configuration = @configurations[configuration_name]
 			else
-				@configuration = @default_configuration
+				@configuration = script.default_configuration
 			end
 			
+			@project = script.default_project
+			
 			if @configuration.nil?
 				raise ArgumentError.new("Could not load configuration: #{configuration_name.inspect}")
 			end
-			
-			# Materialize the configuration:
-			@configuration.materialize if @configuration
 		end
 	end
 end

data/lib/teapot/identity_set.rb

@@ -33,6 +33,8 @@ module Teapot
 			end
 		end
 		
+		attr :table
+		
 		def freeze
 			@table.freeze
 			
@@ -47,8 +49,6 @@ module Teapot
 			object.name
 		end
 		
-		attr :table
-		
 		def add(object)
 			@table[identity(object)] = object
 		end
@@ -67,6 +67,10 @@ module Teapot
 			@table.each_value(&block)
 		end
 		
+		def slice(names)
+			names.collect{|name| @table[name]}
+		end
+		
 		extend Forwardable
 		
 		def_delegators :@table, :size, :empty?, :clear, :count, :[], :to_s, :inspect

data/lib/teapot/loader.rb

@@ -35,6 +35,9 @@ module Teapot
 	# Cannot load packages older than this.
 	MINIMUM_LOADER_VERSION = "1.0"
 	
+	# The package relative path to the file to load:
+	TEAPOT_FILE = 'teapot.rb'.freeze
+	
 	class IncompatibleTeapotError < StandardError
 		def initialize(package, version)
 			super "Unsupported teapot_version #{version} in #{package.path}!"
@@ -51,29 +54,32 @@ module Teapot
 		attr :path
 	end
 	
-	class Loader
+	# The DSL exposed to the `teapot.rb` file.
+	class Script
 		Files = Build::Files
 		Rule = Build::Rule
 		
-		class Definitions < Array
-			def default_configuration
-				find{|definition| Configuration === definition}
-			end
-		end
-		
-		def initialize(context, package)
+		def initialize(context, package, path = TEAPOT_FILE)
 			@context = context
 			@package = package
-
-			@defined = Definitions.new
+			
+			@defined = []
 			@version = nil
+			
+			@default_project = nil
+			@default_configuration = nil
+			
+			@mtime = nil
 		end
-
+		
 		attr :context
 		attr :package
 		attr :defined
 		attr :version
-
+		
+		attr :default_project
+		attr :default_configuration
+		
 		def teapot_version(version)
 			version = version[0..2]
 			
@@ -83,17 +89,18 @@ module Teapot
 				raise IncompatibleTeapotError.new(package, version)
 			end
 		end
-
+		
 		alias required_version teapot_version
-
+		
 		def define_project(*args)
 			project = Project.new(@context, @package, *args)
 			
 			yield project
 			
+			@default_project = project
 			@defined << project
 		end
-
+		
 		def define_target(*args)
 			target = Target.new(@context, @package, *args)
 
@@ -101,21 +108,16 @@ module Teapot
 
 			@defined << target
 		end
-
+		
 		def define_configuration(*args)
 			configuration = Configuration.new(@context, @package, *args)
 
-			configuration.top!
-
 			yield configuration
 
+			@default_configuration ||= configuration
 			@defined << configuration
 		end
 		
-		def define_generator(*args)
-			warn "define_generator(#{args.inspect}) is deprecated and will have no effect. Please use define_target."
-		end
-
 		# Checks the host patterns and executes the block if they match.
 		def host(*args, &block)
 			name = @context.options[:host_platform] || RUBY_PLATFORM
@@ -128,18 +130,50 @@ module Teapot
 				name
 			end
 		end
-
+	end
+	
+	# Loads the teapot.rb script and can reload it if it was changed.
+	class Loader
+		def initialize(context, package, path = TEAPOT_FILE)
+			@context = context
+			@package = package
+			
+			@path = path
+			@mtime = nil
+			
+			@script, @mtime = load!
+		end
+		
+		attr :script
+		
+		def teapot_path
+			@package.path + @path
+		end
+		
+		def changed?
+			File.mtime(teapot_path) > @mtime
+		end
+		
+		def reload
+			self.class.new(@context, @package, @path)
+		end
+		
+		private
+		
 		# Load a teapot.rb file relative to the root of the @package.
-		def load(path)
-			absolute_path = @package.path + path
+		def load!(path = teapot_path)
+			raise NonexistantTeapotError.new(path) unless File.exist?(path)
 			
-			raise NonexistantTeapotError.new(absolute_path) unless File.exist?(absolute_path)
+			script = Script.new(@context, @package)
 			
-			self.instance_eval(absolute_path.read, absolute_path.to_s)
+			mtime = File.mtime(path)
+			script.instance_eval(path.read, path.to_s)
 			
-			if @version == nil
+			if script.version == nil
 				raise IncompatibleTeapotError.new(@package, "<unspecified>")
 			end
+			
+			return script, mtime
 		end
 	end
 end

data/lib/teapot/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Teapot
-	VERSION = "2.1.0"
+	VERSION = "2.2.0"
 end

data/spec/teapot/command/clone_spec.rb

@@ -39,8 +39,10 @@ RSpec.describe Teapot::Command::Clone, order: :defined do
 			
 			expect(File).to be_exist(root + "teapot.rb")
 			
+			selection = top.context.select
+			
 			# Check that we actually fetched some remote targets.
-			expect(top.context.targets).to include(
+			expect(selection.targets).to include(
 				"tagged-format-library",
 				"tagged-format-executable",
 				"tagged-format-tests",

data/spec/teapot/configuration_spec.rb

@@ -22,21 +22,12 @@ require 'teapot/context'
 require 'teapot/configuration'
 
 RSpec.describe Teapot::Configuration do
-	include_context Teapot::Context
+	let(:root) {Build::Files::Path.new(__dir__) + "configuration_spec"}
+	let(:context) {Teapot::Context.new(root)}
 	
-	let(:master) {Teapot::Configuration.new(context, Teapot::Package.new(root + 'master', 'master'), 'master')}
-	let(:embedded) {Teapot::Configuration.new(context, Teapot::Package.new(root + 'embedded', 'embedded'), 'embedded')}
-	
-	context "with create targets" do
-		before(:each) do
-			master.targets[:create] << "hello"
-			embedded.targets[:create] << "world"
-		end
+	it "merged targets" do
+		selection = context.select
 		
-		it "can merge packages" do
-			expect(master.update(embedded, {})).to be_truthy
-			
-			expect(master.targets[:create]).to be == ["hello", "world"]
-		end
+		expect(selection.configuration.targets[:build]).to be == ["Bar", "Foo"]
 	end
 end

data/spec/teapot/configuration_spec/teapot.rb

@@ -0,0 +1,13 @@
+
+teapot_version "2.0"
+
+define_configuration "build-bar" do |configuration|
+	configuration.import "build-foo"
+	
+	configuration.targets[:build] << "Bar"
+end
+
+define_configuration "build-foo" do |configuration|
+	configuration.targets[:build] << "Foo"
+end
+

data/spec/teapot/context_spec.rb

@@ -24,15 +24,20 @@ RSpec.describe Teapot::Context do
 	let(:root) {Build::Files::Path.new(__dir__) + "context_spec"}
 	let(:context) {Teapot::Context.new(root)}
 	
-	it "should load teapot.rb file" do
-		# There is one configuration:
-		expect(context.configurations.count).to be == 1
-	
-		expect(context.targets.count).to be == 1
-	
+	it "should specify correct number of packages" do
 		default_configuration = context.configuration
+		
+		expect(default_configuration.packages.count).to be == 13
+	end
 	
-		# 13 defined packages + 1 implicit package.
-		expect(default_configuration.packages.count).to be == 14
+	it "should load teapot.rb file" do
+		selection = context.select
+		
+		# There is one configuration:
+		expect(selection.configurations.count).to be == 1
+		expect(selection.targets.count).to be == 1
+		
+		# We didn't expect any of them to actually load...
+		expect(selection.unresolved.count).to be > 0
 	end
 end

data/spec/teapot/target_spec.rb

@@ -25,11 +25,12 @@ RSpec.describe Teapot::Target do
 	
 	it "should generate environment for configuration" do
 		context = Teapot::Context.new(root)
+		selection = context.select(["Test/TargetSpec"])
 		
-		target = context.targets['target_spec']
+		target = selection.targets['target_spec']
 		expect(target).to_not be == nil
 		
-		chain = context.dependency_chain(["Test/TargetSpec"])
+		chain = selection.chain
 		expect(chain.providers.size).to be == 4
 		expect(chain.providers).to include target
 		
@@ -39,7 +40,7 @@ RSpec.describe Teapot::Target do
 		expect(chain.ordered[2].name).to be == 'Test/TargetSpec'
 		expect(chain.ordered[2].provider).to be == target
 		
-		environment = target.environment(context.configuration, chain)
+		environment = target.environment(selection.configuration, chain)
 		# Environment#to_hash flattens the environment and evaluates all values:
 		hash = environment.to_hash
 		
@@ -51,11 +52,12 @@ RSpec.describe Teapot::Target do
 	
 	it "should match wildcard packages" do
 		context = Teapot::Context.new(root)
+		selection = context.select(["Test/*"])
 		
-		target = context.targets['target_spec']
+		target = selection.targets['target_spec']
 		expect(target).to_not be == nil
 		
-		chain = context.dependency_chain(["Test/*"])
+		chain = selection.chain
 		expect(chain.providers.size).to be == 4
 		expect(chain.providers).to include target
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teapot
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -228,6 +228,7 @@ files:
 - spec/teapot/command/fetch_spec/test-project/teapot.rb
 - spec/teapot/command_spec.rb
 - spec/teapot/configuration_spec.rb
+- spec/teapot/configuration_spec/teapot.rb
 - spec/teapot/context_spec.rb
 - spec/teapot/context_spec/teapot.rb
 - spec/teapot/identity_set_spec.rb
@@ -267,6 +268,7 @@ test_files:
 - spec/teapot/command/fetch_spec/test-project/teapot.rb
 - spec/teapot/command_spec.rb
 - spec/teapot/configuration_spec.rb
+- spec/teapot/configuration_spec/teapot.rb
 - spec/teapot/context_spec.rb
 - spec/teapot/context_spec/teapot.rb
 - spec/teapot/identity_set_spec.rb