buildr 1.3.0-java

data/lib/buildr/java/deprecated.rb

@@ -0,0 +1,141 @@
+# 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/project'
+
+
+module Java
+
+  # *Deprecated:* In earlier versions, Java.wrapper served as a wrapper around RJB/JRuby.
+  # From this version forward, we apply with JRuby style for importing Java classes:
+  #   Java.java.lang.String.new('hai!')
+  # You still need to call Java.load before using any Java code: it resolves, downloads
+  # and installs various dependencies that are required on the classpath before calling
+  # any Java code (e.g. Ant and its tasks).
+  class JavaWrapper
+
+    include Singleton
+
+    # *Deprecated:* Append to Java.classpath directly.
+    def classpath
+      Buildr.application.deprecated 'Append to Java.classpath instead.'
+      ::Java.classpath
+    end
+
+    def classpath=(paths)
+      fail 'Deprecated: Append to Java.classpath, you cannot replace the classpath.'
+    end
+
+    # *Deprecated:* No longer necessary.
+    def setup
+      Buildr.application.deprecated 'See documentation for new way to access Java code.'
+      yield self if block_given?
+    end
+    
+    # *Deprecated:* Use Java.load instead.
+    def load
+      Buildr.application.deprecated 'Use Java.load instead.'
+      ::Java.load
+    end
+
+    alias :onload :setup
+
+    # *Deprecated:* Use Java.pkg.pkg.ClassName to import a Java class.
+    def import(class_name)
+      Buildr.application.deprecated 'Use Java.pkg.pkg.ClassName to import a Java class.'
+      ::Java.instance_eval(class_name)
+    end
+  end
+
+
+  class << self
+
+    # *Deprecated*: Use Java::Commands.java instead.
+    def java(*args, &block)
+      return send(:method_missing, :java) if args.empty?
+      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
+      Commands.java(*args, &block)
+    end
+
+    # *Deprecated*: Use Java::Commands.apt instead.
+    def apt(*args)
+      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
+      Commands.apt(*args)
+    end
+
+    # *Deprecated*: Use Java::Commands.javac instead.
+    def javac(*args)
+      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
+      Commands.javac(*args)
+    end
+
+    # *Deprecated*: Use Java::Commands.javadoc instead.
+    def javadoc(*args)
+      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
+      Commands.javadoc(*args)
+    end
+
+    # *Deprecated:* Use ENV_JAVA['java.version'] instead.
+    def version
+      Buildr.application.deprecated 'Use ENV_JAVA[\'java.version\'] instead.'
+      Java.load
+      ENV_JAVA['java.version']
+    end
+
+    # *Deprecated:* Use ENV['JAVA_HOME'] instead
+    def home
+      Buildr.application.deprecated 'Use ENV[\'JAVA_HOME\'] instead.'
+      ENV['JAVA_HOME']
+    end
+
+    # *Deprecated:* In earlier versions, Java.wrapper served as a wrapper around RJB/JRuby.
+    # From this version forward, we apply with JRuby style for importing Java classes:
+    #   Java.java.lang.String.new('hai!')
+    # You still need to call Java.load before using any Java code: it resolves, downloads
+    # and installs various dependencies that are required on the classpath before calling
+    # any Java code (e.g. Ant and its tasks).
+    def wrapper
+      Buildr.application.deprecated 'See documentation for new way to access Java code.'
+      if block_given?
+        Java.load
+        yield JavaWrapper.instance
+      else
+        JavaWrapper.instance
+      end
+    end
+
+    alias :rjb :wrapper
+
+  end
+
+
+  class Options
+
+    # *Deprecated:* Use ENV['JAVA_OPTS'] instead.
+    def java_args
+      Buildr.application.deprecated "Use ENV['JAVA_OPTS'] instead"
+      (ENV["JAVA_OPTS"] || ENV["JAVA_OPTIONS"]).to_s.split
+    end
+
+    # *Deprecated:* Use ENV['JAVA_OPTS'] instead.
+    def java_args=(args)
+      Buildr.application.deprecated "Use ENV['JAVA_OPTS'] instead"
+      ENV['JAVA_OPTS'] = Array(args).join(' ')
+    end
+
+  end
+
+end

data/lib/buildr/java/groovyc.rb

@@ -0,0 +1,137 @@
+# 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
+    # Groovyc compiler:
+    #  compile.using(:groovyc)
+    #
+    # You need to require 'buildr/java/groovyc' if you need to use this compiler.
+    #
+    # Used by default if .groovy files are found in the src/main/groovy directory (or src/test/groovy)
+    # and sets the target directory to target/classes (or target/test/classes).
+    #
+    # Groovyc is a joint compiler, this means that when selected for a project, this compiler is used
+    # to compile both groovy and java sources. It's recommended that Groovy sources are placed in the
+    # src/main/groovy directory, even though this compiler also looks in src/main/java
+    #
+    # Groovyc accepts the following options:
+    #
+    # * :encoding          -- Encoding of source files
+    # * :verbose           -- Asks the compiler for verbose output, true when running in verbose mode.
+    # * :fork              -- Whether to execute groovyc using a spawned instance of the JVM; defaults to no
+    # * :memoryInitialSize -- The initial size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
+    #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+    # * :memoryMaximumSize -- The maximum size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
+    #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+    # * :listfiles         -- Indicates whether the source files to be compiled will be listed; defaults to no
+    # * :stacktrace        -- If true each compile error message will contain a stacktrace
+    # * :warnings          -- Issue warnings when compiling.  True when running in verbose mode.
+    # * :debug             -- Generates bytecode with debugging information.  Set from the debug
+    #                                     environment variable/global option.
+    # * :deprecation       -- If true, shows deprecation messages.  False by default.
+    # * :optimise          -- Generates faster bytecode by applying optimisations to the program.
+    # * :source            -- Source code compatibility.
+    # * :target            -- Bytecode compatibility.
+    # * :javac             -- Hash of options passed to the ant javac task
+    #
+    class Groovyc < Base
+      
+      # The groovyc compiler jars are added to classpath at load time,
+      # if you want to customize artifact versions, you must set them on the
+      #
+      #      artifact_ns['Buildr::Compiler::Groovyc'].groovy = '1.5.4'
+      #
+      # namespace before this file is required.
+      REQUIRES = ArtifactNamespace.for(self) do |ns|
+        ns.groovy!       'org.codehaus.groovy:groovy:jar:>=1.5.3'
+        ns.commons_cli!  'commons-cli:commons-cli:jar:>=1.0'
+        ns.asm!          'asm:asm:jar:>=2.2'
+        ns.antlr!        'antlr:antlr:jar:>=2.7.7'
+      end
+      
+      ANT_TASK = 'org.codehaus.groovy.ant.Groovyc'
+      GROOVYC_OPTIONS = [:encoding, :verbose, :fork, :memoryInitialSize, :memoryMaximumSize, :listfiles, :stacktrace]
+      JAVAC_OPTIONS = [:optimise, :warnings, :debug, :deprecation, :source, :target, :javac]
+      OPTIONS = GROOVYC_OPTIONS + JAVAC_OPTIONS
+
+      class << self
+        def dependencies #:nodoc:
+          REQUIRES.artifacts
+        end
+
+        def applies_to?(project, task) #:nodoc:
+          paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
+          paths.flatten!
+          # Just select if we find .groovy files
+          paths.any? { |path| !Dir["#{path}/**/*.groovy"].empty? }
+        end
+      end
+      
+      Java.classpath << dependencies
+      
+      specify :language => :groovy, :sources => [:groovy, :java], :source_ext => [:groovy, :java], 
+              :target => 'classes', :target_ext => 'class', :packaging => :jar
+
+      def initialize(project, options) #:nodoc:
+        super
+        options[:debug] = Buildr.options.debug if options[:debug].nil?
+        options[:deprecation] ||= false
+        options[:optimise] ||= false
+        options[:verbose] ||= Buildr.application.options.trace if options[:verbose].nil?
+        options[:warnings] = verbose if options[:warnings].nil?
+        options[:javac] = OpenObject.new if options[:javac].nil?
+      end
+
+      # http://groovy.codehaus.org/The+groovyc+Ant+Task
+      def compile(sources, target, dependencies) #:nodoc:
+        return if Buildr.application.options.dryrun
+        Buildr.ant 'groovyc' do |ant|
+          classpath = dependencies | self.class.dependencies.map(&:to_s)
+          ant.taskdef :name => 'groovyc', :classname => ANT_TASK, :classpath => classpath.join(File::PATH_SEPARATOR)
+          ant.groovyc groovyc_options(sources, target) do
+            sources.each { |src| ant.src :path => src }
+            ant.classpath do
+              classpath.each { |dep| ant.pathelement :path => dep }
+            end
+            ant.javac(javac_options)
+          end
+        end
+      end
+
+     private 
+      def groovyc_options(sources, target)
+        check_options options, OPTIONS
+        groovyc_options = options.to_hash.only(*GROOVYC_OPTIONS)
+        groovyc_options[:destdir] = File.expand_path(target)
+        groovyc_options
+      end
+
+      def javac_options
+        check_options options, OPTIONS
+        javac_options = options.to_hash.only(*JAVAC_OPTIONS)
+        javac_options[:optimize] = (javac_options.delete(:optimise) || false)
+        javac_options[:nowarn] = (javac_options.delete(:warnings) || verbose).to_s !~ /^(true|yes|on)$/i
+        other = javac_options.delete(:javac) || {}
+        javac_options.merge!(other)
+        javac_options
+      end
+      
+    end
+  end
+end
+
+Buildr::Compiler.compilers.unshift Buildr::Compiler::Groovyc

data/lib/buildr/java/jruby.rb

@@ -0,0 +1,99 @@
+# 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
+
+  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
+
+    # 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
+      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.
+      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))
+      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]
+      end
+      cp.each { |path| add_path[path] }
+      @loaded = true
+      self
+    end
+
+  end
+
+end

data/lib/buildr/java/org/apache/buildr/BuildrNail.java

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+
+package org.apache.buildr;
+
+import com.martiansoftware.nailgun.NGContext;
+
+public interface BuildrNail {
+  
+  public void main(NGContext ctx);
+
+  public static class Main {
+     private static BuildrNail nail;
+     public static void  setNail(BuildrNail _nail) { nail = _nail; }
+     public static void nailMain(NGContext ctx) {
+       nail.main(ctx);
+     }
+  }
+
+}
+
+/* 
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * c-basic-offset: 2
+ * End:
+ */

data/lib/buildr/java/org/apache/buildr/JavaTestFilter.java

@@ -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.
+ */
+
+
+package org.apache.buildr;
+
+import java.lang.reflect.Method;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.MalformedURLException;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class JavaTestFilter {
+
+  private ClassLoader _loader;
+  private Vector methodAnnotations = new Vector();
+  private Vector classAnnotations = new Vector();
+  private Vector interfaces = new Vector();
+
+  public JavaTestFilter(String[] paths) throws IOException {
+    URL[] urls = new URL[paths.length];
+    for (int i = 0 ; i < paths.length ; ++i) {
+      File file = new File(paths[i]).getCanonicalFile();
+      if (file.exists())
+        urls[i] = file.toURL();
+      else
+        throw new IOException("No file or directory with the name " + file);
+    }
+    _loader = new URLClassLoader(urls, getClass().getClassLoader());
+  }
+
+  public JavaTestFilter addInterfaces(String[] names) throws ClassNotFoundException {
+    for (int i = names.length; i -- > 0;) {
+      String name = names[i];
+      interfaces.add(_loader.loadClass(name));
+    }
+    return this;
+  }
+
+  public JavaTestFilter addClassAnnotations(String[] names) throws ClassNotFoundException {
+    for (int i = names.length; i -- > 0;) {
+      String name = names[i];
+      classAnnotations.add(_loader.loadClass(name));
+    }
+    return this;
+  }
+
+  public JavaTestFilter addMethodAnnotations(String[] names) throws ClassNotFoundException {
+    for (int i = names.length; i -- > 0;) {
+      String name = names[i];
+      methodAnnotations.add(_loader.loadClass(name));
+    }
+    return this;
+  }
+  
+  private boolean isTest(Class cls) {
+    if (interfaces != null) {
+      for (Iterator it = interfaces.iterator(); it.hasNext(); ) {
+        Class iface = (Class) it.next();
+        if (iface.isAssignableFrom(cls)) { return true; }
+      }
+    }
+    if (classAnnotations != null) { 
+      for (Iterator it = classAnnotations.iterator(); it.hasNext(); ) {
+        Class annotation = (Class) it.next();
+        if (cls.isAnnotationPresent(annotation)) { return true; }
+      }
+    } 
+    if (methodAnnotations != null) {
+      Method[] methods = cls.getMethods();
+      for (int j = methods.length ; j-- > 0 ;) {
+        for (Iterator it = methodAnnotations.iterator(); it.hasNext(); ) {
+          Class annotation = (Class) it.next();
+          if (methods[j].isAnnotationPresent(annotation)) { return true; }
+        }
+      }
+    }
+    return false;
+  }
+
+
+  public String[] filter(String[] names) throws ClassNotFoundException {
+    Vector testCases = new Vector();
+    for (int i = names.length ; i-- > 0 ;) {
+      Class cls = _loader.loadClass(names[i]);
+      if (isTest(cls)) { testCases.add(names[i]); }
+    }
+    String[] result = new String[testCases.size()];
+    testCases.toArray(result);
+    return result;
+  }
+
+}
+
+/* 
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * c-basic-offset: 2
+ * End:
+ */