bake 0.1.1 → 0.1.2

data/lib/bake/plugin.rb

@@ -1,44 +1,26 @@
-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
+    module PluginManager
+        def load_plugin(full_name)
+            plugin = Object.main_object.class
             full_name.to_s.split('::').each do |name|
-                plugin = load_child_plugin(parent, name)
+                plugin = load_child_plugin(plugin, name)
             end
             return plugin
         end
 
-        def self.load_child_plugin(parent, name)
+        def load_child_plugin(parent, name)
             name = name.to_s
-            full_name = parent.name + '::' + name
+            full_name = parent.equal?(Object.main_object.class) ?
+                name : parent.name + '::' + name
             plugin_file = full_name.underscore.gsub('::', '/')
 
             plugin = nil
             if parent.const_defined?(name)
                 plugin = parent.const_get(name)
+                return plugin if plugin.equal?(Bake)
             end
 
-            @@search_dirs.each do |rootdir|
+            search_dirs.each do |rootdir|
                 if File.exists?(File.join(rootdir, plugin_file + '.rb'))
                     require plugin_file
                     if !plugin && parent.const_defined?(name)
@@ -51,22 +33,17 @@ module Bake
                         plugin = Module.new
                         parent.const_set(name, plugin)
                     end
-                    def plugin.const_missing(name)
-                        return PluginManager.load_child_plugin(self, name)
+                    plugin_manager = self
+                    plugin.metaclass.send(
+                        :define_method, :const_missing) do |name|
+                        return plugin_manager.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
 

data/lib/bake/plugins/cpp.rb

@@ -6,72 +6,129 @@ module Bake
             class SystemLibrary < Target
                 attr_reader :file
 
-                def initialize(parent, toolset, name, file)
-                    super(parent, toolset)
+                def post_initialize(name, file)
                     @built = true
                     @name = name
                     @file = file
-                    opt(:built? => true)
+                end
+
+                def products
+                    return nil
+                end
+
+                def mtimes
+                    return [ Time.at(0) ]
+                end
+            end
+            
+            # +MainTarget+ is a mix-in for the +Library+ and +Executable+
+            # classes containing code common to both types of targets.
+            module MainTarget
+                # A special override of +stale?+ that ignores changes to
+                # dlls when determining if this target is stale. The only
+                # case in which a lib or exe should have to update when a
+                # dll dependency is updated is when the interface changes.
+                # Since exes and libs depend on the headers implicitly,
+                # they will be updated if the interface changes
+                # automatically.
+                def stale?
+                    return @stale if !@stale.nil?
+                    tmin = mtimes.min
+                    @stale = deps.any? do |dep|
+                        is_dll = dep.is_a?(Library) &&
+                            dep[:libtype] == 'dynamic'
+                        (dep.stale? || dep.mtimes.max > tmin) && !is_dll
+                    end
+                    return @stale
+                end
+                
+                def add_dep(target)
+                    if target.is_a?(FileTarget)
+                        target = Source.new(self, toolset, target)
+                    end
+                    return super if !target.is_a?(Source)
+                    deps << Cpp::Object.new(self, toolset, target)
+                end
+
+                def build
+                    toolset.build(self)
                 end
             end
 
             class Library < Target
-                def initialize(parent, toolset, name)
-                    super(parent, toolset)
+                include MainTarget
+                
+                def post_initialize(name)
                     @name = name
                     default(:libtype => 'static')
                     default(:debug_symbols? => false)
                 end
-
-                def add_dep(target)
-                    return super if !target.is_a?(FileTarget)
-                    deps << Cpp::Object.new(self, toolset, target)
-                end
             end
 
             class Executable < Target
-                def initialize(parent, toolset, name)
-                    super(parent, toolset)
+                include MainTarget
+                
+                def post_initialize(name)
                     @name = name
                     default(:debug_symbols? => false)
                 end
 
-                def add_dep(target)
-                    return super if !target.is_a?(FileTarget)
-                    deps << Cpp::Object.new(self, toolset, target)
+                # Enables +Executable+ to be run via a +Runner+ target.
+                def run_command
+                    return toolset.exe_fn(self)
                 end
             end
 
-            class Object < Target
-                def initialize(parent, toolset, file_target)
-                    super(parent, toolset)
-                    deps << file_target
-                    default(:exceptions? => true)
-                    default(:rtti? => true)
-                    default(:optimizations? => false)
-                    default(:multithreaded? => true)
+            class Source < Target
+                def post_initialize(source)
+                    @source = source
+                    @includes = IncludeList.new(self, toolset, source)
+                    dep(source, @includes)
                 end
 
-                def src
-                    return deps.first.path
+                def path
+                    return @source.path
                 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
+                alias :id :path
+
+                def mtimes
+                    return @includes.mtimes
+                end
+            end
+
+            class IncludeList < Target
+                attr_reader :includes
+
+                def post_initialize(source)
+                    @src = source.path
+                    if File.exists?(products)
+                        @includes = load_includes
+                        @calculated = false
+                    else
+                        @includes = calc_includes(@src)
+                        @calculated = true
                     end
-                    return @includes
+                    dep(source, *@includes)
+                end
+                
+                def id
+                    return @src
+                end
+
+                def build
+                    @includes = calc_includes(@src) if !@calculated
+                    toolset.sys.fwrite(products, includes.to_a.join("\n"))
+                end
+
+                def products
+                    return "#{get(:outdir)}/#{@src.basename}.includes"
                 end
 
             private
-                def load_includes(incfile)
+                def load_includes
                     includes = Set.new
-                    file = File.open(incfile)
+                    file = File.open(products)
                     while line = file.gets
                         line.chomp!
                         includes << line if !line.empty?
@@ -80,9 +137,9 @@ module Bake
                     return includes
                 end
 
-                def calc_includes(filename, include_fns)
+                def calc_includes(src, include_fns = Set.new)
                     new_include_fns = Set.new
-                    File.open(filename) do |file|
+                    File.open(src) do |file|
                         incdirs = get(:incdirs)
                         while line = file.gets
                             if line =~ /\s*#\s*include\s+("|<)([^"]+)("|>)/
@@ -107,13 +164,22 @@ module Bake
                 end
             end
 
-            class Runner < Target
-                def initialize(parent, toolset, exe)
-                    super(parent, toolset)
-                    target = dep(exe)[0]
-                    if !target.is_a?(Executable)
-                        raise "target '#{target}' is not an executable"
-                    end
+            class Object < Target
+                attr_reader :src
+                
+                alias :id :src
+
+                def post_initialize(source)
+                    @src = source.path
+                    dep(source)
+                    default(:exceptions? => true)
+                    default(:rtti? => true)
+                    default(:optimizations? => false)
+                    default(:multithreaded? => true)
+                end
+                
+                def build
+                    toolset.build(self)
                 end
             end
         end

data/lib/bake/plugins/cpp/darwin.rb

@@ -7,16 +7,15 @@ module Bake
                     
                     output = lib_fn(lib)
                     if lib[:libtype] == 'dynamic'
-                        sh("g++ #{flags} -dynamiclib -o #{output} #{obj_str} #{lib_str}")
+                        sys.sh("g++ #{flags} -dynamiclib -o #{output} #{obj_str} #{lib_str}")
                     else
-                        sh("ar rcs #{output} #{obj_str}")
+                        sys.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")
+                        return File.join(lib[:outdir], "lib#{lib.name}.dylib")
                     end
                     return File.join(lib[:outdir], "lib#{lib.name}.a")
                 end

data/lib/bake/plugins/cpp/gcc.rb

@@ -2,6 +2,11 @@ module Bake
     module Plugins
         module Cpp
             class Gcc < GccToolsetBase
+                module Library
+                    def post_initialize
+                        opt(:cflags => '-fPIC') if get(:libtype) == 'dynamic'
+                    end
+                end
             end
         end
     end

data/lib/bake/plugins/cpp/gcc_toolset_base.rb

@@ -11,8 +11,6 @@ module Bake
                         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
@@ -26,7 +24,7 @@ module Bake
                     flags += ' -fno-rtti' if !obj[:rtti?]
                     flags += ' -O3' if obj[:optimizations?]
                     flags += ' -g' if obj[:debug_symbols?]
-                    sh("g++ -c -o #{output} #{flags} #{src}")
+                    sys.sh("g++ -c -o #{output} #{flags} #{src}")
                 end
                 
                 def ar(lib)
@@ -34,13 +32,13 @@ module Bake
                     
                     output = lib_fn(lib)
                     if lib[:libtype] == 'dynamic'
-                        sh("g++ #{flags} -shared -Wl,-soname,#{output} -o #{output} #{obj_str} #{lib_str}")
+                        sys.sh("g++ #{flags} -shared -Wl,-soname,#{output} -o #{output} #{obj_str} #{lib_str}")
                         if lib.has_prop?(:gcc_lib_path)
                             fn = File.join(lib[:gcc_lib_path], output.basename)
                             File.symlink(output, fn) if !File.exists?(fn)
                         end
                     else
-                        sh("ar rcs #{output} #{obj_str}")
+                        sys.sh("ar rcs #{output} #{obj_str}")
                     end
                 end
                 
@@ -48,17 +46,7 @@ module Bake
                     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} " }
+                    sys.sh("g++ #{flags} -o #{output} #{obj_str} #{lib_str}")
                 end
                 
                 def obj_fn(obj)
@@ -78,16 +66,16 @@ module Bake
                     return File.join(exe[:outdir], exe.name)
                 end
 
-                def runner_fn(runner)
-                    return "#{exe_fn(runner.deps.first)}.success"
+            private
+                def build_flags(flag, args)
+                    return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
                 end
-
+                
                 def process_inputs(target)
                     output = output(target)
                     obj_str = ''
                     lib_str = ''
                     libdirs = []
-                    rtdirs = []
                     target.deps.each do |input|
                         if input.is_a?(Cpp::Object)
                             fn = obj_fn(input)
@@ -96,14 +84,9 @@ module Bake
                             lib_str += '-l' + input.file + ' '
                         elsif input.is_a?(Cpp::Library)
                             fn = lib_fn(input)
-                            if input[:libtype] == 'dynamic'
-                                obj_str += fn + ' '
-                                rtdirs << File.dirname(fn)
-                            else
-                                lib_str += '-l' + input.name + ' '
-                                libdir = File.dirname(fn)
-                                libdirs << libdir if !libdirs.include?(libdir)
-                            end
+                            lib_str += '-l' + input.name + ' '
+                            libdir = File.dirname(fn)
+                            libdirs << libdir if !libdirs.include?(libdir)
                         end
                     end
                     

data/lib/bake/plugins/cpp/msvc.rb

@@ -26,7 +26,7 @@ module Bake
                     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}")
+                    sys.sh("cl /nologo #{flags} /c /Fo#{output} /Tp#{src}")
                 end
                 
                 def ar(lib)
@@ -35,9 +35,12 @@ module Bake
                     output = lib_fn(lib)
                     if lib[:libtype] == 'dynamic'
                         flags += ' /debug' if lib[:debug_symbols?]
-                        sh("link /nologo /dll #{flags} /out:#{output[1]} #{obj_str}")
+                        sys.sh("link /nologo /dll #{flags} /out:#{output[1]} #{obj_str}")
+                        # need to touch the .exp file because it sometimes
+                        # doesn't get updated
+                        sys.touch(output[2])
                     else
-                        sh("lib /nologo /out:#{output} #{obj_str}")
+                        sys.sh("lib /nologo /out:#{output} #{obj_str}")
                     end
                 end
                 
@@ -46,17 +49,7 @@ module Bake
                     
                     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} " }
+                    sys.sh("link /nologo /subsystem:console #{flags} /out:#{output} #{obj_str}")
                 end
                 
                 def obj_fn(obj)
@@ -78,8 +71,9 @@ module Bake
                     return File.join(exe[:outdir], exe.name + '.exe')
                 end
                 
-                def runner_fn(runner)
-                    return "#{exe_fn(runner.deps.first)}.success"
+            private
+                def build_flags(flag, args)
+                    return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
                 end
                 
                 def process_inputs(target)