rake 0.5.0 → 0.5.3

data/lib/rake/loaders/makefile.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+module Rake
+
+  # Makefile loader to be used with the import file loader.
+  class MakefileLoader
+
+    # Load the makefile dependencies in +fn+.
+    def load(fn)
+      buffer = ''
+      open(fn) do |mf|
+	mf.each do |line|
+	  next if line =~ /^\s*#/
+	  buffer << line
+	  if buffer =~ /\\$/
+	    buffer.sub!(/\\\n/, ' ')
+	    state = :append
+	  else
+	    process_line(buffer)
+	    buffer = ''
+	  end
+	end
+      end
+      process_line(buffer) if buffer != ''
+    end
+
+    private
+
+    # Process one logical line of makefile data.
+    def process_line(line)
+      file_task, args = line.split(':')
+      return if args.nil?
+      dependents = args.split
+      file file_task => dependents
+    end
+  end
+
+  # Install the handler
+  Rake.application.add_loader('mf', MakefileLoader.new)
+
+end

data/lib/rake/rake_test_loader.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# Load the test files from the command line.
+
+ARGV.each { |f| load f }

data/lib/rake/tasklib.rb

@@ -1,19 +1,13 @@
 #!/usr/bin/env ruby
 
+require 'rake'
+
 module Rake
 
   # Base class for Task Libraries.
   class TaskLib
 
-    # Make a copy of a task.
-    def clone
-      sibling = self.class.new
-      instance_variables.each do |ivar|
-	value = self.instance_variable_get(ivar)
-	sibling.instance_variable_set(ivar, value.dup) if value
-      end
-      sibling
-    end
+    include Cloneable
 
     # Make a symbol by pasting two strings together. 
     def paste(a,b)

data/lib/rake/testtask.rb

@@ -58,6 +58,14 @@ module Rake
     # Glob pattern to match test files. (default is 'test/test*.rb')
     attr_accessor :pattern
 
+    # Style of test loader to use.  Options are:
+    #
+    # * :rake -- Rake provided test loading script (default).
+    # * :testrb -- Ruby provided test loading script.
+    # * :direct -- Load tests using command line loader.
+    # 
+    attr_accessor :loader
+
     # Explicitly define the list of test files to be included in a
     # test.  +list+ is expected to be an array of file names (a
     # FileList is acceptable).  If both +pattern+ and +test_files+ are
@@ -75,6 +83,7 @@ module Rake
       @test_files = nil
       @verbose = false
       @warning = false
+      @loader = :rake
       yield self if block_given?
       @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
       define
@@ -86,8 +95,20 @@ module Rake
       warning_flag = (@warning ? "-w " : "")
       desc "Run tests" + (@name==:test ? "" : " for #{@name}")
       task @name do
+	run_code = ''
 	RakeFileUtils.verbose(@verbose) do
-	  ruby %{-I#{lib_path} #{warning_flag}-S testrb #{fix} #{file_list.join(' ')} #{option_list}}
+	  run_code =
+	    case @loader
+	    when :direct
+	      "-e 'ARGV.each{|f| load f}'"
+	    when :testrb
+	      "-S testrb #{fix}"
+	    when :rake
+	      rake_loader
+	    end
+	  ruby "-I#{lib_path} #{warning_flag}#{run_code} " +
+	    file_list.join(' ') +
+	    " #{option_list}"
 	end
       end
       self
@@ -108,16 +129,21 @@ module Rake
       end
     end
 
-    def fix
+    def fix # :nodoc:
       case RUBY_VERSION
       when '1.8.2'
-	find_fix_file 'rake/ruby182_test_unit_fix'
+	find_file 'rake/ruby182_test_unit_fix'
       else
 	nil
       end || ''
     end
 
-    def find_fix_file(fn)
+    def rake_loader # :nodoc:
+      find_file('rake/rake_test_loader') or
+	fail "unable to find rake test loader"
+    end
+
+    def find_file(fn) # :nodoc:
       $LOAD_PATH.each do |path|
 	file_path = File.join(path, "#{fn}.rb")
 	return file_path if File.exist? file_path

data/test/functional.rb

@@ -99,6 +99,25 @@ class FunctionalTest < Test::Unit::TestCase
     assert_status
   end
 
+  def test_imports
+    FileUtils.rm_f "test/data/imports/dynamic_deps"
+    Dir.chdir("test/data/imports") do rake end
+    assert File.exist?("test/data/imports/dynamic_deps"),
+      "'dynamic_deps' file should exist"
+    assert_match(/^FIRST$\s+^DYNAMIC$\s+^STATIC$\s+^OTHER$/, @out)
+    assert_status
+  end
+
+  def test_rules_chaining_to_file_task
+    %w(play.scpt play.app).each do |fn|
+      FileUtils.rm_f File.join("test/data/chains", fn)
+    end
+    Dir.chdir("test/data/chains") do rake end
+    assert File.exist?("test/data/chains/play.app"),
+      "'play.app' file should exist"
+    assert_status
+  end
+
   private
 
   def rake(*option_list)

data/test/test_makefile_loader.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake'
+require 'rake/loaders/makefile'
+
+class TestMakefileLoader < Test::Unit::TestCase
+  def test_create
+    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 4, Task.tasks.size
+  end
+end

data/test/testfilelist.rb

@@ -44,8 +44,9 @@ class TestFileList < Test::Unit::TestCase
 
   def test_add_many
     fl = FileList.new
-    fl.include %w(a d c )
+    fl.include %w(a d c)
     fl.include('x', 'y')
+    assert_equal ['a', 'd', 'c', 'x', 'y'], fl
     assert_equal ['a', 'd', 'c', 'x', 'y'], fl.resolve
   end
 
@@ -137,6 +138,14 @@ class TestFileList < Test::Unit::TestCase
     assert_equal  "a.java b.java", "#{fl}"
   end
 
+  def test_to_array
+    fl = FileList['a.java', 'b.java']
+    assert_equal  ['a.java', 'b.java'], fl.to_a
+    assert_equal  Array, fl.to_a.class
+    assert_equal  ['a.java', 'b.java'], fl.to_ary
+    assert_equal  Array, fl.to_ary.class
+  end
+
   def test_to_s_pending
     fl = FileList['testdata/abc.*']
     assert_equal  %{testdata/abc.c}, fl.to_s
@@ -180,6 +189,33 @@ class TestFileList < Test::Unit::TestCase
       f2.sort
   end
 
+  def test_string_ext
+    assert_equal "one.net", "one.two".ext("net")
+    assert_equal "one.net", "one.two".ext(".net")
+    assert_equal "one.net", "one".ext("net")
+    assert_equal "one.net", "one".ext(".net")
+    assert_equal "one.two.net", "one.two.c".ext(".net")
+    assert_equal "one/two.net", "one/two.c".ext(".net")
+    assert_equal "one.x/two.net", "one.x/two.c".ext(".net")
+    assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net")
+    assert_equal "one.x/two.net", "one.x/two".ext(".net")
+    assert_equal "one.x\\two.net", "one.x\\two".ext(".net")
+    assert_equal ".onerc.net", ".onerc.dot".ext("net")
+    assert_equal ".onerc.net", ".onerc".ext("net")
+    assert_equal ".a/.onerc.net", ".a/.onerc".ext("net")
+    assert_equal "one", "one.two".ext('')
+    assert_equal "one", "one.two".ext
+    assert_equal ".one", ".one.two".ext
+    assert_equal ".one", ".one".ext
+    assert_equal ".", ".".ext("c")
+    assert_equal "..", "..".ext("c")
+  end
+
+  def test_filelist_ext
+    assert_equal FileList['one.c', '.one.c'],
+      FileList['one.net', '.one'].ext('c')
+  end
+
   def test_gsub
     create_test_data
     fl = FileList["testdata/*.c"]
@@ -237,6 +273,156 @@ class TestFileList < Test::Unit::TestCase
     assert_equal ['a', 'b', 'c'], f
   end
 
+  def test_flatten
+    assert_equal ['a', 'testdata/x.c', 'testdata/xyz.c', 'testdata/abc.c'].sort,
+      ['a', FileList['testdata/*.c']].flatten.sort
+  end
+
+  def test_clone
+    a = FileList['a', 'b', 'c']
+    b = a.clone
+    a << 'd'
+    assert_equal ['a', 'b', 'c', 'd'], a
+    assert_equal ['a', 'b', 'c'], b
+  end
+
+  def test_array_comparisons
+    fl = FileList['b', 'b']
+    a = ['b', 'a']
+    b = ['b', 'b']
+    c = ['b', 'c']
+    assert_equal( 1,  fl <=> a )
+    assert_equal( 0,  fl <=> b )
+    assert_equal( -1, fl <=> c )
+    assert_equal( -1, a <=> fl )
+    assert_equal( 0,  b <=> fl )
+    assert_equal( 1,  c <=> fl )
+  end
+
+  def test_array_equality
+    a = FileList['a', 'b']
+    b = ['a', 'b']
+    assert a == b
+    assert b == a
+#    assert a.eql?(b)
+#    assert b.eql?(a)
+    assert ! a.equal?(b)
+    assert ! b.equal?(a)
+  end
+
+  def test_enumeration_methods
+    a = FileList['a', 'b']
+    b = a.collect { |it| it.upcase }
+    assert_equal ['A', 'B'], b
+    assert_equal FileList,  b.class
+
+    b = a.map { |it| it.upcase }
+    assert_equal ['A', 'B'], b
+    assert_equal FileList,  b.class
+
+    b = a.sort
+    assert_equal ['a', 'b'], b
+    assert_equal FileList,  b.class
+
+    b = a.sort_by { |it| it }
+    assert_equal ['a', 'b'], b
+    assert_equal FileList,  b.class
+
+    b = a.find_all { |it| it == 'b'}
+    assert_equal ['b'], b
+    assert_equal FileList,  b.class
+
+    b = a.select { |it| it.size == 1 }
+    assert_equal ['a', 'b'], b
+    assert_equal FileList,  b.class
+
+    b = a.reject { |it| it == 'b' }
+    assert_equal ['a'], b
+    assert_equal FileList,  b.class
+
+    b = a.grep(/./)
+    assert_equal ['a', 'b'], b
+    assert_equal FileList,  b.class
+
+    b = a.partition { |it| it == 'b' }
+    assert_equal [['b'], ['a']], b
+    assert_equal Array, b.class
+    assert_equal FileList,  b[0].class
+    assert_equal FileList,  b[1].class
+
+    b = a.zip(['x', 'y'])
+    assert_equal [['a', 'x'], ['b', 'y']], b
+    assert_equal Array, b.class
+    assert_equal Array, b[0].class
+    assert_equal Array, b[1].class
+  end
+
+  def test_array_operators
+    a = ['a', 'b']
+    b = ['c', 'd']
+    f = FileList['x', 'y']
+    g = FileList['w', 'z']
+
+    r = f + g
+    assert_equal ['x', 'y', 'w', 'z'], r
+    assert_equal FileList, r.class
+
+    r = a + g
+    assert_equal ['a', 'b', 'w', 'z'], r
+    assert_equal Array, r.class
+
+    r = f + b
+    assert_equal ['x', 'y', 'c', 'd'], r
+    assert_equal FileList, r.class
+
+    r = FileList['w', 'x', 'y', 'z'] - f
+    assert_equal ['w', 'z'], r
+    assert_equal FileList, r.class
+
+    r = FileList['w', 'x', 'y', 'z'] & f
+    assert_equal ['x', 'y'], r
+    assert_equal FileList, r.class
+
+    r = f * 2
+    assert_equal ['x', 'y', 'x', 'y'], r
+    assert_equal FileList, r.class
+
+    r = f * ','
+    assert_equal 'x,y', r
+    assert_equal String, r.class
+
+    r = f | ['a', 'x']
+    assert_equal ['a', 'x', 'y'].sort, r.sort
+    assert_equal FileList, r.class
+  end
+
+  def test_other_array_returning_methods
+    f = FileList['a', nil, 'b']
+    r = f.compact
+    assert_equal ['a', 'b'], r
+    assert_equal FileList, r.class
+
+    f = FileList['a', 'b']
+    r = f.concat(['x', 'y'])
+    assert_equal ['a', 'b', 'x', 'y'], r
+    assert_equal FileList, r.class
+
+    f = FileList['a', ['b', 'c'], FileList['d', 'e']]
+    r = f.flatten
+    assert_equal ['a', 'b', 'c', 'd', 'e'], r
+    assert_equal FileList, r.class
+
+    f = FileList['a', 'b', 'a']
+    r = f.uniq
+    assert_equal ['a', 'b'], r
+    assert_equal FileList, r.class
+
+    f = FileList['a', 'b', 'c', 'd']
+    r = f.values_at(1,3)
+    assert_equal ['b', 'd'], r
+    assert_equal FileList, r.class
+  end
+
   def create_test_data
     verbose(false) do
       mkdir "testdata" unless File.exist? "testdata"

data/test/testtasks.rb

@@ -15,7 +15,8 @@ class TestTask < Test::Unit::TestCase
     arg = nil
     t = Task.lookup(:name).enhance { |task| arg = task; 1234 }
     assert_equal "name", t.name
-    assert [], t.prerequisites
+    assert_equal [], t.prerequisites
+    assert t.prerequisites.is_a?(FileList)
     assert t.needed?
     t.execute
     assert_equal t, arg
@@ -211,7 +212,7 @@ class TestDefinitions < Test::Unit::TestCase
     assert_equal [n2.to_s], t.prerequisites.collect{|n| n.to_s}
     t.invoke
     t2 = Task[n2]
-    assert_equal [], t2.prerequisites
+    assert_equal FileList[], t2.prerequisites
     t3 = Task[n3]
     assert_equal [n1.to_s, n2.to_s], t3.prerequisites.collect{|n|n.to_s}
   end
@@ -244,9 +245,10 @@ class TestDefinitions < Test::Unit::TestCase
   private # ----------------------------------------------------------
 
   def create_existing_file
-    if ! File.exist?(EXISTINGFILE)
-      open(EXISTINGFILE, "w") do |f| f.puts "HI" end
-    end
+    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

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.10.1
 specification_version: 1
 name: rake
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
-date: 2005-03-25
+  version: 0.5.3
+date: 2005-04-09
 summary: Ruby based make-like utility.
 require_paths: 
   - lib
@@ -43,12 +43,14 @@ files:
   - lib/rake/testtask.rb
   - lib/rake/gempackagetask.rb
   - lib/rake/ruby182_test_unit_fix.rb
+  - lib/rake/rake_test_loader.rb
   - lib/rake/contrib/ftptools.rb
   - lib/rake/contrib/sys.rb
   - lib/rake/contrib/compositepublisher.rb
   - lib/rake/contrib/publisher.rb
   - lib/rake/contrib/rubyforgepublisher.rb
   - lib/rake/contrib/sshpublisher.rb
+  - lib/rake/loaders/makefile.rb
   - test/filecreation.rb
   - test/testclean.rb
   - test/testfilelist.rb
@@ -59,6 +61,7 @@ files:
   - test/testpackagetask.rb
   - test/functional.rb
   - test/testtesttask.rb
+  - test/test_makefile_loader.rb
   - test/contrib/testsys.rb
   - test/data/rbext/rakefile.rb
   - doc/example