buildr 1.3.2-java → 1.3.3-java

data/lib/buildr/java/commands.rb

@@ -47,7 +47,7 @@ module Java
         cmd_args += (options[:java_args] || (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split).flatten
         cmd_args += args.flatten.compact
         unless Buildr.application.options.dryrun
-          puts "Running #{name}" if verbose
+          info "Running #{name}"
           block = lambda { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok } unless block
           puts cmd_args.join(' ') if Buildr.application.options.trace
           cmd_args = cmd_args.map(&:inspect).join(' ') if Util.win_os?
@@ -83,13 +83,13 @@ module Java
         end
         cmd_args << '-source' << options[:source] if options[:source]
         classpath = classpath_from(options)
-        tools = File.expand_path('lib/tools.jar', ENV['JAVA_HOME']) if ENV['JAVA_HOME']
-        classpath << tools if tools && File.exist?(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
-          puts 'Running apt' if verbose
-          puts (['apt'] + cmd_args).join(' ') if Buildr.application.options.trace
+          info 'Running apt'
+          trace (['apt'] + cmd_args).join(' ')
           Java.load
           Java.com.sun.tools.apt.Main.process(cmd_args.to_java(Java.java.lang.String)) == 0 or
             fail 'Failed to process annotations, see errors above'
@@ -124,8 +124,8 @@ module Java
         cmd_args += options[:javac_args].flatten if options[:javac_args]
         cmd_args += files
         unless Buildr.application.options.dryrun
-          puts "Compiling #{files.size} source files in #{name}" if verbose
-          puts (['javac'] + cmd_args).join(' ') if Buildr.application.options.trace
+          info "Compiling #{files.size} source files in #{name}"
+          trace (['javac'] + cmd_args).join(' ')
           Java.load
           Java.com.sun.tools.javac.Main.compile(cmd_args.to_java(Java.java.lang.String)) == 0 or 
             fail 'Failed to compile, see errors above'
@@ -174,8 +174,8 @@ module Java
         cmd_args += args.flatten.uniq
         name = options[:name] || Dir.pwd
         unless Buildr.application.options.dryrun
-          puts "Generating Javadoc for #{name}" if verbose
-          puts (['javadoc'] + cmd_args).join(' ') if Buildr.application.options.trace
+          info "Generating Javadoc for #{name}"
+          trace (['javadoc'] + cmd_args).join(' ')
           Java.load
           Java.com.sun.tools.javadoc.Main.execute(cmd_args.to_java(Java.java.lang.String)) == 0 or
             fail 'Failed to generate Javadocs, see errors above'

data/lib/buildr/java/{compilers.rb → compiler.rb}

@@ -54,8 +54,8 @@ module Buildr
       def compile(sources, target, dependencies) #:nodoc:
         check_options options, OPTIONS
         cmd_args = []
-        tools = File.expand_path('lib/tools.jar', ENV['JAVA_HOME']) if ENV['JAVA_HOME']
-        dependencies << tools if tools && File.exist?(tools)
+        # 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?
@@ -63,7 +63,7 @@ module Buildr
         cmd_args += javac_args
         cmd_args += files_from_sources(sources)
         unless Buildr.application.options.dryrun
-          puts (['javac'] + cmd_args).join(' ') if Buildr.application.options.trace
+          trace((['javac'] + cmd_args).join(' '))
           Java.load
           Java.com.sun.tools.javac.Main.compile(cmd_args.to_java(Java.java.lang.String)) == 0 or
             fail 'Failed to compile, see errors above'
@@ -89,88 +89,7 @@ module Buildr
       end
 
     end
-
-
-    # Scalac compiler:
-    #   compile.using(:scalac)
-    # Used by default if .scala files are found in the src/main/scala directory (or src/test/scala)
-    # and sets the target directory to target/classes (or target/test/classes).
-    #
-    # Accepts the following options:
-    # * :warnings    -- Generate warnings if true (opposite of -nowarn).
-    # * :deprecation -- Output source locations where deprecated APIs are used.
-    # * :optimise    -- Generates faster bytecode by applying optimisations to the program.
-    # * :target      -- Class file compatibility with specified release.
-    # * :debug       -- Generate debugging info.
-    # * :other       -- Array of options to pass to the Scalac compiler as is, e.g. -Xprint-types
-    class Scalac < Base
-      class << self
-        def scala_home
-          @home ||= ENV['SCALA_HOME']
-        end
-
-        def dependencies
-          [ 'scala-library.jar', 'scala-compiler.jar'].map { |jar| File.expand_path("lib/#{jar}", scala_home) }
-        end
-
-        def use_fsc
-          ENV["USE_FSC"] =~ /^(yes|on|true)$/i
-        end
-      end
-
-      OPTIONS = [:warnings, :deprecation, :optimise, :target, :debug, :other]
-      Java.classpath << dependencies
-
-      specify :language=>:scala, :target=>'classes', :target_ext=>'class', :packaging=>:jar
-
-      def initialize(project, options) #:nodoc:
-        super
-        options[:debug] = Buildr.options.debug if options[:debug].nil?
-        options[:warnings] = verbose if options[:warnings].nil?
-        options[:deprecation] ||= false
-        options[:optimise] ||= false
-      end
-
-      def compile(sources, target, dependencies) #:nodoc:
-        check_options options, OPTIONS
-
-        cmd_args = []
-        cmd_args << '-classpath' << (dependencies + Scalac.dependencies).join(File::PATH_SEPARATOR)
-        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 += scalac_args
-        cmd_args += files_from_sources(sources)
-
-        unless Buildr.application.options.dryrun
-          Scalac.scala_home or fail 'Are we forgetting something? SCALA_HOME not set.'
-          puts (['scalac'] + cmd_args).join(' ') if Buildr.application.options.trace
-          if Scalac.use_fsc
-            system(([File.expand_path('bin/fsc', Scalac.scala_home)] + cmd_args).join(' ')) or
-              fail 'Failed to compile, see errors above'
-          else
-            Java.load
-            Java.scala.tools.nsc.Main.process(cmd_args.to_java(Java.java.lang.String))
-            fail 'Failed to compile, see errors above' if Java.scala.tools.nsc.Main.reporter.hasErrors
-          end
-        end
-      end
-
-    private
-
-      # Returns Scalac command line arguments from the set of options.
-      def scalac_args #:nodoc:
-        args = []
-        args << "-nowarn" unless options[:warnings]
-        args << "-verbose" if Buildr.application.options.trace
-        args << "-g" if options[:debug]
-        args << "-deprecation" if options[:deprecation]
-        args << "-optimise" if options[:optimise]
-        args << "-target:jvm-" + options[:target].to_s if options[:target]
-        args + Array(options[:other])
-      end
-
-    end
+    
   end
 
 
@@ -338,8 +257,8 @@ module Buildr
         end
         cmd_args += sources.flatten.uniq
         unless Buildr.application.options.dryrun
-          puts "Generating Javadoc for #{name}" if verbose
-          puts (['javadoc'] + cmd_args).join(' ') if Buildr.application.options.trace
+          info "Generating Javadoc for #{name}"
+          trace (['javadoc'] + cmd_args).join(' ')
           Java.load
           Java.com.sun.tools.javadoc.Main.execute(cmd_args.to_java(Java.java.lang.String)) == 0 or
             fail 'Failed to generate Javadocs, see errors above'
@@ -410,8 +329,8 @@ module Buildr
         cmd_args += (sources.map(&:to_s) - [task.name]).
           map { |file| File.directory?(file) ? FileList["#{file}/**/*.java"] : file }.flatten
         unless Buildr.application.options.dryrun
-          puts 'Running apt' if verbose
-          puts (['apt'] + cmd_args).join(' ') if Buildr.application.options.trace
+          info 'Running apt'
+          trace (['apt'] + cmd_args).join(' ')
           Java.com.sun.tools.apt.Main.process(cmd_args.to_java(Java.java.lang.String)) == 0 or
             fail 'Failed to process annotations, see errors above'
         end
@@ -423,7 +342,6 @@ module Buildr
 end
 
 Buildr::Compiler << Buildr::Compiler::Javac
-Buildr::Compiler << Buildr::Compiler::Scalac
 class Buildr::Project
   include Buildr::Javadoc
   include Buildr::Apt

data/lib/buildr/java/jruby.rb

@@ -56,6 +56,10 @@ require 'jruby'
 # 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")
+
   class << self
 
     # Returns the classpath, an array listing directories, JAR files and
@@ -67,6 +71,15 @@ module Java
     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
@@ -74,22 +87,27 @@ module Java
     # that append to the classpath and specify which remote repositories to use.
     def load
       return self if @loaded
-      cp = Buildr.artifacts(classpath).map(&:to_s).each { |path| file(path).invoke }
-      #cp ||= java.lang.System.getProperty('java.class.path').split(':').compact
-      # Use system ClassLoader to add classpath.
+
+      # 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].to_java(java.lang.Class))
+        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)) }
-      # Include tools (compiler, Javadoc, etc) for all platforms except OS/X.
-      unless Config::CONFIG['host_os'] =~ /darwin/i
-        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
-        tools = File.expand_path('lib/tools.jar', home)
-        raise "Missing #{tools}, perhaps your JAVA_HOME is not correclty set" unless File.file?(tools)
-        add_path[tools]
+
+      # 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
-      cp.each { |path| add_path[path] }
+      
       @loaded = true
       self
     end

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

@@ -0,0 +1,116 @@
+# 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.
+
+#  ___   ___     _  _  ___ _____    ___ ___ ___ _____    _____ _  _ ___ ___ 
+# |   \ / _ \   | \| |/ _ \_   _|  | __|   \_ _|_   _|  |_   _| || |_ _/ __|
+# | |) | (_) |  | .` | (_) || |    | _|| |) | |  | |      | | | __ || |\__ \
+# |___/ \___/   |_|\_|\___/ |_|    |___|___/___| |_|      |_| |_||_|___|___/
+#                                                                          
+#  ___ ___ _    ___ 
+# | __|_ _| |  | __|  CHANGES TO THIS FILE WILL BE LOST
+# | _| | || |__| _|   AUTO-GENERATED BY BUILDR on <%= Time.now %>
+# |_| |___|____|___|  PREFER TO EDIT JtestR CONFIGURATION FILE:
+#
+# <%= user_config %>
+
+begin
+
+  <%= jruby_gem %>
+  <%= dependencies.map(&:to_s).inspect %>.each { |dep| $CLASSPATH << dep }
+  <%= runner.gems.inspect %>.each { |ary| JRuby.gem(*ary.flatten) }
+  <%= runner.requires.inspect %>.each { |rb| Kernel.require rb }
+  
+  jtestr = JtestR::TestRunner.new
+  
+  class << jtestr
+    def config(&block)
+      @config_blocks ||= []
+      @config_blocks << block if block
+      @config_blocks
+    end
+    
+    def load_configuration
+      super
+      config.each { |block| @configuration.instance_eval(&block) }
+    end
+  end
+  
+  jtestr.config do 
+    classpath [] # already loaded
+    add_common_classpath false
+    
+    <% ts = ( @jtestr_tests[:junit] & tests ).map { |c| 'Java.' + c } %>
+    junit [<%= ts.join(', ') %>]
+    
+    <% ts = ( @jtestr_tests[:testng] & tests ).map { |c| 'Java.' + c } %>
+    testng [<%= ts.join(', ') %>]
+    
+    <% ts = @jtestr_tests[:testunit] & tests %>
+    test_unit <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:story] & tests %>
+    story <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:rspec] & tests %>
+    rspec <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:expect] & tests %>
+    expectations <%= ts.inspect %>
+      
+    ignore __FILE__
+  
+    if File.file?(<%= user_config.inspect %>)
+      ignore <%= user_config.inspect %>
+      load <%= user_config.inspect %>
+    end
+  end # config
+
+  fake_out = StringIO.new
+
+  <% if runner.output == false %>
+     output = fake_out
+  <% elsif runner.output.kind_of?(String) %>
+     output = File.open(<%= result.output.inspect %>, 'w')
+  <% else %>
+     output = STDOUT
+  <% end %>
+  
+  
+  args = [ '<%= spec_dir %>', # the directory to search for jtestr files
+           JtestR::SimpleLogger::ERR, # log level
+           JtestR::GenericResultHandler::QUIET, #output level 
+           fake_out, # output STDOUT
+           [], # groups to run 
+           Buildr::TestFramework::TestResult::RSpecResultHandler, # result handler
+           []  # classpath
+         ]
+  
+  argv = <%= runner.rspec.inspect %> || []
+  argv.push *<%= tests.inspect %>
+  Buildr::TestFramework::TestResult::RSpecResultHandler.init(argv, output, output)
+  
+  jtestr.run *args
+
+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
+# End:
+  

data/lib/buildr/java/packaging.rb

@@ -31,7 +31,7 @@ module Buildr
 
         class << self
 
-          # :call_seq:
+          # :call-seq:
           #   parse(str) => manifest
           #
           # Parse a string in MANIFEST.MF format and return a new Manifest.
@@ -51,7 +51,7 @@ module Buildr
             }
           end
 
-          # :call_seq:
+          # :call-seq:
           #   from_zip(file) => manifest
           #
           # Parse the MANIFEST.MF entry of a ZIP (or JAR) file and return a new Manifest.
@@ -62,7 +62,7 @@ module Buildr
             end
           end
 
-          # :call_seq:
+          # :call-seq:
           #   update_manifest(file) { |manifest| ... }
           #
           # Updates the MANIFEST.MF entry of a ZIP (or JAR) file.  Reads the MANIFEST.MF,
@@ -168,14 +168,14 @@ module Buildr
             if manifest
               # Tempfiles gets deleted on garbage collection, so we're going to hold on to it
               # through instance variable not closure variable.
-              Tempfile.open 'MANIFEST.MF' do |@manifest_tmp|
-                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.to_s
-                @manifest_tmp.write "\n"
-                path('META-INF').include @manifest_tmp.path, :as=>'MANIFEST.MF'
-              end
+              @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.to_s
+              @manifest_tmp.write "\n"
+              @manifest_tmp.rewind
+              path('META-INF').include @manifest_tmp.path, :as=>'MANIFEST.MF'
             end
           end
         end
@@ -546,7 +546,7 @@ module Buildr
           return @descriptor if @descriptor
           descriptor_path = path_to('META-INF/application.xml')
           @descriptor = file(descriptor_path) do |task|
-            puts "Creating EAR Descriptor: #{task.to_s}" if Buildr.application.options.trace
+            trace "Creating EAR Descriptor: #{task.to_s}"
             mkpath File.dirname(task.name), :verbose=>false
             File.open(task.name, 'w') { |file| file.print task.xml }
           end
@@ -572,12 +572,19 @@ module Buildr
 
       before_define do |project|
         ::Java.load
-        project.manifest ||= project.parent && project.parent.manifest ||
-          { 'Build-By'=>ENV['USER'], 'Build-Jdk'=>ENV_JAVA['java.version'],
+        if project.parent && project.parent.manifest 
+          project.manifest = project.parent.manifest.dup
+        else
+          project.manifest = { 
+            'Build-By'=>ENV['USER'], 'Build-Jdk'=>ENV_JAVA['java.version'],
             'Implementation-Title'=>project.comment || project.name,
             'Implementation-Version'=>project.version }
-        project.meta_inf ||= project.parent && project.parent.meta_inf ||
-          [project.file('LICENSE')].select { |file| File.exist?(file.to_s) }
+        end
+        if project.parent && project.parent.meta_inf
+          project.meta_inf = project.parent.meta_inf.dup
+        else
+          project.meta_inf = [project.file('LICENSE')].select { |file| File.exist?(file.to_s) }
+        end
       end
 
 

data/lib/buildr/java/pom.rb

@@ -51,7 +51,7 @@ module Buildr
         when String
           filename = File.expand_path(source)
           unless pom = cache[filename]
-            puts "Loading m2 pom file from #{filename}" if Buildr.application.options.trace
+            trace "Loading m2 pom file from #{filename}"
             pom = POM.new(IO.read(filename))
             cache[filename] = pom
           end