bake 0.1.0 → 0.1.1

data/CHANGELOG

@@ -0,0 +1,16 @@
+= Bake Changelog
+
+== Version 0.1.1
+
+* Created a plugin infrastructure whereby missing constants now result in a search of the plugins/ directory
+* Implemented Addon module which enables adding commands to bakefile contexts via the import method
+* Removed scheme concept in favour of addon plugin classes so all concre Toolset subclasses (e.g. Cpp::Gcc) are now addon plugins
+* Context#macro and Context#glob were moved to addon classes named Macro and System respectively which are plugins that are automatically imported into bakefile contexts
+* Targets no longer found by moving up the target tree, instead all paths are relative to the current project, that is, the project owning the current target
+* Added some content to the CONCEPTS document
+* Introduced Context#using method which is similar to import, except that commands are looked up from addons stored in the :addons property of the current target
+* Removed Cpp::Library#src and Cpp::Executable#src in favor of listing file dependencies in the dep list
+* Added FileTarget class that represents simple file dependencies
+* Created Target#add_dep method that can be overridden to manage individual dependency additions (for example to insert a Cpp::Object between a FileTarget and main Cpp target)
+* Child targets are no longer considered dependencies and so are not built automatically when their parents are built
+

data/CONCEPTS

@@ -1,2 +1,54 @@
 = Concepts
 
+== Bake's Philosophy
+
+Bake is a Ruby based build system similar to Rake[http://rake.rubyforge.org] and Rant[http://rant.rubyforge.org]. Unlike either of these systems, however, there is a logical separation between the the components that are being built and the methods used to build them. This separation is important for large projects having many logical components such as executables and libraries, and also supporting many compilers or platforms.
+
+In the good old days when Make was king, adding another supported platform to a project was usually a traumatic experience. The chief reason for the difficulty was almost always that the declaration of a component and the actions executed to build that component were tightly coupled. So the structure of the project was highly dependent on the content of the actions that build it.
+
+The pitfalls of Make are readily apparent with C++ projects that support Microsoft Visual Studio and GCC. Simple projects are easy enough to accomodate in Make, but as soon as you need to support dynamic libraries and unit test runners and platform dependent build parameters you can quickly find the number of lines in your Make code outpacing the code for your project!
+
+The fundamental reason for this is that your project structure and the actions that build your project are orthogonal concepts. Make forces you to intertwine these two concepts causing your Makefiles to balloon in size. Bake, on the other hand, disentangles the target and toolset concepts and allows you to grow the set of targets and the toolsets that build them independently. This is the primary goal of the Bake project.
+
+Another goal is to provide users with a large set of pre-written toolsets that will perform the actions required to turn your project into built products. Thus, in most cases, the end user simply defines the structure of the their project, indicates which toolsets to use and Bake does the rest.
+
+The end result is that Bake requires a bare minimum of code to provide all the instructions that are needed to build a project. Furthermore, the bulk of the code defines the structure of the project rather than the behaviour of the build tools involved, so the definition files also act as a guide to the project layout, instead of being a distracting maze of complex build actions.
+
+== Targets
+
+In Bake, projects are broken up into components called *targets*. Targets are the basic unit of a project and can represent C libraries, zip files, Java classes or anything else that belongs in a project.
+
+Targets are tree-like. Each target has a single parent target and can have any number of child targets. Every target that belongs in a particular project is connected in a single tree.
+
+=== Products
+
+Every target can have a number of *products*. The products of a target are the concrete set of files that are created during the build process.
+
+=== Dependencies
+
+Targets are related to each other by two relations. The first is the parent-child relation that makes up the tree structure of a project. The other is the *dependency* relation.
+
+Before a particular target is built, there are zero or more dependencies that must be built first. If any of the dependencies fails to build, the target will fail to be built.
+
+Dependencies have two roles for a target. First, partially determine the order in which targets will be built as outlined above. Second, their products are used by dependent target to build its products. For example, an executable target may depend on a the functionality available in a library and thus it must link against that library.
+
+=== Options
+
+=== Requirements
+
+== Bakefiles
+
+=== Commands
+
+=== Projects
+
+== Toolsets
+
+== Features
+
+=== Macros
+
+=== Plugins
+
+=== Addins
+

data/TUTORIAL

@@ -8,7 +8,7 @@ Once you've installed Bake, you should be able to execute it by running the <tt>
 
   # root.bake
   exe 'test' do
-      src 'main.cpp'
+      dep 'main.cpp'
   end
 
 The <tt>exe</tt> command specifies that we'd like to create an executable <b>target</b>. A target is any product that gets created as a result of the build process. There are many kinds of targets, such as <tt>lib</tt>s, or C++ libraries, etc. To make this example a little more concrete, let's also create <i>main.cpp</i>:
@@ -34,7 +34,7 @@ If you run <tt>bake</tt> from the <i>test/</i> directory you should see output r
 Generally, it is a good idea to keep your project definitions separate from which toolset you're using since your choice of toolset is conceptually distinct from your project layout. This is especially true from cross-platform projects. For this reason, in this project we'll keep this information in a separate bakefile called <i>config.bake</i> which will also live in the <i>test/</i> directory:
 
   # config.bake
-  using 'cpp.gcc'
+  using Cpp::Gcc
 
 The <tt>using</tt> directive above tells Bake that when building C++ targets, it should use the <tt>gcc</tt> toolset. If you now run the <tt>bake</tt> command, and as long as your toolset is properly configured, you should get an executable file called <i>test</i> (or <i>test.exe</i> on Windows platforms) in the <i>test/</i> directory.
 
@@ -46,9 +46,7 @@ Unfortunately, the <i>test</i> executable will probably be accompanied by a numb
 
   exe 'test' do
       opt :outdir => 'bin'
-
-      src 'main.cpp'
-
+      dep 'main.cpp'
   end
 
 Note that property names are <b>symbols</b> preceded by a colon (:) whereas, in this case, the property value is a <b>string</b>. Property values can be any of a number of different types such as strings, booleans, numbers, etc.
@@ -57,9 +55,7 @@ Delete all the product files generated by the last build so that your directory
 
   test/
     config.bake
-
     root.bake
-
     main.cpp
 
 Now run Bake again. Note that a new directory called <i>bin/</i> has been created and that all the products of the build have been placed inside. C++ executable targets have a number of other properties that affect different aspects of the build. For example, to turn off multithreading for a single threaded application, you would specify "<tt>opt :multithreaded? => false</tt>". Note that we've used a boolean value type instead of a string. The type is important as a value of <tt>'false'</tt> would result in the opposite behavior we would expect (this is because strings always evaluate to true when examined in a boolean context). For a full list of target properties and their types, see the Reference.
@@ -83,38 +79,31 @@ As a first try at managing this project, let's create a <i>root.bake</i> in the
 
   # root.bake
   lib 'test_lib' do
-      src 'test_lib/source1.cpp', 'test_lib/source2.cpp'
+      dep 'test_lib/source1.cpp', 'test_lib/source2.cpp'
   end
 
   exe 'test_exe' do
-      dep 'test_lib'
-      src 'test_exe/source1.cpp'
+      dep '.:test_lib', 'test_exe/source1.cpp'
   end
 
 Here we have created a <tt>lib</tt> target called <tt>test_lib</tt> containing two source files, and an executable file that depends on the library and another source file. This is pretty simple and will probably seem to work, however, there's an insidious bug waiting to cause trouble when you least expect it. Note that there are two files called <i>source1.cpp</i>. In each case, a C++ object file called <i>source1.o</i> (or <i>source1.obj</i> on Windows) will be created in the <i>test2/</i> directory, the object file from <tt>test_exe</tt> will overwrite the object file from <tt>test_lib</tt>. This will not immediately cause a problem, since the library object file was added to the library before the executable object file was created but it will almost certainly cause problems later on.
 
+Note also the funny way we've referenced the <tt>test_lib</tt> library. Every target reference is composed of two parts: the path to the target's project and the name of the target, separated by a colon. Since the <tt>test_lib</tt> library is in the same directory as the executable the path part of the reference is simply a '.'.
+
 === More About Properties
 
-The easiest way to avoid conflicts like these is to set the <tt>:outdir</tt> property differently on each target so that the object files will live in different directories. To do this, however, we're going to take a shortcut and only set the output directory once:
+The easiest way to avoid conflicts where output files overwrite eachother is to set the <tt>:outdir</tt> property differently on each target so that the object files will live in different directories. To do this, however, we're going to take a shortcut and only set the output directory once:
 
   # root.bake
   opt :outdir => 'bin/${name}'
-
-
   lib 'test_lib' do
-
-      src 'test_lib/source1.cpp', 'test_lib/source2.cpp'
-
+      opt :name => 'test_lib'
+      dep 'test_lib/source1.cpp', 'test_lib/source2.cpp'
   end
 
-
-
   exe 'test_exe' do
-
-      dep 'test_lib'
-
-      src 'test_exe/source1.cpp'
-
+      opt :name => 'test_exe'
+      dep '.:test_lib', 'test_exe/source1.cpp'
   end
 
 If you run Bake now, the outputs from <tt>test_lib</tt> will end up in <i>test2/bin/test_lib/</i> and the outputs from <tt>test_exe</tt> will end up in <i>test2/bin/test_exe</i>. If you're confused, don't worry, we've taken two steps forward here. Not only is the value of the <tt>:outdir</tt> property not explicitly set on either target, but it's out in no-man's land, what gives? Furthermore, what's up with the <tt>${projname}</tt> business?

data/lib/bake.rb

@@ -1,6 +1,7 @@
-require 'bake/scheme_loader'
 require 'bake/context'
 require 'bake/project_loader'
+require 'bake/string_utils'
+require 'bake/plugin'
 require 'bake_version'
 require 'optparse'
 
@@ -21,8 +22,8 @@ module Bake
         def initialize
             raise "App instance already created" if @@instance
             @@instance = self
-            @scheme_loader = SchemeLoader.new
-            @context = Context.new(@scheme_loader)
+            @context = Context.new
+            @context.import(Plugins::System, Plugins::Macro)
         end
 
         def run(*args)
@@ -42,41 +43,13 @@ module Bake
 
             method = options[:clean] ? :clean : :build
             if targets.empty?
-                send(method, @project_loader.invok_project)
+                @project_loader.invok_project.send(method)
             else
-                targets.each { |target| send(method, target) }
+                targets.each { |target| target.send(method) }
             end
         end
 
     private
-        def build(target)
-            return if target[:built?]
-            target.deps.each { |dep| build(dep) }
-            target.children.each { |child| build(child) }
-            toolset = toolset(target)
-            Dir.chdir(target[:cwdir]) do
-                toolset.build(target) if toolset
-            end
-            target.opt :built? => true
-        end
-
-        def clean(target)
-            target.children.each do |child|
-                clean(child)
-            end
-            toolset = toolset(target)
-            toolset.clean(target) if toolset
-        end
-
-        def toolset(target)
-            if !target.class.const_defined?(:SCHEME)
-                raise "no toolset for target '#{target.class.name}'"
-            end
-            scheme = target.class.const_get(:SCHEME)
-            return scheme.toolset if scheme
-            return nil
-        end
-
         def determine_platform
             if RUBY_PLATFORM =~ /darwin/i
                 return 'osx'
@@ -134,7 +107,7 @@ def parse_backtrace(backtrace)
     if backtrace.find { |entry| entry =~ /^.*?(config|root|sub)\.bake:\d+/ }
         return $&
     end
-    return 'internal error'
+    return backtrace.join("\n")
 end
 
 exit_code = 1

data/lib/bake/addon.rb

@@ -0,0 +1,20 @@
+module Bake
+    module Addon
+        def command(name, method = nil, &block)
+            if !block
+                method ||= name
+                addon = self
+                block = Proc.new do |*args|
+                    block = args.last.is_a?(Proc) ? args.pop : nil
+                    addon.send(method, self, *args, &block)
+                end
+            end
+            commands[name] = block
+        end
+
+        def commands
+            return @commands ||= { }
+        end
+    end
+end
+

data/lib/bake/context.rb

@@ -1,10 +1,33 @@
 require 'bake/string_utils.rb'
+require 'bake/addon.rb'
 
 module Bake
     class Context
-        def initialize(scheme_loader)
-            @scheme_loader = scheme_loader
+        attr_reader :current
+
+        def initialize
             @current = nil
+            @commands = { }
+        end
+
+        def import(*addon_classes)
+            addon_classes.each do |addon_class|
+                addon = addon_class.new
+                addon.commands.each_pair do |name, block|
+                    register(name, &block)
+                end
+            end
+        end
+
+        def using(*addon_classes)
+            addon_classes.each do |addon_class|
+                addon = addon_class.new
+                @current.opt(:addons => addon_class.new)
+            end
+        end
+
+        def register(name, &block)
+            @commands[name] = block
         end
 
         def context_eval(target, str = nil, file = nil, &block)
@@ -21,78 +44,35 @@ module Bake
             end
         end
 
-        def using(scheme_and_toolset)
-            scheme_name, toolset_name = scheme_and_toolset.to_s.split('.')
-            toolset_name = 'default' if !toolset_name
-            scheme = @scheme_loader.scheme(scheme_name)
-            raise "invalid scheme '#{scheme_name}'" if !scheme
-            scheme.toolset = toolset_name
-        end
-
-        def glob(*args)
-            has_options = args.last.respond_to?(:to_hash)
-            options = has_options ? args.pop.to_hash : {}
-            exclude = array_opt(options, :exclude)
-            files = []
-            args.each do |pat|
-                matches = Dir[pat]
-                matches.each do |file|
-                    if !exclude.find { |exc| File.fnmatch(exc, file) }
-                        files.push(file) 
-                    end
+        def method_missing(name, *args, &block)
+            command = @commands[name]
+            return call(command, *args, &block) if command
+            if @current
+                if @current.respond_to?(name)
+                    return @current.send(name, *args, &block)
                 end
-            end
-            if block_given?
-                for i in 0...files.size
-                    yield(files[i])
+                @current.get(:addons).each do |addon|
+                    command = addon.commands[name]
+                    return call(command, *args, &block) if command
                 end
             end
-            return files
-        end
-
-        def macro(name, &block)
-            raise "no block given for macro '#{name}'" if !block
-            @current.opt(:macros => { :name => name, :block => block })
-        end
-
-        def method_missing(method, *args, &block)
-            @scheme_loader.schemes.each do |name, scheme|
-                if scheme.has_constructor?(method)
-                    target = scheme.construct(method, @current, *args)
-                    context_eval(target, &block) if block
-                    return target
-                end
-            end
-            return object_method_missing(method, *args, &block) if !@current
-            macro = @current[:macros].find { |macro| macro[:name] == method }
-            if macro
-                return instance_exec(*args, &macro[:block])
-            end
-            if @current.respond_to?(method)
-                return @current.send(method, *args, &block)
-            end
-            raise "undefined symbol '#{method}'"
+            raise "unknown command '#{name}'"
         end
 
     private
-        def array_opt(options, name)
-            opt = options[name]
-            return [] if !opt
-            if opt.respond_to?(:to_ary)
-                opt = opt.to_ary
-            else
-                opt = [ opt ]
-            end
+        def call(command, *args, &block)
+            args << block if block
+            return instance_exec(*args, &command)
         end
 
         # took this implementation from http://tinyurl.com/gzrtn
         def instance_exec(*args, &block)
             mname = "__instance_exec_#{Thread.current.object_id.abs}"
-            class << self; self end.class_eval{ define_method(mname, &block) }
+            class << self; self end.class_eval { define_method(mname, &block) }
             begin
                 ret = send(mname, *args)
             ensure
-                class << self; self end.class_eval{ undef_method(mname) } rescue nil
+                class << self; self end.class_eval { undef_method(mname) } rescue nil
             end
             ret
         end

data/lib/bake/file_target.rb

@@ -0,0 +1,14 @@
+require 'bake/target'
+
+module Bake
+    class FileTarget < Target
+        attr_reader :path
+
+        def initialize(parent, path)
+            super(parent, nil)
+            @path = path
+            @built = true
+        end
+    end
+end
+

data/lib/bake/plugin.rb

@@ -0,0 +1,72 @@
+require 'bake/string_utils'
+
+class Object
+    def self.const_missing(name)
+        return Bake::Plugins.const_get(name)
+    end
+end
+
+module Bake
+    class PluginManager
+        @@plugins = { }
+        @@search_dirs = [ File.join(File.dirname(__FILE__), '..') ]
+
+        def self.search_dirs
+            return @@search_dirs
+        end
+
+        def self.plugins
+            return @@plugins
+        end
+
+        def self.load_plugin(full_name)
+            parent = Plugins
+            plugin = nil
+            full_name.to_s.split('::').each do |name|
+                plugin = load_child_plugin(parent, name)
+            end
+            return plugin
+        end
+
+        def self.load_child_plugin(parent, name)
+            name = name.to_s
+            full_name = parent.name + '::' + name
+            plugin_file = full_name.underscore.gsub('::', '/')
+
+            plugin = nil
+            if parent.const_defined?(name)
+                plugin = parent.const_get(name)
+            end
+
+            @@search_dirs.each do |rootdir|
+                if File.exists?(File.join(rootdir, plugin_file + '.rb'))
+                    require plugin_file
+                    if !plugin && parent.const_defined?(name)
+                        plugin = parent.const_get(name)
+                    end
+                end
+
+                if File.directory?(File.join(rootdir, plugin_file))
+                    if !plugin
+                        plugin = Module.new
+                        parent.const_set(name, plugin)
+                    end
+                    def plugin.const_missing(name)
+                        return PluginManager.load_child_plugin(self, name)
+                    end
+                end
+            end
+
+            raise "could not find plugin '#{name}'" if !plugin
+            @@plugins[full_name] = plugin
+            return plugin
+        end
+    end
+
+    module Plugins
+        def self.const_missing(name)
+            return PluginManager.load_plugin(name)
+        end
+    end
+end
+