mguymon-buildr 1.4.5-java

data/lib/buildr/java/pom.rb

@@ -0,0 +1,178 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+module Buildr
+  class POM
+
+    POM_TO_SPEC_MAP = { :group=>"groupId", :id=>"artifactId", :type=>"type",
+      :version=>"version", :classifier=>"classifier", :scope=>"scope" }
+    SCOPES_TRANSITIVE = [nil, "compile", "runtime"]
+    SCOPES_WE_USE = SCOPES_TRANSITIVE + ["provided"]
+
+    # POM project as Hash (using XmlSimple).
+    attr_reader :project
+    # Parent POM if referenced by this POM.
+    attr_reader :parent
+
+    class << self
+
+      # :call-seq:
+      #   POM.load(arg)
+      #
+      # Load new POM object form various kind of sources such as artifact, hash representing spec, filename, XML.
+      def load(source)
+        case source
+        when Hash
+          load(Buildr.artifact(source).pom)
+        when Artifact
+          pom = source.pom
+          pom.invoke
+          load(pom.to_s)
+        when Rake::FileTask
+          source.invoke
+          load(source.to_s)
+        when String
+          filename = File.expand_path(source)
+          unless pom = cache[filename]
+            trace "Loading m2 pom file from #{filename}"
+            begin
+              pom = POM.new(IO.read(filename))
+            rescue REXML::ParseException => e
+              fail "Could not parse #{filename}, #{e.continued_exception}"
+            end
+            cache[filename] = pom
+          end
+          pom
+        else
+          raise ArgumentError, "Expecting Hash spec, Artifact, file name or file task"
+        end
+      end
+
+    private
+
+      def cache()
+        @cache ||= {}
+      end
+
+    end
+
+    def initialize(xml) #:nodoc:
+      @project = XmlSimple.xml_in(xml)
+      @parent = POM.load(pom_to_hash(project["parent"].first).merge(:type=>'pom')) if project['parent']
+    end
+
+    # :call-seq:
+    #   dependencies(scopes?) => artifacts
+    #
+    # Returns list of required dependencies as specified by the POM. You can specify which scopes
+    # to use (e.g. "compile", "runtime"); use +nil+ for dependencies with unspecified scope.
+    # The default scopes are +nil+, "compile" and "runtime" (aka SCOPES_WE_USE).
+    def dependencies(scopes = SCOPES_WE_USE)
+      #try to cache dependencies also
+      @depends_for_scopes ||= {}
+      unless depends = @depends_for_scopes[scopes]
+        declared = project["dependencies"].first["dependency"] rescue nil
+        depends = (declared || []).reject { |dep| value_of(dep["optional"]) =~ /true/ }.
+          map { |dep|
+            spec = pom_to_hash(dep, properties)
+            apply = managed(spec)
+            spec = apply.merge(spec) if apply
+
+            #calculate transitive dependencies
+            if scopes.include?(spec[:scope])
+              spec.delete(:scope)
+
+              exclusions = dep["exclusions"]["exclusion"] rescue nil
+              transitive_deps = POM.load(spec).dependencies(SCOPES_TRANSITIVE)
+              transitive_deps = transitive_deps.reject{|dep|
+                exclusions.find {|ex| dep.index("#{dep['groupdId'].first}:#{dep['artifactId'].first}:") == 0}
+              } if exclusions
+
+              [Artifact.to_spec(spec)] + transitive_deps
+            end
+          }.flatten.compact #.uniq_by{|spec| art = spec.split(':'); "#{art[0]}:#{art[1]}"}
+
+        @depends_for_scopes[scopes] = depends
+      end
+      depends
+    end
+
+    # :call-seq:
+    #   properties() => hash
+    #
+    # Returns properties available to this POM as hash. Includes explicit properties and pom.xxx/project.xxx
+    # properties for groupId, artifactId, version and packaging.
+    def properties()
+      @properties ||= begin
+        pom = ["groupId", "artifactId", "version", "packaging"].inject({}) { |hash, key|
+          value = project[key] || (parent ? parent.project[key] : nil)
+          hash[key] = hash["pom.#{key}"] = hash["project.#{key}"] = value_of(value) if value
+          hash
+        }
+        props = project["properties"].first rescue {}
+        props = props.inject({}) { |mapped, pair| mapped[pair.first] = value_of(pair.last, pom) ; mapped }
+        (parent ? parent.properties.merge(props) : props).merge(pom)
+      end
+    end
+
+    # :call-seq:
+    #    managed() => hash
+    #    managed(hash) => hash
+    #
+    # The first form returns all the managed dependencies specified by this POM in dependencyManagement.
+    # The second form uses a single spec hash and expands it from the current/parent POM. Used to determine
+    # the version number if specified in dependencyManagement instead of dependencies.
+    def managed(spec = nil)
+      if spec
+        managed.detect { |dep| [:group, :id, :type, :classifier].all? { |key| spec[key] == dep[key] } } ||
+          (parent ? parent.managed(spec) : nil)
+      else
+        @managed ||= begin
+          managed = project["dependencyManagement"].first["dependencies"].first["dependency"] rescue nil
+          managed ? managed.map { |dep| pom_to_hash(dep, properties) } : []
+        end
+      end
+    end
+
+  private
+
+    # :call-seq:
+    #    value_of(element) => string
+    #    value_of(element, true) => string
+    #
+    # Returns the normalized text value of an element from its XmlSimple value. The second form performs
+    # property substitution.
+    def value_of(element, substitute = nil)
+      value = element.to_a.join.strip
+      substitute ? value.gsub(/\$\{([^}]+)\}/) { |key| substitute[$1] } : value
+    end
+
+    # :call-seq:
+    #    pom_to_hash(element) => hash
+    #    pom_to_hash(element, true) => hash
+    #
+    # Return the spec hash from an XmlSimple POM referencing element (e.g. project, parent, dependency).
+    # The second form performs property substitution.
+    def pom_to_hash(element, substitute = nil)
+      hash = POM_TO_SPEC_MAP.inject({}) { |spec, pair|
+        spec[pair.first] = value_of(element[pair.last], substitute) if element[pair.last]
+        spec
+      }
+      { :type=>"jar" }.merge(hash)
+    end
+
+  end
+end

data/lib/buildr/java/rjb.rb

@@ -0,0 +1,154 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'rjb'
+
+
+# Equivalent to Java system properties.  For example:
+#   ENV_JAVA['java.version']
+#   ENV_JAVA['java.class.version']
+ENV_JAVA = {}
+
+
+# Buildr runs along side a JVM, using either RJB or JRuby.  The Java module allows
+# you to access Java classes and create Java objects.
+#
+# Java classes are accessed as static methods on the Java module, for example:
+#   str = Java.java.lang.String.new('hai!')
+#   str.toUpperCase
+#   => 'HAI!'
+#   Java.java.lang.String.isInstance(str)
+#   => true
+#   Java.com.sun.tools.javac.Main.compile(args)
+#
+# The classpath attribute allows Buildr to add JARs and directories to the classpath,
+# for example, we use it to load Ant and various Ant tasks, code generators, test
+# frameworks, and so forth.
+#
+# When using an artifact specification, Buildr will automatically download and
+# install the artifact before adding it to the classpath.
+#
+# For example, Ant is loaded as follows:
+#   Java.classpath << 'org.apache.ant:ant:jar:1.7.0'
+#
+# Artifacts can only be downloaded after the Buildfile has loaded, giving it
+# a chance to specify which remote repositories to use, so adding to classpath
+# does not by itself load any libraries.  You must call Java.load before accessing
+# any Java classes to give Buildr a chance to load the libraries specified in the
+# classpath.
+#
+# When building an extension, make sure to follow these rules:
+# 1. Add to the classpath when the extension is loaded (i.e. in module or class
+#    definition), so the first call to Java.load anywhere in the code will include
+#    the libraries you specify.
+# 2. Call Java.load once before accessing any Java classes, allowing Buildr to
+#    set up the classpath.
+# 3. Only call Java.load when invoked, otherwise you may end up loading the JVM
+#    with a partial classpath, or before all remote repositories are listed.
+# 4. Check on a clean build with empty local repository.
+module Java
+
+  module Package #:nodoc:
+
+    def method_missing(sym, *args, &block)
+      raise ArgumentError, 'No arguments expected' unless args.empty?
+      name = "#{@name}.#{sym}"
+      return ::Rjb.import(name) if sym.to_s =~ /^[[:upper:]]/
+      ::Java.send :__package__, name
+    end
+
+  end
+
+  # On OS X we know where the default JDK is. We can try to guess for other OS.
+  # We set JAVA_HOME early so we can use it without calling Java.load first.
+  ENV['JAVA_HOME'] ||= '/System/Library/Frameworks/JavaVM.framework/Home' if Config::CONFIG['host_os'] =~ /darwin/i
+
+  class << self
+
+    # Returns the classpath, an array listing directories, JAR files and
+    # artifacts.  Use when loading the extension to add any additional
+    # libraries used by that extension.
+    #
+    # For example, Ant is loaded as follows:
+    #   Java.classpath << 'org.apache.ant:ant:jar:1.7.0'
+    def classpath
+      @classpath ||= []
+    end
+
+    # Most platforms requires tools.jar to be on the classpath, tools.jar contains the
+    # Java compiler (OS X and AIX are two exceptions we know about, may be more).
+    # Guess where tools.jar is from JAVA_HOME, which hopefully points to the JDK,
+    # but maybe the JRE.  Return nil if not found.
+    def tools_jar #:nodoc:
+      @tools_jar ||= begin
+        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
+        ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, home) }.
+          find { |path| File.exist?(path) }
+      end
+    end
+
+    # Loads the JVM and all the libraries listed on the classpath.  Call this
+    # method before accessing any Java class, but only call it from methods
+    # used in the build, giving the Buildfile a chance to load all extensions
+    # that append to the classpath and specify which remote repositories to use.
+    def load
+      return self if @loaded
+      classpath << tools_jar if tools_jar
+
+      classpath.map! { |path| Proc === path ? path.call : path }
+      cp = Buildr.artifacts(classpath).map(&:to_s).each { |path| file(path).invoke }
+      java_opts = (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split
+      ::Rjb.load cp.join(File::PATH_SEPARATOR), java_opts
+
+      props = ::Rjb.import('java.lang.System').getProperties
+      enum = props.propertyNames
+      while enum.hasMoreElements
+        name = enum.nextElement.toString
+        ENV_JAVA[name] = props.getProperty(name)
+      end
+      @loaded = true
+      self
+    end
+
+    def method_missing(sym, *args, &block) #:nodoc:
+      raise ArgumentError, 'No arguments expected' unless args.empty?
+      Java.load # need to load RJB's classpath now!
+      name = sym.to_s
+      return ::Rjb.import(name) if name =~ /^[[:upper:]]/
+      __package__ name
+    end
+
+  private
+
+    def __package__(name) #:nodoc:
+      Module.new.tap do |m|
+        m.extend Package
+        m.instance_variable_set :@name, name
+      end
+    end
+
+  end
+
+end
+
+
+class Array
+  # Converts a Ruby array into a typed Java array, argument specifies the element type.
+  # This is necessary for JRuby and causes no harm on RJB.
+  def to_java(cls)
+    map { |item| cls.new(item) }
+  end
+end

data/lib/buildr/java/test_result.rb

@@ -0,0 +1,101 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# necessary to require YAML even if it is mentioned by autoload as it fails on some platforms.
+require 'yaml'
+require 'fileutils'
+require 'rspec/core/formatters/base_formatter'
+
+module Buildr #:nodoc:
+  module TestFramework
+
+    # A class used by buildr for jruby based frameworks, so that buildr can know
+    # which tests succeeded/failed.
+    class TestResult
+
+      class Error < ::Exception
+        attr_reader :message, :backtrace
+        def initialize(message, backtrace)
+          @message = message
+          @backtrace = backtrace
+          set_backtrace backtrace
+        end
+
+        def self.dump_yaml(file, e)
+          FileUtils.mkdir_p File.dirname(file)
+          File.open(file, 'w') { |f| f.puts(YAML.dump(Error.new(e.message, e.backtrace))) }
+        end
+
+        def self.guard(file)
+          begin
+            yield
+          rescue => e
+            dump_yaml(file, e)
+          end
+        end
+      end
+
+      attr_accessor :failed, :succeeded
+
+      def initialize
+        @failed, @succeeded = [], []
+      end
+
+      # An Rspec formatter used by buildr
+      class YamlFormatter  < ::RSpec::Core::Formatters::BaseFormatter
+        attr_reader :result
+
+        def initialize(output)
+          super(output)
+          @result = Hash.new
+          @result[:succeeded] = []
+          @result[:failed] = []
+        end
+
+        def example_passed(example)
+          super(example)
+          result.succeeded << example_name(example)
+        end
+
+        def example_pending(example)
+          super(example)
+          result.succeeded << example_name(example)
+        end
+
+        def example_failed(example)
+          super(example)
+          result.failed << example_name(example)
+        end
+
+        def start(example_count)
+          super(example_count)
+          @result = TestResult.new
+        end
+
+        def close
+          super
+          result.succeeded = result.succeeded - result.failed
+          output.puts YAML.dump(result)
+        end
+
+      private
+        def example_name(example)
+          example.file_path
+        end
+      end # YamlFormatter
+
+    end # TestResult
+  end
+end

data/lib/buildr/java/tests.rb

@@ -0,0 +1,362 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/core/build'
+require 'buildr/core/compile'
+require 'buildr/java/ant'
+
+
+module Buildr
+
+  class TestFramework::Java < TestFramework::Base
+
+    class << self
+
+      def applies_to?(project) #:nodoc:
+        project.test.compile.language == :java || project.test.compile.language == :groovy
+      end
+
+      def dependencies
+        unless @dependencies
+          super
+          # Add buildr utility classes (e.g. JavaTestFilter)
+          @dependencies |= [ File.join(File.dirname(__FILE__)) ]
+        end
+        @dependencies
+      end
+    end
+
+  private
+
+    # Add buildr utilities (JavaTestFilter) to classpath
+    Java.classpath << lambda { dependencies }
+
+    # :call-seq:
+    #     filter_classes(dependencies, criteria)
+    #
+    # Return a list of classnames that match the given criteria.
+    # The criteria parameter is a hash that must contain at least one of:
+    #
+    # * :class_names -- List of patterns to match against class name
+    # * :interfaces -- List of java interfaces or java classes
+    # * :class_annotations -- List of annotations on class level
+    # * :method_annotations -- List of annotations on method level
+    # * :fields -- List of java field names
+    #
+    def filter_classes(dependencies, criteria = {})
+      return [] unless task.compile.target
+      target = task.compile.target.to_s
+      candidates = Dir["#{target}/**/*.class"].
+        map { |file| Util.relative_path(file, target).ext('').gsub(File::SEPARATOR, '.') }.
+        reject { |name| name =~ /\$./ }
+      result = []
+      if criteria[:class_names]
+        result.concat candidates.select { |name| criteria[:class_names].flatten.any? { |pat| pat === name } }
+      end
+      begin
+        Java.load
+        filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
+        if criteria[:interfaces]
+          filter.add_interfaces(criteria[:interfaces].to_java(Java.java.lang.String))
+        end
+        if criteria[:class_annotations]
+          filter.add_class_annotations(criteria[:class_annotations].to_java(Java.java.lang.String))
+        end
+        if criteria[:method_annotations]
+          filter.add_method_annotations(criteria[:method_annotations].to_java(Java.java.lang.String))
+        end
+        if criteria[:fields]
+          filter.add_fields(criteria[:fields].to_java(Java.java.lang.String))
+        end
+        result.concat filter.filter(candidates.to_java(Java.java.lang.String)).map(&:to_s)
+      rescue =>ex
+        info "#{ex.class}: #{ex.message}"
+        raise
+      end
+    end
+
+  end
+
+
+  # JMock is available when using JUnit and TestNG, JBehave.
+  module JMock
+
+    VERSION = '2.5.1'
+
+    class << self
+      def version
+        Buildr.settings.build['jmock'] || VERSION
+      end
+
+      def dependencies
+        two_or_later = version[0,1].to_i >= 2
+        group = two_or_later ? "org.jmock" : "jmock"
+
+        @dependencies ||= ["#{group}:jmock:jar:#{version}"]
+        if two_or_later
+          @dependencies << "org.jmock:jmock-junit#{Buildr::JUnit.version.to_s[0,1]}:jar:#{version}"
+          @dependencies << "org.hamcrest:hamcrest-core:jar:1.1"
+          @dependencies << "org.hamcrest:hamcrest-library:jar:1.1"
+        end
+        @dependencies
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JMock.dependencies/.version instead of JMock::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+  end
+
+
+  # JUnit test framework, the default test framework for Java tests.
+  #
+  # Support the following options:
+  # * :fork        -- If true/:once (default), fork for each test class.  If :each, fork for each individual
+  #                   test case.  If false, run all tests in the same VM (fast, but dangerous).
+  # * :clonevm     -- If true clone the VM each time it is forked.
+  # * :properties  -- Hash of system properties available to the test case.
+  # * :environment -- Hash of environment variables available to the test case.
+  # * :java_args   -- Arguments passed as is to the JVM.
+  class JUnit < TestFramework::Java
+
+    # Used by the junit:report task. Access through JUnit#report if you want to set various
+    # options for that task, for example:
+    #   JUnit.report.frames = false
+    class Report
+
+      # Parameters passed to the Ant JUnitReport task.
+      attr_reader :params
+      # True (default) to produce a report using frames, false to produce a single-page report.
+      attr_accessor :frames
+      # Directory for the report style (defaults to using the internal style).
+      attr_accessor :style_dir
+      # Target directory for generated report.
+      attr_accessor :target
+
+      def initialize
+        @params = {}
+        @frames = true
+        @target = 'reports/junit'
+      end
+
+      # :call-seq:
+      #   generate(projects, target?)
+      #
+      # Generates a JUnit report for these projects (must run JUnit tests first) into the
+      # target directory. You can specify a target, or let it pick the default one from the
+      # target attribute.
+      def generate(projects, target = @target.to_s)
+        html_in = File.join(target, 'html')
+        rm_rf html_in ; mkpath html_in
+
+        Buildr.ant('junit-report') do |ant|
+          ant.taskdef :name=>'junitreport', :classname=>'org.apache.tools.ant.taskdefs.optional.junit.XMLResultAggregator',
+            :classpath=>Buildr.artifacts(JUnit.ant_taskdef).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+          ant.junitreport :todir=>target do
+            projects.select { |project| project.test.framework == :junit }.
+              map { |project| project.test.report_to.to_s }.select { |path| File.exist?(path) }.
+              each { |path| ant.fileset(:dir=>path) { ant.include :name=>'TEST-*.xml' }  }
+            options = { :format=>frames ? 'frames' : 'noframes' }
+            options[:styledir] = style_dir if style_dir
+            ant.report options.merge(:todir=>html_in) do
+              params.each { |key, value| ant.param :name=>key, :expression=>value }
+            end
+          end
+        end
+      end
+
+    end
+
+    # JUnit version number.
+    VERSION = '4.7'
+
+    class << self
+      # :call-seq:
+      #    report()
+      #
+      # Returns the Report object used by the junit:report task. You can use this object to set
+      # various options that affect your report, for example:
+      #   JUnit.report.frames = false
+      #   JUnit.report.params['title'] = 'My App'
+      def report
+        @report ||= Report.new
+      end
+
+      def version
+        Buildr.settings.build['junit'] || VERSION
+      end
+
+      def dependencies
+        @dependencies ||= ["junit:junit:jar:#{version}"]+ JMock.dependencies
+      end
+
+      def ant_taskdef #:nodoc:
+        "org.apache.ant:ant-junit:jar:#{Ant.version}"
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JUnit.dependencies/.version instead of JUnit::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def tests(dependencies) #:nodoc:
+      if (self.class.version.to_s[0,1].to_i < 4)
+        filter_classes(dependencies, :interfaces => %w{junit.framework.TestCase})
+      else
+        filter_classes(dependencies,
+                       :interfaces => %w{junit.framework.TestCase},
+                       :class_annotations => %w{org.junit.runner.RunWith},
+                       :method_annotations => %w{org.junit.Test})
+      end
+      
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      # Use Ant to execute the Junit tasks, gives us performance and reporting.
+      Buildr.ant('junit') do |ant|
+        case options[:fork]
+        when false
+          forking = {}
+        when :each
+          forking = { :fork=>true, :forkmode=>'perTest' }
+        when true, :once
+          forking = { :fork=>true, :forkmode=>'once' }
+        else
+          fail 'Option fork must be :once, :each or false.'
+        end
+        mkpath task.report_to.to_s
+
+        taskdef = Buildr.artifact(JUnit.ant_taskdef)
+        taskdef.invoke
+        ant.taskdef :name=>'junit', :classname=>'org.apache.tools.ant.taskdefs.optional.junit.JUnitTask', :classpath=>taskdef.to_s
+
+        ant.junit forking.merge(:clonevm=>options[:clonevm] || false, :dir=>task.send(:project).path_to) do
+          ant.classpath :path=>dependencies.join(File::PATH_SEPARATOR)
+          (options[:properties] || []).each { |key, value| ant.sysproperty :key=>key, :value=>value }
+          (options[:environment] || []).each { |key, value| ant.env :key=>key, :value=>value }
+          Array(options[:java_args]).each { |value| ant.jvmarg :value=>value }
+          ant.formatter :type=>'plain'
+          ant.formatter :type=>'plain', :usefile=>false # log test
+          ant.formatter :type=>'xml'
+          ant.batchtest :todir=>task.report_to.to_s, :failureproperty=>'failed' do
+            ant.fileset :dir=>task.compile.target.to_s do
+              tests.each { |test| ant.include :name=>File.join(*test.split('.')).ext('class') }
+            end
+          end
+        end
+        return tests unless ant.project.getProperty('failed')
+      end
+      # But Ant doesn't tell us what went kaput, so we'll have to parse the test files.
+      tests.inject([]) do |passed, test|
+        report_file = File.join(task.report_to.to_s, "TEST-#{test}.txt")
+        if File.exist?(report_file)
+          report = File.read(report_file)
+          # The second line (if exists) is the status line and we scan it for its values.
+          status = (report.split("\n")[1] || '').scan(/(run|failures|errors):\s*(\d+)/i).
+            inject(Hash.new(0)) { |hash, pair| hash[pair[0].downcase.to_sym] = pair[1].to_i ; hash }
+          passed << test if status[:failures] == 0 && status[:errors] == 0
+        end
+        passed
+      end
+    end
+
+    namespace 'junit' do
+      desc "Generate JUnit tests report in #{report.target}"
+      task('report') do |task|
+        report.generate Project.projects
+        info "Generated JUnit tests report in #{report.target}"
+      end
+    end
+
+    task('clean') { rm_rf report.target.to_s }
+
+  end
+
+
+  # TestNG test framework.  To use in your project:
+  #   test.using :testng
+  #
+  # Support the following options:
+  # * :properties -- Hash of properties passed to the test suite.
+  # * :java_args -- Arguments passed to the JVM.
+  class TestNG < TestFramework::Java
+
+    VERSION = '5.10'
+
+    class << self
+      def version
+        Buildr.settings.build['testng'] || VERSION
+      end
+
+      def dependencies
+        ["org.testng:testng:jar:jdk15:#{version}"]+ JMock.dependencies
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use TestNG.dependencies/.version instead of TestNG::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def tests(dependencies) #:nodoc:
+      filter_classes(dependencies,
+                     :class_annotations => %w{org.testng.annotations.Test},
+                     :method_annotations => %w{org.testng.annotations.Test})
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      cmd_args = ['-log', '2', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.project.id ]
+      cmd_args << '-d' << task.report_to.to_s
+      # run all tests in the same suite
+      cmd_args << '-testclass' << tests
+      
+      cmd_options = { :properties=>options[:properties], :java_args=>options[:java_args],
+        :classpath=>dependencies, :name => "TestNG in #{task.send(:project).name}" }
+      
+      tmp = nil
+      begin
+        tmp = Tempfile.open("testNG")
+        tmp.write cmd_args.join("\n")
+        tmp.close
+        Java::Commands.java ['org.testng.TestNG', "@#{tmp.path}"], cmd_options
+        return tests
+      rescue
+        # testng-failed.xml contains the list of failed tests *only*
+        report = File.read(File.join(task.report_to.to_s, 'testng-failed.xml'))
+        failed = report.scan(/<class name="(.*?)">/im).flatten
+        error "TestNG regexp returned unexpected failed tests #{failed.inspect}" unless (failed - tests).empty?
+        # return the list of passed tests
+        return tests - failed
+      ensure
+        tmp.close unless tmp.nil?
+      end
+    end
+
+  end
+
+end # Buildr
+
+
+Buildr::TestFramework << Buildr::JUnit
+Buildr::TestFramework << Buildr::TestNG