necktie 0.2.1 → 0.3.0

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

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'rake/clean'
+
+class TestClean < Test::Unit::TestCase
+  include Rake
+  def test_clean
+    assert Task['clean'], "Should define clean"
+    assert Task['clobber'], "Should define clobber"
+    assert Task['clobber'].prerequisites.include?("clean"),
+      "Clobber should require clean"
+  end
+end

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

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+require 'test/rake_test_setup'
+
+######################################################################
+class TestDefinitions < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+  
+  EXISTINGFILE = "testdata/existing"
+
+  def setup
+    Task.clear
+  end
+
+  def test_task
+    done = false
+    task :one => [:two] do done = true end
+    task :two
+    task :three => [:one, :two]
+    check_tasks(:one, :two, :three)
+    assert done, "Should be done"
+  end
+
+  def test_file_task
+    done = false
+    file "testdata/one" => "testdata/two" do done = true end
+    file "testdata/two"
+    file "testdata/three" => ["testdata/one", "testdata/two"]
+    check_tasks("testdata/one", "testdata/two", "testdata/three")
+    assert done, "Should be done"
+  end
+
+  def check_tasks(n1, n2, n3)
+    t = Task[n1]
+    assert Task === t, "Should be a Task"
+    assert_equal n1.to_s, t.name
+    assert_equal [n2.to_s], t.prerequisites.collect{|n| n.to_s}
+    t.invoke
+    t2 = Task[n2]
+    assert_equal FileList[], t2.prerequisites
+    t3 = Task[n3]
+    assert_equal [n1.to_s, n2.to_s], t3.prerequisites.collect{|n|n.to_s}
+  end
+
+  def test_incremental_definitions
+    runs = []
+    task :t1 => [:t2] do runs << "A"; 4321 end
+    task :t1 => [:t3] do runs << "B"; 1234 end
+    task :t1 => [:t3]
+    task :t2
+    task :t3
+    Task[:t1].invoke
+    assert_equal ["A", "B"], runs
+    assert_equal ["t2", "t3"], Task[:t1].prerequisites
+  end
+
+  def test_missing_dependencies
+    task :x => ["testdata/missing"]
+    assert_exception(RuntimeError) { Task[:x].invoke }
+  end
+
+  def test_implicit_file_dependencies
+    runs = []
+    create_existing_file
+    task :y => [EXISTINGFILE] do |t| runs << t.name end
+    Task[:y].invoke
+    assert_equal runs, ['y']
+  end
+
+  private # ----------------------------------------------------------
+
+  def create_existing_file
+    Dir.mkdir File.dirname(EXISTINGFILE) unless
+      File.exist?(File.dirname(EXISTINGFILE))
+    open(EXISTINGFILE, "w") do |f| f.puts "HI" end unless
+      File.exist?(EXISTINGFILE)
+  end
+
+end
+  

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

@@ -0,0 +1,41 @@
+#!/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 DslTest < Test::Unit::TestCase
+  
+  def test_namespace_command
+    namespace "n" do
+      task "t"
+    end
+    assert_not_nil Rake::Task["n:t"]
+  end
+
+  def test_namespace_command_with_bad_name
+    ex = assert_raise(ArgumentError) do
+      namespace 1 do end
+    end
+    assert_match(/string/i, ex.message)
+    assert_match(/symbol/i, ex.message)
+  end
+
+  def test_namespace_command_with_a_string_like_object
+    name = Object.new
+    def name.to_str
+      "bob"
+    end
+    namespace name do
+      task "t"
+    end
+    assert_not_nil Rake::Task["bob:t"]
+  end
+end

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+class TestEarlyTime < Test::Unit::TestCase
+  def test_create
+    early = Rake::EarlyTime.instance
+    time = Time.mktime(1970, 1, 1, 0, 0, 0)
+    assert early <= Time.now
+    assert early < Time.now
+    assert early != Time.now
+    assert Time.now > early
+    assert Time.now >= early
+    assert Time.now != early
+  end
+
+  def test_equality
+    early = Rake::EarlyTime.instance
+    assert_equal early, early, "two early times should be equal"
+  end
+
+  def test_original_time_compare_is_not_messed_up
+    t1 = Time.mktime(1970, 1, 1, 0, 0, 0)
+    t2 = Time.now
+    assert t1 < t2
+    assert t2 > t1
+    assert t1 == t1
+    assert t2 == t2    
+  end
+
+  def test_to_s
+    assert_equal "<EARLY TIME>", Rake::EARLY.to_s
+  end
+end

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

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'test/test_helper'
+require 'rake/environment'
+
+class TestEnvironment < Test::Unit::TestCase
+  def test_load_string
+    Rake::Task.clear
+    Rake::Environment.load_string("task :xyz")
+    assert Rake::Task[:xyz], "should have a task named xyz"
+  end
+
+  def test_load_rakefile
+    Rake::Task.clear
+    Rake::Environment.load_rakefile("test/data/default/Rakefile")
+    assert Rake::Task[:default], "Should have a default task"
+  end
+end

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'stringio'
+
+######################################################################
+class TestExtension < Test::Unit::TestCase
+
+  module Redirect
+    def error_redirect
+      old_err = $stderr
+      result = StringIO.new
+      $stderr = result
+      yield
+      result
+    ensure
+      $stderr = old_err
+    end
+  end
+  
+  class Sample
+    extend Redirect
+
+    def duplicate_method
+      :original
+    end
+    
+    OK_ERRS = error_redirect do
+      rake_extension("a") do
+        def ok_method
+        end
+      end
+    end
+
+
+    DUP_ERRS = error_redirect do
+      rake_extension("duplicate_method") do
+        def duplicate_method
+          :override
+        end
+      end
+    end
+  end
+
+  def test_methods_actually_exist
+    sample = Sample.new
+    sample.ok_method
+    sample.duplicate_method
+  end
+
+  def test_no_warning_when_defining_ok_method
+    assert_equal "", Sample::OK_ERRS.string
+  end
+
+  def test_extension_complains_when_a_method_that_is_present
+    assert_match(/warning:/i, Sample::DUP_ERRS.string)
+    assert_match(/already exists/i, Sample::DUP_ERRS.string)
+    assert_match(/duplicate_method/i, Sample::DUP_ERRS.string)
+    assert_equal :original, Sample.new.duplicate_method
+  end
+
+end

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

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+
+######################################################################
+class TestFileCreationTask < Test::Unit::TestCase
+  include Rake
+  include FileCreation
+
+  DUMMY_DIR = 'testdata/dummy_dir'
+
+  def setup
+    Task.clear
+  end
+
+  def teardown
+    FileUtils.rm_rf DUMMY_DIR
+  end
+
+  def test_file_needed
+    create_dir DUMMY_DIR
+    fc_task = Task[DUMMY_DIR]
+    assert_equal DUMMY_DIR, fc_task.name
+    FileUtils.rm_rf fc_task.name
+    assert fc_task.needed?, "file should be needed"
+    FileUtils.mkdir fc_task.name
+    assert_equal nil, fc_task.prerequisites.collect{|n| Task[n].timestamp}.max
+    assert ! fc_task.needed?, "file should not be needed"
+  end
+
+  def test_directory
+    directory DUMMY_DIR
+    fc_task = Task[DUMMY_DIR]
+    assert_equal DUMMY_DIR, fc_task.name
+    assert FileCreationTask === fc_task
+  end
+
+  def test_no_retriggers_on_filecreate_task
+    create_timed_files(OLDFILE, NEWFILE)
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileCreationTask, NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    assert ! t1.needed?, "Should not need to rebuild old file because of new"
+  end
+
+  def test_no_retriggers_on_file_task
+    create_timed_files(OLDFILE, NEWFILE)
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE])
+    t2 = Rake.application.intern(FileCreationTask, NEWFILE)
+    assert ! t2.needed?, "Should not need to build new file"
+    assert ! t1.needed?, "Should not need to rebuild old file because of new"
+  end
+
+  def test_very_early_timestamp
+    t1 = Rake.application.intern(FileCreationTask, OLDFILE)
+    assert t1.timestamp < Time.now
+    assert t1.timestamp < Time.now - 1000000
+  end
+end

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

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+require 'test/rake_test_setup'
+
+######################################################################
+class TestFileTask < Test::Unit::TestCase
+  include Rake
+  include FileCreation
+  include TestMethods
+
+  def setup
+    Task.clear
+    @runs = Array.new
+    FileUtils.rm_f NEWFILE
+    FileUtils.rm_f OLDFILE
+  end
+
+  def test_file_need
+    name = "testdata/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"
+    open(ftask.name, "w") { |f| f.puts "HI" }
+    assert_equal nil, ftask.prerequisites.collect{|n| Task[n].timestamp}.max
+    assert ! ftask.needed?, "file should not be needed"
+    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_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.collect{|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
+    file OLDFILE => NEWFILE
+    assert_nothing_raised do Task[OLDFILE].invoke end
+  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
+
+end
+
+######################################################################
+class TestDirectoryTask < Test::Unit::TestCase
+  include Rake
+
+  def setup
+    rm_rf "testdata", :verbose=>false
+  end
+
+  def teardown
+    rm_rf "testdata", :verbose=>false
+  end
+
+  def test_directory
+    desc "DESC"
+    directory "testdata/a/b/c"
+    assert_equal FileCreationTask, Task["testdata"].class
+    assert_equal FileCreationTask, Task["testdata/a"].class
+    assert_equal FileCreationTask, Task["testdata/a/b/c"].class
+    assert_nil             Task["testdata"].comment
+    assert_equal "DESC",   Task["testdata/a/b/c"].comment
+    assert_nil             Task["testdata/a/b"].comment
+    verbose(false) {
+      Task['testdata/a/b'].invoke
+    }
+    assert File.exist?("testdata/a/b")
+    assert ! File.exist?("testdata/a/b/c")
+  end
+
+  if Rake::Win32.windows?
+    def test_directory_win32
+      desc "WIN32 DESC"
+      FileUtils.mkdir_p("testdata")
+      Dir.chdir("testdata") do
+        directory 'c:/testdata/a/b/c'
+        assert_equal FileCreationTask, Task['c:/testdata'].class
+        assert_equal FileCreationTask, Task['c:/testdata/a'].class
+        assert_equal FileCreationTask, Task['c:/testdata/a/b/c'].class
+        assert_nil             Task['c:/testdata'].comment
+        assert_equal "WIN32 DESC",   Task['c:/testdata/a/b/c'].comment
+        assert_nil             Task['c:/testdata/a/b'].comment
+        verbose(false) {
+          Task['c:/testdata/a/b'].invoke
+        }
+        assert File.exist?('c:/testdata/a/b')
+        assert ! File.exist?('c:/testdata/a/b/c')
+      end
+    end
+  end
+end