daslabs 0.4.0

data/vendor/cache/ruby/2.5.0/gems/rake-10.5.0/test/test_rake_file_list_path_map.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeFileListPathMap < Rake::TestCase
+  def test_file_list_supports_pathmap
+    assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n")
+  end
+end
+

data/vendor/cache/ruby/2.5.0/gems/rake-10.5.0/test/test_rake_file_task.rb

@@ -0,0 +1,197 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+require 'pathname'
+
+class TestRakeFileTask < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    Task.clear
+    @runs = Array.new
+    FileUtils.rm_f NEWFILE
+    FileUtils.rm_f OLDFILE
+  end
+
+  def test_file_need
+    name = "dummy"
+    file name
+
+    ftask = Task[name]
+
+    assert_equal name.to_s, ftask.name
+    File.delete(ftask.name) rescue nil
+
+    assert ftask.needed?, "file should be needed"
+    assert_equal Rake::LATE, ftask.timestamp
+
+    open(ftask.name, "w") { |f| f.puts "HI" }
+
+    assert_equal nil, ftask.prerequisites.map { |n| Task[n].timestamp }.max
+    assert ! ftask.needed?, "file should not be needed"
+  ensure
+    File.delete(ftask.name) rescue nil
+  end
+
+  def test_file_times_new_depends_on_old
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = Rake.application.intern(FileTask, NEWFILE).enhance([OLDFILE])
+    t2 = Rake.application.intern(FileTask, OLDFILE)
+    assert ! t2.needed?, "Should not need to build old file"
+    assert ! t1.needed?, "Should not need to rebuild new file because of old"
+  end
+
+  def test_file_times_new_depend_on_regular_task_timestamps
+    load_phony
+
+    name = "dummy"
+    task name
+
+    create_timed_files(NEWFILE)
+
+    t1 = Rake.application.intern(FileTask, NEWFILE).enhance([name])
+
+    assert t1.needed?, "depending on non-file task uses Time.now"
+
+    task(name => :phony)
+
+    assert t1.needed?, "unless the non-file task has a timestamp"
+  end
+
+  def test_file_times_old_depends_on_new
+    create_timed_files(OLDFILE, NEWFILE)
+
+    t1 = Rake.application.intern(FileTask, OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileTask, NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    preq_stamp = t1.prerequisites.map { |t| Task[t].timestamp }.max
+    assert_equal t2.timestamp, preq_stamp
+    assert t1.timestamp < preq_stamp, "T1 should be older"
+    assert t1.needed?, "Should need to rebuild old file because of new"
+  end
+
+  def test_file_depends_on_task_depend_on_file
+    create_timed_files(OLDFILE, NEWFILE)
+
+    file NEWFILE => [:obj] do |t| @runs << t.name end
+    task :obj => [OLDFILE] do |t| @runs << t.name end
+    file OLDFILE           do |t| @runs << t.name end
+
+    Task[:obj].invoke
+    Task[NEWFILE].invoke
+    assert @runs.include?(NEWFILE)
+  end
+
+  def test_existing_file_depends_on_non_existing_file
+    create_file(OLDFILE)
+    delete_file(NEWFILE)
+    file NEWFILE            do |t| @runs << t.name end
+    file OLDFILE => NEWFILE do |t| @runs << t.name end
+
+    Task[OLDFILE].invoke
+
+    assert_equal [NEWFILE, OLDFILE], @runs
+  end
+
+  def test_needed_eh_build_all
+    create_file 'a'
+
+    file 'a'
+
+    a_task = Task['a']
+
+    refute a_task.needed?
+
+    Rake.application.options.build_all = true
+
+    assert a_task.needed?
+  ensure
+    delete_file 'a'
+  end
+
+  def test_needed_eh_dependency
+    create_file 'a', Time.now
+    create_file 'b', Time.now - 60
+
+    create_file 'c', Time.now
+    create_file 'd', Time.now - 60
+
+    file 'b' => 'a'
+
+    b_task = Task['b']
+
+    assert b_task.needed?
+
+    file 'c' => 'd'
+
+    c_task = Task['c']
+
+    refute c_task.needed?
+  ensure
+    delete_file 'old'
+    delete_file 'new'
+  end
+
+  def test_needed_eh_exists
+    name = "dummy"
+    file name
+
+    ftask = Task[name]
+
+    assert ftask.needed?
+
+    create_file name
+
+    refute ftask.needed?
+  ensure
+    delete_file name
+  end
+
+  def test_source_is_first_prerequisite
+    t = file :f => ["preqA", "preqB"]
+    assert_equal "preqA", t.source
+  end
+
+  def test_sources_is_all_prerequisites
+    t = file :f => ["preqA", "preqB"]
+    assert_equal ["preqA", "preqB"], t.sources
+  end
+
+  def test_task_can_be_pathname
+      name = "dummy"
+      file Pathname.new name
+
+      ftask = Task[name]
+
+      assert_equal name.to_s, ftask.name
+  end
+
+  def test_prerequisite_can_be_pathname
+    t = file :f => Pathname.new("preq")
+    assert_equal "preq", t.source
+  end
+
+  # I have currently disabled this test.  I'm not convinced that
+  # deleting the file target on failure is always the proper thing to
+  # do.  I'm willing to hear input on this topic.
+  def ztest_file_deletes_on_failure
+    task :obj
+    file NEWFILE => [:obj] do |t|
+      FileUtils.touch NEWFILE
+      fail "Ooops"
+    end
+    assert Task[NEWFILE]
+    begin
+      Task[NEWFILE].invoke
+    rescue Exception
+    end
+    assert(! File.exist?(NEWFILE), "NEWFILE should be deleted")
+  end
+
+  def load_phony
+    load File.join(@rake_lib, "rake/phony.rb")
+  end
+
+end

data/vendor/cache/ruby/2.5.0/gems/rake-10.5.0/test/test_rake_file_utils.rb

@@ -0,0 +1,314 @@
+require File.expand_path('../helper', __FILE__)
+require 'fileutils'
+require 'stringio'
+
+class TestRakeFileUtils < Rake::TestCase
+  def setup
+    super
+    @rake_test_sh = ENV['RAKE_TEST_SH']
+  end
+
+  def teardown
+    FileUtils::LN_SUPPORTED[0] = true
+    RakeFileUtils.verbose_flag = Rake::FileUtilsExt::DEFAULT
+    ENV['RAKE_TEST_SH'] = @rake_test_sh
+
+    super
+  end
+
+  def test_rm_one_file
+    create_file("a")
+    FileUtils.rm_rf "a"
+    refute File.exist?("a")
+  end
+
+  def test_rm_two_files
+    create_file("a")
+    create_file("b")
+    FileUtils.rm_rf ["a", "b"]
+    refute File.exist?("a")
+    refute File.exist?("b")
+  end
+
+  def test_rm_filelist
+    list = Rake::FileList.new << "a" << "b"
+    list.each { |fn| create_file(fn) }
+    FileUtils.rm_r list
+    refute File.exist?("a")
+    refute File.exist?("b")
+  end
+
+  def test_ln
+    open("a", "w") { |f| f.puts "TEST_LN" }
+
+    Rake::FileUtilsExt.safe_ln("a", "b", :verbose => false)
+
+    assert_equal "TEST_LN\n", File.read('b')
+  end
+
+  class BadLink
+    include Rake::FileUtilsExt
+    attr_reader :cp_args
+
+    def initialize(klass)
+      @failure_class = klass
+    end
+
+    def cp(*args)
+      @cp_args = args
+    end
+
+    def ln(*args)
+      fail @failure_class, "ln not supported"
+    end
+
+    public :safe_ln
+  end
+
+  def test_safe_ln_failover_to_cp_on_standard_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(StandardError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+    c.safe_ln "x", "y"
+    assert_equal ['x', 'y'], c.cp_args
+  end
+
+  def test_safe_ln_failover_to_cp_on_not_implemented_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(NotImplementedError)
+    c.safe_ln "a", "b"
+    assert_equal ['a', 'b'], c.cp_args
+  end
+
+  def test_safe_ln_fails_on_script_error
+    FileUtils::LN_SUPPORTED[0] = true
+    c = BadLink.new(ScriptError)
+    assert_raises(ScriptError) do c.safe_ln "a", "b" end
+  end
+
+  def test_verbose
+    verbose true
+    assert_equal true, verbose
+    verbose false
+    assert_equal false, verbose
+    verbose(true) {
+      assert_equal true, verbose
+    }
+    assert_equal false, verbose
+  end
+
+  def test_nowrite
+    nowrite true
+    assert_equal true, nowrite
+    nowrite false
+    assert_equal false, nowrite
+    nowrite(true) {
+      assert_equal true, nowrite
+    }
+    assert_equal false, nowrite
+  end
+
+  def test_file_utils_methods_are_available_at_top_level
+    create_file("a")
+
+    capture_io do
+      rm_rf "a"
+    end
+
+    refute File.exist?("a")
+  end
+
+  def test_fileutils_methods_dont_leak
+    obj = Object.new
+    assert_raises(NoMethodError) { obj.copy } # from FileUtils
+    assert_raises(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils
+  end
+
+  def test_sh
+    shellcommand
+
+    verbose(false) { sh %{#{Rake::TestCase::RUBY} shellcommand.rb} }
+    assert true, "should not fail"
+  end
+
+  def test_sh_with_a_single_string_argument
+    check_expansion
+
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      sh %{#{RUBY} check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_sh_with_multiple_arguments
+    check_no_expansion
+    ENV['RAKE_TEST_SH'] = 'someval'
+
+    verbose(false) {
+      sh RUBY, 'check_no_expansion.rb', env_var, 'someval'
+    }
+  end
+
+  def test_sh_failure
+    shellcommand
+
+    assert_raises(RuntimeError) {
+      verbose(false) { sh %{#{RUBY} shellcommand.rb 1} }
+    }
+  end
+
+  def test_sh_special_handling
+    shellcommand
+
+    count = 0
+    verbose(false) {
+      sh(%{#{RUBY} shellcommand.rb}) do |ok, res|
+        assert(ok)
+        assert_equal 0, res.exitstatus
+        count += 1
+      end
+      sh(%{#{RUBY} shellcommand.rb 1}) do |ok, res|
+        assert(!ok)
+        assert_equal 1, res.exitstatus
+        count += 1
+      end
+    }
+    assert_equal 2, count, "Block count should be 2"
+  end
+
+  def test_sh_noop
+    shellcommand
+
+    verbose(false) { sh %{shellcommand.rb 1}, :noop=>true }
+    assert true, "should not fail"
+  end
+
+  def test_sh_bad_option
+    shellcommand
+
+    ex = assert_raises(ArgumentError) {
+      verbose(false) { sh %{shellcommand.rb}, :bad_option=>true }
+    }
+    assert_match(/bad_option/, ex.message)
+  end
+
+  def test_sh_verbose
+    shellcommand
+
+    _, err = capture_io do
+      verbose(true) {
+        sh %{shellcommand.rb}, :noop=>true
+      }
+    end
+
+    assert_equal "shellcommand.rb\n", err
+  end
+
+  def test_sh_verbose_false
+    shellcommand
+
+    _, err = capture_io do
+      verbose(false) {
+        sh %{shellcommand.rb}, :noop=>true
+      }
+    end
+
+    assert_equal '', err
+  end
+
+  def test_sh_verbose_flag_nil
+    shellcommand
+
+    RakeFileUtils.verbose_flag = nil
+
+    assert_silent do
+      sh %{shellcommand.rb}, :noop=>true
+    end
+  end
+
+  def test_ruby_with_a_single_string_argument
+    check_expansion
+
+    ENV['RAKE_TEST_SH'] = 'someval'
+
+    verbose(false) {
+      replace_ruby {
+        ruby %{check_expansion.rb #{env_var} someval}
+      }
+    }
+  end
+
+  def test_ruby_with_multiple_arguments
+    check_no_expansion
+
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      replace_ruby {
+        ruby 'check_no_expansion.rb', env_var, 'someval'
+      }
+    }
+  end
+
+  def test_split_all
+    assert_equal ['a'], Rake::FileUtilsExt.split_all('a')
+    assert_equal ['..'], Rake::FileUtilsExt.split_all('..')
+    assert_equal ['/'], Rake::FileUtilsExt.split_all('/')
+    assert_equal ['a', 'b'], Rake::FileUtilsExt.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Rake::FileUtilsExt.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b')
+  end
+
+  def command(name, text)
+    open name, 'w', 0750 do |io|
+      io << text
+    end
+  end
+
+  def check_no_expansion
+    command 'check_no_expansion.rb', <<-CHECK_EXPANSION
+if ARGV[0] != ARGV[1]
+  exit 0
+else
+  exit 1
+end
+    CHECK_EXPANSION
+  end
+
+  def check_expansion
+    command 'check_expansion.rb', <<-CHECK_EXPANSION
+if ARGV[0] != ARGV[1]
+  exit 1
+else
+  exit 0
+end
+    CHECK_EXPANSION
+  end
+
+  def replace_ruby
+    ruby = FileUtils::RUBY
+    FileUtils.send :remove_const, :RUBY
+    FileUtils.const_set :RUBY, RUBY
+    yield
+  ensure
+    FileUtils.send :remove_const, :RUBY
+    FileUtils.const_set:RUBY, ruby
+  end
+
+  def shellcommand
+    command 'shellcommand.rb', <<-SHELLCOMMAND
+#!/usr/bin/env ruby
+
+exit((ARGV[0] || "0").to_i)
+    SHELLCOMMAND
+  end
+
+  def env_var
+    windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
+  end
+
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  end
+
+end