rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/rake-0.9.6/test/test_rake_rules.rb

@@ -1,327 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'fileutils'
-
-class TestRakeRules < Rake::TestCase
-  include Rake
-
-  SRCFILE    = "abc.c"
-  SRCFILE2   = "xyz.c"
-  FTNFILE    = "abc.f"
-  OBJFILE    = "abc.o"
-  FOOFILE    = "foo"
-  DOTFOOFILE = ".foo"
-
-  def setup
-    super
-
-    Task.clear
-    @runs = []
-  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
-      create_file('.foo')
-      rule '.o' => "./.foo" do |t|
-        @runs << t.name
-      end
-      Task[OBJFILE].invoke
-      assert_equal [OBJFILE], @runs
-    end
-  end
-
-  def test_file_names_beginning_with_dot_can_be_wrapped_in_lambda
-    verbose(false) 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
-
-  def test_file_names_containing_percent_can_be_wrapped_in_lambda
-    verbose(false) 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
-
-  def test_non_extension_rule_name_refers_to_file
-    verbose(false) do
-      create_file("abc.c")
-      rule "abc" => '.c' do |t|
-        @runs << t.name
-      end
-      Task["abc"].invoke
-      assert_equal ["abc"], @runs
-    end
-  end
-
-  def test_pathmap_automatically_applies_to_name
-    verbose(false) 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
-
-  def test_plain_strings_are_just_filenames
-    verbose(false) 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
-
-  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("x.c")
-    rule '.o' => ['.c'] do |t|
-      @runs << t.name
-    end
-    assert_raises(RuntimeError) { Task['x.obj'].invoke }
-    assert_raises(RuntimeError) { Task['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("src/jw")
-    create_file("src/jw/X.java")
-    rule %r(classes/.*\.class) => [
-      proc { |fn| fn.pathmap("%{classes,src}d/%n.java") }
-    ] do |task|
-      assert_equal task.name, 'classes/jw/X.class'
-      assert_equal task.source, 'src/jw/X.java'
-      @runs << :RULE
-    end
-    Task['classes/jw/X.class'].invoke
-    assert_equal [:RULE], @runs
-  ensure
-    rm_r("src", :verbose=>false) rescue nil
-  end
-
-  def test_proc_returning_lists_are_flattened_into_prereqs
-    ran = false
-    mkdir_p("flatten")
-    create_file("flatten/a.txt")
-    task 'flatten/b.data' do |t|
-      ran = true
-      touch t.name, :verbose => false
-    end
-    rule '.html' =>
-      proc { |fn|
-      [
-        fn.ext("txt"),
-        "flatten/b.data"
-      ]
-    } do |task|
-    end
-    Task['flatten/a.html'].invoke
-    assert ran, "Should have triggered flattened dependency"
-  ensure
-    rm_r("flatten", :verbose=>false) rescue nil
-  end
-
-  def test_recursive_rules_will_work_as_long_as_they_terminate
-    actions = []
-    create_file("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["abc.exe"].invoke
-    assert_equal ['y', 'c', 'o', 'exe'], actions
-  end
-
-  def test_recursive_rules_that_dont_terminate_will_overflow
-    create_file("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["a.z"].invoke
-    }
-    assert_match(/a\.z => 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
-

data/vendor/bundle/ruby/2.1.0/gems/rake-0.9.6/test/test_rake_task.rb

@@ -1,316 +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
-
-    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, :needs => [:bar, :baz])
-    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 }
-    t2 = task(:t2) { |t| runlist << t.name }
-    t3 = 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 }
-    t2 = task(:t2 => [:t3]) { |t| runlist << t.name }
-    t3 = 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'", 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.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
-
-  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_raises(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
-
-    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 + 10, a.timestamp, 0.1, 'computer too slow?'
-  end
-
-  def test_always_multitask
-    mx = Mutex.new
-    result = []
-
-    t_a = task(:a) do |t|
-      sleep 0.02
-      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
-
-
-  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_settable_comments
-    t = task(:t)
-    t.comment = "HI"
-    assert_equal "HI", t.comment
-  end
-end