bake 0.1.0

data/lib/bake_version.rb

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

data/test/bake_test.rb

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

data/test/configuration_test.rb

@@ -0,0 +1,102 @@
+$: << 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

@@ -0,0 +1,94 @@
+$: << 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
+

data/test/scheme_test.rb

@@ -0,0 +1,121 @@
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'bake/toolset'
+require 'bake/target'
+require 'bake/scheme'
+
+module GoodScheme
+    class Tool1 < Bake::Toolset
+    end
+
+    class Tool2 < Bake::Toolset
+    end
+
+    class Target1 < Bake::Target
+        ACCESSORS = :target1
+
+        def some_target1_meth
+        end
+    end
+
+    class Target2 < Bake::Target
+        ACCESSORS = [ :target2_first, :target2_second ]
+    end
+
+    class Target3 < Bake::Target
+        attr_reader :some_value
+
+        def initialize(parent, value)
+            super(parent)
+            @some_value = value
+        end
+    end
+end
+
+module SomeModule
+    module NestedScheme
+        class Tool < Bake::Toolset
+        end
+
+        class Target < Bake::Target
+        end
+    end
+end
+
+module NoTargetsScheme
+    class TestToolset < Bake::Toolset
+    end
+end
+
+module NoToolsetsScheme
+    class TestTarget < Bake::Toolset
+    end
+end
+
+class SchemeTest < Test::Unit::TestCase
+    def setup
+        @good_scheme = Bake::Scheme.new(GoodScheme)
+        @nested_scheme = Bake::Scheme.new(SomeModule::NestedScheme)
+    end
+
+    def test_init
+        assert_equal('good_scheme', @good_scheme.name)
+        assert_equal(2, @good_scheme.toolsets.size)
+        assert_equal(3, @good_scheme.targets.size)
+        assert_nil(@good_scheme.toolset)
+
+        assert_equal('some_module/nested_scheme', @nested_scheme.name)
+        assert_equal(1, @nested_scheme.toolsets.size)
+        assert_equal(1, @nested_scheme.toolsets.size)
+        assert_nil(@nested_scheme.toolset)
+
+        assert_raise(RuntimeError) { Bake::Scheme.new(NoTargetsScheme) }
+        assert_raise(RuntimeError) { Bake::Scheme.new(NoToolsetsScheme) }
+    end
+
+    def test_toolset
+        assert_raise(RuntimeError) { @good_scheme.toolset = :tool3 }
+        assert_raise(RuntimeError) do
+            @good_scheme.toolset = SomeModule::NestedScheme::Tool.new
+        end
+        assert_nil(@good_scheme.toolset)
+
+        @good_scheme.toolset = :tool1
+        assert_instance_of(GoodScheme::Tool1, @good_scheme.toolset)
+        @good_scheme.toolset = GoodScheme::Tool2.new
+        assert_instance_of(GoodScheme::Tool2, @good_scheme.toolset)
+
+        @nested_scheme.toolset = :tool
+        assert_instance_of(SomeModule::NestedScheme::Tool,
+            @nested_scheme.toolset)
+    end
+
+    def test_constructors
+        assert(@good_scheme.has_constructor?(:target1))
+        assert(@good_scheme.has_constructor?(:target2_first))
+        assert(@good_scheme.has_constructor?(:target2_second))
+        assert(!@good_scheme.has_constructor?(:random))
+        assert(!@nested_scheme.has_constructor?(:anything))
+
+        assert_raise(RuntimeError) { @good_scheme.construct(:invalid) }
+        assert_raise(RuntimeError) do
+            @good_scheme.construct(SomeModule::NestedScheme::Tool)
+        end
+
+        root = @good_scheme.construct(:target1, nil)
+        assert_instance_of(GoodScheme::Target1, root)
+        branch1 = @good_scheme.construct(:target2_first, root)
+        assert_instance_of(GoodScheme::Target2, branch1)
+        branch1a = @nested_scheme.construct(
+            SomeModule::NestedScheme::Target, branch1)
+        assert_instance_of(SomeModule::NestedScheme::Target, branch1a)
+        assert_same(branch1, branch1a.parent)
+        assert_same(root, branch1.parent)
+
+        branch1b = @good_scheme.construct(GoodScheme::Target3, branch1, 'yeap')
+        assert_instance_of(GoodScheme::Target3, branch1b)
+        assert_equal('yeap', branch1b.some_value)
+    end
+end
+

data/test/target_test.rb

@@ -0,0 +1,93 @@
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'bake/target'
+
+class SimpleProjectLoader
+    def load_project(path, from_proj)
+        path = path.split('/')
+        proj = from_proj
+        path.each do |subdir|
+            next if subdir == '.'
+            proj = proj.child(subdir)
+            raise "invalid child #{subdir}" if !proj
+        end
+        return proj
+    end
+end
+
+class TargetTest < Test::Unit::TestCase
+    def setup
+        @loader = SimpleProjectLoader.new
+
+        @target = Bake::Target.new(nil)
+        @parent = Bake::Project.new(nil)
+        @parent.name 'parent'
+        @parent.loader = @loader
+        @child1 = Bake::Target.new(@parent)
+        @child1.name 'child1'
+        @child2 = Bake::Target.new(@parent)
+        @child2.name 'child2'
+        @child2a = Bake::Project.new(@child2)
+        @child2a.name 'child2a'
+        @child2a.loader = @loader
+        @child2b = Bake::Target.new(@child2)
+        @child2b.name 'child2b'
+        @child2c = Bake::Target.new(@child2)
+        @child2c.name 'child2c'
+        @child2ai = Bake::Target.new(@child2a)
+        @child2aii = Bake::Target.new(@child2a)
+    end
+
+    def test_initialize
+        assert_nil(@target.parent)
+        assert_equal(0, @target.children.size)
+
+        assert_nil(@parent.parent)
+        assert_equal(2, @parent.children.size)
+        assert_same(@child1.parent, @child2.parent)
+        assert_equal(0, @child1.children.size)
+        assert_equal(3, @child2.children.size)
+    end
+
+    def test_name
+        assert_nil(@target.name)
+        assert_equal('oh no', @target.name('oh no'))
+        assert_equal('oh no', @target.name)
+    end
+
+    def test_child
+        assert_same(@child1, @parent.child('child1'))
+        assert_same(@child2c, @child2.child('child2c'))
+        assert_nil(@child1.child('anything'))
+        assert_nil(@parent.child('child2a'))
+    end
+
+    def test_project
+        assert_same(@parent, @child1.project)
+        assert_same(@parent, @child2.project)
+        assert_same(@parent, @child2a.project)
+        assert_same(@parent, @child2b.project)
+        assert_nil(@parent.project)
+        assert_same(@child2a, @child2ai.project)
+    end
+
+    def test_dep
+        assert(@child2aii.deps.empty?)
+        assert_raise(RuntimeError) { @child2aii.dep('child1') }
+        @parent.map('child1' => '.')
+        @child2aii.dep('child1')
+        assert_equal(1, @child2aii.deps.size)
+        assert_same(@child1, @child2aii.deps[0])
+
+        @child1.dep('child2')
+        assert_equal(1, @child1.deps.size)
+        assert_same(@child2, @child1.deps[0])
+    end
+
+    def test_map
+        @parent.map('child1' => '.')
+        assert_same(@child1, @parent.mapping('child1'))
+    end
+end
+

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: Project-based build utility
+require_paths: 
+- lib
+email: dylan@dylantrotter.com
+homepage: http://dylantrotter.com/
+rubyforge_project: 
+description: 
+autorequire: bake
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Dylan Trotter
+files: 
+- bin/bake
+- lib/bake
+- lib/bake.rb
+- lib/bake_version.rb
+- lib/bake/common_scheme.rb
+- lib/bake/configuration.rb
+- lib/bake/context.rb
+- lib/bake/cpp_scheme.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
+- test/bake_test.rb
+- test/configuration_test.rb
+- test/context_test.rb
+- test/scheme_test.rb
+- test/target_test.rb
+- README
+- MIT-LICENSE
+- TUTORIAL
+- CONCEPTS
+- REFERENCE
+test_files: []
+
+rdoc_options: 
+- --title
+- Bake
+- --main
+- README
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+- TUTORIAL
+- CONCEPTS
+- REFERENCE
+executables: 
+- bake
+extensions: []
+
+requirements: []
+
+dependencies: []
+