teapot 0.6.0 → 0.7.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NWYwMzJlZTQ2ZGEzODQ4ODAwMzY1YWNlMDg2OWI0Mzg2MzFmODlhYQ==
+  data.tar.gz: !binary |-
+    ODk0NTJjMjllMDEzNWFmOWFmMGFlOWUyMjFhMjA0YTllYmQ2NGUzMg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Y2NhNTdkYzgzZTRkZTFjZmFiNGZiMjVlNzkzZDc0ZTYwZThmMzQ3OGJiMjAy
+    NWE3MGNlZjM3NTJjYmY5M2RmYjMxZGRhYzYxMWY4ZDgyYjA0ZGE4M2ExYTJl
+    NTkxODQyNGU1NDk3NWRmMDkzODQ4Y2I1YTljNTIxNWNmYTdjOGM=
+  data.tar.gz: !binary |-
+    NzBmODAzNjJiYjgzYjk2ZWI3OTc2NGJjZjY0YTM3MDk0NWFiYjI1OTA2ZjE4
+    NWExMGY0ZjAyZjNmZjMwMmZlMjIwMjU5ZDViNjU2N2M0OTkzN2RjMDUwMGNi
+    ODIyMWY5ZGYxMTczZTBlMzEyZDM0MTRlY2FjNWU4YTFmZWUxZTg=

data/README.md

@@ -1,71 +1,43 @@
 # Teapot
 
-Teapot is a tool for managing complex cross-platform builds. It provides
-advanced dependency management via the Teapot file and is supported by
-the infusions ecosystem of packages and platform tooling.
+Teapot is a decentralised build tool for managing complex cross-platform projects. It has many goals but it is primarily designed to improve the experience for developers trying to make cross-platform applications and libraries with a minimum of overhead.
+
+- Provide useful feedback when dependencies are not met or errors are encountered.
+- Decentralised dependency management allows use within private organisations without exposing code.
+- Generators can simplify the construction of new projects as well as assist with the development of existing ones.
+- The build subsystem provides a simple set of canonical operations for building libraries and executables to minimise configuration overhead.
 
 [![Build Status](https://secure.travis-ci.org/ioquatix/teapot.png)](http://travis-ci.org/ioquatix/teapot)
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-    gem 'teapot'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+Ensure that you already have a working install of Ruby 1.9.3+
 
     $ gem install teapot
 
 ## Usage
 
-Create a Teapot file in the root directory of your project:
-
-	source "https://github.com/infusions"
-
-	host /linux/ do
-		platform "linux"
-	end
-	
-	host /darwin/ do
-		platform "darwin-osx"
-	end
-
-	package "png"
-	package "freetype"
-	package "vorbis"
-	package "ogg"
-	package "jpeg"
-
-Then run
-
-	$ teapot install
+Teapot doesn't have a centralised package management system. As such, this example shows how to use an existing open source framework.
 
-This will download and compile all the selected packages into the `build` directory.
+Firstly, create your project by running:
 
-### CMake ###
+	$ teapot init "My Project" https://github.com/dream-framework project
+	$ cd my-project
 
-To use these packages in a CMake project, update your `CMakeLists.txt`:
+In the resulting project directory that has been created, you can see the list of dependencies:
 
-	list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SOURCE_DIR}/build/${TEAPOT_PLATFORM}/")
+	$ teapot list
 
-Then configure like so:
+To build your project:
 
-	cmake path/to/src -DTEAPOT_PLATFORM=linux
+	$ teapot build Application/MyProject variant-debug
 
-### Xcode ###
+When you build, you need to specify dependencies. If you haven't specified all dependencies, they will be suggested to you.
 
-To use these packages in an Xcode project, creating a custom `teapot.xcconfig` is recommended:
+The resulting libraries will be framework dependent, but are typically located in
 
-	TEAPOT_PLATFORM=darwin-osx
-	TEAPOT_PREFIX_PATH=$(SRCROOT)/build/$(TEAPOT_PLATFORM)
-	
-	// Search paths:
-	HEADER_SEARCH_PATHS=$(inherited) "$(TEAPOT_PREFIX_PATH)/include"
-	LIBRARY_SEARCH_PATHS=$(inherited) "$(TEAPOT_PREFIX_PATH)/lib"
+	$ cd teapot/$PROJECT_NAME/platforms/$PLATFORM_NAME/bin/
+	$ ./$PROJECT_NAME
 
 ## Contributing
 

data/bin/teapot

@@ -20,160 +20,99 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'teapot/config'
+require 'teapot/controller'
+require 'teapot/controller/build'
+require 'teapot/controller/clean'
+require 'teapot/controller/create'
+require 'teapot/controller/fetch'
+require 'teapot/controller/generate'
+require 'teapot/controller/list'
 
-require 'uri'
-require 'rainbow'
-require 'fileutils'
 require 'benchmark'
-require 'yaml'
-
 require 'trollop'
 
 OPTIONS = Trollop::options do
 	opt :only, "Only compiled direct dependencies."
+	opt :in, "Work in the given directory.", :type => :string
+	
+	opt :configuration, "Specify a specific build configuration.", :type => :string, :default => Teapot::DEFAULT_CONFIGURATION_NAME
 end
 
+def make_controller(root = nil)
+	root ||= OPTIONS[:in] || Dir.getwd
+	Teapot::Controller.new(root, OPTIONS)
+end
+
+# It would be nice to make this code a bit simpler, perhaps moving some parts of it to lib/teapot/application/{function}.rb
 module Application
-	def self.fetch
-		config = Teapot::Config.load_default
-		context = Teapot::Context.new(config)
+	def self.clean
+		make_controller.clean
+	end
 	
-		base_uri = URI(config.options[:source].to_s)
+	def self.fetch
+		make_controller.fetch
+	end
 	
-		if base_uri.scheme == nil || base_uri.scheme == 'file'
-			base_uri = URI "file://" + File.expand_path(base_uri.path, config.root) + "/"
-		end
+	def self.build
+		targets = ARGV
 		
-		puts "Base URI: #{base_uri}".color(:cyan)
-		
-		config.packages.each do |package|
-			destination_path = package.path
-		
-			if package.local?
-				puts "Linking local #{package}...".color(:cyan)
-			
-				local_path = config.root + package.options[:local]
-			
-				# Make the top level directory if required:
-				destination_path.dirname.mkpath
-			
-				unless destination_path.exist?
-					destination_path.make_symlink(local_path)
-				end
-			else
-				puts "Fetching #{package}...".color(:cyan)
-		
-				branch = package.options.fetch(:version, 'master')
-		
-				unless destination_path.exist?
-					puts "Cloning package at path #{destination_path} ...".color(:cyan)
-					destination_path.mkpath
-			
-					Teapot::Commands.run("git", "clone", package.relative_url(base_uri), destination_path, "--branch", branch)
-			
-					Dir.chdir(destination_path) do
-						Teapot::Commands.run("git", "submodule", "update", "--init", "--recursive")
-					end
-				else
-					puts "Updating package at path #{destination_path} ...".color(:cyan)
-			
-					Dir.chdir(destination_path) do
-						Teapot::Commands.run("git", "fetch", "origin")
-				
-						Teapot::Commands.run("git", "checkout", branch)
-				
-						# Pull any changes, if you might get the error from above:
-						# Your branch is behind 'origin/0.1' by 1 commit, and can be fast-forwarded.
-						Teapot::Commands.run("git", "pull")
-				
-						Teapot::Commands.run("git", "submodule", "update", "--init", "--recursive")
-					end
-				end
-			end
-		end
-	
-		puts "Completed fetch successfully.".color(:green)
+		make_controller.build(targets)
 	end
 	
-	def self.install(package_names = ARGV)
-		config = Teapot::Config.load_default
-		context = Teapot::Context.new(config)
+	def self.list
+		make_controller.list
+	end
 	
-		config.packages.each do |package|
-			context.load(package)
-		end
-		
-		context.select(package_names)
-		
-		chain = Teapot::Dependency::chain(context.selection, context.dependencies, context.targets.values)
-		
-		if chain.unresolved.size > 0
-			puts "Unresolved dependencies:"
+	def self.create
+		project_name = ARGV.shift
+		project_directory = project_name.gsub(/\s+/, '-').downcase
+		source = ARGV.shift
+		packages = ARGV
 		
-			chain.unresolved.each do |(name, parent)|
-				puts "#{parent} depends on #{name.inspect}".color(:red)
-				
-				conflicts = chain.conflicts[name]
-				
-				if conflicts
-					conflicts.each do |conflict|
-						puts " - provided by #{conflict.inspect}".color(:red)
-					end
-				end
-			end
-			
-			abort "Cannot continue build due to unresolved dependencies!"
-		end
-	
-		puts "Resolved: #{chain.resolved.inspect}".color(:magenta)
+		root = Pathname(Dir.getwd) + project_directory
 	
-		ordered = chain.ordered
-		
-		if OPTIONS[:only]
-			ordered = context.direct_targets(ordered)
+		if root.exist?
+			abort "#{root} already exists!".color(:red)
 		end
 		
-		ordered.each do |(target, dependency)|
-			puts "Building #{target.name} for dependency #{dependency}...".color(:cyan)
+		# Make the path:
+		root.mkpath
 		
-			if target.respond_to? :install! and !ENV['TEAPOT_DRY']
-				target.install!(context)
-			end
+		Dir.chdir(root) do
+			Teapot::Commands.run("git", "init")
 		end
+		
+		controller = make_controller(root)
 	
-		puts "Completed build successfully.".color(:green)
+		controller.create(project_name, source, packages)
+		controller.generate('project', [project_name])
 	end
 	
-	def self.list
-		config = Teapot::Config.load_default
-		context = Teapot::Context.new(config)
-	
-		config.packages.each do |package|
-			targets = context.load(package)
-		
-			targets.each do |target|
-				puts "Target #{target.name} from #{package.name}"
-			
-				target.dependencies.each do |name|
-					puts " - depends on #{name.inspect}".color(:red)
-				end
-			
-				target.provisions.each do |(name, provision)|
-					if Teapot::Dependency::Alias === provision
-						puts " - provides #{name.inspect} => #{provision.dependencies.inspect}".color(:green)
-					else
-						puts " - provides #{name.inspect}".color(:green)
-					end
-				end
-			end
-		end
+	def self.generate(arguments = ARGV)
+		make_controller.generate(arguments)
 	end
 end
 
+valid_actions = (Application.public_methods - Module.methods).collect(&:to_s)
+action = ARGV.shift
+
+# Check that the command was invoked correctly...
+unless action and valid_actions.include?(action)
+	puts "You must specify an action from: #{valid_actions.join(', ')}".color(:red)
+	exit -1
+end
+
 time = Benchmark.measure do
-	action = ARGV.shift.to_sym
-	Application.send(action) if Application.methods.include?(action)
+	begin
+		Application.send(action.to_sym)
+	rescue Teapot::NonexistantTeapotError => error
+		$stderr.puts error.message.color(:red)
+	rescue Teapot::IncompatibleTeapotError => error
+		$stderr.puts error.message.color(:red)
+	rescue Teapot::Commands::CommandError => error
+		$stderr.puts error.message.color(:red)
+	end
 end
 
-puts time.format("Elapsed Time: %r").color(:magenta)
+$stdout.flush
+$stderr.puts time.format("Elapsed Time: %r").color(:magenta)

data/lib/teapot/build.rb

@@ -32,20 +32,20 @@ module Teapot
 		end
 		
 		module Helpers
-			def install_directory(root, directory, *args)
+			def build_directory(root, directory, *args)
 				target = Build.top(root)
 		
 				target.add_directory(directory)
 		
-				target.execute(:install, *args)
+				target.execute(:build, *args)
 			end
 		
-			def install_external(root, directory, *args, &block)
+			def build_external(root, directory, *args, &block)
 				target = Build.top(root)
 			
 				target << Targets::External.new(target, directory, &block)
 			
-				target.execute(:install, *args)
+				target.execute(:build, *args)
 			end
 		end
 	end

data/lib/teapot/build/targets/application.rb

@@ -33,7 +33,7 @@ module Teapot
 				end
 				
 				def subdirectory
-					"apps/#{@name}"
+					"Applications/#{@name}"
 				end
 				
 				def << target

data/lib/teapot/build/targets/external.rb

@@ -41,7 +41,7 @@ module Teapot
 					@parent.root + @directory
 				end
 				
-				def install(values)
+				def build(values)
 					return unless @install
 					
 					source_path = @parent.root + @directory

data/lib/teapot/build/targets/files.rb

@@ -51,7 +51,7 @@ module Teapot
 					options[:subdirectory] || "./"
 				end
 				
-				def install(environment)
+				def build(environment)
 					prefix = install_prefix!(environment)
 					
 					if self.respond_to? :source_files

data/lib/teapot/build/targets/library.rb

@@ -53,7 +53,7 @@ module Teapot
 					return library_file
 				end
 			
-				def build(environment)
+				def compile_and_link(environment)
 					file_list = self.source_files(environment)
 				
 					pool = Commands::Pool.new
@@ -79,10 +79,10 @@ module Teapot
 					end
 				end
 			
-				def install(environment)
+				def build(environment)
 					prefix = install_prefix!(environment)
 					
-					build(environment).each do |path|
+					compile_and_link(environment).each do |path|
 						destination_path = prefix + subdirectory + path.basename
 					
 						destination_path.dirname.mkpath

data/lib/teapot/commands.rb

@@ -48,7 +48,7 @@ module Teapot
 			if system(*args)
 				true
 			else
-				raise CommandError.new("Non-zero exit status!")
+				raise CommandError.new("Non-zero exit status: #{args.join(' ')}!")
 			end
 		end
 		

data/lib/teapot/configuration.rb

@@ -0,0 +1,174 @@
+# 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 'set'
+
+require 'yaml/store'
+
+require 'teapot/context'
+require 'teapot/environment'
+require 'teapot/commands'
+
+require 'teapot/definition'
+
+module Teapot
+	class Configuration < Definition
+		Import = Struct.new(:name, :options)
+		
+		def initialize(context, package, name, packages = Set.new)
+			super context, package, name
+
+			@options = {}
+
+			@packages = packages
+			@imports = []
+
+			@visibility = :private
+		end
+
+		# Controls how the configuration is exposed in the context.
+		attr :visibility
+
+		def public?
+			@visibility == :public
+		end
+
+		def public!
+			@visibility = :public
+		end
+
+		# Options used to bind packages to this configuration.
+		attr :options
+
+		# A list of packages which are required by this configuration.
+		attr :packages
+
+		# A list of other configurations to include when materialising the list of packages.
+		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
+			
+			@packages << Package.new(packages_path + name.to_s, name, options)
+		end
+
+		# Specifies that this package will import additional configuration records from another definition.
+		def import(name)
+			@imports << Import.new(name, @options.dup)
+		end
+
+		# Require and import the named package.
+		def import!(name, options = nil)
+			require(name, options)
+			import(name)
+		end
+
+		# Create a group for configuration options which will be only be active within the group block.
+		def group
+			options = @options.dup
+			
+			yield
+			
+			@options = options
+		end
+
+		# Set a configuration option.
+		def []= key, value
+			@options[key] = value
+		end
+
+		# Get a configuration option.
+		def [] key
+			@options[key]
+		end
+
+		# The path where packages will be located when fetched.
+		def packages_path
+			context.root + "teapot/packages/#{name}"
+		end
+
+		# The path where built products will be installed.
+		def platforms_path
+			context.root + "teapot/platforms/#{name}"
+		end
+
+		def lock_path
+			context.root + "#{@name}-lock.yml"
+		end
+
+		def lock_store
+			@lock_store ||= 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
+		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 self if @imports.count == 0
+			
+			# Before trying to materialize, we should load all possible packages:
+			@packages.each{|package| @context.load(package) rescue nil}
+			
+			# Create a new configuration which will represent the materialised version:
+			configuration = self.class.new(@context, @package, @name, @packages.dup)
+			
+			# Enumerate all imports and attempt to resolve the packages:
+			@imports.each do |import|
+				resolved_configuration = @context.configuration_named(import.name)
+				
+				if resolved_configuration
+					configuration.append(resolved_configuration, import.options)
+				else
+					# It couldn't be resolved...
+					configuration.imports << import
+				end
+			end
+			
+			return configuration
+		end
+		
+		def append(configuration, options)
+			@packages += configuration.packages.collect do |package|
+				package.dup.tap{|package| package.options = options.merge(package.options)}
+			end
+			
+			@imports += configuration.imports.collect do |import|
+				import.dup.tap{|import| import.options = options.merge(import.options)}
+			end
+		end
+		
+		def to_s
+			"<#{self.class.name} #{@name.dump} visibility=#{@visibility}>"
+		end
+	end
+end