mguymon-buildr 1.4.5-java

data/lib/buildr/java/external.rb

@@ -0,0 +1,73 @@
+# 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
+  module Compiler
+    class ExternalJavac< Buildr::Compiler::Javac
+
+      OPTIONS = [:jvm, :warnings, :debug, :deprecation, :source, :target, :lint, :other]
+
+      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?
+        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)
+        cmd_args += externaljavac_args
+        Tempfile.open("external") {|tmp|
+          tmp.write files_from_sources(sources).join(' ')
+          cmd_args << "@#{tmp.path}"
+        }
+        unless Buildr.application.options.dryrun
+          javac_path = File.join(options[:jvm] || ENV['JAVA_HOME'], "bin", "javac")
+          final_args = cmd_args.insert(0, javac_path).push('2>&1').join(' ')
+          trace(final_args)
+          info %x[#{final_args}]
+          fail 'Failed to compile, see errors above' unless $?.success?
+        end
+      end
+
+      private
+
+      # See arg list here: http://publib.boulder.ibm.com/infocenter/rsahelp/v7r0m0/index.jsp?topic=/org.eclipse.jdt.doc.isv/guide/jdt_api_compile.htm
+      def externaljavac_args #:nodoc:
+        args = []
+        args << '-nowarn' unless options[:warnings]
+        args << '-verbose' if trace?(:javac)
+        args << '-g' if options[:debug]
+        args << '-deprecation' if options[:deprecation]
+        args << '-source' << options[:source].to_s if options[:source]
+        args << '-target' << options[:target].to_s if options[:target]
+        case options[:lint]
+        when Array  then args << "-Xlint:#{options[:lint].join(',')}"
+        when String then args << "-Xlint:#{options[:lint]}"
+        when true   then args << '-Xlint'
+        end
+        args + Array(options[:other])
+      end
+
+    end
+
+  end
+end
+
+Buildr::Compiler.compilers << Buildr::Compiler::ExternalJavac

data/lib/buildr/java/jruby.rb

@@ -0,0 +1,122 @@
+# 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 'java'
+require 'jruby'
+
+
+# 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
+
+  # Since we already have a JVM loaded, we can use it to guess where JAVA_HOME is.
+  # We set JAVA_HOME early so we can use it without calling Java.load first.
+  ENV['JAVA_HOME'] ||= java.lang.System.getProperty("java.home")
+  
+  # This version is the minimal version Buildr will support.
+  # Any older version of JRuby will raise an exception.
+  JRUBY_MIN_VERSION = '1.5.1' 
+  raise "JRuby must be at least at version #{JRUBY_MIN_VERSION}" unless JRUBY_VERSION >= JRUBY_MIN_VERSION
+
+  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 ||= ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, ENV['JAVA_HOME']) }.
+        find { |path| File.exist?(path) }
+    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
+
+      # Adding jars to the jruby's $CLASSPATH should be the correct thing, however it
+      # seems like some tools require their jars on system class loader (javadoc, junit, etc)
+      # cp.each { |path| $CLASSPATH << path }
+
+      # Use system ClassLoader to add classpath
+      sysloader = java.lang.ClassLoader.getSystemClassLoader
+      add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
+        getDeclaredMethod('addURL', [java.net.URL.java_class].to_java(java.lang.Class))
+      add_url_method.setAccessible(true)
+      add_path = lambda { |path| add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL)) }
+
+      # Most platforms requires tools.jar to be on the classpath.
+      add_path[tools_jar] if tools_jar
+
+      classpath.map! { |path| Proc === path ? path.call : path }
+      Buildr.artifacts(classpath).map(&:to_s).each do |path|
+        file(path).invoke
+        add_path[path]
+      end
+
+      @loaded = true
+      self
+    end
+
+  end
+
+end

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
+