mguymon-buildr 1.4.5-java

data/lib/buildr/java/compiler.rb

@@ -0,0 +1,135 @@
+# 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', '-encoding', 'iso-8859-1'])
+    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] ||= false
+        options[:deprecation] ||= false
+        options[:lint] ||= false
+      end
+
+      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 += javac_args
+        cmd_args += files_from_sources(sources)
+        unless Buildr.application.options.dryrun
+          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'
+        end
+      end
+
+    private
+
+      def javac_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
+
+
+  # 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 = [ trace?(:apt) ? '-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
+          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
+      end
+    end
+
+  end
+
+end
+
+Buildr::Compiler << Buildr::Compiler::Javac
+class Buildr::Project
+  include Buildr::Apt
+end

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.java instead.'
+      Commands.java(*args, &block)
+    end
+
+    # *Deprecated*: Use Java::Commands.apt instead.
+    def apt(*args)
+      Buildr.application.deprecated 'Use Java::Commands.apt instead.'
+      Commands.apt(*args)
+    end
+
+    # *Deprecated*: Use Java::Commands.javac instead.
+    def javac(*args)
+      Buildr.application.deprecated 'Use Java::Commands.javac 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/doc.rb

@@ -0,0 +1,86 @@
+# 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/doc'
+
+module Buildr
+  module Doc
+
+    module JavadocDefaults
+      include Extension
+
+      # Default javadoc -windowtitle to project's comment or name
+      after_define(:javadoc => :doc) do |project|
+        if project.doc.engine? Javadoc
+          options = project.doc.options
+          options[:windowtitle] = (project.comment || project.name) unless options[:windowtitle]
+        end
+      end
+    end
+
+    # A convenient task for creating Javadocs from the project's compile task. Minimizes all
+    # the hard work to calling #from and #using.
+    #
+    # For example:
+    #   doc.from(projects('myapp:foo', 'myapp:bar')).using(:windowtitle=>'My App')
+    # Or, short and sweet:
+    #   desc 'My App'
+    #   define 'myapp' do
+    #     . . .
+    #     doc projects('myapp:foo', 'myapp:bar')
+    #   end
+    class Javadoc < Base
+
+      specify :language => :java, :source_ext => 'java'
+
+      def generate(sources, target, options = {})
+        cmd_args = [ '-d', target, trace?(:javadoc) ? '-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
+          info "Generating Javadoc for #{project.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'
+        end
+      end
+    end
+  end
+
+  class Project
+    include JavadocDefaults
+  end
+end
+
+Buildr::Doc.engines << Buildr::Doc::Javadoc

data/lib/buildr/java/ecj.rb

@@ -0,0 +1,69 @@
+# 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 Ecj < Javac
+
+      OPTIONS = Buildr::Compiler::Javac::OPTIONS
+
+      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 += ecj_args
+        cmd_args += files_from_sources(sources)
+        unless Buildr.application.options.dryrun
+          trace((%w[javac -classpath org.eclipse.jdt.internal.compiler.batch.Main] + cmd_args).join(' '))
+          Java.load
+          Java.org.eclipse.jdt.internal.compiler.batch.Main.compile(cmd_args.join(" ")) or
+          fail 'Failed to compile, see errors above'
+        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 ecj_args #:nodoc:
+        args = []
+        args << '-warn:none' unless options[:warnings]
+        args << '-verbose' if trace?(:ecj)
+        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
+
+Java.classpath << "org.eclipse.jdt.core.compiler:ecj:jar:3.5.1"
+# Adding ecj before javac
+Buildr::Compiler.compilers.unshift Buildr::Compiler::Ecj

data/lib/buildr/java/emma.rb

@@ -0,0 +1,244 @@
+# 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/java'
+
+
+module Buildr
+
+  # Provides the <code>emma:html</code> and <code>emma:xml</code> tasks.
+  # Require explicitly using <code>require "buildr/emma"</code>.
+  #
+  # You can generate emma reports for a single project
+  # using the project name as prefix:
+  #
+  #   project_name:emma:html
+  #
+  # You can also specify which classes to include/exclude from instrumentation by
+  # passing a class name regexp to the <code>emma.include</code> or
+  # <code>emma.exclude</code> methods.
+  #
+  #   define 'someModule' do
+  #      emma.include 'some.package.*'
+  #      emma.exclude 'some.foo.util.SimpleUtil'
+  #   end
+  module Emma
+
+    VERSION = '2.0.5312'
+
+    class << self
+
+      def version
+        Buildr.settings.build['emma'] || VERSION
+      end
+
+      def dependencies
+        @dependencies ||= ["emma:emma_ant:jar:#{version}", "emma:emma:jar:#{version}"]
+      end
+
+      def report_to format=nil
+        File.expand_path('reports/emma')
+      end
+
+      def data_file()
+        File.join(report_to, 'coverage.es')
+      end
+
+      def ant
+
+        Buildr.ant 'emma' do |ant|
+          ant.taskdef :resource=>'emma_ant.properties',
+            :classpath=>Buildr.artifacts(dependencies).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+          ant.emma :verbosity=>(trace?(:emma) ? 'verbose' : 'warning') do
+            yield ant
+          end
+        end
+      end
+    end
+
+    class EmmaConfig # :nodoc:
+
+      def initialize(project)
+        @project = project
+      end
+
+      attr_reader :project
+      private :project
+
+      attr_writer :metadata_file, :coverage_file, :instrumented_dir, :report_dir
+
+      def coverage_file
+        @coverage_file ||= File.join(report_dir, 'coverage.ec')
+      end
+
+      def metadata_file
+        @metadata_file ||= File.join(report_dir, 'coverage.em')
+      end
+
+      def instrumented_dir
+        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
+      end
+
+      def report_dir
+        @report_dir ||= project.path_to(:reports, :emma)
+      end
+
+      def report_to format
+        report_dir
+      end
+
+      # :call-seq:
+      #   project.emma.include(*classPatterns)
+      #
+      def include(*classPatterns)
+        includes.push(*classPatterns)
+        self
+      end
+
+      def includes
+        @includeClasses ||= []
+      end
+
+      # :call-seq:
+      #   project.emma.exclude(*classPatterns)
+      #
+      def exclude(*classPatterns)
+        excludes.push(*classPatterns)
+        self
+      end
+
+      def excludes
+        @excludeClasses ||= []
+      end
+
+      def sources
+        project.compile.sources
+      end
+    end
+
+    module EmmaExtension # :nodoc:
+      include Buildr::Extension
+
+      def emma
+        @emma_config ||= EmmaConfig.new(self)
+      end
+
+      after_define do |project|
+        emma = project.emma
+
+        namespace 'emma' do
+          unless project.compile.target.nil?
+            # Instrumented bytecode goes in a different directory. This task creates before running the test
+            # cases and monitors for changes in the generate bytecode.
+            instrumented = project.file(emma.instrumented_dir => project.compile.target) do |task|
+              unless project.compile.sources.empty?
+                info "Instrumenting classes with emma metadata file #{emma.metadata_file}"
+                Emma.ant do |ant|
+                  ant.instr :instrpath=>project.compile.target.to_s, :destdir=>task.to_s, :metadatafile=>emma.metadata_file do
+                    ant.filter :includes=>emma.includes.join(', ') unless emma.includes.empty?
+                    ant.filter :excludes=>emma.excludes.join(', ') unless emma.excludes.empty?
+                  end
+                end
+                touch task.to_s
+              end
+            end
+
+            task 'instrument' => instrumented
+
+            # We now have two target directories with bytecode.
+            project.test.dependencies.unshift emma.instrumented_dir
+            project.test.with Emma.dependencies
+            project.test.options[:properties]["emma.coverage.out.file"] = emma.coverage_file
+
+            [:xml, :html].each do |format|
+              task format => ['instrument', 'test'] do
+                missing_required_files = [emma.metadata_file, emma.coverage_file].reject { |f| File.exist?(f) }
+                if missing_required_files.empty?
+                  info "Creating test coverage reports in #{emma.report_dir}"
+                  mkdir_p emma.report_dir
+                  Emma.ant do |ant|
+                    ant.report do
+                      ant.infileset :file=>emma.metadata_file
+                      ant.infileset :file=>emma.coverage_file
+                      ant.send format, :outfile=>File.join(emma.report_to(format),"coverage.#{format}")
+                      ant.sourcepath do
+                        emma.sources.flatten.each do |src|
+                          ant.dirset(:dir=>src.to_s) if File.exist?(src.to_s)
+                        end
+                      end
+                    end
+                  end
+                else
+                  info "No test coverage report for #{project}. Missing: #{missing_required_files.join(', ')}"
+                end
+              end
+            end
+          end
+        end
+
+        project.clean do
+          rm_rf [emma.report_dir, emma.coverage_file, emma.metadata_file, emma.instrumented_dir]
+        end
+
+      end
+
+    end
+
+    class Buildr::Project
+      include EmmaExtension
+    end
+
+    namespace "emma" do
+
+      Project.local_task('instrument') { |name| "Instrumenting #{name}" }
+
+      [:xml, :html].each do |format|
+        desc "Run the test cases and produce code coverage reports in #{format}"
+        task format => ['instrument', 'test'] do
+          info "Creating test coverage reports in #{format}"
+          mkdir_p report_to(format)
+          Emma.ant do |ant|
+            ant.merge :outfile=>data_file do
+              Buildr.projects.each do |project|
+                [project.emma.metadata_file, project.emma.coverage_file].each do |data_file|
+                  ant.fileset :file=>data_file if File.exist?(data_file)
+                end
+              end
+            end
+            ant.report do
+              ant.infileset :file=>data_file
+              ant.send format, :outfile=>File.join(report_to(format), "coverage.#{format}")
+              ant.sourcepath do
+                Buildr.projects.map(&:emma).map(&:sources).flatten.map(&:to_s).each do |src|
+                  ant.dirset :dir=>src if File.exist?(src)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      task :clean do
+        rm_rf [report_to, data_file]
+      end
+      end
+
+    task :clean do
+      task('emma:clean').invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end