bake 0.1.0 → 0.1.1

data/lib/bake_version.rb

@@ -1,5 +1,5 @@
 module Bake
-    VERSION = [ 0, 1, 0 ]
+    VERSION = [ 0, 1, 1 ]
     VERSION_STRING = VERSION.join('.')
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: bake
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-04-19 00:00:00 -04:00
+  version: 0.1.1
+date: 2007-05-02 00:00:00 -04:00
 summary: Project-based build utility
 require_paths: 
 - lib
@@ -32,17 +32,27 @@ files:
 - lib/bake
 - lib/bake.rb
 - lib/bake_version.rb
-- lib/bake/common_scheme.rb
+- lib/bake/addon.rb
 - lib/bake/configuration.rb
 - lib/bake/context.rb
-- lib/bake/cpp_scheme.rb
+- lib/bake/file_target.rb
+- lib/bake/plugin.rb
+- lib/bake/plugins
+- lib/bake/project.rb
 - lib/bake/project_loader.rb
-- lib/bake/qt_scheme.rb
-- lib/bake/scheme.rb
-- lib/bake/scheme_loader.rb
 - lib/bake/string_utils.rb
 - lib/bake/target.rb
 - lib/bake/toolset.rb
+- lib/bake/plugins/cpp
+- lib/bake/plugins/cpp.rb
+- lib/bake/plugins/macro.rb
+- lib/bake/plugins/system.rb
+- lib/bake/plugins/cpp/darwin.rb
+- lib/bake/plugins/cpp/gcc.rb
+- lib/bake/plugins/cpp/gcc_toolset_base.rb
+- lib/bake/plugins/cpp/msvc.rb
+- lib/bake/plugins/cpp/qt.rb
+- lib/bake/plugins/cpp/toolset_base.rb
 - test/bake_test.rb
 - test/configuration_test.rb
 - test/context_test.rb
@@ -53,6 +63,7 @@ files:
 - TUTORIAL
 - CONCEPTS
 - REFERENCE
+- CHANGELOG
 test_files: []
 
 rdoc_options: 
@@ -66,6 +77,7 @@ extra_rdoc_files:
 - TUTORIAL
 - CONCEPTS
 - REFERENCE
+- CHANGELOG
 executables: 
 - bake
 extensions: []

data/lib/bake/common_scheme.rb

@@ -1,42 +0,0 @@
-require 'bake/toolset'
-require 'bake/target'
-
-module Common
-    class Default < Bake::Toolset
-        def build(target)
-            if target.is_a?(Directory)
-                make_dir(target)
-            elsif target.is_a?(FileClone)
-                copy(target)
-            else
-                raise "unrecognized target of class '#{target.class}'"
-            end
-        end
-
-        def clean(target)
-        end
-
-    private
-        def make_dir(target)
-            puts "building directory '#{target.name}'"
-        end
-
-        def copy(target)
-            puts "building copy '#{target.name}'"
-        end
-    end
-
-    class Directory < Bake::Target
-        ACCESSORS = :dir
-
-        def initialize(name, parent)
-            super(parent)
-            @name = name
-        end
-    end
-
-    class FileClone < Bake::Target
-        ACCESSORS = [ :copy, :clone ]
-    end
-end
-

data/lib/bake/cpp_scheme.rb

@@ -1,460 +0,0 @@
-require 'bake/toolset'
-require 'bake/target'
-require 'fileutils'
-require 'set'
-
-class CppToolsetBase < Bake::Toolset
-    def build(target)
-        if stale?(target)
-            FileUtils.mkdir_p(target[:outdir])
-            if target.is_a?(Cpp::Object)
-                compile(target)
-                # refresh the .includes file
-                includes = target.includes
-                filename = "#{target[:outdir]}/#{target.src.basename}.includes"
-                File.open(filename, "w") do |file|
-                    includes.each { |inc| file.puts(inc) }
-                end
-            elsif target.is_a?(Cpp::Library)
-                ar(target)
-            elsif target.is_a?(Cpp::Executable)
-                link(target)
-            elsif target.is_a?(Cpp::Runner)
-                run(target)
-            else
-                raise "unknown Cpp target of class '#{target.class}"
-            end
-        end
-    end
-    
-    def stale?(target)
-        t = Time.now
-        output_files(target).each do |out|
-            return true if !File.exists?(out)
-            out_time = File.mtime(out)
-            t = out_time if out_time < t
-        end
-        if target.is_a?(Cpp::Object)
-            return true if File.mtime(target.src) > t
-            target.includes.each { |file| return true if File.mtime(file) > t }
-        elsif target.is_a?(Cpp::Runner)
-            return File.mtime(output_files(target.deps[0])[0]) > t
-        else
-            is_linked = target.is_a?(Cpp::Executable) ||
-                (target.is_a?(Cpp::Library) && target[:libtype] == 'dynamic')
-            target.children.each do |child|
-                output_files(child).each do |file|
-                    return true if File.mtime(file) > t
-                end
-            end
-            target.deps.each do |dep|
-                if is_linked && dep.is_a?(Cpp::Library) &&
-                    dep[:libtype] != 'dynamic'
-                    output_files(dep).each do |file|
-                        return true if File.mtime(file) > t
-                    end
-                end
-            end
-        end
-        return false
-    end
-    
-    def clean(target)
-        output_files(target).each { |file| FileUtils.rm_f(file) }
-        if target.is_a?(Cpp::Object)
-            filename = "#{target[:outdir]}/#{target.src.basename}.includes"
-            FileUtils.rm_f(filename)
-        end
-    end
-    
-    def output_files(target)
-        out = output(target)
-        return [] if !out
-        return out.to_a if out.respond_to?(:to_a)
-        return [ out ]
-    end
-end
-
-class GccToolsetBase < CppToolsetBase
-    def output(target)
-        if target.is_a?(Cpp::Object)
-            return obj_fn(target)
-        elsif target.is_a?(Cpp::Library)
-            return lib_fn(target)
-        elsif target.is_a?(Cpp::Executable)
-            return exe_fn(target)
-        elsif target.is_a?(Cpp::Runner)
-            return runner_fn(target)
-        end
-        return nil
-    end
-    
-    def compile(obj)
-        src = obj.src
-        output = obj_fn(obj)
-        flags = build_flags('-I', obj[:incdirs] + obj[:sysincdirs]) +
-            build_flags('-D', obj[:defines])
-        flags += obj[:cflags].join(' ')
-        flags += ' -fno-rtti' if !obj[:rtti?]
-        flags += ' -O3' if obj[:optimizations?]
-        flags += ' -g' if obj[:debug_symbols?]
-        sh("g++ -c -o #{output} #{flags} #{src}")
-    end
-    
-    def ar(lib)
-        obj_str, lib_str, flags = process_inputs(lib)
-        
-        output = lib_fn(lib)
-        if lib[:libtype] == 'dynamic'
-            sh("g++ #{flags} -shared -Wl,-soname,#{output} -o #{output} #{obj_str} #{lib_str}")
-        else
-            sh("ar rcs #{output} #{obj_str}")
-        end
-    end
-    
-    def link(exe)
-        obj_str, lib_str, flags = process_inputs(exe)
-        
-        output = exe_fn(exe)
-        sh("g++ #{flags} -o #{output} #{obj_str} #{lib_str}")
-    end
-
-    def run(runner)
-        sh(exe_fn(runner.deps.first))
-        FileUtils.touch(runner_fn(runner))
-    end
-    
-private
-    def build_flags(flag, args)
-        return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
-    end
-    
-    def obj_fn(obj)
-        src = obj.src
-        basename = File.basename(src, File.extname(src)) + '.o'
-        return File.join(obj[:outdir], basename)
-    end
-    
-    def lib_fn(lib)
-        if lib[:libtype] == 'dynamic'
-            return File.join(lib[:outdir], "#{lib.name}.so")
-        end
-        return File.join(lib[:outdir], "lib#{lib.name}.a")
-    end
-    
-    def exe_fn(exe)
-        return File.join(exe[:outdir], exe.name)
-    end
-
-    def runner_fn(runner)
-        return "#{exe_fn(runner.deps.first)}.success"
-    end
-    
-    def process_inputs(target)
-        output = output(target)
-        obj_str = ''
-        lib_str = ''
-        libdirs = []
-        (target.children + target.deps).each do |input|
-            if input.is_a?(Cpp::Object)
-                fn = obj_fn(input)
-                obj_str += fn + ' '
-            elsif input.is_a?(Cpp::SystemLibrary)
-                lib_str += '-l' + input.file + ' '
-            elsif input.is_a?(Cpp::Library)
-                fn = lib_fn(input)
-                if input[:libtype] == 'dynamic'
-                    obj_str += fn + ' '
-                else
-                    lib_str += '-l' + input.name + ' '
-                    libdir = File.dirname(fn)
-                    libdirs << libdir if !libdirs.include?(libdir)
-                end
-            end
-        end
-        
-        libdirs.concat(target[:libdirs])
-        flags = build_flags('-L', libdirs)
-        
-        return [ obj_str, lib_str, flags ]
-    end
-end
-
-module Cpp
-    class Darwin < GccToolsetBase
-        def ar(lib)
-            obj_str, lib_str, flags = process_inputs(lib)
-            
-            output = lib_fn(lib)
-            if lib[:libtype] == 'dynamic'
-                sh("g++ #{flags} -dynamiclib -o #{output} #{obj_str} #{lib_str}")
-            else
-                sh("ar rcs #{output} #{obj_str}")
-            end
-        end
-        
-    private
-        def lib_fn(lib)
-            if lib[:libtype] == 'dynamic'
-                return File.join(lib[:outdir], "#{lib.name}.dylib")
-            end
-            return File.join(lib[:outdir], "lib#{lib.name}.a")
-        end
-    end
-
-    class Gcc < GccToolsetBase
-    end
-
-    class Msvc6 < CppToolsetBase
-        def output(target)
-            if target.is_a?(Object)
-                return obj_fn(target)
-            elsif target.is_a?(Library)
-                return lib_fn(target)
-            elsif target.is_a?(Executable)
-                return exe_fn(target)
-            end
-            return nil
-        end
-        
-        def compile(obj)
-            src = obj.src
-            output = obj_fn(obj)
-            flags = build_flags('/I', obj[:incdirs] + obj[:sysincdirs]) +
-                build_flags('/D', obj[:defines])
-            flags += obj[:cflags].join(' ')
-            flags += ' /MD'
-            flags += ' /EHsc' if obj[:exceptions?]
-            flags += ' /GR' if obj[:rtti?]
-            flags += obj[:optimizations?] ? ' /O2' : ' /Od'
-            flags += ' /Z7' if obj[:debug_symbols?]
-            sh("cl /nologo #{flags} /c /Fo#{output} /Tp#{src}")
-        end
-        
-        def ar(lib)
-            obj_str, flags = process_inputs(lib)
-            
-            output = lib_fn(lib)
-            if lib[:libtype] == 'dynamic'
-                flags += ' /debug' if lib[:debug_symbols?]
-                sh("link /nologo /dll #{flags} /out:#{output[1]} #{obj_str}")
-            else
-                sh("lib /nologo /out:#{output} #{obj_str}")
-            end
-        end
-        
-        def link(exe)
-            obj_str, flags = process_inputs(exe)
-            
-            output = exe_fn(exe)
-            flags += ' /debug' if exe[:debug_symbols?]
-            sh("link /nologo /subsystem:console #{flags} /out:#{output} #{obj_str}")
-        end
-        
-        def run(runner)
-            sh(exe_fn(runner.deps.first))
-            FileUtils.touch(runner_fn(runner))
-        end
-        
-    private
-        def build_flags(flag, args)
-            return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
-        end
-        
-        def obj_fn(obj)
-            src = obj.src
-            basename = File.basename(src, File.extname(src)) + '.obj'
-            return File.join(obj[:outdir], basename)
-        end
-        
-        def lib_fn(lib)
-            if lib[:libtype] == 'dynamic'
-                return [File.join(lib[:outdir], "#{lib.name}.lib"),
-                    File.join(lib[:outdir], "#{lib.name}.dll"),
-                    File.join(lib[:outdir], "#{lib.name}.exp")]
-            end
-            return File.join(lib[:outdir], "#{lib.name}.lib")
-        end
-        
-        def exe_fn(exe)
-            return File.join(exe[:outdir], exe.name + '.exe')
-        end
-        
-        def runner_fn(runner)
-            return "#{exe_fn(runner.deps.first)}.success"
-        end
-        
-        def process_inputs(target)
-            output = output(target)
-            obj_str = ''
-            libdirs = []
-            static_lib = target.is_a?(Library) && target[:libtype] == 'static'
-            (target.children + target.deps).each do |input|
-                if input.is_a?(Object)
-                    fn = obj_fn(input)
-                    obj_str += fn + ' '
-                elsif input.is_a?(SystemLibrary)
-                    if !static_lib
-                        obj_str += input.file + '.lib '
-                    end
-                elsif input.is_a?(Library)
-                    if !static_lib
-                        if input[:libtype] == 'dynamic'
-                            fn = lib_fn(input)[0]
-                        else
-                            fn = lib_fn(input)
-                        end
-                        libdir = File.dirname(fn)
-                        libdirs << libdir if !libdirs.include?(libdir)
-                        obj_str += File.basename(fn) + ' '
-                    end
-                end
-            end
-            
-            if !static_lib
-                target[:libs].each { |lib| obj_str += lib + '.lib ' }
-            end
-            libdirs.concat(target[:libdirs])
-            flags = build_flags('/LIBPATH:', libdirs)
-            
-            return [ obj_str, flags ]
-        end
-    end
-
-    class Library < Bake::Target
-        ACCESSORS = :lib
-
-        def initialize(parent, name)
-            super(parent)
-            @name = name
-            default(:libtype => 'static')
-            default(:debug_symbols? => false)
-        end
-
-        def src(*args)
-            return args.flatten.collect { |file| Cpp::Object.new(self, file) }
-        end
-    end
-
-    class SystemLibrary < Bake::Target
-        ACCESSORS = :syslib
-
-        attr_reader :file
-
-        def initialize(parent, name, file)
-            super(parent)
-            @name = name
-            @file = file
-            opt(:built? => true)
-        end
-    end
-
-    class Executable < Bake::Target
-        ACCESSORS = :exe
-
-        def initialize(parent, name)
-            super(parent)
-            @name = name
-            default(:debug_symbols? => false)
-        end
-
-        def src(*args)
-            return args.flatten.collect { |file| Cpp::Object.new(self, file) }
-        end
-    end
-
-    class Source < Bake::Target
-        attr_reader :output
-
-        def initialize(parent, src)
-            super(parent)
-            @output = src
-            opt(:built? => true)
-        end
-    end
-
-    class Object < Bake::Target
-        ACCESSORS = :obj
-
-        def initialize(parent, src = nil)
-            super(parent)
-            return if !src
-            if src.instance_of?(String)
-                children << Source.new(self, src)
-            else
-                children << src
-            end
-            default(:exceptions? => true)
-            default(:rtti? => true)
-            default(:optimizations? => false)
-            default(:multithreaded? => true)
-        end
-
-        def src
-            return children.first.output
-        end
-
-        def includes(recalc = false)
-            incfile = "#{get(:outdir)}/#{src}.includes"
-            if !@includes || recalc
-                if File.exists?(incfile)
-                    @includes = load_includes(incfile)
-                else
-                    @includes = calc_includes(src, Set.new)
-                end
-            end
-            return @includes
-        end
-
-    private
-        def load_includes(incfile)
-            includes = Set.new
-            file = File.open(incfile)
-            while line = file.gets
-                line.chomp!
-                includes << line if !line.empty?
-            end
-            file.close
-            return includes
-        end
-
-        def calc_includes(filename, include_fns)
-            new_include_fns = Set.new
-            File.open(filename) do |file|
-                incdirs = get(:incdirs)
-                while line = file.gets
-                    if line =~ /\s*#\s*include\s+("|<)([^"]+)("|>)/
-                        inc = $2
-                        incdirs.each do |include_dir|
-                            fn = File.join(include_dir, inc)
-                            break if include_fns.include?(fn)
-                            if File.exists?(fn)
-                                new_include_fns << fn
-                                include_fns << fn
-                                break
-                            end
-                        end
-                    end
-                end
-            end
-            
-            new_include_fns.each do |inc|
-                calc_includes(inc, include_fns)
-            end
-            return include_fns
-        end
-    end
-
-    class Runner < Bake::Target
-        ACCESSORS = :run
-
-        def initialize(parent, exe)
-            super(parent)
-            target = dep(exe)[0]
-            if !target.is_a?(Executable)
-                raise "target '#{target.name}' is not an executable"
-            end
-        end
-    end
-end
-