rant 0.5.6 → 0.5.7

data/test/rule.rf

@@ -26,6 +26,10 @@ gen Rule, :rt => src do |t|
     sys.touch t.name
 end
 
+gen Rule, :ett => :et do |t|
+    sys.touch t.name
+end
+
 if var[:enhance_t]
     enhance "eh.t" do
 	puts "eh.t created"

data/test/test_filetask.rb~

@@ -0,0 +1,97 @@
+
+require 'test/unit'
+require 'tutil'
+
+$test_filetask_file = File.expand_path(__FILE__)
+$test_dir ||= File.dirname($test_filetask_file)
+
+class TestFileTask < Test::Unit::TestCase
+    include Rant::TestUtil
+
+    def setup
+        Dir.chdir $test_dir
+        @rant = Rant::RantApp.new
+    end
+    def test_needed_non_existent
+	run = false
+	t = Rant::FileTask.new(@rant, "non_existent") { run = true }
+	assert(t.needed?,
+	    "`non_existent' doesn't exist, so filetask is needed")
+	assert(!run,
+	    "only FileTask#needed? was called, which shouldn't run task block")
+    end
+    def test_needed_no_dep
+	run = false
+	t = @rant.file $test_filetask_file do
+	    run = true
+	end
+	assert(!t.needed?,
+	    "file exists and has no prerequisite, so needed? should return false")
+	assert(!run)
+    end
+=begin
+    commented out due to a semantics change in 0.4.5
+    def test_single_dep
+	tr = false
+	t = @rant.task :t do
+	    tr = true
+	end
+	run = false
+	f = @rant.file "testfile" => :t do
+	    run = true
+	end
+	f.invoke
+	assert(tr)
+	assert(run)
+    end
+=end
+    def test_prerequisites
+	@rant.file "a" do
+	    true
+	end
+	@rant.file "b" do
+	    true
+	end
+	f = @rant.file "c" => %w(a b) do |t|
+	    assert_equal(t.prerequisites, %w(a b),
+		"prerequisites should always be an array of _strings_")
+	    true
+	end
+	f.invoke
+    end
+    def test_no_invoke_task_dep
+        write_to_file "print_name.t", "b\n"
+        out, err = assert_rant "depends_name.t"
+        assert err.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+        assert_match(/writing.*depends_name\.t/, out)
+        assert !out.include?("print_name.t"),
+            "file task mustn't invoke task as prerequisite"
+        out, err = assert_rant "depends_name.t"
+        assert err.empty?
+        assert out.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+    ensure
+        Rant::Sys.rm_f %w(print_name.t depends_name.t)
+    end
+    def test_no_invoke_task_dep_md5
+        write_to_file "print_name.t", "b\n"
+        out, err = assert_rant "-imd5", "depends_name.t"
+        assert err.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+        assert_match(/writing.*depends_name\.t/, out)
+        assert !out.include?("print_name.t"),
+            "file task mustn't invoke task as prerequisite"
+        out, err = assert_rant "-imd5", "depends_name.t"
+        assert err.empty?
+        assert out.empty?
+        assert test(?f, "depends_name.t")
+        assert_equal "b\na\n", File.read("depends_name.t")
+    ensure
+        Rant::Sys.rm_f %w(auto.rf .rant.meta print_name.t depends_name.t)
+        Rant::Sys.rm_f Dir["*.t"]
+    end
+end

data/test/test_rule.rb

@@ -185,4 +185,14 @@ if Rant::Env.find_bin("cc") && Rant::Env.find_bin("gcc")
 else
     $stderr.puts "*** cc/gcc not available, less rule tests ***"
 end
+    def test_abs_path_source
+        FileUtils.touch "abs_rule_test.et"
+        abs_target_path = File.expand_path "abs_rule_test.ett"
+        out, err = assert_rant("-frule.rf", abs_target_path)
+        assert test(?f, abs_target_path)
+        out, err = assert_rant("-frule.rf", abs_target_path)
+        assert out.empty?
+    ensure
+        Rant::Sys.rm_f ["abs_rule_test.et", "abs_rule_test.ett"]
+    end
 end

data/test/test_sys_methods.rb

@@ -594,4 +594,26 @@ class TestSysMethods < Test::Unit::TestCase
             assert !Rant::Sys.root_dir?("C:/foo/bar")
         end
     end
+    def test_absolute_path?
+        assert Rant::Sys.absolute_path?("/foo")
+        assert Rant::Sys.absolute_path?("/foo/bar/baz.txt")
+        assert Rant::Sys.absolute_path?("/")
+        assert Rant::Sys.absolute_path?("//foo")
+        assert !Rant::Sys.absolute_path?("foo/")
+        assert !Rant::Sys.absolute_path?("")
+        assert !Rant::Sys.absolute_path?("foo\\bar")
+        if Rant::Env.on_windows?
+            assert Rant::Sys.absolute_path?("\\foo")
+            assert Rant::Sys.absolute_path?("\\")
+            assert Rant::Sys.absolute_path?("C:\\foo")
+            assert Rant::Sys.absolute_path?("C:/foo")
+            assert Rant::Sys.absolute_path?("C:\\")
+            assert Rant::Sys.absolute_path?("C:/")
+        else
+            assert !Rant::Sys.absolute_path?("C:/")
+            assert !Rant::Sys.absolute_path?("C:/foo")
+            assert !Rant::Sys.absolute_path?("\\")
+            assert !Rant::Sys.absolute_path?("C:\\")
+        end
+    end
 end

data/test/units/csharp/test_base_compiler_adapter.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/../csharp_test_helper')
+require File.expand_path(File.dirname(__FILE__) + 
+    '/../../../lib/rant/csharp/base_compiler_adapter')
+
+class TestBaseCompilerAdapter < Test::Unit::TestCase
+  begin
+    require 'mocha'
+    @@mocha_required = true
+  rescue LoadError
+    @@mocha_required = false
+  end
+
+  def setup
+    @c = Rant::CSharp::BaseCompilerAdapter.new("testbin")
+  end
+
+  # Tests
+  def test_initialize_should_fail_with_blank_bin
+    assert_raise(Exception) { Rant::CSharp::BaseCompilerAdapter.new }
+    assert_raise(Exception) { Rant::CSharp::BaseCompilerAdapter.new("") }
+  end
+  
+  def test_cmd_should_fail_with_blank_target
+    assert_raise(Exception) { @c.cmd("", nil, nil) }
+  end
+
+  def test_cmd_should_create_compile_line
+    assert_equal "testbin out:outfile target:library ", 
+                  @c.cmd("outfile", {}, mock_context)
+  end
+  
+  def test_cmd_should_create_complex_compile_line
+    args = {:sources => ["a", "b"], 
+            :libs => ["c", "d"], 
+            :target => "exe", 
+            :checked => false}
+
+    cmd = @c.cmd("outfile", args, mock_context)
+    # Order of arguments is undefined, so use regex to test
+    assert_regex "^testbin out:outfile "  , cmd
+    assert_regex " target:exe "           , cmd 
+    assert_regex " checked- "             , cmd
+    assert_regex " libs:c libs:d "        , cmd
+    assert_regex "a b$"                   , cmd         
+  end
+  
+  def test_should_provide_default_map_target
+    assert_equal "string 1", @c.map_target("string 1")
+    assert_equal "string 2", @c.map_target("string 2")
+  end
+
+  def test_should_guess_module_target
+    assert_equal "module", @c.guess_target("outfile.netmodule")
+  end
+
+  def test_should_guess_exe_target_as_winexe
+    assert_equal "winexe", @c.guess_target("outfile.exe")
+  end
+
+  def test_should_default_to_library_target
+    assert_equal "library", @c.guess_target("outfile.dll")
+    assert_equal "library", @c.guess_target("outfile")
+  end
+
+  if @@mocha_required
+    def test_should_escape_sources_as_string
+      sys = mock()
+      sys.expects(:sp).with("outfile").returns("outfile")
+      sys.expects(:sp).with("a").returns("a")
+      
+      context = mock()
+      context.expects(:sys).at_least_once.returns(sys)
+      
+      @c.cmd("outfile", {:sources => "a"}, context)
+    end
+
+    def test_should_escape_sources_as_array
+      sys = mock()
+      sys.expects(:sp).with("outfile").returns("outfile")
+      sys.expects(:sp).with("a").returns("a").times(2)
+      
+      context = mock()
+      context.expects(:sys).at_least_once.returns(sys)
+      
+      @c.cmd("outfile", {:sources => ["a", "a"]}, context)
+    end
+  else
+    print "**** Could not run all tests for BaseCompilerAdapter, " +
+          "requires mocha libary ****\n"
+  end
+    
+  # Helpers
+  def mock_context
+    Struct.new(:sys).new(MockSys.new)
+  end
+
+  def assert_regex regex, actual
+    assert actual =~ Regexp.new(regex), "<\"#{actual}\"> did not match /#{regex}/"
+  end
+  
+  # Mocks
+  class MockSys
+    def sp(file)
+      file
+    end
+  end
+end

data/test/units/csharp/test_base_compiler_adapter.rb~

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../csharp_test_helper')
+require File.expand_path(File.dirname(__FILE__) + 
+    '/../../../lib/rant/csharp/base_compiler_adapter')
+
+class TestBaseCompilerAdapter < Test::Unit::TestCase
+  def setup
+    @c = Rant::CSharp::BaseCompilerAdapter.new("testbin")
+  end
+
+  # Tests
+  def test_initialize_should_fail_with_blank_bin
+    assert_raise(Exception) { Rant::CSharp::BaseCompilerAdapter.new }
+    assert_raise(Exception) { Rant::CSharp::BaseCompilerAdapter.new("") }
+  end
+  
+  def test_cmd_should_fail_with_blank_target
+    assert_raise(Exception) { @c.cmd("", nil, nil) }
+  end
+
+  def test_cmd_should_create_compile_line
+    assert_equal "testbin out:outfile target:library ", 
+                  @c.cmd("outfile", {}, mock_context)
+  end
+
+  def test_cmd_should_create_complex_compile_line
+    args = {:sources => ["a", "b"], 
+            :libs => ["c", "d"], 
+            :target => "exe", 
+            :checked => false}
+
+    cmd = @c.cmd("outfile", args, mock_context)
+    # Order of arguments is undefined, so use regex to test
+    assert_regex "^testbin out:outfile "  , cmd
+    assert_regex " target:exe "           , cmd 
+    assert_regex " checked- "             , cmd
+    assert_regex " libs:c libs:d "        , cmd
+    assert_regex "a b$"                   , cmd         
+  end
+  
+  def test_should_provide_default_map_target
+    assert_equal "string 1", @c.map_target("string 1")
+    assert_equal "string 2", @c.map_target("string 2")
+  end
+
+  def test_should_guess_module_target
+    assert_equal "module", @c.guess_target("outfile.netmodule")
+  end
+
+  def test_should_guess_exe_target_as_winexe
+    assert_equal "winexe", @c.guess_target("outfile.exe")
+  end
+
+  def test_should_default_to_library_target
+    assert_equal "library", @c.guess_target("outfile.dll")
+    assert_equal "library", @c.guess_target("outfile")
+  end
+
+  # Helpers
+  def mock_context
+    Struct.new(:sys).new(MockSys.new)
+  end
+
+  def assert_regex regex, actual
+    assert actual =~ Regexp.new(regex), "<\"#{actual}\"> did not match /#{regex}/"
+  end
+  
+  # Mocks
+  class MockSys
+    def sp(file)
+      file
+    end
+  end
+end

data/test/units/csharp/test_compiler_adapter_factory.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../csharp_test_helper')
+require File.expand_path(File.dirname(__FILE__) + 
+    '/../../../lib/rant/csharp/compiler_adapter_factory')
+
+class TestCompilerAdapterFactory < Test::Unit::TestCase
+  # Tests
+  def test_should_create_compiler_from_bin_in_path
+    c = Rant::CSharp::CompilerAdapterFactory.new(mock_context(MockEnv.new))
+    c.compiler_map = {"testbin" => MockCompiler }
+    
+    assert c.compiler.kind_of?(MockCompiler),
+        "Compiler was not an instance of MockCompiler"
+  end
+
+  def test_should_raise_exception_if_no_compiler_found
+    mock_context = Struct.new(:env).new(MockEnvNoBin.new)
+    c = Rant::CSharp::CompilerAdapterFactory.new(mock_context(MockEnvNoBin.new))
+    assert_raise(Exception) { c.compiler }
+  end
+
+  def test_should_cache_compiler
+    mock_context = Struct.new(:env).new(MockEnv.new)
+    c = ::Rant::CSharp::CompilerAdapterFactory.new(mock_context)
+    c.compiler_map = {"testbin" => MockCompiler }
+    
+    c.compiler # First call to populate cache
+    c.compiler_map = nil
+    
+    assert c.compiler.kind_of?(MockCompiler), 
+        "Complier was not cached"
+  end
+  
+  def test_should_have_valid_default_compiler_map
+    c = Rant::CSharp::CompilerAdapterFactory.new(nil)
+    
+    assert c.compiler_map.respond_to?("[]"), "Default compiler map is invalid"
+    c.compiler_map.each_pair do |key, value|
+      assert value.respond_to?(:new), 
+          "Default compiler map contains an invalid pair: #{key} => #{value}"
+    end
+  end
+
+  # Helpers
+  def mock_context(env)
+    Struct.new(:env).new(env)
+  end
+  
+  # Mocks
+  class MockEnv
+    def find_bin(bin)
+      bin == "testbin"
+    end
+  end
+
+  class MockEnvNoBin
+    def find_bin(bin)
+      false
+    end
+  end
+  
+  class MockCompiler
+    def initialize context
+    end
+  end
+end
+

data/test/units/csharp/test_compiler_adapter_factory.rb~

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/csharp_test_helper')
+require File.expand_path(File.dirname(__FILE__) + 
+    '/../../../lib/rant/csharp/compiler_adapter_factory')
+
+class TestCompilerAdapterFactory < Test::Unit::TestCase
+  # Tests
+  def test_should_create_compiler_from_bin_in_path
+    c = Rant::CSharp::CompilerAdapterFactory.new(mock_context(MockEnv.new))
+    c.compiler_map = {"testbin" => MockCompiler }
+    
+    assert c.compiler.kind_of?(MockCompiler),
+        "Compiler was not an instance of MockCompiler"
+  end
+
+  def test_should_raise_exception_if_no_compiler_found
+    mock_context = Struct.new(:env).new(MockEnvNoBin.new)
+    c = Rant::CSharp::CompilerAdapterFactory.new(mock_context(MockEnvNoBin.new))
+    assert_raise(Exception) { c.compiler }
+  end
+
+  def test_should_cache_compiler
+    mock_context = Struct.new(:env).new(MockEnv.new)
+    c = ::Rant::CSharp::CompilerAdapterFactory.new(mock_context)
+    c.compiler_map = {"testbin" => MockCompiler }
+    
+    c.compiler # First call to populate cache
+    c.compiler_map = nil
+    
+    assert c.compiler.kind_of?(MockCompiler), 
+        "Complier was not cached"
+  end
+  
+  def test_should_have_valid_default_compiler_map
+    c = Rant::CSharp::CompilerAdapterFactory.new(nil)
+    
+    assert c.compiler_map.respond_to?("[]"), "Default compiler map is invalid"
+    c.compiler_map.each_pair do |key, value|
+      assert value.respond_to?(:new), 
+          "Default compiler map contains an invalid pair: #{key} => #{value}"
+    end
+  end
+
+  # Helpers
+  def mock_context(env)
+    Struct.new(:env).new(env)
+  end
+  
+  # Mocks
+  class MockEnv
+    def find_bin(bin)
+      bin == "testbin"
+    end
+  end
+
+  class MockEnvNoBin
+    def find_bin(bin)
+      false
+    end
+  end
+  
+  class MockCompiler
+    def initialize context
+    end
+  end
+end
+