rake 0.9.2 → 13.0.3

data/test/test_rake_pseudo_status.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakePseudoStatus < Rake::TestCase
-  def test_with_zero_exit_status
-    s = Rake::PseudoStatus.new
-    assert_equal 0, s.exitstatus
-    assert_equal 0, s.to_i
-    assert_equal 0, s >> 8
-    assert ! s.stopped?
-    assert s.exited?
-  end
-  def test_with_99_exit_status
-    s = Rake::PseudoStatus.new(99)
-    assert_equal 99, s.exitstatus
-    assert_equal 25344, s.to_i
-    assert_equal 99, s >> 8
-    assert ! s.stopped?
-    assert s.exited?
-  end
-end

data/test/test_rake_rdoc_task.rb

@@ -1,81 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-begin
-  old_verbose = $VERBOSE
-  $VERBOSE = nil
-  require 'rake/rdoctask'
-ensure
-  $VERBOSE = old_verbose
-end
-
-class TestRakeRDocTask < Rake::TestCase
-  include Rake
-
-  def setup
-    super
-
-    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]
-    assert Task[:clobber_rdoc_dev]
-    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]
-    assert Task[:clobber_rdoc_dev]
-    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)
-    assert Task[:"rdoc"]
-    assert Task[:"rdoc:clean"]
-    assert Task[:"rdoc:force"]
-    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
-    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_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
-end

data/test/test_rake_require.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeRequire < Rake::TestCase
-
-  def test_can_load_rake_library
-    app = Rake::Application.new
-    assert app.instance_eval {
-      rake_require("test2", ['test/data/rakelib'], [])
-    }
-  end
-
-  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", paths, loaded_files)
-    }
-  end
-
-  def test_throws_error_if_library_not_found
-    app = Rake::Application.new
-    ex = assert_raises(LoadError) {
-      assert app.instance_eval {
-        rake_require("testx", ['test/data/rakelib'], [])
-      }
-    }
-    assert_match(/(can *not|can't)\s+find/i, ex.message)
-    assert_match(/testx/, ex.message)
-  end
-end
-

data/test/test_rake_rules.rb

@@ -1,346 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'fileutils'
-
-######################################################################
-class TestRakeRules < Rake::TestCase
-  include Rake
-
-  SRCFILE  = "testdata/abc.c"
-  SRCFILE2 =  "testdata/xyz.c"
-  FTNFILE  = "testdata/abc.f"
-  OBJFILE  = "testdata/abc.o"
-  FOOFILE  = "testdata/foo"
-  DOTFOOFILE = "testdata/.foo"
-
-  def setup
-    super
-
-    Task.clear
-    @runs = []
-    FileUtils.mkdir_p 'testdata' # HACK use tmpdir
-  end
-
-  def teardown
-    FileList['testdata/*'].uniq.each do |f| rm_r(f, :verbose=>false) end
-
-    super
-  end
-
-  def test_multiple_rules1
-    create_file(FTNFILE)
-    delete_file(SRCFILE)
-    delete_file(OBJFILE)
-    rule(/\.o$/ => ['.c']) do @runs << :C end
-    rule(/\.o$/ => ['.f']) do @runs << :F end
-    t = Task[OBJFILE]
-    t.invoke
-    Task[OBJFILE].invoke
-    assert_equal [:F], @runs
-  end
-
-  def test_multiple_rules2
-    create_file(FTNFILE)
-    delete_file(SRCFILE)
-    delete_file(OBJFILE)
-    rule(/\.o$/ => ['.f']) do @runs << :F end
-    rule(/\.o$/ => ['.c']) do @runs << :C end
-    Task[OBJFILE].invoke
-    assert_equal [:F], @runs
-  end
-
-  def test_create_with_source
-    create_file(SRCFILE)
-    rule(/\.o$/ => ['.c']) do |t|
-      @runs << t.name
-      assert_equal OBJFILE, t.name
-      assert_equal SRCFILE, t.source
-    end
-    Task[OBJFILE].invoke
-    assert_equal [OBJFILE], @runs
-  end
-
-  def test_single_dependent
-    create_file(SRCFILE)
-    rule(/\.o$/ => '.c') do |t|
-      @runs << t.name
-    end
-    Task[OBJFILE].invoke
-    assert_equal [OBJFILE], @runs
-  end
-
-  def test_rule_can_be_created_by_string
-    create_file(SRCFILE)
-    rule '.o' => ['.c'] do |t|
-      @runs << t.name
-    end
-    Task[OBJFILE].invoke
-    assert_equal [OBJFILE], @runs
-  end
-
-  def test_rule_prereqs_can_be_created_by_string
-    create_file(SRCFILE)
-    rule '.o' => '.c' do |t|
-      @runs << t.name
-    end
-    Task[OBJFILE].invoke
-    assert_equal [OBJFILE], @runs
-  end
-
-  def test_plain_strings_as_dependents_refer_to_files
-    create_file(SRCFILE)
-    rule '.o' => SRCFILE do |t|
-      @runs << t.name
-    end
-    Task[OBJFILE].invoke
-    assert_equal [OBJFILE], @runs
-  end
-
-  def test_file_names_beginning_with_dot_can_be_tricked_into_referring_to_file
-    verbose(false) do
-      chdir("testdata") do
-        create_file('.foo')
-        rule '.o' => "./.foo" do |t|
-          @runs << t.name
-        end
-        Task[OBJFILE].invoke
-        assert_equal [OBJFILE], @runs
-      end
-    end
-  end
-
-  def test_file_names_beginning_with_dot_can_be_wrapped_in_lambda
-    verbose(false) do
-      chdir("testdata") do
-        create_file(".foo")
-        rule '.o' => lambda{".foo"} do |t|
-          @runs << "#{t.name} - #{t.source}"
-        end
-        Task[OBJFILE].invoke
-        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
-
-  def test_non_extension_rule_name_refers_to_file
-    verbose(false) do
-      chdir("testdata") do
-        create_file("abc.c")
-        rule "abc" => '.c' do |t|
-          @runs << t.name
-        end
-        Task["abc"].invoke
-        assert_equal ["abc"], @runs
-      end
-    end
-  end
-
-  def test_pathmap_automatically_applies_to_name
-    verbose(false) do
-      chdir("testdata") do
-        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 - plainname"], @runs
-      end
-    end
-  end
-
-  def test_rule_runs_when_explicit_task_has_no_actions
-    create_file(SRCFILE)
-    create_file(SRCFILE2)
-    delete_file(OBJFILE)
-    rule '.o' => '.c' do |t|
-      @runs << t.source
-    end
-    file OBJFILE => [SRCFILE2]
-    Task[OBJFILE].invoke
-    assert_equal [SRCFILE], @runs
-  end
-
-  def test_close_matches_on_name_do_not_trigger_rule
-    create_file("testdata/x.c")
-    rule '.o' => ['.c'] do |t|
-      @runs << t.name
-    end
-    assert_raises(RuntimeError) { Task['testdata/x.obj'].invoke }
-    assert_raises(RuntimeError) { Task['testdata/x.xyo'].invoke }
-  end
-
-  def test_rule_rebuilds_obj_when_source_is_newer
-    create_timed_files(OBJFILE, SRCFILE)
-    rule(/\.o$/ => ['.c']) do
-      @runs << :RULE
-    end
-    Task[OBJFILE].invoke
-    assert_equal [:RULE], @runs
-  end
-
-  def test_rule_with_two_sources_runs_if_both_sources_are_present
-    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
-    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
-      @runs << :RULE
-    end
-    Task[OBJFILE].invoke
-    assert_equal [:RULE], @runs
-  end
-
-  def test_rule_with_two_sources_but_one_missing_does_not_run
-    create_timed_files(OBJFILE, SRCFILE)
-    delete_file(SRCFILE2)
-    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
-      @runs << :RULE
-    end
-    Task[OBJFILE].invoke
-    assert_equal [], @runs
-  end
-
-  def test_rule_with_two_sources_builds_both_sources
-    task 'x.aa'
-    task 'x.bb'
-    rule '.a' => '.aa' do
-      @runs << "A"
-    end
-    rule '.b' => '.bb' do
-      @runs << "B"
-    end
-    rule ".c" => ['.a', '.b'] do
-      @runs << "C"
-    end
-    Task["x.c"].invoke
-    assert_equal ["A", "B", "C"], @runs.sort
-  end
-
-  def test_second_rule_runs_when_first_rule_doesnt
-    create_timed_files(OBJFILE, SRCFILE)
-    delete_file(SRCFILE2)
-    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
-      @runs << :RULE1
-    end
-    rule OBJFILE => [lambda{SRCFILE}] do
-      @runs << :RULE2
-    end
-    Task[OBJFILE].invoke
-    assert_equal [:RULE2], @runs
-  end
-
-  def test_second_rule_doest_run_if_first_triggers
-    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
-    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
-      @runs << :RULE1
-    end
-    rule OBJFILE => [lambda{SRCFILE}] do
-      @runs << :RULE2
-    end
-    Task[OBJFILE].invoke
-    assert_equal [:RULE1], @runs
-  end
-
-  def test_second_rule_doest_run_if_first_triggers_with_reversed_rules
-    create_timed_files(OBJFILE, SRCFILE, SRCFILE2)
-    rule OBJFILE => [lambda{SRCFILE}] do
-      @runs << :RULE1
-    end
-    rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do
-      @runs << :RULE2
-    end
-    Task[OBJFILE].invoke
-    assert_equal [:RULE1], @runs
-  end
-
-  def test_rule_with_proc_dependent_will_trigger
-    mkdir_p("testdata/src/jw")
-    create_file("testdata/src/jw/X.java")
-    rule %r(classes/.*\.class) => [
-      proc { |fn| fn.pathmap("%{classes,testdata/src}d/%n.java") }
-    ] do |task|
-      assert_equal task.name, 'classes/jw/X.class'
-      assert_equal task.source, 'testdata/src/jw/X.java'
-      @runs << :RULE
-    end
-    Task['classes/jw/X.class'].invoke
-    assert_equal [:RULE], @runs
-  ensure
-    rm_r("testdata/src", :verbose=>false) rescue nil
-  end
-
-  def test_proc_returning_lists_are_flattened_into_prereqs
-    ran = false
-    mkdir_p("testdata/flatten")
-    create_file("testdata/flatten/a.txt")
-    task 'testdata/flatten/b.data' do |t|
-      ran = true
-      touch t.name, :verbose => false
-    end
-    rule '.html' =>
-      proc { |fn|
-      [
-        fn.ext("txt"),
-        "testdata/flatten/b.data"
-      ]
-    } do |task|
-    end
-    Task['testdata/flatten/a.html'].invoke
-    assert ran, "Should have triggered flattened dependency"
-  ensure
-    rm_r("testdata/flatten", :verbose=>false) rescue nil
-  end
-
-  def test_recursive_rules_will_work_as_long_as_they_terminate
-    actions = []
-    create_file("testdata/abc.xml")
-    rule '.y' => '.xml' do actions << 'y' end
-    rule '.c' => '.y' do actions << 'c'end
-    rule '.o' => '.c' do actions << 'o'end
-    rule '.exe' => '.o' do actions << 'exe'end
-    Task["testdata/abc.exe"].invoke
-    assert_equal ['y', 'c', 'o', 'exe'], actions
-  end
-
-  def test_recursive_rules_that_dont_terminate_will_overflow
-    create_file("testdata/a.a")
-    prev = 'a'
-    ('b'..'z').each do |letter|
-      rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end
-      prev = letter
-    end
-    ex = assert_raises(Rake::RuleRecursionOverflowError) {
-      Task["testdata/a.z"].invoke
-    }
-    assert_match(/a\.z => testdata\/a.y/, ex.message)
-  end
-
-  def test_rules_with_bad_dependents_will_fail
-    rule "a" => [ 1 ] do |t| puts t.name end
-    assert_raises(RuntimeError) do Task['a'].invoke end
-  end
-
-end
-