rake 0.4.8

data/test/contrib/testsys.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'test/filecreation'
+require 'rake/contrib/sys'
+
+class TestSys < Test::Unit::TestCase
+  include FileCreation
+
+#   def test_delete
+#     create_file("testdata/a")
+#     Sys.delete_all("testdata/a")
+#     assert ! File.exist?("testdata/a")
+#   end
+
+#   def test_copy
+#     create_file("testdata/a")
+#     Sys.copy("testdata/a", "testdata/b")
+#     assert File.exist?("testdata/b")
+#   end
+
+#   def test_for_files
+#     test_files = ["testdata/a.pl", "testdata/c.pl", "testdata/b.rb"]
+#     test_files.each { |fn| create_file(fn) }
+#     list = []
+#     Sys.for_files("testdata/*.pl", "testdata/*.rb") { |fn|
+#       list << fn
+#     }
+#     assert_equal test_files.sort, list.sort
+#   end
+
+#   def test_indir
+#     here = Dir.pwd
+#     Sys.makedirs("testdata/dir")
+#     assert_equal "#{here}/testdata/dir", Sys.indir("testdata/dir") { Dir.pwd }
+#     assert_equal here, Dir.pwd
+#   end
+
+  def test_split_all
+    assert_equal ['a'], Sys.split_all('a')
+    assert_equal ['..'], Sys.split_all('..')
+    assert_equal ['/'], Sys.split_all('/')
+    assert_equal ['a', 'b'], Sys.split_all('a/b')
+    assert_equal ['/', 'a', 'b'], Sys.split_all('/a/b')
+    assert_equal ['..', 'a', 'b'], Sys.split_all('../a/b')
+  end
+end

data/test/data/rbext/rakefile.rb

@@ -0,0 +1,3 @@
+task :default do
+  puts "OK"
+end

data/test/filecreation.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'ftools'
+
+module FileCreation
+  def create_timed_files(oldfile, newfile)
+    return if File.exist?(oldfile) && File.exist?(newfile)
+    old_time = create_file(oldfile)
+    while create_file(newfile) <= old_time
+      sleep(0.1)
+      File.delete(newfile) rescue nil
+    end
+  end
+
+  def create_file(name)
+    dirname = File.dirname(name)
+    FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+    open(name, "w") {|f| f.puts "HI" } unless File.exist?(name)
+    File.new(name).mtime
+  end
+
+  def delete_file(name)
+    File.delete(name) rescue nil
+  end
+end
+

data/test/functional.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+  require_gem 'session'
+rescue LoadError
+  puts "UNABLE TO RUN FUNCTIONAL TESTS"
+  puts "No Session Found"
+end
+
+require 'test/unit'
+require 'fileutils'
+
+class FunctionalTest < Test::Unit::TestCase
+  def setup
+    @rake_path = File.expand_path("bin/rake")
+    lib_path = File.expand_path("lib")
+    @ruby_options = "-I#{lib_path} -I."
+    @verbose = true if ENV['VERBOSE']
+  end
+
+  def test_rake_default
+    Dir.chdir("test/data/default") do rake end
+    assert_match /^DEFAULT$/, @out
+    assert_status
+  end
+
+  def test_rake_error_on_bad_task
+    Dir.chdir("test/data/default") do rake "xyz" end
+    assert_match /rake aborted/, @out
+    assert_status(1)
+  end
+
+  def test_env_availabe_at_top_scope
+    Dir.chdir("test/data/default") do rake "TESTTOPSCOPE=1" end
+    assert_match /^TOPSCOPE$/, @out
+    assert_status
+  end
+
+  def test_env_availabe_at_task_scope
+    Dir.chdir("test/data/default") do rake "TESTTASKSCOPE=1 task_scope" end
+    assert_match /^TASKSCOPE$/, @out
+    assert_status
+  end
+
+  def test_multi_desc
+    Dir.chdir("test/data/multidesc") do rake "-T" end
+    assert_match %r{^rake a *# A / A2 *$}, @out
+    assert_match %r{^rake b *# B *$}, @out
+    assert_no_match %r{^rake c}, @out
+  end
+
+  def test_rbext
+    Dir.chdir("test/data/rbext") do rake "-N" end
+    assert_match %r{^OK$}, @out
+  end
+
+  def test_nosearch
+    Dir.chdir("test/data/nosearch") do rake "-N" end
+    assert_match %r{^No Rakefile found}, @out
+  end
+
+  private
+
+  def rake(options="")
+    shell = Session::Shell.new
+    command = "ruby #{@ruby_options} #{@rake_path} #{options}"
+    puts "COMMAND: [#{command}]" if @verbose
+    @out, @err = shell.execute command
+    @status = shell.exit_status
+    puts "STATUS:  [#{@status}]" if @verbose
+    puts "OUTPUT:  [#{@out}]" if @verbose
+    puts "ERROR:   [#{@err}]" if @verbose
+    puts "PWD:     [#{Dir.pwd}]" if @verbose
+    shell.close
+  end
+
+  def assert_status(expected_status=0)
+    assert_equal expected_status, @status
+  end
+
+end

data/test/testclean.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/clean'
+
+class TestClean < Test::Unit::TestCase
+  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/test/testfilelist.rb

@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+
+class TestFileList < Test::Unit::TestCase
+  FileList = Rake::FileList
+
+  def setup
+    create_test_data
+  end
+
+  def teardown
+    FileList.select_default_ignore_patterns
+  end
+
+  def test_create
+    fl = FileList.new
+    assert_equal 0, fl.size
+  end
+
+  def test_create_with_args
+    fl = FileList.new("testdata/*.c", "x")
+    assert_equal ["testdata/abc.c", "testdata/x.c", "testdata/xyz.c", "x"].sort,
+      fl.sort
+  end
+
+  def test_create_with_block
+    fl = FileList.new { |f| f.include("x") }
+    assert_equal ["x"], fl.resolve
+  end
+
+  def test_create_with_brackets
+    fl = FileList["testdata/*.c", "x"]
+    assert_equal ["testdata/abc.c", "testdata/x.c", "testdata/xyz.c", "x"].sort,
+      fl.sort
+  end
+
+  def test_append
+    fl = FileList.new
+    fl << "a.rb" << "b.rb"
+    assert_equal ['a.rb', 'b.rb'], fl
+  end
+
+  def test_add_many
+    fl = FileList.new
+    fl.include %w(a d c )
+    fl.include('x', 'y')
+    assert_equal ['a', 'd', 'c', 'x', 'y'], fl.resolve
+  end
+
+  def test_add_return
+    f = FileList.new
+    g = f << "x"
+    assert_equal f.id, g.id
+    h = f.include("y")
+    assert_equal f.id, h.id
+  end
+  
+  def test_match
+    fl = FileList.new
+    fl.include('test/test*.rb')
+    assert fl.include?("test/testfilelist.rb")
+    assert fl.size > 3
+    fl.each { |fn| assert_match /\.rb$/, fn }
+  end
+
+  def test_add_matching
+    fl = FileList.new
+    fl << "a.java"
+    fl.include("test/*.rb")
+    assert_equal "a.java", fl[0]
+    assert fl.size > 2
+    assert fl.include?("test/testfilelist.rb")
+  end
+
+  def test_multiple_patterns
+    create_test_data
+    fl = FileList.new
+    fl.include('*.c', '*xist*')
+    assert_equal [], fl
+    fl.include('testdata/*.c', 'testdata/*xist*')
+    assert_equal [
+      'testdata/x.c', 'testdata/xyz.c', 'testdata/abc.c', 'testdata/existing'
+    ].sort, fl.sort
+  end
+
+  def test_reject
+    fl = FileList.new
+    fl.include %w(testdata/x.c testdata/abc.c testdata/xyz.c testdata/existing)
+    fl.reject! { |fn| fn =~ %r{/x} }
+    assert_equal [
+      'testdata/abc.c', 'testdata/existing'
+    ], fl
+  end
+
+  def test_exclude
+    fl = FileList['testdata/x.c', 'testdata/abc.c', 'testdata/xyz.c', 'testdata/existing']
+    fl.each { |fn| touch fn, :verbose => false }
+    x = fl.exclude(%r{/x.+\.})
+    assert_equal FileList, x.class
+    assert_equal [
+      'testdata/x.c', 'testdata/abc.c', 'testdata/existing'
+    ], fl
+    assert_equal fl.id, x.id
+    fl.exclude('testdata/*.c')
+    assert_equal ['testdata/existing'], fl
+    fl.exclude('testdata/existing')
+    assert_equal [], fl
+  end
+
+  def test_exclude_return_on_create
+    fl = FileList['testdata/*'].exclude(/.*\.c$/)
+    assert_equal FileList, fl.class
+  end
+
+  def test_default_exclude
+    fl = FileList.new
+    fl.clear_exclude
+    fl.include("**/*~", "**/*.bak", "**/core")
+    assert fl.member?("testdata/core"), "Should include core"
+    assert fl.member?("testdata/x.bak"), "Should include .bak files"
+  end
+
+  def test_unique
+    fl = FileList.new
+    fl << "x.c" << "a.c" << "b.rb" << "a.c"
+    assert_equal ['x.c', 'a.c', 'b.rb', 'a.c'], fl
+    fl.uniq!
+    assert_equal ['x.c', 'a.c', 'b.rb'], fl
+  end
+
+  def test_to_string
+    fl = FileList.new
+    fl << "a.java" << "b.java"
+    assert_equal  "a.java b.java", fl.to_s
+    assert_equal  "a.java b.java", "#{fl}"
+  end
+
+  def test_to_s_pending
+    fl = FileList['testdata/abc.*']
+    assert_equal  %{testdata/abc.c}, fl.to_s
+  end
+
+  def test_inspect_pending
+    fl = FileList['testdata/abc.*']
+    assert_equal  %{["testdata/abc.c"]}, fl.inspect
+  end
+
+  def test_sub
+    fl = FileList["testdata/*.c"]
+    f2 = fl.sub(/\.c$/, ".o")
+    assert_equal FileList, f2.class
+    assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
+      f2.sort
+    f3 = fl.gsub(/\.c$/, ".o")
+    assert_equal FileList, f3.class
+    assert_equal ["testdata/abc.o", "testdata/x.o", "testdata/xyz.o"].sort,
+      f3.sort
+  end
+
+  def test_sub!
+    f = "x/a.c"
+    fl = FileList[f, "x/b.c"]
+    res = fl.sub!(/\.c$/, ".o")
+    assert_equal ["x/a.o", "x/b.o"].sort, fl.sort
+    assert_equal "x/a.c", f
+    assert_equal fl.id, res.id
+  end
+
+  def test_sub_with_block
+    fl = FileList["src/org/onestepback/a.java", "src/org/onestepback/b.java"]
+# The block version doesn't work the way I want it to ...
+#    f2 = fl.sub(%r{^src/(.*)\.java$}) { |x|  "classes/" + $1 + ".class" }
+    f2 = fl.sub(%r{^src/(.*)\.java$}, "classes/\\1.class")
+    assert_equal [
+      "classes/org/onestepback/a.class",
+      "classes/org/onestepback/b.class"
+    ].sort,
+      f2.sort
+  end
+
+  def test_gsub
+    create_test_data
+    fl = FileList["testdata/*.c"]
+    f2 = fl.gsub(/a/, "A")
+    assert_equal ["testdAtA/Abc.c", "testdAtA/x.c", "testdAtA/xyz.c"].sort,
+      f2.sort
+  end
+
+  def test_ignore_special
+    f = FileList['testdata/*']
+    assert ! f.include?("testdata/CVS"), "Should not contain CVS"
+    assert ! f.include?("testdata/.dummy"), "Should not contain dot files"
+    assert ! f.include?("testdata/x.bak"), "Should not contain .bak files"
+    assert ! f.include?("testdata/x~"), "Should not contain ~ files"
+    assert ! f.include?("testdata/core"), "Should not contain core files"
+  end
+
+  def test_clear_ignore_patterns
+    f = FileList['testdata/*']
+    f.clear_exclude
+    assert f.include?("testdata/abc.c")
+    assert f.include?("testdata/xyz.c")
+    assert f.include?("testdata/CVS")
+    assert f.include?("testdata/x.bak")
+    assert f.include?("testdata/x~")
+  end
+
+  def test_exclude_with_alternate_file_seps
+    fl = FileList.new
+    assert fl.exclude?("x/CVS/y")
+    assert fl.exclude?("x\\CVS\\y")
+    assert fl.exclude?("x/core")
+    assert fl.exclude?("x\\core")
+  end
+
+  def test_add_default_exclude_list
+    fl = FileList.new
+    fl.exclude(/~\d+$/)
+    assert fl.exclude?("x/CVS/y")
+    assert fl.exclude?("x\\CVS\\y")
+    assert fl.exclude?("x/core")
+    assert fl.exclude?("x\\core")
+    assert fl.exclude?("x/abc~1")
+  end
+
+  def test_basic_array_functions
+    f = FileList['b', 'c', 'a']
+    assert_equal 'b', f.first
+    assert_equal 'b', f[0]
+    assert_equal 'a', f.last
+    assert_equal 'a', f[2]
+    assert_equal 'a', f[-1]
+    assert_equal ['a', 'b', 'c'], f.sort
+    f.sort!
+    assert_equal ['a', 'b', 'c'], f
+  end
+
+  def create_test_data
+    verbose(false) do
+      mkdir "testdata" unless File.exist? "testdata"
+      mkdir "testdata/CVS" rescue nil
+      touch "testdata/.dummy"
+      touch "testdata/x.bak"
+      touch "testdata/x~"
+      touch "testdata/core"
+      touch "testdata/x.c"
+      touch "testdata/xyz.c"
+      touch "testdata/abc.c"
+      touch "testdata/existing"
+    end
+  end
+  
+end

data/test/testfileutils.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'test/unit'
+require 'test/filecreation'
+require 'fileutils'
+
+class TestFileUtils < Test::Unit::TestCase
+  include FileCreation
+
+  def test_rm_one_file
+    create_file("testdata/a")
+    FileUtils.rm_r "testdata/a"
+    assert ! File.exist?("testdata/a")
+  end
+
+  def test_rm_two_files
+    create_file("testdata/a")
+    create_file("testdata/b")
+    FileUtils.rm_r ["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_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
+
+end