vic-buildr 1.3.3 → 1.3.4

data/lib/buildr/java/commands.rb

@@ -83,7 +83,8 @@ module Java
         end
         cmd_args << '-source' << options[:source] if options[:source]
         classpath = classpath_from(options)
-        Java.tools_jar { |tools| classpath << tools }
+        tools = Java.tools_jar
+        classpath << tools if tools
         cmd_args << '-classpath' << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
         cmd_args += files
         unless Buildr.application.options.dryrun

data/lib/buildr/java/emma.rb

@@ -0,0 +1,238 @@
+# 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/java'
+
+
+module Buildr
+
+  # Provides the <code>emma:html</code> and <code>emma:xml</code> tasks.
+  # Require explicitly using <code>require "buildr/emma"</code>.
+  #
+  # You can generate emma reports for a single project 
+  # using the project name as prefix:
+  #
+  #   project_name:emma:html
+  #
+  # You can also specify which classes to include/exclude from instrumentation by 
+  # passing a class name regexp to the <code>emma.include</code> or 
+  # <code>emma.exclude</code> methods. 
+  # 
+  #   define 'someModule' do 
+  #      emma.include 'some.package.*'
+  #      emma.exclude 'some.foo.util.SimpleUtil'
+  #   end
+  module Emma
+
+    class << self
+
+      REQUIRES = ['emma:emma_ant:jar:2.0.5312', 'emma:emma:jar:2.0.5312'] unless const_defined?('REQUIRES')
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
+      end
+
+      def report_to format=nil
+        File.expand_path('reports/emma')
+      end
+
+      def data_file()
+        File.join(report_to, 'coverage.es')
+      end
+
+      def ant
+          Buildr.ant 'emma' do |ant|
+            ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>'emma_ant.properties'
+            ant.emma :verbosity=>(Buildr.application.options.trace ? 'verbose' : 'warning') do
+              yield ant
+            end
+          end
+      end
+    end
+    
+    class EmmaConfig # :nodoc:
+      
+      def initialize(project)
+        @project = project
+      end
+      
+      attr_reader :project
+      private :project
+
+      attr_writer :metadata_file, :coverage_file, :instrumented_dir, :report_dir
+      
+      def coverage_file
+        @coverage_file ||= File.join(report_dir, 'coverage.ec')
+      end
+
+      def metadata_file
+        @metadata_file ||= File.join(report_dir, 'coverage.em')
+      end
+
+      def instrumented_dir
+        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
+      end
+
+      def report_dir
+        @report_dir ||= project.path_to(:reports, :emma)
+      end
+      
+      def report_to format
+        report_dir
+      end
+
+      # :call-seq:
+      #   project.emma.include(*classPatterns)
+      #
+      def include(*classPatterns)
+        includes.push(*classPatterns)
+        self
+      end
+      
+      def includes
+        @includeClasses ||= []
+      end
+
+      # :call-seq:
+      #   project.emma.exclude(*classPatterns)
+      #
+      def exclude(*classPatterns)
+        excludes.push(*classPatterns)
+        self
+      end
+
+      def excludes
+        @excludeClasses ||= []
+      end
+
+      def sources
+        project.compile.sources
+      end
+    end
+
+    module EmmaExtension # :nodoc:
+      include Buildr::Extension
+
+      def emma
+        @emma_config ||= EmmaConfig.new(self)
+      end
+
+      after_define do |project|
+        emma = project.emma
+        
+        namespace 'emma' do
+          unless project.compile.target.nil?
+            # Instrumented bytecode goes in a different directory. This task creates before running the test
+            # cases and monitors for changes in the generate bytecode.
+            instrumented = project.file(emma.instrumented_dir => project.compile.target) do |task|
+              unless project.compile.sources.empty?
+                info "Instrumenting classes with emma metadata file #{emma.metadata_file}"
+                Emma.ant do |ant|
+                  ant.instr :instrpath=>project.compile.target.to_s, :destdir=>task.to_s, :metadatafile=>emma.metadata_file do
+                    ant.filter :includes=>emma.includes.join(', ') unless emma.includes.empty?
+                    ant.filter :excludes=>emma.excludes.join(', ') unless emma.excludes.empty?
+                  end
+                end
+                touch task.to_s, :verbose=>false
+              end
+            end
+            
+            task 'instrument' => instrumented
+            
+            # We now have two target directories with bytecode.
+            project.test.dependencies.unshift emma.instrumented_dir
+            project.test.with Emma.requires
+            project.test.options[:properties]["emma.coverage.out.file"] = emma.coverage_file
+            
+            [:xml, :html].each do |format|
+              task format => ['instrument', 'test'] do
+                missing_required_files = [emma.metadata_file, emma.coverage_file].reject { |f| File.exist?(f) }
+                if missing_required_files.empty?
+                  info "Creating test coverage reports in #{emma.report_dir}"
+                  mkdir_p emma.report_dir, :verbose=>false
+                  Emma.ant do |ant|
+                    ant.report do
+                      ant.infileset :file=>emma.metadata_file
+                      ant.infileset :file=>emma.coverage_file
+                      ant.send format, :outfile=>File.join(emma.report_to(format),"coverage.#{format}")
+                      ant.sourcepath do
+                        emma.sources.flatten.each do |src|
+                          ant.dirset(:dir=>src.to_s) if File.exist?(src.to_s)
+                        end
+                      end
+                    end
+                  end
+                else
+                  info "No test coverage report for #{project}. Missing: #{missing_required_files.join(', ')}"
+                end
+              end
+            end
+          end
+        end
+
+        project.clean do
+          rm_rf [emma.report_dir, emma.coverage_file, emma.metadata_file, emma.instrumented_dir], :verbose=>false
+        end
+        
+      end
+      
+    end
+
+    class Buildr::Project
+      include EmmaExtension
+    end
+
+    namespace "emma" do
+
+      Project.local_task('instrument') { |name| "Instrumenting #{name}" }
+      
+      [:xml, :html].each do |format|
+        desc "Run the test cases and produce code coverage reports in #{format}"
+        task format => ['instrument', 'test'] do
+          info "Creating test coverage reports in #{format}"
+          mkdir_p report_to(format), :verbose=>false
+          Emma.ant do |ant|
+            ant.merge :outfile=>data_file do
+              Buildr.projects.each do |project|
+                [project.emma.metadata_file, project.emma.coverage_file].each do |data_file|
+                  ant.fileset :file=>data_file if File.exist?(data_file)
+                end
+              end
+            end
+            ant.report do
+              ant.infileset :file=>data_file
+              ant.send format, :outfile=>File.join(report_to(format), "coverage.#{format}")
+              ant.sourcepath do
+                Buildr.projects.map(&:emma).map(&:sources).flatten.map(&:to_s).each do |src|
+                  ant.dirset :dir=>src if File.exist?(src)
+                end    
+              end
+            end
+          end
+        end
+      end
+      
+      task :clean do
+        rm_rf [report_to, data_file], :verbose=>false
+      end
+      end
+
+    task :clean do
+      task('emma:clean').invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end

data/lib/buildr/java/jtestr_runner.rb.erb

@@ -107,6 +107,8 @@ rescue => e
   Buildr::TestFramework::TestResult::Error.dump_yaml('<%= runner.result %>', e) rescue \
   puts "-[--- ERROR ---]-", e.class, e.message, *e.backtrace
 end
+
+exit 0 # let buildr find the erros from the result yaml
   
 # Local Variables:
 # mode: ruby

data/lib/buildr/java/packaging.rb

@@ -25,7 +25,7 @@ module Buildr
 
       class Manifest
 
-        STANDARD_HEADER = "Manifest-Version: 1.0\nCreated-By: Buildr\n"
+        STANDARD_HEADER = { 'Manifest-Version'=>'1.0', 'Created-By'=>'Buildr' }
         LINE_SEPARATOR = /\r\n|\n|\r[^\n]/ #:nodoc:
         SECTION_SEPARATOR = /(#{LINE_SEPARATOR}){2}/ #:nodoc:
 
@@ -97,6 +97,10 @@ module Buildr
           else
             fail 'Invalid manifest, expecting Hash, Array, file name/task or proc/method.'
           end
+          # Add Manifest-Version and Created-By, if not specified.
+          STANDARD_HEADER.each do |name, value|
+            sections.first[name] ||= value
+          end
         end
 
         # The sections of this manifest.
@@ -171,7 +175,7 @@ module Buildr
               @manifest_tmp = Tempfile.new('MANIFEST.MF')
               self.manifest = File.read(manifest.to_s) if String === manifest || Rake::Task === manifest
               self.manifest = Manifest.new(manifest) unless Manifest === manifest
-              @manifest_tmp.write Manifest::STANDARD_HEADER
+              #@manifest_tmp.write Manifest::STANDARD_HEADER
               @manifest_tmp.write manifest.to_s
               @manifest_tmp.write "\n"
               @manifest_tmp.rewind

data/lib/buildr/java/pom.rb

@@ -14,10 +14,6 @@
 # the License.
 
 
-require 'xmlsimple'
-require 'buildr/packaging'
-
-
 module Buildr
   class POM
 

data/lib/buildr/java/test_result.rb

@@ -13,7 +13,6 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'yaml'
 
 module Buildr #:nodoc:
   module TestFramework
@@ -27,6 +26,7 @@ module Buildr #:nodoc:
         def initialize(message, backtrace)
           @message = message
           @backtrace = backtrace
+          set_backtrace backtrace
         end
 
         def self.dump_yaml(file, e)
@@ -59,9 +59,12 @@ module Buildr #:nodoc:
         def initialize(options, where)
           @options = options
           @where = where
+          @result = Hash.new
+          @result[:succeeded] = []
+          @result[:failed] = []
         end
         
-        %w[ example_started example_passed example_failed example_pending
+        %w[ example_started
             start_dump dump_failure dump_summary dump_pending ].each do |meth|
           module_eval "def #{meth}(*args); end"
         end
@@ -70,24 +73,38 @@ module Buildr #:nodoc:
           @example_group = example_group
         end
 
+        def example_passed(example)
+        end
+
+        def example_pending(example, counter, failure)
+        end
+
+        def example_failed(example, counter, failure)
+          if example_group.respond_to?(:spec_path)
+            result.failed << example_group.spec_path.gsub(/:\d+$/, '')
+          else
+            path = path_from_bt(failure.exception.backtrace)
+            result.failed << path if path
+          end
+        end
+
         def start(example_count)
           @result = TestResult.new
         end
 
-        def close
+        def path_from_bt(ary)
           files = options.files
-          failure_from_bt = lambda do |ary|
-            test = nil
-            ary.find do |bt|
-              bt = bt.split(':').first.strip
-              test = bt if files.include?(bt)
-            end
-            test
-          end
-          options.reporter.instance_variable_get(:@failures).each do |failure|
-            result.failed << files.delete(failure_from_bt[failure.exception.backtrace])
+          test = nil
+          ary.find do |bt|
+            bt = bt.split(':').first.strip
+            test = bt if files.include?(bt)
           end
-          result.succeeded |= files
+          test
+        end
+
+        def close
+          files = options.files
+          result.succeeded = files - result.failed
           
           FileUtils.mkdir_p(File.dirname(where))
           File.open(where, 'w') { |f| f.puts YAML.dump(result) }
@@ -238,8 +255,21 @@ module Buildr #:nodoc:
             nil
           when Test::Unit::Failure
             Error.new(fault.message, fault.location)
-          when Test::Unit::Error, Expectations::Results::Error, Spec::Runner::Reporter::Failure
+          when Test::Unit::Error
+            if fault.exception.is_a?(NativeException)
+              exception = fault.exception.cause
+              bt = exception.stack_trace.to_a
+            else
+              exception = fault.exception
+              bt = exception.backtrace
+            end
+            Error.new(exception.message, bt)
+          when Expectations::Results::Error
             fault.exception
+          when Spec::Runner::Reporter::Failure
+            ex = fault.exception
+            fault.example.instance_variable_get(:@_implementation).to_s =~ /@(.+:\d+)/
+            Error.new(ex.message, [$1.to_s] + ex.backtrace)
           when Expectations::Results
             file = fault.file
             line = fault.line

data/lib/buildr/java/tests.rb

@@ -301,17 +301,22 @@ module Buildr
     end
 
     def run(tests, dependencies) #:nodoc:
-      cmd_args = [ 'org.testng.TestNG', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.send(:project).name ]
+      cmd_args = [ 'org.testng.TestNG', '-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 }
-      tests.inject([]) do |passed, test|
-        begin
-          Java::Commands.java cmd_args, '-testclass', test, cmd_options.merge(:name=>test)
-          passed << test
-        rescue
-          passed
-        end
+        :classpath=>dependencies, :name => "TestNG in #{task.send(:project).name}" }
+
+      begin
+        Java::Commands.java cmd_args, 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
+        # return the list of passed tests
+        return tests - failed
       end
     end
 

data/lib/buildr/packaging.rb

@@ -14,8 +14,11 @@
 # the License.
 
 
-require 'buildr/packaging/zip'
-require 'buildr/packaging/tar'
 require 'buildr/packaging/artifact'
 require 'buildr/packaging/package'
+require 'buildr/packaging/archive'
+require 'buildr/packaging/ziptask'
+require 'buildr/packaging/tar'
 require 'buildr/packaging/gems'
+autoload :Zlib, 'zlib'
+autoload :Zip, 'buildr/packaging/zip'