rake 0.8.7 → 0.9.0.beta.0

data/test/lib/package_task_test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/packagetask'
+require 'test/rake_test_setup'
+
+class TestPackageTask < Test::Unit::TestCase
+  include TestMethods
+
+  def test_initialize
+    pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
+      p.package_files << "install.rb"
+      p.package_files.include(
+        '[A-Z]*',
+        'bin/**/*',
+        'lib/**/*.rb',
+        'test/**/*.rb',
+        'doc/**/*',
+        'build/rubyapp.rb',
+        '*.blurb')
+      p.package_files.exclude(/\bCVS\b/)
+      p.package_files.exclude(/~$/)
+      p.package_dir = 'pkg'
+      p.need_tar = true
+      p.need_tar_gz = true
+      p.need_tar_bz2 = true
+      p.need_zip = true
+    }
+
+    assert_equal "pkg", pkg.package_dir
+    assert pkg.package_files.include?("bin/rake")
+    assert_equal 'pkgr', pkg.name
+    assert_equal '1.2.3', pkg.version
+    assert Rake::Task[:package]
+    assert Rake::Task['pkg/pkgr-1.2.3.tgz']
+    assert Rake::Task['pkg/pkgr-1.2.3.tar.gz']
+    assert Rake::Task['pkg/pkgr-1.2.3.tar.bz2']
+    assert Rake::Task['pkg/pkgr-1.2.3.zip']
+    assert Rake::Task['pkg/pkgr-1.2.3']
+    assert Rake::Task[:clobber_package]
+    assert Rake::Task[:repackage]
+  end
+
+  def test_initialize_no_version
+    e = assert_raises RuntimeError do
+      Rake::PackageTask.new 'pkgr'
+    end
+
+    assert_equal 'Version required (or :noversion)', e.message
+  end
+
+  def test_initialize_noversion
+    pkg = Rake::PackageTask.new 'pkgr', :noversion
+
+    assert_equal 'pkg',  pkg.package_dir
+    assert_equal 'pkgr', pkg.name
+    assert_equal nil,    pkg.version
+  end
+
+  def test_clone
+    pkg = Rake::PackageTask.new("x", :noversion)
+    p2 = pkg.clone
+    pkg.package_files << "y"
+    p2.package_files << "x"
+    assert_equal ["y"], pkg.package_files
+    assert_equal ["x"], p2.package_files
+  end
+
+  def test_package_name
+    pkg = Rake::PackageTask.new 'a', '1'
+
+    assert_equal 'a-1', pkg.package_name
+  end
+
+  def test_package_name_noversion
+    pkg = Rake::PackageTask.new 'a', :noversion
+
+    assert_equal 'a', pkg.package_name
+  end
+
+end
+

data/test/{test_pathmap.rb → lib/pathmap_test.rb}

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'test/unit'
+require 'test/rake_test_setup'
 require 'rake'
 
 # ====================================================================
@@ -26,7 +27,7 @@ class TestPathMap < Test::Unit::TestCase
 
   def test_n_returns_basename_without_extension
     assert_equal "abc", "abc.rb".pathmap("%n")
-    assert_equal "abc", "abc".pathmap("%n") 
+    assert_equal "abc", "abc".pathmap("%n")
     assert_equal "abc", "this/is/a/dir/abc.rb".pathmap("%n")
     assert_equal "abc", "/this/is/a/dir/abc.rb".pathmap("%n")
     assert_equal "abc", "/this/is/a/dir/abc".pathmap("%n")
@@ -87,7 +88,7 @@ class TestPathMap < Test::Unit::TestCase
   end
 
   def test_undefined_percent_causes_error
-    ex = assert_exception(ArgumentError) {
+    assert_exception(ArgumentError) {
       "dir/abc.rb".pathmap("%z")
     }
   end

data/test/{test_rake.rb → lib/rake_test.rb}

@@ -37,5 +37,5 @@ class TestRake < Test::Unit::TestCase
   def test_original_dir_reports_current_dir
     assert_equal Dir.pwd, Rake.original_dir
   end
-    
+
 end

data/test/{test_rdoc_task.rb → lib/rdoc_task_test.rb}

@@ -1,24 +1,31 @@
 #!/usr/bin/env ruby
 
 require 'test/unit'
-require 'rake/rdoctask'
+require 'test/capture_stdout'
+begin
+  old_verbose = $VERBOSE
+  $VERBOSE = nil
+  require 'rake/rdoctask'
+ensure
+  $VERBOSE = old_verbose
+end
 require 'test/rake_test_setup'
 
 class TestRDocTask < Test::Unit::TestCase
   include Rake
   include TestMethods
-  
+
   def setup
     Task.clear
   end
-  
+
   def test_tasks_creation
     Rake::RDocTask.new
     assert Task[:rdoc]
     assert Task[:clobber_rdoc]
     assert Task[:rerdoc]
   end
-  
+
   def test_tasks_creation_with_custom_name_symbol
     rd = Rake::RDocTask.new(:rdoc_dev)
     assert Task[:rdoc_dev]
@@ -26,7 +33,7 @@ class TestRDocTask < Test::Unit::TestCase
     assert Task[:rerdoc_dev]
     assert_equal :rdoc_dev, rd.name
   end
-  
+
   def test_tasks_creation_with_custom_name_string
     rd = Rake::RDocTask.new("rdoc_dev")
     assert Task[:rdoc_dev]
@@ -34,7 +41,7 @@ class TestRDocTask < Test::Unit::TestCase
     assert Task[:rerdoc_dev]
     assert_equal "rdoc_dev", rd.name
   end
-  
+
   def test_tasks_creation_with_custom_name_hash
     options = { :rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force" }
     rd = Rake::RDocTask.new(options)
@@ -44,45 +51,34 @@ class TestRDocTask < Test::Unit::TestCase
     assert_raises(RuntimeError) { Task[:clobber_rdoc] }
     assert_equal options, rd.name
   end
-  
+
   def test_tasks_creation_with_custom_name_hash_will_use_default_if_an_option_isnt_given
-    rd = Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
+    Rake::RDocTask.new(:clobber_rdoc => "rdoc:clean")
     assert Task[:rdoc]
     assert Task[:"rdoc:clean"]
     assert Task[:rerdoc]
   end
-  
+
   def test_tasks_creation_with_custom_name_hash_raises_exception_if_invalid_option_given
     assert_raises(ArgumentError) do
       Rake::RDocTask.new(:foo => "bar")
     end
-    
+
     begin
       Rake::RDocTask.new(:foo => "bar")
     rescue ArgumentError => e
       assert_match(/foo/, e.message)
     end
   end
-  
-  def test_inline_source_is_enabled_by_default
-    rd = Rake::RDocTask.new
-    assert rd.option_list.include?('--inline-source')
-  end
-  
+
   def test_inline_source_option_is_only_appended_if_option_not_already_given
     rd = Rake::RDocTask.new
     rd.options << '--inline-source'
     assert_equal 1, rd.option_list.grep('--inline-source').size
-    
+
     rd = Rake::RDocTask.new
     rd.options << '-S'
     assert_equal 1, rd.option_list.grep('-S').size
     assert_equal 0, rd.option_list.grep('--inline-source').size
   end
-  
-  def test_inline_source_option_can_be_disabled
-    rd = Rake::RDocTask.new
-    rd.inline_source = false
-    assert !rd.option_list.include?('--inline-source')
-  end
 end

data/test/{test_require.rb → lib/require_test.rb}

@@ -17,8 +17,13 @@ class TestRequire < Test::Unit::TestCase
 
   def test_wont_reload_rake_library
     app = Rake::Application.new
+
+    paths = ['test/data/rakelib']
+    loaded_files = []
+    app.rake_require("test2", paths, loaded_files)
+
     assert ! app.instance_eval {
-      rake_require("test2", ['test/data/rakelib'], ['test2'])
+      rake_require("test2", paths, loaded_files)
     }
   end
 
@@ -29,7 +34,8 @@ class TestRequire < Test::Unit::TestCase
         rake_require("testx", ['test/data/rakelib'], [])
       }
     }
-    assert_match(/x/, ex.message)
+    assert_match(/(can *not|can't)\s+find/i, ex.message)
+    assert_match(/testx/, ex.message)
   end
 end
 

data/test/{test_rules.rb → lib/rules_test.rb}

@@ -97,7 +97,7 @@ class TestRules < Test::Unit::TestCase
     assert_equal [OBJFILE], @runs
   end
 
-  def test_file_names_beginning_with_dot_can_be_tricked_into_refering_to_file
+  def test_file_names_beginning_with_dot_can_be_tricked_into_referring_to_file
     verbose(false) do
       chdir("testdata") do
         create_file('.foo')
@@ -278,7 +278,6 @@ class TestRules < Test::Unit::TestCase
   end
 
   def test_rule_with_proc_dependent_will_trigger
-    ran = false
     mkdir_p("testdata/src/jw")
     create_file("testdata/src/jw/X.java")
     rule %r(classes/.*\.class) => [

data/test/{test_task_arguments.rb → lib/task_arguments_test.rb}

@@ -50,12 +50,12 @@ class TestTaskArguments < Test::Unit::TestCase
     assert_nil ta.cc
   end
 
-  def test_args_can_reference_env_values
+  def test_args_do_not_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
+    assert_nil ta.rev
+    assert_nil ta.ver
   end
 
   def test_creating_new_argument_scopes
@@ -73,7 +73,7 @@ class TestTaskArguments < Test::Unit::TestCase
     child = Rake::TaskArguments.new(['aa'], [2], parent)
     assert_equal 2, child.aa
   end
-  
+
   def test_default_arguments_values_can_be_merged
     ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
     ta.with_defaults({ :aa => 'default_val' })
@@ -81,7 +81,7 @@ class TestTaskArguments < Test::Unit::TestCase
     assert_equal 'original_val', ta[:bb]
   end
 
-  def test_default_arguements_that_dont_match_names_are_ignored
+  def test_default_arguments_that_dont_match_names_are_ignored
     ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
     ta.with_defaults({ "cc" => "default_val" })
     assert_nil ta[:cc]

data/test/{test_task_manager.rb → lib/task_manager_test.rb}

@@ -65,14 +65,14 @@ class TestTaskManager < Test::Unit::TestCase
   end
 
   def test_name_lookup_with_implicit_file_tasks
-    t = @tm["README"]
-    assert_equal "README", t.name
+    t = @tm["README.rdoc"]
+    assert_equal "README.rdoc", t.name
     assert Rake::FileTask === t
   end
 
   def test_name_lookup_with_nonexistent_task
     assert_exception(RuntimeError) {
-      t = @tm["DOES NOT EXIST"]
+      @tm["DOES NOT EXIST"]
     }
   end
 
@@ -129,7 +129,7 @@ class TestTaskManager < Test::Unit::TestCase
       end
     end
     assert_equal t1, @tm[:t, []]
-    assert_equal t2, @tm[:t, ["a"]]    
+    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"]]
@@ -147,7 +147,7 @@ class TestTaskManager < Test::Unit::TestCase
     @tm["a:x"].invoke
     assert_equal ["next z"], values
   end
-  
+
 end
 
 class TestTaskManagerArgumentResolution < Test::Unit::TestCase

data/test/{test_tasks.rb → lib/task_test.rb}

@@ -3,8 +3,6 @@
 require 'test/unit'
 require 'fileutils'
 require 'rake'
-require 'test/filecreation'
-require 'test/capture_stdout'
 require 'test/rake_test_setup'
 
 ######################################################################
@@ -12,9 +10,16 @@ class TestTask < Test::Unit::TestCase
   include CaptureStdout
   include Rake
   include TestMethods
+  include Rake::DSL
 
   def setup
     Task.clear
+    Rake::TaskManager.record_task_metadata = true
+  end
+
+  def teardown
+    super
+    Rake::TaskManager.record_task_metadata = false
   end
 
   def test_create
@@ -27,6 +32,8 @@ class TestTask < Test::Unit::TestCase
     assert_equal t, arg
     assert_nil t.source
     assert_equal [], t.sources
+    assert_equal 1, t.locations.size
+    assert_match(/#{Regexp.quote(__FILE__)}/, t.locations.first)
   end
 
   def test_inspect
@@ -61,7 +68,7 @@ class TestTask < Test::Unit::TestCase
     Rake.application.options.dryrun = true
     runlist = []
     t1 = task(:t1) { |t| runlist << t.name; 3321 }
-    out = capture_stdout { t1.invoke }
+    out = capture_stderr { t1.invoke }
     assert_match(/execute .*t1/i, out)
     assert_match(/dry run/i, out)
     assert_no_match(/invoke/i, out)
@@ -73,7 +80,7 @@ class TestTask < Test::Unit::TestCase
   def test_tasks_can_be_traced
     Rake.application.options.trace = true
     t1 = task(:t1)
-    out = capture_stdout {
+    out = capture_stderr {
       t1.invoke
     }
     assert_match(/invoke t1/i, out)
@@ -174,6 +181,56 @@ class TestTask < Test::Unit::TestCase
     assert_equal ["b", "c"], Task[:a].prerequisites
   end
 
+  def test_prerequiste_tasks_returns_tasks_not_strings
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+    assert_equal [b, c], a.prerequisite_tasks
+  end
+
+  def test_prerequiste_tasks_fails_if_prerequisites_are_undefined
+    a = task :a => ["b", "c"]
+    b = task :b
+    assert_exception(RuntimeError) do
+      a.prerequisite_tasks
+    end
+  end
+
+  def test_prerequiste_tasks_honors_namespaces
+    a = b = nil
+    namespace "X" do
+      a = task :a => ["b", "c"]
+      b = task :b
+    end
+    c = task :c
+
+    assert_equal [b, c], a.prerequisite_tasks
+  end
+
+  def test_timestamp_returns_now_if_all_prereqs_have_no_times
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+
+    faux_stamp = 100
+    flexmock(Time, :now => faux_stamp)
+
+    assert_equal faux_stamp, a.timestamp
+  end
+
+  def test_timestamp_returns_latest_prereq_timestamp
+    a = task :a => ["b", "c"]
+    b = task :b
+    c = task :c
+
+    faux_stamp = 100
+    flexmock(Time, :now => faux_stamp-10)
+    flexmock(b, :timestamp => faux_stamp - 1)
+    flexmock(c, :timestamp => faux_stamp)
+
+    assert_equal faux_stamp, a.timestamp
+  end
+
   def test_investigation_output
     t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
     task(:t2)
@@ -221,9 +278,17 @@ class TestTaskWithArguments < Test::Unit::TestCase
   include CaptureStdout
   include Rake
   include TestMethods
+  include Rake::DSL
 
   def setup
+    super
     Task.clear
+    Rake::TaskManager.record_task_metadata = true
+  end
+
+  def teardown
+    Rake::TaskManager.record_task_metadata = false
+    super
   end
 
   def test_no_args_given