buildr 1.3.0-java

data/lib/buildr/java/commands.rb

@@ -0,0 +1,210 @@
+# 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.
+
+
+# Base module for all things Java.
+module Java
+
+  # JDK commands: java, javac, javadoc, etc.
+  module Commands
+
+    class << self
+
+      # :call-seq:
+      #   java(class, *args, options?)
+      #
+      # Runs Java with the specified arguments.
+      #
+      # The last argument may be a Hash with additional options:
+      # * :classpath -- One or more file names, tasks or artifact specifications.
+      #   These are all expanded into artifacts, and all tasks are invoked.
+      # * :java_args -- Any additional arguments to pass (e.g. -hotspot, -xms)
+      # * :properties -- Hash of system properties (e.g. 'path'=>base_dir).
+      # * :name -- Shows this name, otherwise shows the first argument (the class name).
+      # * :verbose -- If true, prints the command and all its argument.
+      def java(*args, &block)
+        options = Hash === args.last ? args.pop : {}
+        options[:verbose] ||= Buildr.application.options.trace || false
+        rake_check_options options, :classpath, :java_args, :properties, :name, :verbose
+
+        name = options[:name] || "java #{args.first}"
+        cmd_args = [path_to_bin('java')]
+        classpath = classpath_from(options)
+        cmd_args << '-classpath' << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+        options[:properties].each { |k, v| cmd_args << "-D#{k}=#{v}" } if options[:properties]
+        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
+          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
+          system(*cmd_args).tap do |ok|
+            block.call ok, $?
+          end
+        end
+      end
+  
+      # :call-seq:
+      #   apt(*files, options)
+      #
+      # Runs Apt with the specified arguments.
+      #
+      # The last argument may be a Hash with additional options:
+      # * :compile -- If true, compile source files to class files.
+      # * :source -- Specifies source compatibility with a given JVM release.
+      # * :output -- Directory where to place the generated source files, or the
+      #   generated class files when compiling.
+      # * :classpath -- One or more file names, tasks or artifact specifications.
+      #   These are all expanded into artifacts, and all tasks are invoked.
+      def apt(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :compile, :source, :output, :classpath
+
+        files = args.flatten.map(&:to_s).
+          collect { |arg| File.directory?(arg) ? FileList["#{arg}/**/*.java"] : arg }.flatten
+        cmd_args = [ Buildr.application.options.trace ? '-verbose' : '-nowarn' ]
+        if options[:compile]
+          cmd_args << '-d' << options[:output].to_s
+        else
+          cmd_args << '-nocompile' << '-s' << options[:output].to_s
+        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)
+        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
+          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'
+        end
+      end
+
+      # :call-seq:
+      #   javac(*files, options)
+      #
+      # Runs Javac with the specified arguments.
+      #
+      # The last argument may be a Hash with additional options:
+      # * :output -- Target directory for all compiled class files.
+      # * :classpath -- One or more file names, tasks or artifact specifications.
+      #   These are all expanded into artifacts, and all tasks are invoked.
+      # * :sourcepath -- Additional source paths to use.
+      # * :javac_args -- Any additional arguments to pass (e.g. -extdirs, -encoding)
+      # * :name -- Shows this name, otherwise shows the working directory.
+      def javac(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :classpath, :sourcepath, :output, :javac_args, :name
+
+        files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
+          collect { |arg| File.directory?(arg) ? FileList["#{arg}/**/*.java"] : arg }.flatten
+        name = options[:name] || Dir.pwd
+
+        cmd_args = []
+        classpath = classpath_from(options)
+        cmd_args << '-classpath' << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+        cmd_args << '-sourcepath' << options[:sourcepath].join(File::PATH_SEPARATOR) if options[:sourcepath]
+        cmd_args << '-d' << options[:output].to_s if options[:output]
+        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
+          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'
+        end
+      end
+
+      # :call-seq:
+      #   javadoc(*files, options)
+      #
+      # Runs Javadocs with the specified files and options.
+      #
+      # This method accepts the following special options:
+      # * :output -- The output directory
+      # * :classpath -- Array of classpath dependencies.
+      # * :sourcepath -- Array of sourcepaths (paths or tasks).
+      # * :name -- Shows this name, otherwise shows the working directory.
+      #
+      # All other options are passed to Javadoc as following:
+      # * true -- As is, for example, :author=>true becomes -author
+      # * false -- Prefixed, for example, :index=>false becomes -noindex
+      # * string -- Option with value, for example, :windowtitle=>'My project' becomes -windowtitle "My project"
+      # * array -- Option with set of values separated by spaces.
+      def javadoc(*args)
+        options = Hash === args.last ? args.pop : {}
+
+        cmd_args = [ '-d', options[:output], Buildr.application.options.trace ? '-verbose' : '-quiet' ]
+        options.reject { |key, value| [:output, :name, :sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          options[option].to_a.flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        end
+        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
+          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'
+        end
+      end
+
+    protected
+
+      # :call-seq:
+      #   path_to_bin(cmd?) => path
+      #
+      # Returns the path to the specified Java command (with no argument to java itself).
+      def path_to_bin(name = nil)
+        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
+        File.expand_path(File.join(home, 'bin', name.to_s))
+      end
+
+      # :call-seq:
+      #    classpath_from(options) => files
+      #
+      # Extracts the classpath from the options, expands it by calling artifacts, invokes
+      # each of the artifacts and returns an array of paths.
+      def classpath_from(options)
+        Buildr.artifacts(options[:classpath] || []).map(&:to_s).
+          map { |t| task(t).invoke; File.expand_path(t) }
+      end
+
+    end
+
+  end
+
+end
+

data/lib/buildr/java/compilers.rb

@@ -0,0 +1,432 @@
+# 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'
+require 'buildr/core/common'
+require 'buildr/core/compile'
+require 'buildr/packaging'
+
+
+module Buildr
+  module Compiler
+
+    # Javac compiler:
+    #   compile.using(:javac)
+    # Used by default if .java files are found in the src/main/java directory (or src/test/java)
+    # and sets the target directory to target/classes (or target/test/classes).
+    #
+    # Accepts the following options:
+    # * :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.
+    # * :source      -- Source code compatibility.
+    # * :target      -- Bytecode compatibility.
+    # * :lint        -- Lint option is one of true, false (default), name (e.g. 'cast') or array.
+    # * :other       -- Array of options passed to the compiler (e.g. '-implicit:none')
+    class Javac < Base
+
+      OPTIONS = [:warnings, :debug, :deprecation, :source, :target, :lint, :other]
+
+      specify :language=>:java, :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[:lint] ||= false
+      end
+
+      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)
+        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 += javac_args
+        cmd_args += files_from_sources(sources)
+        unless Buildr.application.options.dryrun
+          puts (['javac'] + cmd_args).join(' ') if Buildr.application.options.trace
+          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'
+        end
+      end
+
+    private
+
+      def javac_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 << '-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
+
+
+    # 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.
+    # * :source      -- Source compatibility with specified release.
+    # * :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, :source, :target, :debug, :other]
+      Java.classpath << dependencies unless Scalac.use_fsc
+
+      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 << "-source" << options[:source].to_s if options[:source]
+        args << "-target:jvm-" + options[:target].to_s if options[:target]
+        args + Array(options[:other])
+      end
+
+    end
+  end
+
+
+  # Methods added to Project for creating JavaDoc documentation.
+  module Javadoc
+
+    # A convenient task for creating Javadocs from the project's compile task. Minimizes all
+    # the hard work to calling #from and #using.
+    #
+    # For example:
+    #   javadoc.from(projects('myapp:foo', 'myapp:bar')).using(:windowtitle=>'My App')
+    # Or, short and sweet:
+    #   desc 'My App'
+    #   define 'myapp' do
+    #     . . .
+    #     javadoc projects('myapp:foo', 'myapp:bar')
+    #   end
+    class JavadocTask < Rake::Task
+
+      def initialize(*args) #:nodoc:
+        super
+        @options = {}
+        @classpath = []
+        @sourcepath = []
+        @files = FileList[]
+        enhance do |task|
+          rm_rf target.to_s, :verbose=>false
+          generate source_files, File.expand_path(target.to_s), options.merge(:classpath=>classpath, :sourcepath=>sourcepath)
+          touch target.to_s, :verbose=>false
+        end
+      end
+
+      # The target directory for the generated Javadoc files.
+      attr_reader :target
+
+      # :call-seq:
+      #   into(path) => self
+      #
+      # Sets the target directory and returns self. This will also set the Javadoc task
+      # as a prerequisite to a file task on the target directory.
+      #
+      # For example:
+      #   package :zip, :classifier=>'docs', :include=>javadoc.target
+      def into(path)
+        @target = file(path.to_s).enhance([self]) unless @target && @target.to_s == path.to_s
+        self
+      end
+
+      # :call-seq:
+      #   include(*files) => self
+      #
+      # Includes additional source files and directories when generating the documentation
+      # and returns self. When specifying a directory, includes all .java files in that directory.
+      def include(*files)
+        @files.include *files.flatten.compact
+        self
+      end
+
+      # :call-seq:
+      #   exclude(*files) => self
+      #
+      # Excludes source files and directories from generating the documentation.
+      def exclude(*files)
+        @files.exclude *files
+        self
+      end
+
+      # Classpath dependencies.
+      attr_accessor :classpath
+
+      # :call-seq:
+      #   with(*artifacts) => self
+      #
+      # Adds files and artifacts as classpath dependencies, and returns self.
+      def with(*specs)
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
+        self
+      end
+
+      # Additional sourcepaths that are not part of the documented files.
+      attr_accessor :sourcepath
+        
+      # Returns the Javadoc options.
+      attr_reader :options
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the Javadoc options from a hash and returns self.
+      #
+      # For example:
+      #   javadoc.using :windowtitle=>'My application'
+      def using(*args)
+        args.pop.each { |key, value| @options[key.to_sym] = value } if Hash === args.last
+        args.each { |key| @options[key.to_sym] = true }
+        self
+      end
+
+      # :call-seq:
+      #   from(*sources) => self
+      #
+      # Includes files, directories and projects in the Javadoc documentation and returns self.
+      #
+      # You can call this method with Java source files and directories containing Java source files
+      # to include these files in the Javadoc documentation, similar to #include. You can also call
+      # this method with projects. When called with a project, it includes all the source files compiled
+      # by that project and classpath dependencies used when compiling.
+      #
+      # For example:
+      #   javadoc.from projects('myapp:foo', 'myapp:bar')
+      def from(*sources)
+        sources.flatten.each do |source|
+          case source
+          when Project
+            self.enhance source.prerequisites
+            self.include source.compile.sources
+            self.with source.compile.dependencies 
+          when Rake::Task, String
+            self.include source
+          else
+            fail "Don't know how to generate Javadocs from #{source || 'nil'}"
+          end
+        end
+        self
+      end
+
+      def prerequisites() #:nodoc:
+        super + @files + classpath + sourcepath
+      end
+
+      def source_files() #:nodoc:
+        @source_files ||= @files.map(&:to_s).
+          map { |file| File.directory?(file) ? FileList[File.join(file, "**/*.java")] : file }.
+          flatten.reject { |file| @files.exclude?(file) }
+      end
+
+      def needed?() #:nodoc:
+        return false if source_files.empty?
+        return true unless File.exist?(target.to_s)
+        source_files.map { |src| File.stat(src.to_s).mtime }.max > File.stat(target.to_s).mtime
+      end
+
+    private
+
+      def generate(sources, target, options = {})
+        cmd_args = [ '-d', target, Buildr.application.options.trace ? '-verbose' : '-quiet' ]
+        options.reject { |key, value| [:sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          Array(options[option]).flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        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
+          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'
+        end
+      end
+
+    end
+
+
+    include Extension
+
+    first_time do
+      desc 'Create the Javadocs for this project'
+      Project.local_task('javadoc')
+    end
+
+    before_define do |project|
+      JavadocTask.define_task('javadoc').tap do |javadoc|
+        javadoc.into project.path_to(:target, :javadoc)
+        javadoc.using :windowtitle=>project.comment || project.name
+      end
+    end
+
+    after_define do |project|
+      project.javadoc.from project
+    end
+
+    # :call-seq:
+    #   javadoc(*sources) => JavadocTask
+    #
+    # This method returns the project's Javadoc task. It also accepts a list of source files,
+    # directories and projects to include when generating the Javadocs.
+    #
+    # By default the Javadoc task uses all the source directories from compile.sources and generates
+    # Javadocs in the target/javadoc directory. This method accepts sources and adds them by calling
+    # JavadocsTask#from.
+    #
+    # For example, if you want to generate Javadocs for a given project that includes all source files
+    # in two of its sub-projects:
+    #   javadoc projects('myapp:foo', 'myapp:bar').using(:windowtitle=>'Docs for foo and bar')
+    def javadoc(*sources, &block)
+      task('javadoc').from(*sources).enhance &block
+    end
+
+  end
+
+
+  # Methods added to Project to support the Java Annotation Processor.
+  module Apt
+
+    # :call-seq:
+    #   apt(*sources) => task
+    #
+    # Returns a task that will use Java#apt to generate source files in target/generated/apt,
+    # from all the source directories passed as arguments. Uses the compile.sources list if
+    # on arguments supplied.
+    #
+    # For example:
+    #
+    def apt(*sources)
+      sources = compile.sources if sources.empty?
+      file(path_to(:target, 'generated/apt')=>sources) do |task|
+        cmd_args = [ Buildr.application.options.trace ? '-verbose' : '-nowarn' ]
+        cmd_args << '-nocompile' << '-s' << task.name
+        cmd_args << '-source' << compile.options.source if compile.options.source
+        classpath = Buildr.artifacts(compile.dependencies).map(&:to_s).each { |t| task(t).invoke }
+        cmd_args << '-classpath' << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+        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
+          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
+      end
+    end
+
+  end
+
+end
+
+Buildr::Compiler << Buildr::Compiler::Javac
+Buildr::Compiler << Buildr::Compiler::Scalac
+class Buildr::Project
+  include Buildr::Javadoc
+  include Buildr::Apt
+end