teapot 0.9.10 → 1.0.0.pre.rc1

data/lib/teapot/environment/system.rb

@@ -36,15 +36,15 @@ module Teapot
 				end
 			end
 			
-			def self.convert_to_shell(values)
-				Hash[values.map{|key, value| [
+			def self.convert_to_shell(environment)
+				Hash[environment.values.map{|key, value| [
 					key.to_s.upcase,
 					shell_escape(value)
 				]}]
 			end
 			
 			def self.dump(environment, io = STDOUT)
-				environment.to_hash.each do |key, value|
+				environment.values.each do |key, value|
 					io.puts "#{key}:".rjust(20).color(:magenta) + " #{value.inspect}"
 				end
 			end

data/lib/teapot/extractors/linker_extractor.rb

@@ -28,7 +28,7 @@ module Teapot
 				roots = []
 				libraries = []
 				paths = []
-
+				
 				# Extract include directories:
 				flags.each do |option|
 					if option.to_s =~ /^-L(.+)/
@@ -37,7 +37,7 @@ module Teapot
 						libraries << Pathname($1)
 					end
 				end
-
+				
 				libraries.each do |name|
 					archive_name = "lib#{name}.a"
 					

data/lib/teapot/loader.rb

@@ -22,13 +22,15 @@ require 'teapot/project'
 require 'teapot/target'
 require 'teapot/generator'
 require 'teapot/configuration'
+require 'teapot/rule'
 
 require 'teapot/name'
-require 'teapot/build'
+
+require 'build/files'
 
 module Teapot
-	LOADER_VERSION = "0.9"
-	MINIMUM_LOADER_VERSION = "0.8"
+	LOADER_VERSION = "1.0.0"
+	MINIMUM_LOADER_VERSION = "1.0"
 	
 	class IncompatibleTeapotError < StandardError
 		def initialize(package, version)
@@ -47,18 +49,14 @@ module Teapot
 	end
 	
 	class Loader
+		Files = ::Build::Files
+		
 		class Definitions < Array
 			def default_configuration
 				find{|definition| Configuration === definition}
 			end
 		end
 		
-		# Provides build_directory and build_external methods
-		include Build::Helpers
-		
-		# Provides run_executable and other related methods.
-		include Commands::Helpers
-		
 		def initialize(context, package)
 			@context = context
 			@package = package
@@ -134,9 +132,9 @@ module Teapot
 		# Load a teapot.rb file relative to the root of the @package.
 		def load(path)
 			absolute_path = @package.path + path
-
+			
 			raise NonexistantTeapotError.new(absolute_path) unless File.exist?(absolute_path)
-
+			
 			self.instance_eval(absolute_path.read, absolute_path.to_s)
 			
 			if @version == nil

data/lib/teapot/name.rb

@@ -24,6 +24,10 @@ module Teapot
 			@text = text
 		end
 		
+		def self.from_target(string)
+			self.new(string.gsub(/(^|[ \-_])(.)/){" " + $2.upcase}.strip)
+		end
+		
 		attr :text
 		
 		def identifier

data/lib/teapot/package.rb

@@ -18,19 +18,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'pathname'
+require 'build/files'
 
 require 'teapot/context'
 require 'teapot/environment'
-require 'teapot/commands'
 
 require 'teapot/definition'
 
 module Teapot
+	Path = Build::Files::Path
+	
 	class Package
 		def initialize(path, name, options = {})
 			# The path where the package is (or will be) located:
-			@path = path
+			@path = Path[path]
 
 			# Get the name of the package from the options, if provided:
 			if options[:name]
@@ -49,7 +50,7 @@ module Teapot
 			
 			# Copy the options provided:
 			@options = options
- 		end
+		end
 
 		attr :name
 		attr :path

data/lib/teapot/repository.rb

@@ -18,10 +18,38 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'teapot/commands'
+require 'rexec'
 
 module Teapot
 	module Git
+		module Commands
+			class CommandError < StandardError
+			end
+			
+			def self.run(*args, &block)
+				options = Hash === args.last ? args.pop : {}
+				options[:passthrough] ||= :all
+			
+				args = args.flatten.collect &:to_s
+			
+				puts args.join(' ').color(:blue) + " in #{options[:chdir] || Dir.getwd}"
+			
+				task = RExec::Task.open(args, options, &block)
+			
+				if task.wait == 0
+					true
+				else
+					raise CommandError.new("Non-zero exit status: #{args.join(' ')}!")
+				end
+			end
+		
+			def self.run!(*args, &block)
+				run(*args, &block)
+			rescue CommandError
+				false
+			end
+		end
+		
 		class Repository
 			def initialize(root, options = {})
 				@root = root

data/lib/teapot/rule.rb

@@ -0,0 +1,196 @@
+# 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
+	# A rule is a function with a specific set of input and output parameters, which can match against a given set of specific inputs and outputs. For example, there might be several rules for compiling, but the specific rules depend on the language being compiled.
+	class Rule
+		class Parameter
+			def initialize(direction, name, options = {}, &block)
+				@direction = direction
+				@name = name
+				
+				@options = options
+				
+				@dynamic = block_given? ? Proc.new(&block) : nil
+			end
+			
+			attr :direction
+			attr :name
+			
+			attr :options
+			
+			def dynamic?
+				@dynamic != nil
+			end
+			
+			def implicit?
+				dynamic? and @options[:implicit]
+			end
+			
+			def typed?
+				@options[:typed]
+			end
+			
+			def applicable? arguments
+				# The parameter is either optional, or is included in the argument list, otherwise we fail.
+				unless @options[:optional] or arguments.include?(@name)
+					return false
+				end
+				
+				value = arguments[@name]
+				
+				# If the parameter is optional, and wasn't provided, we are okay.
+				if @options[:optional]
+					return true if value == nil
+				end
+				
+				# If the parameter is typed, and we don't match the expected type, we fail.
+				if type = @options[:typed]
+					return false unless type === value
+				end
+				
+				# If a pattern is provided, we must match it.
+				if pattern = @options[:pattern]
+					return Array(value).all? {|item| pattern.match(item)}
+				end
+				
+				return true
+			end
+			
+			def compute(arguments)
+				if implicit?
+					@dynamic.call(arguments)
+				elsif dynamic?
+					@dynamic.call(arguments[@name], arguments)
+				else
+					arguments[@name]
+				end
+			end
+			
+			def inspect
+				"#{direction}:#{@name} (#{options.inspect})"
+			end
+		end
+		
+		def initialize(process_name, type)
+			@name = process_name + "." + type
+			@full_name = @name.gsub(/[^\w]/, '_')
+			
+			@process_name = process_name.gsub('-', '_').to_sym
+			@type = type
+			
+			@apply = nil
+			
+			@parameters = []
+		end
+		
+		# compile.cpp
+		attr :name
+		
+		# compile
+		attr :process_name
+		
+		# compile_cpp
+		attr :full_name
+		
+		attr :primary_output
+		
+		def input(name, options = {}, &block)
+			@parameters << Parameter.new(:input, name, options, &block)
+		end
+		
+		def parameter(name, options = {}, &block)
+			@parameters << Parameter.new(:argument, name, options, &block)
+		end
+		
+		def output(name, options = {}, &block)
+			@parameters << Parameter.new(:output, name, options, &block)
+			
+			@primary_output ||= @parameters.last
+		end
+		
+		# Check if this rule can process these parameters
+		def applicable?(arguments)
+			@parameters.each do |parameter|
+				next if parameter.implicit?
+				
+				return false unless parameter.applicable?(arguments)
+			end
+			
+			return true
+		end
+		
+		def normalize(arguments)
+			Hash[
+				@parameters.collect do |parameter|
+					[parameter.name, parameter.compute(arguments)]
+				end
+			]
+		end
+		
+		def files(arguments)
+			input_files = []
+			output_files = []
+			
+			@parameters.each do |parameter|
+				# This could probably be improved a bit, we are assuming all parameters are file based:
+				value = arguments[parameter.name]
+				
+				next unless value
+				
+				case parameter.direction
+				when :input
+					input_files << value
+				when :output
+					output_files << value
+				end
+			end
+			
+			return Build::Files::Composite.new(input_files), Build::Files::Composite.new(output_files)
+		end
+		
+		def apply(&block)
+			@apply = Proc.new(&block)
+		end
+		
+		def apply!(scope, arguments)
+			scope.instance_exec(arguments, &@apply) if @apply
+		end
+		
+		def result(arguments)
+			if @primary_output
+				arguments[@primary_output.name]
+			end
+		end
+		
+		def to_s
+			"<#{self.class.name} #{@name.dump}>"
+		end
+	end
+	
+	class NoApplicableRule < StandardError
+		def initialize(name, arguments)
+			super "No applicable rule with name #{name}.* for parameters: #{arguments.inspect}"
+			
+			@name = name
+			@arguments = arguments
+		end
+	end
+end

data/lib/teapot/rulebook.rb

@@ -0,0 +1,91 @@
+# 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/rule'
+
+module Teapot
+	class Rulebook
+		def initialize
+			@rules = {}
+			@processes = {}
+		end
+		
+		attr :rules
+		
+		def << rule
+			@rules[rule.name] = rule
+		
+			# A cache for fast process/file-type lookup:
+			processes = @processes[rule.process_name] ||= []
+			processes << rule
+		end
+
+		def [] name
+			@rules[name]
+		end
+		
+		def with(superclass, state = {})
+			task_class = Class.new(superclass)
+			
+			# Define methods for all processes, e.g. task_class#compile
+			@processes.each do |key, rules|
+				# Define general rules, which use rule applicability for disambiguation:
+				task_class.send(:define_method, key) do |arguments, &block|
+					rule = rules.find{|rule| rule.applicable? arguments }
+					
+					if rule
+						update(rule, arguments, &block)
+					else
+						raise NoApplicableRule.new(key, arguments)
+					end
+				end
+			end
+			
+			# Define methods for all rules, e.g. task_class#compile_cpp
+			@rules.each do |key, rule|
+				task_class.send(:define_method, rule.full_name) do |arguments, &block|
+					update(rule, arguments, &block)
+				end
+			end
+			
+			state.each do |key, value|
+				task_class.send(:define_method, key) do
+					value
+				end
+			end
+			
+			return task_class
+		end
+		
+		def self.for(environment)
+			rulebook = self.new
+			
+			environment.defined.each do |name, define|
+				object = define.klass.new(*name.split('.', 2))
+				
+				object.instance_eval(&define.block)
+				
+				rulebook << object
+			end
+			
+			return rulebook
+		end
+	end
+end

data/lib/teapot/target.rb

@@ -19,10 +19,11 @@
 # THE SOFTWARE.
 
 require 'pathname'
-require 'teapot/build'
 require 'teapot/dependency'
 require 'teapot/definition'
 
+require 'teapot/rulebook'
+
 module Teapot
 	class BuildError < StandardError
 	end
@@ -32,19 +33,23 @@ module Teapot
 		
 		def initialize(context, package, name)
 			super context, package, name
-
+			
 			@build = nil
+			
+			@rulebook = Rulebook.new
 		end
-
-		def builder
-			Build.top(@path)
-		end
-
-		def environment_for_configuration(configuration)
+		
+		attr :rulebook
+		
+		def provision_chain(configuration)
 			# Reduce the number of keystrokes for good health:
 			context = configuration.context
 			
 			chain = Dependency::chain(context.selection, dependencies, context.targets.values)
+		end
+		
+		def environment_for_configuration(configuration)
+			chain = provision_chain(configuration)
 			
 			environments = []
 			
@@ -63,45 +68,15 @@ module Teapot
 				default platforms_path configuration.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
 		end
-
+		
 		def build(&block)
 			if block_given?
-				@build = Proc.new(&block)
+				@build = block
 			end
 			
 			return @build
 		end
-
-		def build!(configuration)
-			return unless @build
-			
-			local_environment = environment_for_configuration(configuration)
-			
-			@build.call(local_environment)
-		end
-		
-		# Specify a default block which is used to run the configuration.
-		def run(&block)
-			if block_given?
-				@run = block
-			end
-			
-			return @run
-		end
-
-		def run!(configuration)
-			return unless @run
-			
-			local_environment = environment_for_configuration(configuration)
-			
-			if @run
-				@run.call(local_environment)
-			end
-		end
 	end
 end

data/lib/teapot/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Teapot
-	VERSION = "0.9.10"
+	VERSION = "1.0.0-rc1"
 end

data/{lib/teapot/build/targets/application.rb → spec/teapot/build_spec.rb}

@@ -1,4 +1,4 @@
-# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyright, 2014, 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
@@ -18,38 +18,35 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'teapot/build/targets/library'
-require 'teapot/build/targets/directory'
+require 'teapot/build'
+require 'teapot/environment'
 
-module Teapot
-	module Build
-		module Targets
-			class Application < Directory
-				def initialize(parent, name, options = {})
-					super parent
-					
-					@name = name
-					@options = options
-				end
-				
-				def subdirectory
-					"Applications/#{@name}"
-				end
-				
-				def << target
-					if target.respond_to? :subdirectory
-						target.options[:subdirectory] = subdirectory
-					end
-					
-					super
-				end
+module Teapot::BuildSpec
+	class DummyTarget
+		def name
+			"dummy-target"
+		end
+		
+		def build
+			lambda do
+				# This is technically incorrect, because this Top graph node specifies no outputs. But, for testing, it's fine.
+				fs.touch "bob"
 			end
+		end
+	end
+	
+	describe Teapot::Build do
+		let(:environment) {Teapot::Environment.hash(foo: 'bar')}
+		
+		it "should create a simple build graph" do
+			expect(FileUtils::NoWrite).to receive(:touch).with("bob").once
+			expect(FileUtils::Verbose).to receive(:touch).with("bob").once
 			
-			class Directory
-				def add_application(*args, &block)
-					self << Application.target(self, *args, &block)
-				end
+			controller = Teapot::Build::Controller.new do |controller|
+				controller.add_target(DummyTarget.new, environment)
 			end
+			
+			controller.update!
 		end
 	end
 end

data/{test/test_teapot.rb → spec/teapot/context_spec.rb}

@@ -18,25 +18,25 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require "minitest/autorun"
-
 require 'teapot/context'
 
-class TestConfig < MiniTest::Test
-	ROOT = Pathname.new(__FILE__).dirname
+module Teapot::ContextSpec
+	ROOT = Build::Files::Path.new(__dir__)
 	
-	def test_context
-		context = Teapot::Context.new(ROOT)
+	describe Teapot::Context do
+		it "should load teapot.rb file" do
+			context = Teapot::Context.new(ROOT)
 		
-		# There is one configuration:
-		assert_equal 1, context.configurations.count
+			# There is one configuration:
+			expect(context.configurations.count).to be == 1
 		
-		# No targets were defined:
-		assert_equal 0, context.targets.count
+			# No targets were defined:
+			expect(context.targets.count).to be == 0
 		
-		default_configuration = context.configuration
+			default_configuration = context.configuration
 		
-		# 13 defined packages + 1 implicit package.
-		assert_equal 14, default_configuration.packages.count
+			# 13 defined packages + 1 implicit package.
+			expect(default_configuration.packages.count).to be == 14
+		end
 	end
 end