rake 0.7.3 → 0.8.0

data/test/test_invocation_chain.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+######################################################################
+class TestAnEmptyInvocationChain < Test::Unit::TestCase
+
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+  end
+
+  def test_should_be_able_to_add_members
+    assert_nothing_raised do
+      @empty.append("A")
+    end
+  end
+
+  def test_to_s
+    assert_equal "TOP", @empty.to_s
+  end
+end
+
+######################################################################
+class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+    @first_member = "A"
+    @chain = @empty.append(@first_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_raise RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/circular +dependency/i, ex.message)
+    assert_match(/A.*=>.*A/, ex.message)
+  end
+
+  def test_to_s
+    assert_equal "TOP => A", @chain.to_s
+  end
+
+end
+
+######################################################################
+class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
+  def setup
+    @first_member = "A"
+    @second_member = "B"
+    ch = Rake::InvocationChain::EMPTY.append(@first_member)
+    @chain = ch.append(@second_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_report_second_member_as_a_member
+    assert @chain.member?(@second_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_raise RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/A.*=>.*B.*=>.*A/, ex.message)
+  end
+end
+
+

data/test/test_namespace.rb

@@ -1,12 +1,16 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
+begin
+  require 'rubygems'
+rescue LoadError
+  # got no gems
+end
+
 require 'test/unit'
-require 'flexmock'
+require 'flexmock/test_unit'
 require 'rake'
 
 class TestNameSpace < Test::Unit::TestCase
-  include FlexMock::TestCase
 
   def test_namespace_creation
     mgr = flexmock("TaskManager")

data/test/test_package_task.rb

@@ -85,20 +85,6 @@ else
       assert_equal "pkgr-1.2.3.gem", pkg.gem_file
     end
 
-    def test_gem_package_with_specific_platform
-      gem = Gem::Specification.new do |g|
-        g.name = "pkgr"
-        g.version = "1.2.3"
-        g.files = FileList["x"].resolve
-        g.platform = Gem::Platform::WIN32
-      end
-      pkg = Rake::GemPackageTask.new(gem)  do |p|
-        p.package_files << "y"
-      end
-      assert_equal ["x", "y"], pkg.package_files
-      assert_equal "pkgr-1.2.3-mswin32.gem", pkg.gem_file
-    end
-
     def test_gem_package_with_current_platform
       gem = Gem::Specification.new do |g|
         g.name = "pkgr"

data/test/test_pathmap.rb

@@ -60,6 +60,11 @@ class TestPathMap < Test::Unit::TestCase
     assert_equal "abc", "abc".pathmap("%X")
     assert_equal "abc", "abc.rb".pathmap("%X")
     assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
+    assert_equal "ab.xyz", "ab.xyz.rb".pathmap("%X")
+    assert_equal "a.xyz", "a.xyz.rb".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "ab", "ab.rb".pathmap("%X")
+    assert_equal "a", "a.rb".pathmap("%X")
     assert_equal ".depends", ".depends".pathmap("%X")
     assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X")
     assert_equal "/.depends", "/.depends".pathmap("%X")
@@ -181,6 +186,22 @@ class TestPathMapExplode < Test::Unit::TestCase
   end
 end
 
+class TestPathMapPartial < Test::Unit::TestCase
+  def test_pathmap_partial
+    @path = "1/2/file"
+    def @path.call(n)
+      pathmap_partial(n)
+    end
+    assert_equal("1", @path.call(1))
+    assert_equal("1/2", @path.call(2))
+    assert_equal("1/2", @path.call(3))
+    assert_equal(".", @path.call(0))
+    assert_equal("2", @path.call(-1))
+    assert_equal("1/2", @path.call(-2))
+    assert_equal("1/2", @path.call(-3))
+  end
+end
+
 class TestFileListPathMap < Test::Unit::TestCase
   def test_file_list_supports_pathmap
     assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")

data/test/test_rules.rb

@@ -113,10 +113,23 @@ class TestRules < Test::Unit::TestCase
       chdir("testdata") do
         create_file(".foo")
         rule '.o' => lambda{".foo"} do |t|
-          @runs << t.name
+          @runs << "#{t.name} - #{t.source}"
         end
         Task[OBJFILE].invoke
-        assert_equal [OBJFILE], @runs
+        assert_equal ["#{OBJFILE} - .foo"], @runs
+      end
+    end
+  end
+
+  def test_file_names_containing_percent_can_be_wrapped_in_lambda
+    verbose(false) do
+      chdir("testdata") do
+        create_file("foo%x")
+        rule '.o' => lambda{"foo%x"} do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task[OBJFILE].invoke
+        assert_equal ["#{OBJFILE} - foo%x"], @runs
       end
     end
   end
@@ -137,12 +150,25 @@ class TestRules < Test::Unit::TestCase
   def test_pathmap_automatically_applies_to_name
     verbose(false) do
       chdir("testdata") do
-        create_file("abc.c")
-        rule ".o" => '%{x,a}n.c' do |t|
+        create_file("zzabc.c")
+        rule ".o" => 'zz%{x,a}n.c' do |t|
+          @runs << "#{t.name} - #{t.source}"
+        end
+        Task["xbc.o"].invoke
+        assert_equal ["xbc.o - zzabc.c"], @runs
+      end
+    end
+  end
+
+  def test_plain_strings_are_just_filenames
+    verbose(false) do
+      chdir("testdata") do
+        create_file("plainname")
+        rule ".o" => 'plainname' do |t|
           @runs << "#{t.name} - #{t.source}"
         end
         Task["xbc.o"].invoke
-        assert_equal ["xbc.o - abc.c"], @runs
+        assert_equal ["xbc.o - plainname"], @runs
       end
     end
   end

data/test/test_task_arguments.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+######################################################################
+class TestTaskArguments < Test::Unit::TestCase
+  def teardown
+    ENV.delete('rev')
+    ENV.delete('VER')
+  end
+
+  def test_empty_arg_list_is_empty
+    ta = Rake::TaskArguments.new([], [])
+    assert_equal({}, ta.to_hash)
+  end
+
+  def test_multiple_values_in_args
+    ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three])
+    assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash)
+  end
+
+  def test_to_s
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal ta.to_hash.inspect, ta.to_s
+    assert_equal ta.to_hash.inspect, ta.inspect
+  end
+
+  def test_enumerable_behavior
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2 ,3])
+    assert_equal [10, 20, 30], ta.collect { |k,v| v * 10 }.sort
+  end
+
+  def test_named_args
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal 1, ta.aa
+    assert_equal 1, ta[:aa]
+    assert_equal 1, ta["aa"]
+    assert_equal 2, ta.bb
+    assert_nil ta.cc
+  end
+
+  def test_args_knows_its_names
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal ["aa", "bb"], ta.names
+  end
+
+  def test_extra_names_are_nil
+    ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2])
+    assert_nil ta.cc
+  end
+
+  def test_args_can_reference_env_values
+    ta = Rake::TaskArguments.new(["aa"], [1])
+    ENV['rev'] = "1.2"
+    ENV['VER'] = "2.3"
+    assert_equal "1.2", ta.rev
+    assert_equal "2.3", ta.ver
+  end
+
+  def test_creating_new_argument_scopes
+    parent = Rake::TaskArguments.new(['p'], [1])
+    child = parent.new_scope(['c', 'p'])
+    assert_equal({:c => nil, :p=>1}, child.to_hash)
+    assert_equal 1, child.p
+    assert_equal 1, child["p"]
+    assert_equal 1, child[:p]
+    assert_nil child.c
+  end
+
+  def test_child_hides_parent_arg_names
+    parent = Rake::TaskArguments.new(['aa'], [1])
+    child = Rake::TaskArguments.new(['aa'], [2], parent)
+    assert_equal 2, child.aa
+  end
+end

data/test/test_tasks.rb

@@ -6,10 +6,20 @@ require 'rake'
 require 'test/filecreation'
 require 'test/capture_stdout'
 
+
+module Interning
+  private
+
+  def intern(name, *args)
+    Rake.application.define_task(Rake::Task, name, *args)
+  end
+end
+
 ######################################################################
 class TestTask < Test::Unit::TestCase
   include CaptureStdout
   include Rake
+  include Interning
 
   def setup
     Task.clear
@@ -22,12 +32,17 @@ class TestTask < Test::Unit::TestCase
     assert_equal [], t.prerequisites
     assert t.prerequisites.is_a?(FileList)
     assert t.needed?
-    t.execute
+    t.execute(0)
     assert_equal t, arg
     assert_nil t.source
     assert_equal [], t.sources
   end
 
+  def test_inspect
+    t = intern(:foo).enhance([:bar, :baz])
+    assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
+  end
+
   def test_invoke
     runlist = []
     t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
@@ -38,6 +53,19 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["t2", "t3", "t1"], runlist
   end
 
+  def test_invoke_with_circular_dependencies
+    runlist = []
+    t1 = intern(:t1).enhance([:t2]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance([:t1]) { |t| runlist << t.name }
+    assert_equal [:t2], t1.prerequisites
+    assert_equal [:t1], t2.prerequisites
+    ex = assert_raise RuntimeError do
+      t1.invoke
+    end
+    assert_match(/circular dependency/i, ex.message)
+    assert_match(/t1 => t2 => t1/, ex.message)
+  end
+
   def test_dry_run_prevents_actions
     Rake.application.options.dryrun = true
     runlist = []
@@ -136,11 +164,193 @@ class TestTask < Test::Unit::TestCase
     assert_match(/pre-requisites:\s*--t2/, out)
   end
 
-  private
 
-  def intern(name)
-    Rake.application.define_task(Rake::Task,name)
+  def test_extended_comments
+    desc %{
+      This is a comment.
+
+      And this is the extended comment.
+      name -- Name of task to execute.
+      rev  -- Software revision to use.
+    }
+    t = intern(:t, :name, :rev)
+    assert_equal "[name,rev]", t.arg_description
+    assert_equal "This is a comment.", t.comment
+    assert_match(/^\s*name -- Name/, t.full_comment)
+    assert_match(/^\s*rev  -- Software/, t.full_comment)
+    assert_match(/\A\s*This is a comment\.$/, t.full_comment)
+  end
+
+  def test_multiple_comments
+    desc "line one"
+    t = intern(:t)
+    desc "line two"
+    intern(:t)
+    assert_equal "line one / line two", t.comment
   end
 
+  def test_settable_comments
+    t = intern(:t)
+    t.comment = "HI"
+    assert_equal "HI", t.comment
+  end
 end
 
+######################################################################
+class TestTaskWithArguments < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include Interning
+
+  def setup
+    Task.clear
+  end
+
+  def test_no_args_given
+    t = task :t
+    assert_equal [], t.arg_names
+  end
+
+  def test_args_given
+    t = task :t, :a, :b
+    assert_equal [:a, :b], t.arg_names
+  end
+
+  def test_name_and_needs
+    t = task(:t => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_and_explicit_needs
+    t = task(:t, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_args_and_explicit_needs
+    t = task(:t, :x, :y, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [:x, :y], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_illegal_keys_in_task_name_hash
+    assert_raise RuntimeError do
+      t = task(:t, :x, :y => 1, :needs => [:pre])
+    end
+  end
+
+  def test_arg_list_is_empty_if_no_args_given
+    t = intern(:t).enhance do |tt, args|
+      assert_equal({}, args.to_hash)
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_tasks_can_access_arguments_as_hash
+    t = task :t, :a, :b, :c do |tt, args|
+      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
+      assert_equal 1, args[:a]
+      assert_equal 2, args[:b]
+      assert_equal 3, args[:c]
+      assert_equal 1, args.a
+      assert_equal 2, args.b
+      assert_equal 3, args.c
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_actions_of_various_arity_are_ok_with_args
+    notes = []
+    t = intern(:t, :x).enhance do
+      notes << :a
+    end
+    t.enhance do | |
+      notes << :b
+    end
+    t.enhance do |task|
+      notes << :c
+      assert_kind_of Task, task
+    end
+    t.enhance do |t2, args|
+      notes << :d
+      assert_equal t, t2
+      assert_equal({:x => 1}, args.to_hash)
+    end
+    assert_nothing_raised do t.invoke(1) end
+    assert_equal [:a, :b, :c, :d], notes
+  end
+
+  def test_arguments_are_passed_to_block
+    t = intern(:t, :a, :b).enhance { |tt, args|
+      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_extra_parameters_are_ignored
+    t = intern(:t, :a).enhance { |tt, args|
+      assert_equal 1, args.a
+      assert_nil args[2]
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_arguments_are_passed_to_all_blocks
+    counter = 0
+    t = task :t, :a
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    t.invoke(1)
+    assert_equal 2, counter
+  end
+
+  def test_block_with_no_parameters_is_ok
+    t = intern(:t).enhance { }
+    t.invoke(1, 2)
+  end
+
+  def test_name_with_args
+    desc "T"
+    t = intern(:tt, :a, :b)
+    assert_equal "tt", t.name
+    assert_equal "T", t.comment
+    assert_equal "[a,b]", t.arg_description
+    assert_equal "tt[a,b]", t.name_with_args
+    assert_equal [:a, :b],t.arg_names
+  end
+
+  def test_named_args_are_passed_to_prereqs
+    value = nil
+    pre = intern(:pre, :rev).enhance { |t, args| value = args.rev }
+    t = intern(:t, :name, :rev).enhance([:pre])
+    t.invoke("bill", "1.2")
+    assert_equal "1.2", value
+  end
+
+  def test_args_not_passed_if_no_prereq_names
+    pre = intern(:pre).enhance { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = intern(:t, :name, :rev).enhance([:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_arg_names
+    pre = intern(:pre, :rev).enhance { |t, args|
+      assert_equal({ :rev => nil }, args.to_hash)
+    }
+    t = intern(:t).enhance([:pre])
+    t.invoke("bill", "1.2")
+  end
+end