lotrd 0.1.3 → 0.1.9

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_path_map_explode.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMapExplode < Rake::TestCase
+  def setup
+    super
+
+    String.class_eval { public :pathmap_explode }
+  end
+
+  def teardown
+    String.class_eval { protected :pathmap_explode }
+
+    super
+  end
+
+  def test_explode
+    assert_equal ['a'], 'a'.pathmap_explode
+    assert_equal ['a', 'b'], 'a/b'.pathmap_explode
+    assert_equal ['a', 'b', 'c'], 'a/b/c'.pathmap_explode
+    assert_equal ['/', 'a'], '/a'.pathmap_explode
+    assert_equal ['/', 'a', 'b'], '/a/b'.pathmap_explode
+    assert_equal ['/', 'a', 'b', 'c'], '/a/b/c'.pathmap_explode
+
+    if File::ALT_SEPARATOR
+      assert_equal ['c:.', 'a'], 'c:a'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b'], 'c:a/b'.pathmap_explode
+      assert_equal ['c:.', 'a', 'b', 'c'], 'c:a/b/c'.pathmap_explode
+      assert_equal ['c:/', 'a'], 'c:/a'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b'], 'c:/a/b'.pathmap_explode
+      assert_equal ['c:/', 'a', 'b', 'c'], 'c:/a/b/c'.pathmap_explode
+    end
+  end
+end
+

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_path_map_partial.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMapPartial < Rake::TestCase
+  def test_pathmap_partial
+    @path = "1/2/file"
+    def @path.call(n)
+      pathmap_partial(n)
+    end
+    assert_equal("1", @path.call(1))
+    assert_equal("1/2", @path.call(2))
+    assert_equal("1/2", @path.call(3))
+    assert_equal(".", @path.call(0))
+    assert_equal("2", @path.call(-1))
+    assert_equal("1/2", @path.call(-2))
+    assert_equal("1/2", @path.call(-3))
+  end
+end
+

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_pathname_extensions.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/ext/pathname'
+
+class TestRakePathnameExtensions < Rake::TestCase
+  def test_ext_works_on_pathnames
+    pathname = Pathname.new("abc.foo")
+    assert_equal Pathname.new("abc.bar"), pathname.ext("bar")
+  end
+
+  def test_path_map_works_on_pathnames
+    pathname = Pathname.new("this/is/a/dir/abc.rb")
+    assert_equal Pathname.new("abc.rb"), pathname.pathmap("%f")
+    assert_equal Pathname.new("this/is/a/dir"), pathname.pathmap("%d")
+  end
+end

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_pseudo_status.rb

@@ -0,0 +1,21 @@
+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
+    refute 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
+    refute s.stopped?
+    assert s.exited?
+  end
+end

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_rake_test_loader.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeRakeTestLoader < Rake::TestCase
+
+  def test_pattern
+    orig_loaded_features = $:.dup
+    FileUtils.touch 'foo.rb'
+    FileUtils.touch 'test_a.rb'
+    FileUtils.touch 'test_b.rb'
+
+    ARGV.replace %w[foo.rb test_*.rb -v]
+
+    load File.join(@rake_lib, 'rake/rake_test_loader.rb')
+
+    assert_equal %w[-v], ARGV
+  ensure
+    $:.replace orig_loaded_features
+  end
+
+end

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_reduce_compat.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../helper', __FILE__)
+require 'open3'
+
+class TestRakeReduceCompat < Rake::TestCase
+  include RubyRunner
+
+  def invoke_normal(task_name)
+    rake task_name.to_s
+    @out
+  end
+
+  def test_no_deprecated_dsl
+    rakefile %q{
+      task :check_task do
+        Module.new { p defined?(task) }
+      end
+
+      task :check_file do
+        Module.new { p defined?(file) }
+      end
+    }
+
+    assert_equal "nil", invoke_normal(:check_task).chomp
+    assert_equal "nil", invoke_normal(:check_file).chomp
+  end
+end

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_require.rb

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

data/vendor/cache/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_rules.rb

@@ -0,0 +1,388 @@
+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
+
+  def test_string_rule_with_args
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule '.o', [:a] => SRCFILE do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_regex_rule_with_args
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule(/.o$/, [:a] => SRCFILE) do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_string_rule_with_args_and_lambda_prereq
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule '.o', [:a] => [lambda{SRCFILE}]do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_regex_rule_with_args_and_lambda_prereq
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule(/.o$/, [:a] => [lambda{SRCFILE}]) do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_rule_with_method_prereq
+    create_file(".foo")
+    obj = Object.new
+    def obj.find_prereq
+      ".foo"
+    end
+    rule '.o' => obj.method(:find_prereq) do |t|
+      @runs << "#{t.name} - #{t.source}"
+    end
+    Task[OBJFILE].invoke
+    assert_equal ["#{OBJFILE} - .foo"], @runs
+  end
+
+  def test_rule_with_one_arg_method_prereq
+    create_file(SRCFILE)
+    obj = Object.new
+    def obj.find_prereq(task_name)
+      task_name.ext(".c")
+    end
+    rule '.o' => obj.method(:find_prereq) do |t|
+      @runs << "#{t.name} - #{t.source}"
+    end
+    Task[OBJFILE].invoke
+    assert_equal ["#{OBJFILE} - abc.c"], @runs
+  end
+
+end