rake 0.6.2 → 0.7.0

data/lib/rake/rdoctask.rb

@@ -64,6 +64,9 @@ module Rake
     # List of options to be passed rdoc.  (default is [])
     attr_accessor :options
 
+    # Run the rdoc process as an external shell (default is false)
+    attr_accessor :external
+
     # Create an RDoc task named <em>rdoc</em>.  Default task name is +rdoc+.
     def initialize(name=:rdoc)	# :yield: self
       @name = name
@@ -72,6 +75,7 @@ module Rake
       @main = nil
       @title = nil
       @template = 'html'
+      @external = false
       @options = []
       yield self if block_given?
       define
@@ -100,20 +104,35 @@ module Rake
       task name => [rdoc_target]
       file rdoc_target => @rdoc_files + [$rakefile] do
 	rm_r @rdoc_dir rescue nil
-	opts = option_list.join(' ')
-	sh %{rdoc -o #{@rdoc_dir} #{opts} #{@rdoc_files}}
+	args = option_list + @rdoc_files
+	if @external
+	  argstring = args.join(' ')
+	  sh %{ruby -Ivendor vender/rd #{argstring}}
+	else
+	  require 'rdoc/rdoc'
+	  RDoc::RDoc.new.document(args)
+	end
       end
       self
     end
 
     def option_list
       result = @options.dup
-      result << "--main" << "'#{main}'" if main
-      result << "--title" << "'#{title}'" if title
-      result << "-T" << "'#{template}'" if template
+      result << "-o" << @rdoc_dir
+      result << "--main" << quote(main) if main
+      result << "--title" << quote(title) if title
+      result << "-T" << quote(template) if template
       result
     end
 
+    def quote(str)
+      if @external
+	"'#{str}'"
+      else
+	str
+      end
+    end
+
     def option_string
       option_list.join(' ')
     end

data/test/data/namespace/Rakefile

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+desc "copy"
+task :copy do
+  puts "COPY"
+end
+
+namespace "nest" do
+  desc "nest copy"
+  task :copy do
+    puts "NEST COPY"
+  end
+  task :xx => :copy
+end
+
+anon_ns = namespace do
+  desc "anonymous copy task"
+  task :copy do
+    puts "ANON COPY"
+  end
+end
+
+desc "Top level task to run the anonymous version of copy"
+task :anon => anon_ns[:copy]
+
+namespace "very" do
+  namespace "nested" do
+    task "run" => "rake:copy"
+  end
+end
+
+namespace "a" do
+  desc "Run task in the 'a' namespace"
+  task "run" do
+    puts "IN A"
+  end
+end
+
+namespace "b" do
+  desc "Run task in the 'b' namespace"
+  task "run" => "a:run" do
+    puts "IN B"
+  end
+end
+
+namespace "file1" do
+  file "xyz.rb" do
+    puts "XYZ1"
+  end
+end
+
+namespace "file2" do
+  file "xyz.rb" do
+    puts "XYZ2"
+  end
+end
+

data/test/session_functional.rb

@@ -130,6 +130,55 @@ class FunctionalTest < Test::Unit::TestCase
     end
   end
 
+  def test_can_invoke_task_in_toplevel_namespace
+    Dir.chdir("test/data/namespace") do
+      rake "copy"
+      assert_match(/^COPY$/, @out)
+    end
+  end
+
+  def test_can_invoke_task_in_nested_namespace
+    Dir.chdir("test/data/namespace") do
+      rake "nest:copy"
+      assert_match(/^NEST COPY$/, @out)
+    end
+  end
+
+  def test_tasks_can_reference_task_in_same_namespace
+    Dir.chdir("test/data/namespace") do
+      rake "nest:xx"
+      assert_match(/^NEST COPY$/m, @out)
+    end
+  end
+
+  def test_tasks_can_reference_task_in_other_namespaces
+    Dir.chdir("test/data/namespace") do
+      rake "b:run"
+      assert_match(/^IN A\nIN B$/m, @out)
+    end
+  end
+
+  def test_anonymous_tasks_can_be_invoked_indirectly
+    Dir.chdir("test/data/namespace") do
+      rake "anon"
+      assert_match(/^ANON COPY$/m, @out)
+    end
+  end
+
+  def test_rake_namespace_refers_to_toplevel
+    Dir.chdir("test/data/namespace") do
+      rake "very:nested:run"
+      assert_match(/^COPY$/m, @out)
+    end
+  end
+
+  def test_file_task_are_not_scoped_by_namespaces
+    Dir.chdir("test/data/namespace") do
+      rake "xyz.rb"
+      assert_match(/^XYZ1\nXYZ2$/m, @out)
+    end
+  end
+
   private
 
   def remove_chaining_files

data/test/test_file_creation_task.rb

@@ -40,16 +40,16 @@ class TestFileCreationTask < Test::Unit::TestCase
 
   def test_no_retriggers_on_filecreate_task
     create_timed_files(OLDFILE, NEWFILE)
-    t1 = FileCreationTask.lookup(OLDFILE).enhance([NEWFILE])
-    t2 = FileCreationTask.lookup(NEWFILE)
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileCreationTask, NEWFILE)
     assert ! t2.needed?, "Should not need to build new file"
     assert ! t1.needed?, "Should not need to rebuild old file because of new"
   end
 
   def test_no_retriggers_on_file_task
     create_timed_files(OLDFILE, NEWFILE)
-    t1 = FileTask.lookup(OLDFILE).enhance([NEWFILE])
-    t2 = FileCreationTask.lookup(NEWFILE)
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileCreationTask, NEWFILE)
     assert ! t2.needed?, "Should not need to build new file"
     assert ! t1.needed?, "Should not need to rebuild old file because of new"
   end

data/test/test_file_task.rb

@@ -33,8 +33,8 @@ class TestFileTask < Test::Unit::TestCase
   def test_file_times_new_depends_on_old
     create_timed_files(OLDFILE, NEWFILE)
 
-    t1 = FileTask.lookup(NEWFILE).enhance([OLDFILE])
-    t2 = FileTask.lookup(OLDFILE)
+    t1 = Rake.application.intern(FileTask, NEWFILE).enhance([OLDFILE])
+    t2 = Rake.application.intern(FileTask, OLDFILE)
     assert ! t2.needed?, "Should not need to build old file"
     assert ! t1.needed?, "Should not need to rebuild new file because of old"
   end
@@ -42,8 +42,8 @@ class TestFileTask < Test::Unit::TestCase
   def test_file_times_old_depends_on_new
     create_timed_files(OLDFILE, NEWFILE)
 
-    t1 = FileTask.lookup(OLDFILE).enhance([NEWFILE])
-    t2 = FileTask.lookup(NEWFILE)
+    t1 = Rake.application.intern(FileTask,OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileTask, NEWFILE)
     assert ! t2.needed?, "Should not need to build new file"
     preq_stamp = t1.prerequisites.collect{|t| Task[t].timestamp}.max
     assert_equal t2.timestamp, preq_stamp

data/test/test_multitask.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+######################################################################
+class TestMultiTask < Test::Unit::TestCase
+  include Rake
+
+  def setup
+    Task.clear
+    @runs = Array.new
+  end
+
+  def test_running_multitasks
+    task :a do 3.times do |i| @runs << "A#{i}"; sleep 0.01; end end
+    task :b do 3.times do |i| @runs << "B#{i}"; sleep 0.01;  end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 6, @runs.size
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+
+  def test_all_multitasks_wait_on_slow_prerequisites
+    task :slow do 3.times do |i| @runs << "S#{i}"; sleep 0.05 end end
+    task :a => [:slow] do 3.times do |i| @runs << "A#{i}"; sleep 0.01 end end
+    task :b => [:slow] do 3.times do |i| @runs << "B#{i}"; sleep 0.01 end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 9, @runs.size
+    assert @runs.index("S0") < @runs.index("S1")
+    assert @runs.index("S1") < @runs.index("S2")
+    assert @runs.index("S2") < @runs.index("A0")
+    assert @runs.index("S2") < @runs.index("B0")
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+end
+
+ 

data/test/test_namespace.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'test/unit'
+require 'flexmock'
+require 'rake'
+
+class TestNameSpace < Test::Unit::TestCase
+  def test_namespace_creation
+    FlexMock.use("TaskManager") do |mgr|
+      ns = Rake::NameSpace.new(mgr, [])
+      assert_not_nil ns
+    end
+  end
+
+  def test_namespace_lookup
+    FlexMock.use("TaskManager") do |mgr|
+      mgr.should_receive(:lookup).with(:t, ["a"]).
+	and_return(nil).once
+      ns = Rake::NameSpace.new(mgr, ["a"])
+      ns[:t]
+    end
+  end
+end

data/test/test_task_manager.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+class TaskManager
+  include Rake::TaskManager
+end
+
+class TestTaskManager < Test::Unit::TestCase
+  def setup
+    @tm = TaskManager.new
+  end
+
+  def test_create_task_manager
+    assert_not_nil @tm
+    assert_equal [], @tm.tasks
+  end
+
+  def test_define_task
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal "t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_name_lookup
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal t, @tm[:t]
+  end
+
+  def test_namespace_task_create
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "x:t", t.name
+    end
+    assert_equal ["x:t"], @tm.tasks.collect { |t| t.name }
+  end
+
+  def test_anonymous_namespace
+    anon_ns = @tm.in_namespace(nil) do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "_anon_1:t", t.name
+    end
+    task = anon_ns[:t]
+    assert_equal "_anon_1:t", task.name
+  end
+
+  def test_create_filetask_in_namespace
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::FileTask, "fn")
+      assert_equal "fn", t.name
+    end
+    assert_equal ["fn"], @tm.tasks.collect { |t| t.name }
+  end
+
+  def testS_namespace_yields_same_namespace_as_returned
+    yielded_namespace = nil
+    returned_namespace = @tm.in_namespace("x") do |ns|
+      yielded_namespace = ns
+    end
+    assert_equal returned_namespace, yielded_namespace
+  end
+
+  def test_name_lookup_with_implicit_file_tasks
+    t = @tm["README"]
+    assert_equal "README", t.name
+    assert Rake::FileTask === t
+  end
+
+  def test_name_lookup_with_nonexistent_task
+    assert_raise(RuntimeError) {
+      t = @tm["DOES NOT EXIST"]
+    }
+  end
+
+  def test_name_lookup_in_multiple_scopes
+    aa = nil
+    bb = nil
+    xx = @tm.define_task(Rake::Task, :xx)
+    top_z = @tm.define_task(Rake::Task, :z)
+    @tm.in_namespace("a") do
+      aa = @tm.define_task(Rake::Task, :aa)
+      mid_z = @tm.define_task(Rake::Task, :z)
+      @tm.in_namespace("b") do
+	bb = @tm.define_task(Rake::Task, :bb)
+	bot_z = @tm.define_task(Rake::Task, :z)
+
+	assert_equal ["a", "b"], @tm.current_scope
+
+	assert_equal bb, @tm["a:b:bb"]
+	assert_equal aa, @tm["a:aa"]
+	assert_equal xx, @tm["xx"]
+	assert_equal bot_z, @tm["z"]
+	assert_equal mid_z, @tm["^z"]
+	assert_equal top_z, @tm["^^z"]
+	assert_equal top_z, @tm["rake:z"]
+      end
+
+      assert_equal ["a"], @tm.current_scope
+
+      assert_equal bb, @tm["a:b:bb"]
+      assert_equal aa, @tm["a:aa"]
+      assert_equal xx, @tm["xx"]
+      assert_equal bb, @tm["b:bb"]
+      assert_equal aa, @tm["aa"]
+      assert_equal mid_z, @tm["z"]
+      assert_equal top_z, @tm["^z"]
+      assert_equal top_z, @tm["rake:z"]
+    end
+
+    assert_equal [], @tm.current_scope
+
+    assert_equal [], xx.scope
+    assert_equal ['a'], aa.scope
+    assert_equal ['a', 'b'], bb.scope
+  end
+
+  def test_lookup_with_explicit_scopes
+    t1, t2, t3, s = (0...4).collect { nil }
+    t1 = @tm.define_task(Rake::Task, :t)
+    @tm.in_namespace("a") do
+      t2 = @tm.define_task(Rake::Task, :t)
+      s =  @tm.define_task(Rake::Task, :s)
+      @tm.in_namespace("b") do
+	t3 = @tm.define_task(Rake::Task, :t)
+      end
+    end
+    assert_equal t1, @tm[:t, []]
+    assert_equal t2, @tm[:t, ["a"]]    
+    assert_equal t3, @tm[:t, ["a", "b"]]
+    assert_equal s,  @tm[:s, ["a", "b"]]
+    assert_equal s,  @tm[:s, ["a"]]
+  end
+
+  def test_correctly_scoped_prerequisites_are_invoked
+    values = []
+    @tm = Rake::Application.new
+    @tm.define_task(Rake::Task, :z) do values << "top z" end
+    @tm.in_namespace("a") do
+      @tm.define_task(Rake::Task, :z) do values << "next z" end
+      @tm.define_task(Rake::Task, :x => :z)
+    end
+
+    @tm["a:x"].invoke
+    assert_equal ["next z"], values
+  end
+  
+end

data/test/test_tasks.rb

@@ -15,7 +15,7 @@ class TestTask < Test::Unit::TestCase
 
   def test_create
     arg = nil
-    t = Task.lookup(:name).enhance { |task| arg = task; 1234 }
+    t = intern(:name).enhance { |task| arg = task; 1234 }
     assert_equal "name", t.name
     assert_equal [], t.prerequisites
     assert t.prerequisites.is_a?(FileList)
@@ -27,19 +27,23 @@ class TestTask < Test::Unit::TestCase
 
   def test_invoke
     runlist = []
-    t1 = Task.lookup(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
-    t2 = Task.lookup(:t2).enhance { |t| runlist << t.name }
-    t3 = Task.lookup(:t3).enhance { |t| runlist << t.name }
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance { |t| runlist << t.name }
+    t3 = intern(:t3).enhance { |t| runlist << t.name }
     assert_equal [:t2, :t3], t1.prerequisites
     t1.invoke
     assert_equal ["t2", "t3", "t1"], runlist
   end
 
+  def intern(name)
+    Rake.application.define_task(Rake::Task,name)
+  end
+
   def test_no_double_invoke
     runlist = []
-    t1 = Task.lookup(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
-    t2 = Task.lookup(:t2).enhance([:t3]) { |t| runlist << t.name }
-    t3 = Task.lookup(:t3).enhance { |t| runlist << t.name }
+    t1 = intern(:t1).enhance([:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = intern(:t2).enhance([:t3]) { |t| runlist << t.name }
+    t3 = intern(:t3).enhance { |t| runlist << t.name }
     t1.invoke
     assert_equal ["t3", "t2", "t1"], runlist
   end
@@ -73,5 +77,30 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["t1", "t2"], Task.tasks.collect {|t| t.name}
   end
 
+  def test_task_gives_name_on_to_s
+    task :abc
+    assert_equal "abc", Task[:abc].to_s
+  end
+
+  def test_symbols_can_be_prerequisites
+    task :a => :b
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_strings_can_be_prerequisites
+    task :a => "b"
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_arrays_can_be_prerequisites
+    task :a => ["b", "c"]
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
+  def test_filelists_can_be_prerequisites
+    task :a => FileList.new.include("b", "c")
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
 end