rake 10.5.0 → 13.0.6

data/test/test_rake_task.rb

@@ -1,393 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'fileutils'
-
-class TestRakeTask < Rake::TestCase
-  include Rake
-
-  def setup
-    super
-
-    Task.clear
-    Rake::TaskManager.record_task_metadata = true
-  end
-
-  def teardown
-    Rake::TaskManager.record_task_metadata = false
-    Rake.application.thread_pool.join
-
-    super
-  end
-
-  def test_create
-    arg = nil
-    t = task(:name) { |task| arg = task; 1234 }
-    assert_equal "name", t.name
-    assert_equal [], t.prerequisites
-    assert t.needed?
-    t.execute(0)
-    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
-    t = task(:foo => [:bar, :baz])
-    assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
-  end
-
-  def test_invoke
-    runlist = []
-    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
-    task(:t2) { |t| runlist << t.name }
-    task(:t3) { |t| runlist << t.name }
-    assert_equal ["t2", "t3"], t1.prerequisites
-    t1.invoke
-    assert_equal ["t2", "t3", "t1"], runlist
-  end
-
-  def test_invoke_with_circular_dependencies
-    runlist = []
-    t1 = task(:t1 => [:t2]) { |t| runlist << t.name; 3321 }
-    t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
-    assert_equal ["t2"], t1.prerequisites
-    assert_equal ["t1"], t2.prerequisites
-    ex = assert_raises 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 = []
-    t1 = task(:t1) { |t| runlist << t.name; 3321 }
-    _, err = capture_io { t1.invoke }
-    assert_match(/execute .*t1/i, err)
-    assert_match(/dry run/i, err)
-    refute_match(/invoke/i, err)
-    assert_equal [], runlist
-  ensure
-    Rake.application.options.dryrun = false
-  end
-
-  def test_tasks_can_be_traced
-    Rake.application.options.trace = true
-    t1 = task(:t1)
-    _, err = capture_io {
-      t1.invoke
-    }
-    assert_match(/invoke t1/i, err)
-    assert_match(/execute t1/i, err)
-  ensure
-    Rake.application.options.trace = false
-  end
-
-  def test_no_double_invoke
-    runlist = []
-    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
-    task(:t2 => [:t3]) { |t| runlist << t.name }
-    task(:t3) { |t| runlist << t.name }
-    t1.invoke
-    assert_equal ["t3", "t2", "t1"], runlist
-  end
-
-  def test_can_double_invoke_with_reenable
-    runlist = []
-    t1 = task(:t1) { |t| runlist << t.name }
-    t1.invoke
-    t1.reenable
-    t1.invoke
-    assert_equal ["t1", "t1"], runlist
-  end
-
-  def test_clear
-    desc "a task"
-    t = task("t" => "a") { }
-    t.clear
-    assert t.prerequisites.empty?, "prerequisites should be empty"
-    assert t.actions.empty?, "actions should be empty"
-    assert_nil t.comment, "comments should be empty"
-  end
-
-  def test_clear_prerequisites
-    t = task("t" => ["a", "b"])
-    assert_equal ['a', 'b'], t.prerequisites
-    t.clear_prerequisites
-    assert_equal [], t.prerequisites
-  end
-
-  def test_clear_actions
-    t = task("t") { }
-    t.clear_actions
-    assert t.actions.empty?, "actions should be empty"
-  end
-
-  def test_clear_comments
-    desc "the original foo"
-    task :foo => [:x] do
-      # Dummy action
-    end
-
-    task(:foo).clear_comments
-
-    desc "a slightly different foo"
-    task :foo
-
-    assert_equal "a slightly different foo", task(:foo).comment
-    assert_equal ["x"], task(:foo).prerequisites
-    assert_equal 1, task(:foo).actions.size
-  end
-
-  def test_find
-    task :tfind
-    assert_equal "tfind", Task[:tfind].name
-    ex = assert_raises(RuntimeError) { Task[:leaves] }
-    assert_equal "Don't know how to build task 'leaves' (see --tasks)", ex.message
-  end
-
-  def test_defined
-    assert ! Task.task_defined?(:a)
-    task :a
-    assert Task.task_defined?(:a)
-  end
-
-  def test_multi_invocations
-    runs = []
-    p = proc do |t| runs << t.name end
-    task({ :t1 => [:t2, :t3] }, &p)
-    task({ :t2 => [:t3] }, &p)
-    task(:t3, &p)
-    Task[:t1].invoke
-    assert_equal ["t1", "t2", "t3"], runs.sort
-  end
-
-  def test_task_list
-    task :t2
-    task :t1 => [:t2]
-    assert_equal ["t1", "t2"], Task.tasks.map { |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
-
-  def test_prerequisite_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_prerequisite_tasks_fails_if_prerequisites_are_undefined
-    a = task :a => ["b", "c"]
-    task :b
-    assert_raises(RuntimeError) do
-      a.prerequisite_tasks
-    end
-  end
-
-  def test_prerequisite_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_all_prerequisite_tasks_includes_all_prerequisites
-    a = task :a => "b"
-    b = task :b => ["c", "d"]
-    c = task :c => "e"
-    d = task :d
-    e = task :e
-
-    assert_equal [b, c, d, e], a.all_prerequisite_tasks.sort_by { |t| t.name }
-  end
-
-  def test_all_prerequisite_tasks_does_not_include_duplicates
-    a = task :a => ["b", "c"]
-    b = task :b => "c"
-    c = task :c
-
-    assert_equal [b, c], a.all_prerequisite_tasks.sort_by { |t| t.name }
-  end
-
-  def test_all_prerequisite_tasks_includes_self_on_cyclic_dependencies
-    a = task :a => "b"
-    b = task :b => "a"
-
-    assert_equal [a, b], a.all_prerequisite_tasks.sort_by { |t| t.name }
-  end
-
-  def test_timestamp_returns_now_if_all_prereqs_have_no_times
-    a = task :a => ["b", "c"]
-    task :b
-    task :c
-
-    assert_in_delta Time.now, a.timestamp, 0.1, 'computer too slow?'
-  end
-
-  def test_timestamp_returns_latest_prereq_timestamp
-    a = task :a => ["b", "c"]
-    b = task :b
-    c = task :c
-
-    now = Time.now
-    def b.timestamp() Time.now + 10 end
-    def c.timestamp() Time.now + 5 end
-
-    assert_in_delta now, a.timestamp, 0.1, 'computer too slow?'
-  end
-
-  def test_always_multitask
-    mx = Mutex.new
-    result = []
-
-    t_a = task(:a) do |t|
-      sleep 0.2
-      mx.synchronize { result << t.name }
-    end
-
-    t_b = task(:b) do |t|
-      mx.synchronize { result << t.name }
-    end
-
-    t_c = task(:c => [:a, :b]) do |t|
-      mx.synchronize { result << t.name }
-    end
-
-    t_c.invoke
-
-    # task should always run in order
-    assert_equal ['a', 'b', 'c'], result
-
-    [t_a, t_b, t_c].each { |t| t.reenable }
-    result.clear
-
-    Rake.application.options.always_multitask = true
-    t_c.invoke
-
-    # with multitask, task 'b' should grab the mutex first
-    assert_equal ['b', 'a', 'c'], result
-  end
-
-  def test_investigation_output
-    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
-    task(:t2)
-    task(:t3)
-    out = t1.investigation
-    assert_match(/class:\s*Rake::Task/, out)
-    assert_match(/needed:\s*true/, out)
-    assert_match(/pre-requisites:\s*--t[23]/, out)
-  end
-
-  # NOTE: Rail-ties uses comment=.
-  def test_comment_setting
-    t = task(:t, :name, :rev)
-    t.comment = "A Comment"
-    assert_equal "A Comment", t.comment
-  end
-
-  def test_comments_with_sentences
-    desc "Comment 1. Comment 2."
-    t = task(:t, :name, :rev)
-    assert_equal "Comment 1", t.comment
-  end
-
-  def test_comments_with_tabbed_sentences
-    desc "Comment 1.\tComment 2."
-    t = task(:t, :name, :rev)
-    assert_equal "Comment 1", t.comment
-  end
-
-  def test_comments_with_decimal_points
-    desc "Revision 1.2.3."
-    t = task(:t, :name, :rev)
-    assert_equal "Revision 1.2.3", t.comment
-  end
-
-  def test_comments_do_not_set
-    t = task(:t, :name, :rev)
-    assert_equal nil, t.comment
-  end
-
-  def test_comments_is_nil
-    t = task(:t, :name, :rev)
-    t.comment = nil
-    assert_equal nil, t.comment
-  end
-
-  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 = task(: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 = task(:t)
-    desc "line two"
-    task(:t)
-    assert_equal "line one / line two", t.comment
-  end
-
-  def test_duplicate_comments
-    desc "line one"
-    t = task(:t)
-    desc "line one"
-    task(:t)
-    assert_equal "line one", t.comment
-  end
-
-  def test_interspersed_duplicate_comments
-    desc "line one"
-    t = task(:t)
-    desc "line two"
-    task(:t)
-    desc "line one"
-    task(:t)
-    assert_equal "line one / line two", t.comment
-  end
-
-  def test_source_is_first_prerequisite
-    t = task :t => ["preqA", "preqB"]
-    assert_equal "preqA", t.source
-  end
-end

data/test/test_rake_task_argument_parsing.rb

@@ -1,119 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTaskArgumentParsing < Rake::TestCase
-  def setup
-    super
-
-    @app = Rake::Application.new
-  end
-
-  def test_name_only
-    name, args = @app.parse_task_string("name")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-
-  def test_empty_args
-    name, args = @app.parse_task_string("name[]")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-
-  def test_one_argument
-    name, args = @app.parse_task_string("name[one]")
-    assert_equal "name", name
-    assert_equal ["one"], args
-  end
-
-  def test_two_arguments
-    name, args = @app.parse_task_string("name[one,two]")
-    assert_equal "name", name
-    assert_equal ["one", "two"], args
-  end
-
-  def test_can_handle_spaces_between_args
-    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
-    assert_equal "name", name
-    assert_equal ["one", "two", "three", "four"], args
-  end
-
-  def test_keeps_embedded_spaces
-    name, args = @app.parse_task_string("name[a one ana, two]")
-    assert_equal "name", name
-    assert_equal ["a one ana", "two"], args
-  end
-
-  def test_can_handle_commas_in_args
-    name, args = @app.parse_task_string("name[one, two, three_a\\, three_b, four]")
-    assert_equal "name", name
-    assert_equal ["one", "two", "three_a, three_b", "four"], args
-  end
-
-  def test_treat_blank_arg_as_empty_string
-    name, args = @app.parse_task_string("name[one,]")
-    assert_equal "name", name
-    assert_equal ["one", ""], args
-
-    name, args = @app.parse_task_string("name[one,,two]")
-    assert_equal "name", name
-    assert_equal ["one", "", "two"], args
-  end
-
-  def test_terminal_width_using_env
-    app = Rake::Application.new
-    app.terminal_columns = 1234
-
-    assert_equal 1234, app.terminal_width
-  end
-
-  def test_terminal_width_using_stty
-    def @app.unix?() true end
-    def @app.dynamic_width_stty() 1235 end
-    def @app.dynamic_width_tput() 0 end
-
-    assert_equal 1235, @app.terminal_width
-  end
-
-  def test_terminal_width_using_tput
-    def @app.unix?() true end
-    def @app.dynamic_width_stty() 0 end
-    def @app.dynamic_width_tput() 1236 end
-
-    assert_equal 1236, @app.terminal_width
-  end
-
-  def test_terminal_width_using_hardcoded_80
-    def @app.unix?() false end
-
-    assert_equal 80, @app.terminal_width
-  end
-
-  def test_terminal_width_with_failure
-    def @app.unix?() raise end
-
-    assert_equal 80, @app.terminal_width
-  end
-
-  def test_no_rakeopt
-    ARGV << '--trace'
-    app = Rake::Application.new
-    app.init
-    assert !app.options.silent
-  end
-
-  def test_rakeopt_with_blank_options
-    ARGV << '--trace'
-    app = Rake::Application.new
-    app.init
-    assert !app.options.silent
-  end
-
-  def test_rakeopt_with_silent_options
-    ENV['RAKEOPT'] = '-s'
-    app = Rake::Application.new
-
-    app.init
-
-    assert app.options.silent
-  end
-end

data/test/test_rake_task_arguments.rb

@@ -1,127 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-######################################################################
-class TestRakeTaskArguments < Rake::TestCase
-  def teardown
-    ENV.delete('rev')
-    ENV.delete('VER')
-
-    super
-  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_has_key
-    ta = Rake::TaskArguments.new([:a], [:one])
-    assert(ta.has_key?(:a))
-    refute(ta.has_key?(:b))
-  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.map { |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_do_not_reference_env_values
-    ta = Rake::TaskArguments.new(["aa"], [1])
-    ENV['rev'] = "1.2"
-    ENV['VER'] = "2.3"
-    assert_nil ta.rev
-    assert_nil ta.ver
-  end
-
-  def test_creating_new_argument_scopes
-    parent = Rake::TaskArguments.new(['p'], [1])
-    child = parent.new_scope(['c', 'p'])
-    assert_equal({: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
-
-  def test_default_arguments_values_can_be_merged
-    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
-    ta.with_defaults({ :aa => 'default_val' })
-    assert_equal 'default_val', ta[:aa]
-    assert_equal 'original_val', ta[:bb]
-  end
-
-  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]
-  end
-
-  def test_all_and_extra_arguments_without_named_arguments
-    app = Rake::Application.new
-    _, args = app.parse_task_string("task[1,two,more]")
-    ta = Rake::TaskArguments.new([], args)
-    assert_equal [], ta.names
-    assert_equal ['1', 'two', 'more'], ta.to_a
-    assert_equal ['1', 'two', 'more'], ta.extras
-  end
-
-  def test_all_and_extra_arguments_with_named_arguments
-    app = Rake::Application.new
-    _, args = app.parse_task_string("task[1,two,more,still more]")
-    ta = Rake::TaskArguments.new([:first, :second], args)
-    assert_equal [:first, :second], ta.names
-    assert_equal "1", ta[:first]
-    assert_equal "two", ta[:second]
-    assert_equal ['1', 'two', 'more', 'still more'], ta.to_a
-    assert_equal ['more', 'still more'], ta.extras
-  end
-
-  def test_extra_args_with_less_than_named_arguments
-    app = Rake::Application.new
-    _, args = app.parse_task_string("task[1,two]")
-    ta = Rake::TaskArguments.new([:first, :second, :third], args)
-    assert_equal [:first, :second, :third], ta.names
-    assert_equal "1", ta[:first]
-    assert_equal "two", ta[:second]
-    assert_equal nil, ta[:third]
-    assert_equal ['1', 'two'], ta.to_a
-    assert_equal [], ta.extras
-  end
-
-end

data/test/test_rake_task_lib.rb

@@ -1,9 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/tasklib'
-
-class TestRakeTaskLib < Rake::TestCase
-  def test_paste
-    tl = Rake::TaskLib.new
-    assert_equal :ab, tl.paste(:a, :b)
-  end
-end