teapot 0.3.2 → 0.5.0

data/lib/teapot/config.rb

@@ -26,10 +26,11 @@ require 'teapot/commands'
 
 module Teapot
 	class Config
-		class Record
-			def initialize(config, klass, name, options = {})
+		include Dependency
+		
+		class Package
+			def initialize(config, name, options = {})
 				@config = config
-				@klass = klass
 				
 				if options[:name]
 					@name = options[:name]
@@ -47,60 +48,61 @@ module Teapot
 				@global = Environment.new
 			end
 			
-			attr :klass
 			attr :name
 			attr :uri
 			attr :options
 			attr :global
 			
-			def transient?
-				@klass == FakePackage
+			def relative_url(base_uri)
+				source_uri = URI(@uri)
+
+				unless source_uri.absolute?
+					source_uri = base_uri + source_uri
+				end
+		
+				# Git can't handle the default formatting that Ruby uses for file URIs.
+				if source_uri.scheme == "file"
+					source_uri = "file://" + source_uri.path
+				end
+				
+				return source_uri
 			end
 			
 			def local?
 				@options.key? :local
 			end
 			
-			def load(context)
-				if @klass == FakePackage
-					context.packages[@name] = @klass.new(@context, self, @name)
-				else
-					context.load(self)
-				end
-			end
-			
 			def loader_path
-				"infusion.rb"
+				"teapot.rb"
 			end
 			
-			def destination_path
-				@config.base_path_for_record(self) + @name
+			def path
+				@config.packages_path + @name
 			end
 			
 			def to_s
-				"<#{@klass} #{@name}>"
-			end
-		end
-		
-		def base_path_for_record(record)
-			if record.klass == Package
-				packages_path
-			elsif record.klass == Platform
-				platforms_path
+				"<#{@name}>"
 			end
 		end
 		
 		def initialize(root, options = {})
 			@root = Pathname.new(root)
 			@options = options
-		
+
 			@packages = []
-			@platforms = []
-			
+
 			@environment = Environment.new
 		end
 
+		def name
+			:config
+		end
+
 		attr :root
+		attr :packages
+		attr :options
+
+		attr :environment
 
 		def packages_path
 			@root + (@options[:packages_path] || "packages")
@@ -110,22 +112,6 @@ module Teapot
 			@root + (@options[:platforms_path] || "platforms")
 		end
 		
-		def build_path
-			@root + (@options[:build_path] || "build")
-		end
-		
-		def variant(*args, &block)
-			name = @options[:variant] || 'debug'
-			
-			if block_given?
-				if args.find{|arg| arg === name}
-					yield
-				end
-			else
-				name
-			end
-		end
-		
 		def host(*args, &block)
 			name = @options[:host_platform] || RUBY_PLATFORM
 			
@@ -140,28 +126,13 @@ module Teapot
 		
 		attr :options
 		attr :packages
-		attr :platforms
-		attr :environment
 
 		def source(path)
 			@options[:source] = path
 		end
 
-		def records
-			@packages + @platforms
-		end
-
 		def package(name, options = {})
-			@packages << Record.new(self, Package, name, options)
-		end
-
-		def platform(name, options = {})
-			options = {:environment => @environment}.merge(options)
-			@platforms << Record.new(self, Platform, name, options)
-		end
-
-		def provides(name, options = {})
-			@packages << Record.new(self, FakePackage, name, options)
+			@packages << Package.new(self, name, options)
 		end
 
 		def load(teapot_path)
@@ -180,8 +151,6 @@ module Teapot
 		end
 		
 		def self.load_default(root = Dir.getwd, options = {})
-			options.merge!(:variant => ENV['TEAPOT_VARIANT'])
-			
 			# Load project specific Teapot file
 			load(root, options) do |config|
 				user_path = File.expand_path("~/.Teapot")

data/lib/teapot/context.rb

@@ -21,56 +21,43 @@
 require 'pathname'
 require 'rainbow'
 
-require 'teapot/package'
-require 'teapot/platform'
+require 'teapot/target'
 
 module Teapot
-	INFUSION_VERSION = "0.2"
+	LOADER_VERSION = "0.5"
 	
-	class IncompatibleInfusion < StandardError
+	class IncompatibleTeapot < StandardError
 	end
 	
-	class Infusion
-		def initialize(context, record)
+	class Loader
+		def initialize(context, package)
 			@context = context
-			@record = record
+			@package = package
 			
 			@defined = []
 			@version = nil
 		end
 		
-		attr :record
+		attr :package
 		attr :defined
 		attr :version
 		
 		def required_version(version)
-			if version <= INFUSION_VERSION
+			if version <= LOADER_VERSION
 				@version = version
 			else
-				raise IncompatibleInfusion.new("Version #{version} more recent than #{INFUSION_VERSION}!")
+				raise IncompatibleTeapot.new("Version #{version} more recent than #{LOADER_VERSION}!")
 			end
 		end
 
-		def define_package(*args, &block)
-			package = Package.new(@context, @record, *args)
+		def define_target(*args, &block)
+			target = Target.new(@context, @package, *args)
 
-			yield(package)
+			yield(target)
 
-			@context.packages[package.name] = package
+			@context.targets[target.name] = target
 
-			@defined << package
-		end
-		
-		def define_platform(*args, &block)
-			platform = Platform.new(@context, @record, *args)
-
-			yield(platform)
-
-			if platform.available?
-				@context.platforms[platform.name] = platform
-			end
-
-			@defined << platform
+			@defined << target
 		end
 		
 		def load(path)
@@ -82,25 +69,47 @@ module Teapot
 		def initialize(config)
 			@config = config
 
-			@packages = {}
-			@platforms = {}
+			@selection = nil
+
+			@targets = {config.name => config}
+
+			@dependencies = []
+			@selection = Set.new
 		end
 
 		attr :config
-		attr :packages
-		attr :platforms
+		attr :targets
 
-		def load(record)
-			infusion = Infusion.new(self, record)
+		def select(names)
+			names.each do |name|
+				if @targets.key? name
+					@selection << name
+				else
+					@dependencies << name
+				end
+			end
+		end
+		
+		attr :dependencies
+		attr :selection
+		
+		def direct_targets(ordered)
+			@dependencies.collect do |dependency|
+				ordered.find{|(package, _)| package.provides? dependency}
+			end.compact
+		end
+		
+		def load(package)
+			loader = Loader.new(self, package)
 			
-			path = (record.destination_path + record.loader_path).to_s
-			infusion.load(path)
+			path = (package.path + package.loader_path).to_s
+			loader.load(path)
 			
-			if infusion.version == nil
-				raise IncompatibleInfusion.new("No version specified in #{path}!")
+			if loader.version == nil
+				raise IncompatibleTeapot.new("No version specified in #{path}!")
 			end
 			
-			infusion.defined
+			loader.defined
 		end
 	end
 end

data/lib/teapot/dependency.rb

@@ -0,0 +1,182 @@
+# 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 'set'
+
+require 'teapot/environment'
+
+module Teapot
+	module Dependency
+		Provision = Struct.new(:value)
+		Alias = Struct.new(:dependencies)
+		
+		def provides?(name)
+			provisions.key? name
+		end
+		
+		def provides(name_or_aliases, &block)
+			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
+			else
+				aliases = name_or_aliases
+				
+				aliases.each do |(name, dependencies)|
+					provisions[name] = Alias.new(Array dependencies)
+				end
+			end
+		end
+		
+		def provisions
+			@provisions ||= {}
+		end
+		
+		def depends(name)
+			dependencies << name
+		end
+		
+		def depends?(name)
+			dependencies.include? name
+		end
+		
+		def dependencies
+			@dependencies ||= Set.new
+		end
+		
+		class Chain
+			def initialize(selection, dependencies, providers)
+				# Explicitly selected targets which will be used when resolving ambiguity:
+				@selection = Set.new(selection)
+				
+				# The list of dependencies that needs to be satisfied:
+				@dependencies = dependencies
+				
+				# The available providers which match up to required dependencies:
+				@providers = providers
+				
+				@resolved = Set.new
+				@ordered = []
+				@provisions = []
+				@unresolved = []
+				@conflicts = {}
+				
+				@dependencies.each do |dependency|
+					expand(dependency, nil)
+				end
+			end
+			
+			attr :selection
+			attr :dependencies
+			attr :providers
+			
+			attr :resolved
+			attr :ordered
+			attr :provisions
+			attr :unresolved
+			attr :conflicts
+			
+			private
+			
+			def find_provider(dependency, parent)
+				# Mostly, only one package will satisfy the dependency...
+				viable_providers = @providers.select{|provider| provider.provides? dependency}
+
+				# puts "** Found #{viable_providers.collect(&:name).join(', ')} viable providers.".color(:magenta)
+
+				if viable_providers.size > 1
+					# ... however in some cases (typically where aliases are being used) an explicit selection must be made for the build to work correctly.
+					explicit_providers = viable_providers.select{|provider| @selection.include? provider.name}
+
+					# puts "** Filtering to #{explicit_providers.collect(&:name).join(', ')} explicit providers.".color(:magenta)
+
+					if explicit_providers.size == 0
+						# No provider was explicitly specified, thus we require explicit conflict resolution:
+						@conflicts[dependency] = viable_providers
+						return nil
+					elsif explicit_providers.size == 1
+						# The best outcome, a specific provider was named:
+						return explicit_providers.first
+					else
+						# Multiple providers were explicitly mentioned that satisfy the dependency.
+						@conflicts[dependency] = explicit_providers
+						return nil
+					end
+				else
+					return viable_providers.first
+				end
+			end
+			
+			def expand(dependency, parent)
+				# puts "** Expanding #{dependency} from #{parent}".color(:magenta)
+				
+				if @resolved.include? dependency
+					# puts "** Already resolved dependency!".color(:magenta)
+					
+					return
+				end
+				
+				provider = find_provider(dependency, parent)
+
+				if provider == nil
+					# puts "** Couldn't find provider -> unresolved".color(:magenta)
+					@unresolved << [dependency, parent]
+					return nil
+				end
+				
+				provision = provider.provisions[dependency]
+				
+				# We will now satisfy this dependency by satisfying any dependent dependencies, but we no longer need to revisit this one.
+				@resolved << dependency
+				
+				if Alias === provision
+					# puts "** Resolving alias #{provision}".color(:magenta)
+					
+					provision.dependencies.each do |dependency|
+						expand(dependency, provider)
+					end
+				elsif provision != nil
+					# puts "** Appending #{dependency} -> provisions".color(:magenta)
+					@provisions << provision
+				end
+				
+				unless @resolved.include?(provider)
+					# We are now satisfying the provider by expanding all its own dependencies:
+					@resolved << provider
+					
+					provider.dependencies.each do |dependency|
+						expand(dependency, provider)
+					end
+					
+					# puts "** Appending #{dependency} -> ordered".color(:magenta)
+					@ordered << [provider, dependency]
+				end
+			end
+		end
+		
+		def self.chain(selection, dependencies, providers)
+			Chain.new(selection, dependencies, providers)
+		end
+	end
+end

data/lib/teapot/environment/constructor.rb

@@ -49,6 +49,10 @@ module Teapot
 			def replace(name)
 				@environment[name] = Replace.new(@environment[name])
 			end
+			
+			def append(name)
+				@environment[name] = Array(@environment[name])
+			end
 		end
 		
 		def self.combine(*environments)

data/lib/teapot/target.rb

@@ -0,0 +1,94 @@
+# 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 'pathname'
+require 'teapot/build'
+require 'teapot/dependency'
+
+module Teapot
+	class BuildError < StandardError
+	end
+	
+	class Target
+		include Dependency
+		
+		def initialize(context, package, name)
+			@context = context
+			@package = package
+
+			@name = name
+
+			@install = nil
+
+			@path = @package.path
+		end
+
+		attr :context
+		attr :package
+		attr :name
+
+		attr :path
+
+		def builder
+			Build.top(@path)
+		end
+
+		def install(&block)
+			@install = Proc.new(&block)
+		end
+
+		def install!(context, config = {})
+			return unless @install
+			
+			chain = Dependency::chain(context.selection, dependencies, context.targets.values)
+			
+			environments = []
+			
+			# The base configuration environment:
+			environments << context.config.environment
+			
+			# The dependencies environments':
+			environments += chain.provisions.collect do |provision|
+				Environment.new(&provision.value)
+			end
+			
+			# Per-configuration package package environment:
+			environments << @package.options[:environment]
+			
+			# Merge all the environments together:
+			environment = Environment.combine(*environments)
+				
+			local_build = environment.merge do
+				default platforms_path context.config.platforms_path
+				default build_prefix {platforms_path + "cache/#{platform_name}-#{variant}"}
+				default install_prefix {platforms_path + "#{platform_name}-#{variant}"}
+			
+				append buildflags {"-I#{install_prefix + "include"}"}
+				append linkflags {"-L#{install_prefix + "lib"}"}
+			end
+			
+			@install.call(local_build)
+		end
+
+		def to_s
+			"<Target: #{@name}>"
+		end
+	end
+end

data/lib/teapot/version.rb

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

data/teapot.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
 	gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
 	gem.require_paths = ["lib"]
 	
-	gem.add_dependency "rake"
 	gem.add_dependency "rainbow"
 	gem.add_dependency "rexec"
+	gem.add_dependency "trollop"
 end

data/test/test_config.rb

@@ -0,0 +1,41 @@
+# 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 'pathname'
+require 'test/unit'
+require 'stringio'
+
+require 'teapot/config'
+
+class TestConfig < Test::Unit::TestCase
+	ROOT = Pathname.new(__FILE__).dirname
+	
+	def test_config
+		config = Teapot::Config.new(ROOT)
+		
+		config.instance_eval do
+			source "../infusions/"
+			package "png"
+		end
+		
+		assert_equal "../infusions/", config.options[:source]
+		assert_equal 1, config.packages.size
+	end
+end