bake 0.1.1 → 0.1.2

data/lib/bake/target.rb

@@ -1,45 +1,72 @@
 require 'bake/configuration'
-require 'bake/string_utils'
+require 'bake/toolset'
 
 module Bake
     class Target
         include Configuration
 
-        attr_reader :parent, :children, :deps, :toolset
+        attr_reader :parent, :children, :deps, :posts, :toolset
         attr_accessor :name
 
-        def initialize(parent, toolset)
+        def initialize(parent, *args)
             @parent = parent
-            @toolset = toolset
             @children = []
             @deps = []
+            @posts = []
+            @stale = nil
             parent.children << self if parent
 
-            if toolset
-                mixin_name = self.class.name.split('::').last
-                toolset.class
-                if toolset.class.const_defined?(mixin_name)
-                    extend(toolset.class.const_get(mixin_name))
-                end
-            end
-            post_initialize if respond_to?(:post_initialize)
+            @toolset = args.first.is_a?(Toolset) ? args.shift : nil
+            @building = false
+            props = args.last.respond_to?(:to_hash) ? args.pop : {}
+            props.each_pair { |name, val| opt(name => val) }
+
+            post_initialize(*args) if respond_to?(:post_initialize)
+            mix_in_toolset
+        end
+        
+        def stale?
+            return @stale if !@stale.nil?
+            tmin = mtimes.min
+            @stale = deps.any? { |dep| dep.stale? || dep.mtimes.max > tmin }
+            return @stale
         end
 
-        def build
+        def products
+            return nil
+        end
+
+        def built?
+            return @built
+        end
+        
+        def build_r
             return if @built
-            deps.each { |dep| dep.build }
-            children.each { |child| child.build }
-            if toolset
-                Dir.chdir(get(:cwdir)) do
-                    toolset.build(self)
+            raise "circular dependency detected in '#{self}'" if @building
+            @building = true
+            deps.each { |dep| dep.build_r }
+            Dir.chdir(get(:cwdir)) do
+                if stale?
+                    if products
+                        outdir = get(:outdir)
+                        toolset.sys.mkdir_p(outdir) if !File.exists?(outdir)
+                    end
+                    build if respond_to?(:build)
                 end
             end
+            @building = false
             @built = true
+            posts.each { |post| post.build_r }
+        end
+
+        def clean_r
+            children.each { |child| child.clean_r }
+            clean
         end
 
         def clean
-            children.each { |child| child.clean }
-            toolset.clean(self) if toolset
+            prods = products.make_array
+            toolset.sys.rm_f(prods) if !prods.empty?
         end
 
         def dep(*targets)
@@ -51,25 +78,75 @@ module Bake
             deps << target
         end
 
+        def post(*targets)
+            normalize_targets(*targets).each { |target| posts << target }
+        end
+
         def current_project
             return parent.current_project
         end
+        
+        def mtimes
+            prods = products.make_array
+            return [ Time.now ] if prods.empty?
+            return products.make_array.collect do |prod|
+                File.exists?(prod) ? File.mtime(prod) : Time.at(0)
+            end
+        end
+
+        alias :id :name
+
+        def to_s
+            return "<#{class_name}: #{id}>"
+        end
+
+    protected
+        def class_name
+            return self.class.name.split('::').last
+        end
 
     private
         def normalize_targets(*targets)
             normalized_targets = []
             targets.flatten.each do |target|
                 if !target.is_a?(Target)
-                    if File.exists?(target)
-                        target = FileTarget.new(self, target)
-                    else
+                    begin
+                        # resolve normal targets
                         target = current_project.resolve(target)
+                    rescue RuntimeError => e
+                        # when no normal target exists, see if a file exists
+                        if File.exists?(target)
+                            target = FileTarget.new(self, toolset, target)
+                        else
+                            raise e
+                        end
                     end
                 end
                 normalized_targets << target
             end
             return normalized_targets
         end
+
+        def mix_in_toolset
+            return if !toolset
+            mixin_name = self.class.name.split('::').last
+            # collect all the relevant mixins
+            modules = []
+            toolset_class = toolset.class
+            while toolset_class && !toolset_class.equal?(::Object)
+                if toolset_class.const_defined?(mixin_name)
+                    modules << toolset_class.const_get(mixin_name)
+                end
+                toolset_class = toolset_class.superclass
+            end
+            # add them in reverse order to preserve inheritance relations
+            modules.reverse_each do |mod|
+                extend(mod)
+                if mod.instance_methods.include?('post_initialize')
+                    post_initialize
+                end
+            end
+        end
     end
 end
 

data/lib/bake/toolset.rb

@@ -1,8 +1,15 @@
 require 'bake/plugin'
+require 'fileutils'
 
 module Bake
-    module Toolset
+    class Toolset
         include Addon
+        
+        attr_reader :sys
+        
+        def initialize(sys)
+            @sys = sys
+        end
 
         def constructor(name, target_class)
             toolset = self

data/lib/bake_version.rb

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

data/test/test_bake.rb

@@ -0,0 +1,2 @@
+require 'test_configuration'
+

data/test/test_configuration.rb

@@ -0,0 +1,58 @@
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'bake/configuration'
+
+class ConfigTree
+    include Bake::Configuration
+
+    def initialize(parent = nil)
+        @parent = parent
+        parent.children << self if parent
+        @children = []
+    end
+
+protected
+    attr_reader :parent, :children
+end
+
+class TestConfigTree < Test::Unit::TestCase
+    def setup
+        @cfg = ConfigTree.new
+        @parent = ConfigTree.new
+        @child = ConfigTree.new(@parent)
+    end
+
+    def test_opt
+        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
+        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
+
+        @cfg.opt(:defines => 'DEBUG')
+        assert_equal(1, @cfg[:defines].size)
+        assert(@cfg[:defines].include?('DEBUG'))
+
+        @cfg.opt(:defines => 'WIN32')
+        assert_equal(2, @cfg[:defines].size)
+        assert(@cfg[:defines].include?('DEBUG'))
+        assert(@cfg[:defines].include?('WIN32'))
+
+        @cfg.opt(:libtype => 'static')
+        assert_equal('static', @cfg[:libtype])
+
+        @cfg.opt(:libtype => 'dynamic')
+        assert_equal('dynamic', @cfg[:libtype])
+
+        assert_raise(Bake::PropertyNotFoundException) { @cfg[:random] }
+
+        assert_equal(0, @child[:defines].size)
+
+        @parent.opt(:defines => 'DEBUG')
+        @child.opt(:defines => 'WIN32')
+        assert_equal(1, @parent[:defines].size)
+        assert(@child[:defines].include?('DEBUG'))
+        assert_equal(2, @child[:defines].size)
+        assert(@child[:defines].include?('DEBUG'))
+        assert(@child[:defines].include?('WIN32'))
+    end
+end
+

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: bake
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-05-02 00:00:00 -04:00
+  version: 0.1.2
+date: 2007-05-17 00:00:00 -04:00
 summary: Project-based build utility
 require_paths: 
 - lib
@@ -35,17 +35,23 @@ files:
 - lib/bake/addon.rb
 - lib/bake/configuration.rb
 - lib/bake/context.rb
+- lib/bake/extensions
+- lib/bake/extensions.rb
 - lib/bake/file_target.rb
 - lib/bake/plugin.rb
 - lib/bake/plugins
 - lib/bake/project.rb
 - lib/bake/project_loader.rb
-- lib/bake/string_utils.rb
+- lib/bake/system_utils.rb
 - lib/bake/target.rb
 - lib/bake/toolset.rb
+- lib/bake/extensions/class.rb
+- lib/bake/extensions/object.rb
+- lib/bake/extensions/string.rb
 - lib/bake/plugins/cpp
 - lib/bake/plugins/cpp.rb
 - lib/bake/plugins/macro.rb
+- lib/bake/plugins/runner.rb
 - lib/bake/plugins/system.rb
 - lib/bake/plugins/cpp/darwin.rb
 - lib/bake/plugins/cpp/gcc.rb
@@ -53,11 +59,8 @@ files:
 - 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
-- test/scheme_test.rb
-- test/target_test.rb
+- test/test_bake.rb
+- test/test_configuration.rb
 - README
 - MIT-LICENSE
 - TUTORIAL

data/test/bake_test.rb

@@ -1,5 +0,0 @@
-require 'configuration_test'
-require 'scheme_test'
-require 'context_test'
-require 'target_test'
-

data/test/configuration_test.rb

@@ -1,102 +0,0 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'test/unit'
-require 'bake/configuration'
-
-class ConfigTree
-    include Bake::Configuration
-
-    def initialize(parent = nil)
-        @parent = parent
-        parent.children << self if parent
-        @children = []
-    end
-
-protected
-    attr_reader :parent, :children
-end
-
-class ConfigurationTest < Test::Unit::TestCase
-    def setup
-        @cfg = ConfigTree.new
-        @parent = ConfigTree.new
-        @child = ConfigTree.new(@parent)
-    end
-
-    def test_opt
-        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
-        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
-
-        @cfg.opt(:defines => 'DEBUG')
-        assert_equal(1, @cfg[:defines].size)
-        assert(@cfg[:defines].include?('DEBUG'))
-
-        @cfg.opt(:defines => 'WIN32')
-        assert_equal(2, @cfg[:defines].size)
-        assert(@cfg[:defines].include?('DEBUG'))
-        assert(@cfg[:defines].include?('WIN32'))
-
-        @cfg.opt(:libtype => 'static')
-        assert_equal('static', @cfg[:libtype])
-
-        @cfg.opt(:libtype => 'dynamic')
-        assert_equal('dynamic', @cfg[:libtype])
-
-        assert_nil(@cfg[:random])
-
-        assert_equal(0, @child[:defines].size)
-
-        @parent.opt(:defines => 'DEBUG')
-        @child.opt(:defines => 'WIN32')
-        assert_equal(1, @parent[:defines].size)
-        assert(@child[:defines].include?('DEBUG'))
-        assert_equal(2, @child[:defines].size)
-        assert(@child[:defines].include?('DEBUG'))
-        assert(@child[:defines].include?('WIN32'))
-    end
-
-    def test_req
-        assert_raise(RuntimeError) { @cfg.req(:yes => true, :no => false) }
-
-        assert_raise(RuntimeError) { @cfg.req(:defines) }
-        assert_raise(RuntimeError) { @cfg.req(:defines => 'DEBUG') }
-
-        @cfg.req(:libtype => 'static')
-        assert_equal('static', @cfg[:libtype])
-
-        assert_nothing_raised { @cfg.req(:libtype => 'static') }
-        assert_raise(RuntimeError) { @cfg.req(:libtype => 'dynamic') }
-
-        @parent.req(:libtype => 'static')
-        assert_equal('static', @parent[:libtype])
-        assert_equal('static', @child[:libtype])
-
-        assert_nothing_raised { @child.req(:libtype => 'static') }
-        assert_raise(RuntimeError) { @child.req(:libtype => 'dynamic') }
-
-        @child.req(:outdir => 'bin')
-        assert_nil(@parent[:outdir])
-        assert_equal('bin', @child[:outdir])
-    end
-
-    def test_opt_req
-        @cfg.opt(:libtype => 'static')
-        assert_equal('static', @cfg[:libtype])
-        @cfg.req(:libtype => 'dynamic')
-        assert_equal('dynamic', @cfg[:libtype])
-
-        @parent.req(:outdir => 'bin')
-        assert_equal('bin', @parent[:outdir])
-        assert_equal('bin', @child[:outdir])
-        @child.opt(:outdir => 'output')
-        assert_equal('bin', @child[:outdir])
-
-        @parent.opt(:libtype => 'static')
-        assert_equal('static', @parent[:libtype])
-        assert_equal('static', @child[:libtype])
-        @child.req(:libtype => 'dynamic')
-        assert_equal('static', @parent[:libtype])
-        assert_equal('dynamic', @child[:libtype])
-    end
-end
-

data/test/context_test.rb

@@ -1,94 +0,0 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'test/unit'
-require 'bake/context'
-require 'bake/scheme'
-require 'bake/target'
-require 'bake/toolset'
-
-module Cpp
-    class Object < Bake::Target
-    end
-
-    class Gcc < Bake::Toolset
-    end
-
-    class Vc6 < Bake::Toolset
-    end
-end
-
-module Common
-    class Directory < Bake::Target
-        ACCESSORS = :dir
-    end
-
-    class Toolset < Bake::Toolset
-    end
-end
-
-class MockSchemeLoader
-    def initialize
-        @schemes =
-        {
-            'cpp' => Bake::Scheme.new(Cpp),
-            'common' => Bake::Scheme.new(Common)
-        }
-    end
-
-    def scheme(name)
-        return @schemes[name]
-    end
-
-    def schemes
-        return @schemes.values
-    end
-end
-
-class ContextTest < Test::Unit::TestCase
-    def setup
-        @loader = MockSchemeLoader.new
-        @context = Bake::Context.new(@loader)
-    end
-
-    def test_context_eval
-        test_case = self
-        ctx = @context
-        proj = Bake::Project.new(nil)
-        @context.context_eval(proj) { test_case.assert_same(ctx, self) }
-        @context.context_eval(proj) { name 'a name' }
-        assert_equal('a name', proj.name)
-        @context.context_eval(proj, "name 'another'")
-        assert_equal('another', proj.name)
-    end
-
-    def test_using
-        assert_raise(RuntimeError) { @context.using('invalid.gcc') }
-        assert_raise(RuntimeError) { @context.using('cpp.invalid') }
-        assert_raise(RuntimeError) { @context.using('cpp') }
-        assert_raise(RuntimeError) { @context.using(12345) }
-        @context.using('cpp.gcc')
-        assert_instance_of(Cpp::Gcc, @loader.scheme('cpp').toolset)
-        @context.using('cpp.vc6')
-        assert_instance_of(Cpp::Vc6, @loader.scheme('cpp').toolset)
-    end
-
-    def test_accessor_calls
-        assert_raise(NoMethodError) { @context.no_dir }
-
-        test_case = self
-        assert_instance_of(Common::Directory, @context.dir)
-        dir = @context.dir do
-            name 'yup'
-        end
-        assert_equal('yup', dir.name)
-
-        proj = Bake::Project.new(nil)
-        @context.context_eval(proj) do
-            dir { name 'a dir' }
-        end
-        assert_equal(1, proj.children.size)
-        assert_instance_of(Common::Directory, proj.children[0])
-        assert_equal('a dir', proj.children[0].name)
-    end
-end
-