buildr 1.4.4-java → 1.4.5-java

data/lib/buildr/java/bdd.rb

@@ -17,7 +17,6 @@
 require 'buildr/java/tests'
 require 'buildr/java/test_result'
 
-
 module Buildr
 
   # Mixin for test frameworks using src/spec/{lang}
@@ -48,7 +47,7 @@ module Buildr
   module TestFramework::JRubyBased
     extend self
 
-    VERSION = '1.5.2'
+    VERSION = '1.5.6'
 
     class << self
       def version
@@ -107,9 +106,11 @@ module Buildr
       else
         cmd_options = task.options.only(:properties, :java_args)
         cmd_options.update(:classpath => dependencies, :project => task.project)
-        jruby runner.file, tests, cmd_options
+        jruby runner.file, tests, cmd_options rescue nil
       end
 
+      fail "Missing result YAML file: #{runner.result}" unless File.exist? runner.result
+
       result = YAML.load(File.read(runner.result))
       if Exception === result
         raise [result.message, result.backtrace].flatten.join("\n")
@@ -197,7 +198,8 @@ module Buildr
       runner.gems ||= {}
       runner.rspec ||= ['--format', 'progress', '--format', "html:#{runner.html_report}"]
       runner.format.each { |format| runner.rspec << '--format' << format } if runner.format
-      runner.rspec.push '--format', "Buildr::TestFramework::TestResult::YamlFormatter:#{runner.result}"
+      runner.rspec.push '--format', "Buildr::TestFramework::TestResult::YamlFormatter"
+      runner.rspec.push '-o', runner.result
       runner
     end
 
@@ -240,8 +242,8 @@ module Buildr
 
     def runner_config
       runner = super
-      runner.gems.update 'rspec' => '~>1.3.1'
-      runner.requires.unshift 'spec'
+      runner.gems.update 'rspec' => '~> 2.1.0'
+      runner.requires.unshift 'rspec'
       runner
     end
 
@@ -258,14 +260,12 @@ module Buildr
         <% else %>
           output = STDOUT
         <% end %>
-        parser = ::Spec::Runner::OptionParser.new(output, output)
+        parser = ::RSpec::Core::Parser.new
         argv = <%= runner.rspec.inspect %> || []
         argv.push *<%= tests.inspect %>
-        parser.order!(argv)
-        $rspec_options = parser.options
 
         Buildr::TestFramework::TestResult::Error.guard('<%= runner.result %>') do
-          ::Spec::Runner::CommandLine.run($rspec_options)
+          ::RSpec::Core::CommandLine.new(argv).run(output, output)
         end
         exit 0 # let buildr figure the result from the yaml file
       }
@@ -368,9 +368,15 @@ module Buildr
 
     def runner_config
       runner = super
-      # JtestR 0.3.1 comes with rspec 1.1.4 (and any other jtestr dependency) included,
+      # JtestR 0.6.0 comes with rspec 1.3.0 (and any other jtestr dependency) included,
       # so the rspec version used depends on the jtestr jar.
       runner.requires.unshift 'jtestr'
+      runner.gems.update 'rspec' => '=1.3.0'
+      runner.requires.unshift 'spec'
+      runner.requires.unshift File.join(File.dirname(__FILE__), 'jtestr_result')
+      runner.rspec = ['--format', 'progress', '--format', "html:#{runner.html_report}"]
+      runner.format.each { |format| runner.rspec << '--format' << format } if runner.format
+      runner.rspec.push '--format', "Buildr::JtestR::YamlFormatter:#{runner.result}"
       runner
     end
 
@@ -378,10 +384,8 @@ module Buildr
       runner_erb = File.join(File.dirname(__FILE__), 'jtestr_runner.rb.erb')
       Filter::Mapper.new(:erb, binding).transform(File.read(runner_erb), runner_erb)
     end
-
   end
 
-
   # JBehave is a Java BDD framework. To use in your project:
   #   test.using :jbehave
   #
@@ -453,3 +457,4 @@ end
 Buildr::TestFramework << Buildr::RSpec
 Buildr::TestFramework << Buildr::JtestR
 Buildr::TestFramework << Buildr::JBehave
+

data/lib/buildr/java/ecj.rb

@@ -23,14 +23,12 @@ module Buildr
       specify :language=>:java, :sources => 'java', :source_ext => 'java',
       :target=>'classes', :target_ext=>'class', :packaging=>:jar
 
-
-
       def compile(sources, target, dependencies) #:nodoc:
         check_options options, OPTIONS
         cmd_args = []
         # tools.jar contains the Java compiler.
         dependencies << Java.tools_jar if Java.tools_jar
-        cmd_args << '-classpath' << dependencies.join(File::PATH_SEPARATOR) unless dependencies.empty?
+        cmd_args << '-classpath' << ('"' + dependencies.join(File::PATH_SEPARATOR) + '"') unless dependencies.empty?
         source_paths = sources.select { |source| File.directory?(source) }
         cmd_args << '-sourcepath' << source_paths.join(File::PATH_SEPARATOR) unless source_paths.empty?
         cmd_args << '-d' << File.expand_path(target)

data/lib/buildr/java/jtestr_result.rb

@@ -0,0 +1,295 @@
+# 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'
+
+module Buildr #:nodoc:
+
+  module JtestR
+
+    # An Rspec formatter used by JtestR
+    class YamlFormatter
+      attr_reader :result
+
+      attr_accessor :example_group, :options, :where
+
+      def initialize(options, where)
+        @options = options
+        @where = where
+      end
+
+      %w[ example_started
+          start_dump dump_failure dump_summary dump_pending ].each do |meth|
+        module_eval "def #{meth}(*args); end"
+      end
+
+      def example_group_started(example_group)
+        @example_group = example_group
+      end
+
+      def example_passed(example)
+        result.succeeded << example_name(example)
+      end
+
+      def example_pending(example, counter)
+        result.succeeded << example_name(example)
+      end
+
+      def example_failed(example, counter, failure)
+        result.failed << example_name(example)
+      end
+
+      def start(example_count)
+        @result = Buildr::TestFramework::TestResult.new
+      end
+
+      def close
+        result.succeeded = result.succeeded - result.failed
+        FileUtils.mkdir_p File.dirname(where)
+        File.open(where, 'w') { |f| f.puts YAML.dump(result) }
+      end
+
+    private
+      def example_name(example)
+        if Spec::Example::ExampleProxy === example
+          example_group.location.gsub(/:\d+$/, '')
+        else
+          example.name.gsub(/(.+)(\..+\(\))/, '\1')
+        end
+      end
+    end # YamlFormatter
+
+    # A JtestR ResultHandler
+    # Using this handler we can use RSpec formatters, like html/ci_reporter with JtestR
+    # Created for JTestrYamlFormatter
+    class ResultHandler
+
+      # Workaround for http://jira.codehaus.org/browse/JTESTR-68
+      module TestNGResultHandlerMixin
+        def onTestSuccess(test_result)
+          @result_handler.succeed_single(test_result.name)
+        end
+      end
+
+      class BacktraceTweaker
+        attr_reader :ignore_patterns
+        def initialize
+          @ignore_patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.dup
+          # ignore jruby/jtestr backtrace
+          ignore_patterns << /org\.jruby\.javasupport\.JavaMethod\./
+          ignore_patterns << /jtestr.*\.jar!/i << /runner\.rb/
+        end
+
+        def clean_up_double_slashes(line)
+          line.gsub!('//','/')
+        end
+
+        def tweak_backtrace(error)
+          return if error.backtrace.nil?
+          error.backtrace.collect! do |line|
+            clean_up_double_slashes(line)
+            ignore_patterns.each do |ignore|
+              if line =~ ignore
+                line = nil
+                break
+              end
+            end
+            line
+          end
+          error.backtrace.compact!
+        end
+      end
+
+      class << self
+        # an rspec reporter used to proxy events to rspec formatters
+        attr_reader :reporter
+        attr_accessor :test_files
+
+        def init(argv = [], out = STDOUT, err = STDERR)
+          ::JtestR::TestNGResultHandler.module_eval { include TestNGResultHandlerMixin }
+          rspec_parser = ::Spec::Runner::OptionParser.new(err, out)
+          rspec_parser.order!(argv)
+          rspec_parser.options.backtrace_tweaker = BacktraceTweaker.new
+          @reporter = Spec::Runner::Reporter.new(rspec_parser.options)
+        end
+
+        def before
+          reporter.start(reporter.options.files.size)
+        end
+
+        def after
+          reporter.end
+          reporter.dump
+        end
+
+      end
+
+      module ExampleMethods
+        attr_accessor :name, :description, :__full_description, :location
+      end
+
+      def reporter
+        self.class.reporter
+      end
+
+      attr_accessor :example_group, :current_example, :current_failure
+
+      def initialize(name, desc, *args)
+        self.example_group = ::Spec::Example::ExampleGroup.new(desc)
+        example_group.extend ExampleMethods
+        example_group.name = name.to_s
+        if example_group.name[/Spec/]
+          example_group.description = desc.to_s
+        else
+          example_group.description = name.to_s
+        end
+        reporter.example_group_started(example_group)
+      end
+
+
+      def starting
+      end
+
+      def ending
+      end
+
+      def add_fault(fault)
+        self.current_failure = fault
+      end
+
+      def add_pending(pending)
+      end
+
+      def starting_single(name = nil)
+        self.current_failure = nil
+        self.current_example = Object.new
+        current_example.extend ::Spec::Example::ExampleMethods
+        current_example.extend ExampleMethods
+        name = name.to_s
+        current_example.location = name.to_s
+        current_example.name = name.gsub(/(.*)\((.+)\)/, '\2')
+        current_example.description = name
+        if example_group.name[/Spec/]
+          current_example.__full_description = "#{example_group.description} #{name}"
+        else
+          current_example.__full_description = "#{example_group.name}: #{name}"
+        end
+        reporter.example_started(current_example)
+      end
+
+      def succeed_single(name = nil)
+        reporter.example_finished(current_example, nil)
+      end
+
+      def fail_single(name = nil)
+        current_example.name = current_name
+        reporter.example_finished(current_example, current_error)
+      end
+
+      def error_single(name = nil)
+        current_example.name = current_name
+        reporter.example_finished(current_example, current_error)
+      end
+
+      def pending_single(name = nil)
+        error = ::Spec::Example::ExamplePendingError.new(name)
+        reporter.example_finished(current_example, error)
+      end
+
+    private
+      def detect_file(trace)
+        # find first matching test file in stacktrace
+        file = nil
+        first_pos = nil
+        ResultHandler.test_files.each do |f|
+          pos = trace.index(f)
+          if pos && (first_pos.nil? || pos < first_pos)
+            file = f
+            first_pos = pos
+          end
+        end
+        file || fail("JTestR::ResultHandler.detect_file failed: #{trace}")
+      end
+
+      def current_name(example = current_example, fault = current_failure)
+        return example.name unless fault
+        case fault
+        when Test::Unit::Error
+          detect_file(fault.long_display)
+        when Test::Unit::Failure
+          detect_file(fault.location.to_s)
+        when Spec::Runner::Reporter::Failure
+          detect_file(fault.exception.backtrace.to_s)
+        else
+          example.name
+        end
+      end
+
+      def current_error(fault = current_failure)
+        case fault
+        when nil
+          nil
+        when Test::Unit::Failure
+          Buildr::TestFramework::TestResult::Error.new(fault.message, fault.location)
+        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
+          Buildr::TestFramework::TestResult::Error.new(exception.message, bt)
+        when Expectations::Results::Error
+          fault.exception
+        when Spec::Runner::Reporter::Failure
+          ex = fault.exception
+          Buildr::TestFramework::TestResult::Error.new(ex.message, ex.backtrace)
+        when Expectations::Results
+          file = fault.file
+          line = fault.line
+          Buildr::TestFramework::TestResult::Error.new(fault.message, ["#{fault.file}:#{fault.line}"])
+        else
+          if fault.respond_to?(:test_header)
+            fault.test_header[/\((.+)\)/]
+            test_cls, test_meth = $1.to_s, $`.to_s
+            exception = fault.exception
+            (class << exception; self; end).module_eval do
+              define_method(:backtrace) do
+                (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+              end
+            end
+            exception
+          elsif fault.respond_to?(:method)
+            test_cls, test_meth = fault.method.test_class.name, fault.method.method_name
+            exception = fault.throwable
+            (class << exception; self; end).module_eval do
+              define_method(:backtrace) do
+                (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+              end
+            end
+            exception
+          else
+            raise "Cannot handle fault #{fault.class}: #{fault.inspect}"
+          end
+        end
+      end
+
+    end # ResultHandler
+  end
+end
+

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

@@ -26,7 +26,6 @@
 # <%= user_config %>
 
 begin
-
   <%= jruby_gem %>
   <%= dependencies.map(&:to_s).inspect %>.each { |dep| $CLASSPATH << dep }
   <%= runner.gems.inspect %>.each { |ary| JRuby.gem(*ary.flatten) }
@@ -87,21 +86,20 @@ begin
      output = STDOUT
   <% end %>
 
-
   args = [ '<%= spec_dir %>', # the directory to search for jtestr files
            JtestR::SimpleLogger::ERR, # log level (DEBUG/WARN/ERR)
            JtestR::GenericResultHandler::QUIET, #output level (QUIET/VERBOSE)
            fake_out, # output STDOUT
            [], # groups to run
            # Use JtestR::GenericResultHandler for debugging
-           Buildr::TestFramework::TestResult::RSpecResultHandler, # result handler
+           Buildr::JtestR::ResultHandler, # result handler
            []  # classpath
          ]
 
   argv = <%= runner.rspec.inspect %> || []
   argv.push *<%= tests.inspect %>
-  Buildr::TestFramework::TestResult::RSpecResultHandler.init(argv, output, output)
-  Buildr::TestFramework::TestResult::RSpecResultHandler.test_files = <%= tests.inspect %>
+  Buildr::JtestR::ResultHandler.init(argv, output, output)
+  Buildr::JtestR::ResultHandler.test_files = <%= tests.inspect %>
 
   jtestr.run *args
 
@@ -110,7 +108,7 @@ rescue => e
   puts "-[--- ERROR ---]-", e.class, e.message, *e.backtrace
 end
 
-exit 0 # let buildr find the erros from the result yaml
+exit 0 # let buildr find the errors from the result yaml
 
 # Local Variables:
 # mode: ruby