necktie 0.2.1 → 0.3.0

data/vendor/rake/test/lib/fileutils_test.rb

@@ -0,0 +1,251 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'test/unit'
+require 'test/filecreation'
+require 'fileutils'
+require 'stringio'
+require 'test/rake_test_setup'
+
+class TestFileUtils < Test::Unit::TestCase
+  include FileCreation
+  include TestMethods
+
+  def setup
+    File.chmod(0750,"test/shellcommand.rb")
+  end
+  
+  def teardown
+    FileUtils.rm_rf("testdata")
+    FileUtils::LN_SUPPORTED[0] = true
+  end
+  
+  def test_rm_one_file
+    create_file("testdata/a")
+    FileUtils.rm_rf "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_rm_two_files
+    create_file("testdata/a")
+    create_file("testdata/b")
+    FileUtils.rm_rf ["testdata/a", "testdata/b"]
+    assert ! File.exist?("testdata/a")
+    assert ! File.exist?("testdata/b")
+  end
+
+  def test_rm_filelist
+    list = Rake::FileList.new << "testdata/a" << "testdata/b"
+    list.each { |fn| create_file(fn) }
+    FileUtils.rm_r list
+    assert ! File.exist?("testdata/a")
+    assert ! File.exist?("testdata/b")
+  end
+
+  def test_ln
+    create_dir("testdata")
+    open("testdata/a", "w") { |f| f.puts "TEST_LN" }
+    RakeFileUtils.safe_ln("testdata/a", "testdata/b", :verbose => false)
+    assert_equal "TEST_LN\n", open("testdata/b") { |f| f.read }
+  end
+
+  class BadLink
+    include RakeFileUtils
+    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_exception(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("testdata/a")
+    rm_rf "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_fileutils_methods_dont_leak
+    obj = Object.new
+    assert_exception(NoMethodError) { obj.copy } # from FileUtils
+    assert_exception(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils
+  end
+
+  def test_sh
+    verbose(false) { sh %{ruby test/shellcommand.rb} }
+    assert true, "should not fail"
+  end
+
+  # If the :sh method is invoked directly from a test unit instance
+  # (under mini/test), the mini/test version of fail is invoked rather
+  # than the kernel version of fail. So we run :sh from within a
+  # non-test class to avoid the problem.
+  class Sh
+    include FileUtils
+    def run(*args)
+      sh(*args)
+    end
+    def self.run(*args)
+      new.run(*args)
+    end
+  end
+
+  def test_sh_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      sh %{ruby test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_sh_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      Sh.run 'ruby', 'test/check_no_expansion.rb', env_var, 'someval'
+    }
+  end
+
+  def test_sh_failure
+    assert_exception(RuntimeError) { 
+      verbose(false) { Sh.run %{ruby test/shellcommand.rb 1} }
+    }
+  end
+
+  def test_sh_special_handling
+    count = 0
+    verbose(false) {
+      sh(%{ruby test/shellcommand.rb}) do |ok, res|
+        assert(ok)
+        assert_equal 0, res.exitstatus
+        count += 1
+      end
+      sh(%{ruby test/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
+    verbose(false) { sh %{test/shellcommand.rb 1}, :noop=>true }
+    assert true, "should not fail"
+  end
+
+  def test_sh_bad_option
+    ex = assert_exception(ArgumentError) {
+      verbose(false) { sh %{test/shellcommand.rb}, :bad_option=>true }
+    }
+    assert_match(/bad_option/, ex.message)
+  end
+
+  def test_sh_verbose
+    out = redirect_stderr {
+      verbose(true) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_match(/^test\/shellcommand\.rb$/, out)
+  end
+
+  def test_sh_no_verbose
+    out = redirect_stderr {
+      verbose(false) {
+        sh %{test/shellcommand.rb}, :noop=>true
+      }
+    }
+    assert_equal '', out
+  end
+
+  def test_ruby_with_a_single_string_argument
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby %{test/check_expansion.rb #{env_var} someval}
+    }
+  end
+
+  def test_ruby_with_multiple_arguments
+    ENV['RAKE_TEST_SH'] = 'someval'
+    verbose(false) {
+      ruby 'test/check_no_expansion.rb', env_var, 'someval'
+    }
+  end
+
+  def test_split_all
+    assert_equal ['a'], RakeFileUtils.split_all('a')
+    assert_equal ['..'], RakeFileUtils.split_all('..')
+    assert_equal ['/'], RakeFileUtils.split_all('/')
+    assert_equal ['a', 'b'], RakeFileUtils.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], RakeFileUtils.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], RakeFileUtils.split_all('../a/b')
+  end
+
+  private
+  
+  def redirect_stderr
+    old_err = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = old_err
+  end
+
+  def windows?
+    ! File::ALT_SEPARATOR.nil?
+  end
+
+  def env_var
+    windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH'
+  end
+  
+end

data/vendor/rake/test/lib/ftp_test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'time'
+require 'test/unit'
+require 'rake/contrib/ftptools'
+
+class FakeDate
+  def self.today
+    Date.new(2003,10,3)
+  end
+  def self.now
+    Time.local(2003,10,3,12,00,00)
+  end
+end
+
+
+class TestFtpFile < Test::Unit::TestCase
+
+  def setup
+    Rake::FtpFile.class_eval { @date_class = FakeDate; @time_class = FakeDate }
+  end
+
+  def test_general
+    file = Rake::FtpFile.new("here", "-rw-r--r--   1 a279376  develop   121770 Mar  6 14:50 wiki.pl")
+    assert_equal "wiki.pl", file.name
+    assert_equal "here/wiki.pl", file.path
+    assert_equal "a279376", file.owner
+    assert_equal "develop", file.group
+    assert_equal 0644, file.mode
+    assert_equal 121770, file.size
+    assert_equal Time.mktime(2003,3,6,14,50,0,0), file.time
+    assert ! file.directory?
+    assert ! file.symlink?
+  end
+
+  def test_far_date
+    file = Rake::FtpFile.new(".", "drwxr-xr-x   3 a279376  develop     4096 Nov 26  2001 vss")
+    assert_equal Time.mktime(2001,11,26,0,0,0,0), file.time
+  end
+
+  def test_close_date
+    file = Rake::FtpFile.new(".", "drwxr-xr-x   3 a279376  develop     4096 Nov 26 15:35 vss")
+    assert_equal Time.mktime(2002,11,26,15,35,0,0), file.time
+  end
+
+  def test_directory
+    file = Rake::FtpFile.new(".", "drwxrwxr-x   9 a279376  develop     4096 Mar 13 14:32 working")
+    assert file.directory?
+    assert !file.symlink?
+  end
+
+  def test_symlink
+    file = Rake::FtpFile.new(".", "lrwxrwxrwx   1 a279376  develop       64 Mar 26  2002 xtrac -> /home/a279376/working/ics/development/java/com/fmr/fwp/ics/xtrac")
+    assert_equal 'xtrac', file.name
+    assert file.symlink?
+    assert !file.directory?
+  end
+end

data/vendor/rake/test/lib/invocation_chain_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'test/rake_test_setup'
+
+######################################################################
+class TestAnEmptyInvocationChain < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+  end
+
+  def test_should_be_able_to_add_members
+    assert_nothing_raised do
+      @empty.append("A")
+    end
+  end
+
+  def test_to_s
+    assert_equal "TOP", @empty.to_s
+  end
+end
+
+######################################################################
+class TestAnInvocationChainWithOneMember < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @empty = Rake::InvocationChain::EMPTY
+    @first_member = "A"
+    @chain = @empty.append(@first_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_exception RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/circular +dependency/i, ex.message)
+    assert_match(/A.*=>.*A/, ex.message)
+  end
+
+  def test_to_s
+    assert_equal "TOP => A", @chain.to_s
+  end
+
+end
+
+######################################################################
+class TestAnInvocationChainWithMultipleMember < Test::Unit::TestCase
+  include TestMethods
+
+  def setup
+    @first_member = "A"
+    @second_member = "B"
+    ch = Rake::InvocationChain::EMPTY.append(@first_member)
+    @chain = ch.append(@second_member)
+  end
+
+  def test_should_report_first_member_as_a_member
+    assert @chain.member?(@first_member)
+  end
+
+  def test_should_report_second_member_as_a_member
+    assert @chain.member?(@second_member)
+  end
+
+  def test_should_fail_when_adding_original_member
+    ex = assert_exception RuntimeError do
+      @chain.append(@first_member)
+    end
+    assert_match(/A.*=>.*B.*=>.*A/, ex.message)
+  end
+end
+
+

data/vendor/rake/test/lib/makefile_loader_test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'rake/loaders/makefile'
+
+class TestMakefileLoader < Test::Unit::TestCase
+  include Rake
+
+  def test_parse
+    Task.clear
+    loader = Rake::MakefileLoader.new
+    loader.load("test/data/sample.mf")
+    %w(a b c d).each do |t|
+      assert Task.task_defined?(t), "#{t} should be a defined task"
+    end
+    assert_equal %w(a1 a2 a3 a4 a5 a6 a7).sort, Task['a'].prerequisites.sort
+    assert_equal %w(b1 b2 b3 b4 b5 b6 b7).sort, Task['b'].prerequisites.sort
+    assert_equal %w(c1).sort, Task['c'].prerequisites.sort
+    assert_equal %w(d1 d2).sort, Task['d'].prerequisites.sort
+    assert_equal %w(e1 f1).sort, Task['e'].prerequisites.sort
+    assert_equal %w(e1 f1).sort, Task['f'].prerequisites.sort
+    assert_equal ["g1", "g 2", "g 3", "g4"].sort, Task['g 0'].prerequisites.sort
+    assert_equal 7, Task.tasks.size
+  end
+end

data/vendor/rake/test/lib/multitask_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'thread'
+require 'rake'
+
+######################################################################
+class TestMultiTask < Test::Unit::TestCase
+  include Rake
+
+  def setup
+    Task.clear
+    @runs = Array.new
+    @mutex = Mutex.new
+  end
+
+  def add_run(obj)
+    @mutex.synchronize do
+      @runs << obj
+    end
+  end
+
+  def test_running_multitasks
+    task :a do 3.times do |i| add_run("A#{i}"); sleep 0.01; end end
+    task :b do 3.times do |i| add_run("B#{i}"); sleep 0.01;  end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 6, @runs.size
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+
+  def test_all_multitasks_wait_on_slow_prerequisites
+    task :slow do 3.times do |i| add_run("S#{i}"); sleep 0.05 end end
+    task :a => [:slow] do 3.times do |i| add_run("A#{i}"); sleep 0.01 end end
+    task :b => [:slow] do 3.times do |i| add_run("B#{i}"); sleep 0.01 end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 9, @runs.size
+    assert @runs.index("S0") < @runs.index("S1")
+    assert @runs.index("S1") < @runs.index("S2")
+    assert @runs.index("S2") < @runs.index("A0")
+    assert @runs.index("S2") < @runs.index("B0")
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+end
+
+ 

data/vendor/rake/test/lib/namespace_test.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # got no gems
+end
+
+require 'test/unit'
+require 'flexmock/test_unit'
+require 'rake'
+require 'test/rake_test_setup'
+
+class TestNameSpace < Test::Unit::TestCase
+  include TestMethods
+
+  class TM
+    include Rake::TaskManager
+  end
+
+  def test_namespace_creation
+    mgr = TM.new
+    ns = Rake::NameSpace.new(mgr, [])
+    assert_not_nil ns
+  end
+
+  def test_namespace_lookup
+    mgr = TM.new
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, "t")
+    end
+
+    assert_not_nil ns["t"]
+    assert_equal mgr["n:t"], ns["t"]
+  end
+
+  def test_namespace_reports_tasks_it_owns
+    mgr = TM.new
+    nns = nil
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, :x)
+      mgr.define_task(Rake::Task, :y)
+      nns = mgr.in_namespace("nn") do
+        mgr.define_task(Rake::Task, :z)
+      end
+    end
+    mgr.in_namespace("m") do
+      mgr.define_task(Rake::Task, :x)
+    end
+
+    assert_equal ["n:nn:z", "n:x", "n:y"],
+      ns.tasks.map { |tsk| tsk.name }
+    assert_equal ["n:nn:z"], nns.tasks.map {|t| t.name}
+  end
+end

data/vendor/rake/test/lib/package_task_test.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/packagetask'
+require 'test/rake_test_setup'
+
+class TestPackageTask < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+
+  def test_create
+    pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
+      p.package_files << "install.rb"
+      p.package_files.include(
+        '[A-Z]*',
+        'bin/**/*',
+        'lib/**/*.rb',
+        'test/**/*.rb',
+        'doc/**/*',
+        'build/rubyapp.rb',
+        '*.blurb')
+      p.package_files.exclude(/\bCVS\b/)
+      p.package_files.exclude(/~$/)
+      p.package_dir = 'pkg'
+      p.need_tar = true
+      p.need_tar_gz = true
+      p.need_tar_bz2 = true
+      p.need_zip = true
+    }
+    assert_equal "pkg", pkg.package_dir
+    assert pkg.package_files.include?("bin/rake")
+    assert "pkgr", pkg.name
+    assert "1.2.3", pkg.version
+    assert Task[:package]
+    assert Task['pkg/pkgr-1.2.3.tgz']
+    assert Task['pkg/pkgr-1.2.3.tar.gz']
+    assert Task['pkg/pkgr-1.2.3.tar.bz2']
+    assert Task['pkg/pkgr-1.2.3.zip']
+    assert Task["pkg/pkgr-1.2.3"]
+    assert Task[:clobber_package]
+    assert Task[:repackage]
+  end
+
+  def test_missing_version
+    assert_exception(RuntimeError) {
+      pkg = Rake::PackageTask.new("pkgr") { |p| }
+    }
+  end
+
+  def test_no_version
+    pkg = Rake::PackageTask.new("pkgr", :noversion) { |p| }
+    assert "pkgr", pkg.send(:package_name)
+  end
+
+  def test_clone
+    pkg = Rake::PackageTask.new("x", :noversion)
+    p2 = pkg.clone
+    pkg.package_files << "y"
+    p2.package_files << "x"
+    assert_equal ["y"], pkg.package_files
+    assert_equal ["x"], p2.package_files
+  end
+end
+
+
+begin
+  require 'rubygems'
+  require 'rake/gempackagetask'
+rescue Exception
+  puts "WARNING: RubyGems not installed"
+end
+
+if ! defined?(Gem)
+  puts "WARNING: Unable to test GemPackaging ... requires RubyGems"
+else
+  class TestGemPackageTask < Test::Unit::TestCase
+    def test_gem_package
+      gem = Gem::Specification.new do |g|
+        g.name = "pkgr"
+        g.version = "1.2.3"
+        g.files = FileList["x"].resolve
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+        p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_equal "pkgr-1.2.3.gem", pkg.gem_file
+    end
+
+    def test_gem_package_with_current_platform
+      gem = Gem::Specification.new do |g|
+        g.name = "pkgr"
+        g.version = "1.2.3"
+        g.files = FileList["x"].resolve
+        g.platform = Gem::Platform::CURRENT
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+        p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_match(/^pkgr-1\.2\.3-(\S+)\.gem$/, pkg.gem_file)
+    end
+
+    def test_gem_package_with_ruby_platform
+      gem = Gem::Specification.new do |g|
+        g.name = "pkgr"
+        g.version = "1.2.3"
+        g.files = FileList["x"].resolve
+        g.platform = Gem::Platform::RUBY
+      end
+      pkg = Rake::GemPackageTask.new(gem)  do |p|
+        p.package_files << "y"
+      end
+      assert_equal ["x", "y"], pkg.package_files
+      assert_equal "pkgr-1.2.3.gem", pkg.gem_file
+    end
+  end
+end