RubyGems - warbler - Versions diffs - 2.0.2 → 2.0.3 - Mend

warbler 2.0.2 → 2.0.3

Files changed (543) hide show

data/spec/sample_bundler/vendor/bundle/jruby/2.2.0/gems/rake-10.5.0/test/test_rake_file_list_path_map.rb DELETED

@@ -1,8 +0,0 @@
-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/spec/sample_bundler/vendor/bundle/jruby/2.2.0/gems/rake-10.5.0/test/test_rake_file_task.rb DELETED

@@ -1,197 +0,0 @@
-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/spec/sample_bundler/vendor/bundle/jruby/2.2.0/gems/rake-10.5.0/test/test_rake_file_utils.rb DELETED

@@ -1,314 +0,0 @@
-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