buildr 0.16.0 → 0.18.0

data/lib/java/test.rb

@@ -2,57 +2,120 @@ module Buildr
 
   class JUnitTask < Rake::Task
 
-    attr_accessor :base_dir
-    attr_accessor :target
     attr_accessor :classpath
 
     def initialize(*args)
       super
       @classpath = []
+      @paths = []
+      @include = []
+      @exclude = []
       enhance do |task|
-        test_cases.each do |test|
-          Dir.chdir base_dir
-          java "junit.textui.TestRunner", test, :classpath=>real_classpath, :name=>"tests in #{test}"
+        if test_cases.empty?
+          puts "#{name}: No tests to run"
+        else
+          passed, failed = Java.junit(test_cases, :classpath=>classpath)
+          fail "#{name}: The following tests failed:\n#{failed.join("\n")}" unless failed.empty?
         end
       end
     end
 
+    def from(*files)
+      @paths += files
+      self
+    end
+
+    def include(*files)
+      @include += files
+      self
+    end
+
+    def exclude(*files)
+      @exclude += files
+      self
+    end
+
+    def with(*files)
+      @classpath |= artifacts(files.flatten).uniq
+      self
+    end
+
     def test_cases()
-      target = File.expand_path(self.target)
-      return [] unless File.exist?(target)
-      prefix = Regexp.new("^" + Regexp.escape(target) + "/")
-      FileList[File.join(target, "**", "*Test.class")].
-        map { |path| path.sub(prefix, "").ext("").gsub(File::SEPARATOR, ".") }.sort
+      unless @cases
+        @include << "*" if @include.empty?
+        @cases = @paths.map do |path|
+          base = Pathname.new(path)
+          FileList[File.join(path, "**", "*Test.class")].
+            map { |file| Pathname.new(file).relative_path_from(base).to_s.ext("").gsub(File::SEPARATOR, ".") }.
+            select { |name| @include.any? { |pattern| File.fnmatch(pattern, name) } }.
+            reject { |name| @exclude.any? { |pattern| File.fnmatch(pattern, name) } }
+        end.flatten.sort
+      end
+      @cases
+    end
+
+    def invoke()
+      setup
+      begin
+        super
+      ensure
+        teardown
+      end
+    end
+
+    def needed?()
+      return true unless ENV["TESTS"] =~ /(no|off|false|disable)/i
+    end
+
+    def prerequisites()
+      super + classpath + @paths
+    end
+
+    def invoke_prerequisites()
+      prerequisites.each { |n| application[n, @scope].invoke }
     end
 
-    def real_classpath()
-      @real_classpath ||= artifacts(@classpath).map(&:to_s)
+    def setup()
+      Rake::Task[name.sub(/run$/, "setup")].invoke
+    end
+  
+    def teardown()
+      Rake::Task[name.sub(/run$/, "teardown")].invoke
     end
 
   end
 
+
   class Tests
+
+    def initialize(project)
+      @project = project
+    end
+
     def prepare(*tasks, &block)
-      returning(@prepare_task ||= task("prepare")) { |task| task.enhance tasks, &block }
+      @project.task("tests:prepare").enhance tasks, &block
     end
 
     def compile(*sources, &block)
-      unless @compile_task
-        @compile_task = Java::CompileTask.define_task("compile"=>prepare) { |task| resources.invoke }
-      end
-      returning(@compile_task) { |task| task.sources |= sources ; task.enhance &block }
+      @project.task("tests:compile").from(sources).enhance &block
     end
-
+  
     def resources(*tasks, &block)
-      returning(@resources_task ||= Filter.define_task("resources")) { |task| task.enhance tasks, &block }
+      @project.task("tests:resources").enhance tasks, &block
     end
 
-    def junit(*tasks, &block)
-      unless @junit_task
-        @junit_task = JUnitTask.define_task("junit"=>compile)
-      end
-      returning(@junit_task) { |task| task.enhance tasks, &block }
+    def setup(*tasks, &block)
+      @project.task("tests:setup").enhance tasks, &block
+    end
+
+    def run(*tasks, &block)
+      @project.task("tests:run").enhance tasks, &block
+    end
+
+    def teardown(*tasks, &block)
+      @project.task("tests:teardown").enhance tasks, &block
     end
+
   end
 
   class Project
@@ -61,45 +124,52 @@ module Buildr
     inherited_attr :test_target_dir do File.join(target_dir, "test-classes") end
 
     def tests()
-      @tests ||= Tests.new
+      @tests ||= Tests.new(self)
     end
 
     def test(*tasks, &block)
-      @tests.junit *tasks, &block
+      tests.run *tasks, &block
     end
   end
       
   # Global task compiles all projects.
   desc "Run all test cases"
-  LocalDirectoryTask.define_task "test"
+  Project.local_task task("test")
 
   Project.on_define do |project|
-    tests = nil
-    namespace "test" do
-      tests = project.tests
-    #tests.compile.enhance([tests.prepare]) { |task| tests.resources.invoke }
-      tests.compile.classpath += [ "junit:junit:jar:3.8.1", "jmock:jmock:jar:1.1.0" ]
-      tests.junit
-    end
-    tests.compile.enhance [ project.compile ]
+    namespace "tests" do
+      # Compile task requires prepare and performs resources, if anything compiled.
+      #Java::CompileTask.define_task("compile"=>[project.compile, task("prepare")]) { |task| project.tests.resources.invoke }
+      Java::CompileTask.define_task("compile"=>[project.compile, task("prepare")]) { |task| project.tests.resources.invoke }
+      # Resources task is a filter.
+      FilterTask.define_task("resources")
+      JUnitTask.define_task("run"=>task("compile"))
+      task("setup")
+      task("teardown")
+    end
+    project.tests.compile.with Java::JUNIT_REQUIRES
     project.recursive_task("test"=>project.test)
 
-    #project.recursive_task("compile")
-    #task("build").enhance [ project.compile ]
-    #task("clean") { rm_rf project.path_to(:target_dir), :verbose=>false }
-
-    project.after_block do |project|
-      tests.compile.sources << project.path_to(:test_src_dir) if File.exist?(project.path_to(:test_src_dir))
-      tests.compile.target ||= project.path_to(:test_target_dir)
-      tests.compile.classpath << project.compile.target
-      tests.resources.include project.path_to(:test_resources_dir, "*") if File.exists?(project.path_to(:test_resources_dir))
-      tests.resources.target ||= tests.compile.target
-      tests.junit.target = tests.compile.target
-      tests.junit.classpath += tests.compile.classpath
-      tests.junit.classpath += [ tests.compile.target, project.compile.target ]
-      tests.junit.base_dir = project.base_dir
-      file(tests.compile.target).enhance [ tests.compile ]
-      file(tests.resources.target).enhance [ tests.resources ]
+    project.enhance do |project|
+      project.tests.compile.from project.path_to(:test_src_dir) if File.exist?(project.path_to(:test_src_dir))
+      project.tests.compile.into project.path_to(:test_target_dir) unless project.tests.compile.target
+      project.tests.resources.include project.path_to(:test_resources_dir, "*") if File.exists?(project.path_to(:test_resources_dir))
+      project.tests.resources.into project.tests.compile.target unless project.tests.resources.target
+
+      project.tests.compile.classpath += project.compile.classpath
+      project.tests.compile.classpath << project.compile.target
+      project.tests.run.from project.tests.compile.target
+      project.tests.run.classpath += project.tests.compile.classpath
+      project.tests.run.classpath << project.tests.compile.target
     end
+
+  end
+
+  rule /^test:.*$/ do |task|
+    test = task.name.scan(/test:(.*)/)[0][0]
+    Project.projects.select { |project| project.base_dir == Rake.application.original_dir }.
+      map { |project| project.task("tests:run") }.
+      each { |task| task.include("*#{test}").invoke }
   end
+
 end

data/lib/java/xmlbeans.rb

@@ -9,8 +9,6 @@ module Buildr
       options[:verbose] ||= Rake.application.options.trace || false
       fu_check_options options, :verbose, :noop, :javasource, :jar, :classes, :output
 
-      # Classpath for XMLBeans.
-      cp = REQUIRES.map { |id| artifact(id) }.each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
       # Options for SchemaCompiler.
       cmd_args = [ options[:verbose] ? "-verbose" : "-quiet" ]
       cmd_args << "-javasource" << options[:javasource].collect.join(File::PATH_SEPARATOR) if options[:javasource]
@@ -21,10 +19,10 @@ module Buildr
       cmd_args << { :verbose=>options[:verbose] }
 
       unless options[:noop]
-        verbose { puts "Running XMLBeans schema compiler" }
+        puts "Running XMLBeans schema compiler" if verbose
         mkpath options[:classes], :verbose=>false rescue nil if options[:classes]
         mkpath options[:output], :verbose=>false rescue nil if options[:output]
-        sh(Java.path_to_bin("java"), "-Xmx256m", "-cp", cp,
+        sh(Java.path_to_bin("java"), "-Xmx256m", "-cp", requires.join(File::PATH_SEPARATOR),
           "org.apache.xmlbeans.impl.tool.SchemaCompiler", *cmd_args) { |ok, res|
           fail "Failed to compile schemas, see errors above" unless ok }
         # Touch paths to let other tasks know there's an update.
@@ -32,6 +30,10 @@ module Buildr
         touch options[:output], :verbose=>false if options[:output]
       end
     end
+
+    def self.requires()
+      @requires ||= artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+    end
     
     class CompileTask < Rake::FileTask
 

data/lib/tasks/filter.rb

@@ -1,9 +1,9 @@
 module Buildr
 
-  class Filter < Rake::Task
+  class FilterTask < Rake::Task
 
     # The target directory.
-    attr_accessor :target
+    attr_reader :target
     # Filter to use. 
     attr_accessor :filter
 
@@ -46,7 +46,11 @@ module Buildr
     end
 
     def into(dir)
-      self.target = dir
+      dir = File.expand_path(dir)
+      unless @target == dir
+        @target = dir
+        file(dir).enhance [self]
+      end
       self
     end
 
@@ -55,6 +59,13 @@ module Buildr
       self
     end
 
+    def needed?
+      return false if target.nil? || copy_map.empty?
+      return true unless File.exist?(target)
+      return true if copy_map.any? { |dest, src| !File.exist?(dest) || File.mtime(src) > File.mtime(dest) }
+      false
+    end
+    
   protected
 
     # Return a copy map of all the files that need copying: the key is
@@ -89,7 +100,7 @@ module Buildr
 
   def filter(*files)
     task = nil
-    namespace { task = Filter.define_task("filter").include *files }
+    namespace { task = FilterTask.define_task("filter").include *files }
     task
   end
 

data/lib/tasks/zip.rb

@@ -19,18 +19,19 @@ module Buildr
         else
           options = {}
         end
+        files = files.flatten
 
         if options[:path]
           path(options[:path]).include *files +[ options.reject { |k,v| k == :path } ]
         elsif options[:as]
           raise "You can only use the :as option in combination with the :path option" unless options.keys.size == 1
           raise "You can only use one file with the :as option" unless files.size == 1
-          include_as(files.first, options[:as])
+          include_as(files.first.to_s, options[:as])
         elsif options[:merge]
           raise "You can only use the :merge option in combination with the :path option" unless options.keys.size == 1
           files.each { |file| merge file }
         elsif options.keys.empty?
-          (@files ||= FileList[]).include *files
+          (@files ||= FileList[]).include files.map(&:to_s)
         else
           raise "Unrecognized option #{options.keys.join(", ")}"
         end
@@ -55,7 +56,7 @@ module Buildr
           path(options[:path]).merge *files +[ options.reject { |k,v| k == :path } ]
         elsif options.keys.empty?
           files.collect do |file|
-            @expand_sources << proc { artifacts(file).map(&:to_s) }
+            @expand_sources << proc { file.to_s }
             expander = ZipExpander.new(file)
             @add_files << proc { |zip| expander.expand(zip, @path) }
             expander
@@ -69,7 +70,7 @@ module Buildr
 
       def setup_path(path = nil)
         @path = "#{path}/" if path
-        expand_src = proc { artifacts(*@files || []).map(&:to_s) }
+        expand_src = proc { (@files || []).map(&:to_s).uniq }
         @expand_sources = [ expand_src ]
         @add_files = [] << proc do |zip|
           expand_src.call.each do |file|
@@ -87,9 +88,9 @@ module Buildr
       end
 
       def include_as(source, as)
-        @expand_sources << proc { artifacts(source).map(&:to_s) }
+        @expand_sources << proc { source }
         @add_files << proc do |zip|
-          file = artifacts(source).first.to_s
+          file = source.to_s
           if File.directory?(file)
             in_directory(file) do |file, rel_path|
               puts "Adding #{@path}#{as}/#{rel_path}" if Rake.application.options.trace
@@ -158,7 +159,7 @@ module Buildr
     class ZipExpander
 
       def initialize(zip_file)
-        @zip_file = zip_file
+        @zip_file = zip_file.to_s
       end
 
       def include(*files)
@@ -176,7 +177,7 @@ module Buildr
       def expand(zip, path)
         @includes ||= ["*"]
         @excludes ||= []
-        Zip::ZipFile.open(artifacts(@zip_file).map(&:to_s).first) do |source|
+        Zip::ZipFile.open(@zip_file) do |source|
           source.entries.reject { |entry| entry.directory? }.each do |entry|
             if @includes.any? { |pattern| File.fnmatch(pattern, entry.name) } &&
                !@excludes.any? { |pattern| File.fnmatch(pattern, entry.name) }
@@ -232,7 +233,7 @@ module Buildr
       most_recent = @paths.collect { |name, path| path.expand_sources }.flatten.
         each { |src| File.directory?(src) ? FileList[File.join(src, "**", "*")] | [src] : src }.flatten.
         select { |file| File.exist?(file) }.collect { |file| File.stat(file).mtime }.max
-      File.stat(name).mtime < (most_recent || Rake::EARLY)
+      File.stat(name).mtime < (most_recent || Rake::EARLY) || super
     end
 
   protected
@@ -241,33 +242,6 @@ module Buildr
       @paths.each { |name, obj| obj.add_file zip }
     end
 
-    def zip_map()
-      unless @zip_map
-        args = @paths.collect do |path, files|
-          if path
-            dest_for = proc { |f| File.join(path, f) }
-          else
-            dest_for = proc { |f| f }
-          end
-          artifacts(*files).map(&:to_s).collect do |file|
-            if File.directory?(file)
-              # Include all files inside the directory, with path starting
-              # from the directory itself.
-              prefix = File.dirname(file) + File::SEPARATOR
-              Dir[File.join(file, "**", "*")].sort.
-                reject { |file| File.directory?(file) || files.exclude?(file) }.
-                collect { |file| [ dest_for[file.sub(prefix, "")], file ] }
-            else
-              # Include just that one file, sans its diectory path.
-              [ dest_for[File.basename(file)], file ]
-            end
-          end
-        end.flatten
-        @zip_map = Hash[ *args ]
-      end
-      @zip_map
-    end
-
   end
 
   # The ZipTask creates a new ZIP file. You can include any number of files and

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: buildr
 version: !ruby/object:Gem::Version 
-  version: 0.16.0
-date: 2007-03-07 00:00:00 -08:00
+  version: 0.18.0
+date: 2007-03-30 00:00:00 -07:00
 summary: A build system that doesn't suck
 require_paths: 
 - lib
@@ -42,12 +42,19 @@ files:
 - lib/core/artifact.rb
 - lib/core/project.rb
 - lib/java/test.rb
+- lib/java/eclipse.rb
+- lib/java/jetty.rb
 - lib/java/xmlbeans.rb
 - lib/java/java.rb
 - lib/java/javacc.rb
 - lib/java/packaging.rb
 - lib/java/openjpa.rb
 - lib/java/compile.rb
+- lib/java/jetty
+- lib/java/jetty/JettyWrapper.java
+- lib/java/jetty/JettyWrapper$1.class
+- lib/java/jetty/JettyWrapper$BuildrHandler.class
+- lib/java/jetty/JettyWrapper.class
 - CHANGELOG
 - README
 - LICENSE