buildr-gemjar 1.0.0

data/vendor/buildr/lib/buildr/java/cobertura.rb

@@ -0,0 +1,297 @@
+# 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>cobertura:html</code>, <code>cobertura:xml</code> and <code>cobertura:check</code> tasks.
+  # Require explicitly using <code>require "buildr/cobertura"</code>.
+  #
+  # You can generate cobertura reports for a single project
+  # using the project name as prefix:
+  #
+  #   project_name:cobertura:html
+  #
+  # You can also specify which classes to include/exclude from instrumentation by
+  # passing a class name regexp to the <code>cobertura.include</code> or
+  # <code>cobertura.exclude</code> methods.
+  #
+  #   define 'someModule' do
+  #      cobertura.include 'some.package.*'
+  #      cobertura.include /some.(foo|bar).*/
+  #      cobertura.exclude 'some.foo.util.SimpleUtil'
+  #      cobertura.exclude /*.Const(ants)?/i
+  #   end
+  #
+  module Cobertura
+
+    VERSION = '1.9.4.1'
+
+    class << self
+      def version
+        Buildr.settings.build['cobertura'] || VERSION
+      end
+    end
+
+    REQUIRES = ArtifactNamespace.for(self).tap do |ns|
+      ns.cobertura! "net.sourceforge.cobertura:cobertura:jar:#{version}", '>=1.9'
+      ns.log4j! 'log4j:log4j:jar:1.2.9', ">=1.2.9"
+      ns.asm! 'asm:asm:jar:2.2.1', '>=2.2.1'
+      ns.asm_tree! 'asm:asm-tree:jar:2.2.1', '>=2.2.1'
+      ns.oro! 'oro:oro:jar:2.0.8', '>=2.0.8'
+    end
+
+    class << self
+      def dependencies
+        if (VersionRequirement.create('>=1.9.1').satisfied_by?(REQUIRES.cobertura.version))
+          [:asm, :asm_tree].each { |s| REQUIRES[s] = '3.0' unless REQUIRES[s].selected? }
+        end
+
+        REQUIRES.artifacts
+      end
+
+      def report_to(file = nil)
+        File.expand_path(File.join(*["reports/cobertura", file.to_s].compact))
+      end
+
+      def data_file()
+        File.expand_path("reports/cobertura.ser")
+      end
+
+    end
+
+    class CoberturaConfig # :nodoc:
+
+      def initialize(project)
+        @project = project
+      end
+
+      attr_reader :project
+      private :project
+
+      attr_writer :data_file, :instrumented_dir, :report_dir
+
+      def data_file
+        @data_file ||= project.path_to(:reports, 'cobertura.ser')
+      end
+
+      def instrumented_dir
+        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
+      end
+
+      def report_dir
+        @report_dir ||= project.path_to(:reports, :cobertura)
+      end
+
+      def report_to(file = nil)
+        File.expand_path(File.join(*[report_dir, file.to_s].compact))
+      end
+
+      # :call-seq:
+      #   project.cobertura.include(*classPatterns)
+      #
+      def include(*classPatterns)
+        includes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
+        self
+      end
+
+      def includes
+        @includeClasses ||= []
+      end
+
+      # :call-seq:
+      #   project.cobertura.exclude(*classPatterns)
+      #
+      def exclude(*classPatterns)
+        excludes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
+        self
+      end
+
+      def excludes
+        @excludeClasses ||= []
+      end
+
+      def ignore(*regexps)
+        ignores.push(*regexps)
+      end
+
+      def ignores
+        @ignores ||= []
+      end
+
+      def sources
+        project.compile.sources
+      end
+
+      def check
+        @check ||= CoberturaCheck.new
+      end
+    end
+
+    class CoberturaCheck
+      attr_writer :branch_rate, :line_rate, :total_branch_rate, :total_line_rate, :package_line_rate, :package_branch_rate
+      attr_reader :branch_rate, :line_rate, :total_branch_rate, :total_line_rate, :package_line_rate, :package_branch_rate
+    end
+
+    module CoberturaExtension # :nodoc:
+      include Buildr::Extension
+
+      def cobertura
+        @cobertura_config ||= CoberturaConfig.new(self)
+      end
+
+      after_define do |project|
+        cobertura = project.cobertura
+
+        namespace 'cobertura' 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(cobertura.instrumented_dir => project.compile.target) do |task|
+              mkdir_p task.to_s
+              unless project.compile.sources.empty?
+                info "Instrumenting classes with cobertura data file #{cobertura.data_file}"
+                Buildr.ant "cobertura" do |ant|
+                  ant.taskdef :resource=>"tasks.properties",
+                    :classpath=>Buildr.artifacts(Cobertura.dependencies).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+                  ant.send "cobertura-instrument", :todir=>task.to_s, :datafile=>cobertura.data_file do
+                    includes, excludes = cobertura.includes, cobertura.excludes
+
+                    classes_dir = project.compile.target.to_s
+                    if includes.empty? && excludes.empty?
+                      ant.fileset :dir => classes_dir do
+                        ant.include :name => "**/*.class"
+                      end
+                    else
+                      includes = [//] if includes.empty?
+                      Dir.glob(File.join(classes_dir, "**/*.class")) do |cls|
+                        cls_name = cls.gsub(/#{classes_dir}\/?|\.class$/, '').gsub('/', '.')
+                        if includes.any? { |p| p === cls_name } && !excludes.any? { |p| p === cls_name }
+                          ant.fileset :file => cls
+                        end
+                      end
+                    end
+
+                    cobertura.ignores.each { |r| ant.ignore :regex => r }
+                  end
+                end
+              end
+              touch task.to_s
+            end
+
+            task 'instrument' => instrumented
+
+            # We now have two target directories with bytecode. It would make sense to remove compile.target
+            # and add instrumented instead, but apparently Cobertura only creates some of the classes, so
+            # we need both directories and instrumented must come first.
+            project.test.dependencies.unshift cobertura.instrumented_dir
+            project.test.with Cobertura.dependencies
+            project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = cobertura.data_file
+
+            unless project.compile.sources.empty?
+              [:xml, :html].each do |format|
+                task format => ['instrument', 'test'] do
+                  info "Creating test coverage reports in #{cobertura.report_to(format)}"
+                  Buildr.ant "cobertura" do |ant|
+                    ant.taskdef :resource=>"tasks.properties",
+                      :classpath=>Buildr.artifacts(Cobertura.dependencies).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+                    ant.send "cobertura-report", :format=>format,
+                      :destdir=>cobertura.report_to(format), :datafile=>cobertura.data_file do
+                      cobertura.sources.flatten.each do |src|
+                        ant.fileset(:dir=>src.to_s) if File.exist?(src.to_s)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            task :check => [:instrument, :test] do
+              Buildr.ant "cobertura" do |ant|
+                ant.taskdef :classpath=>Cobertura.dependencies.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
+                params = { :datafile => Cobertura.data_file }
+
+                # oh so ugly...
+                params[:branchrate] = cobertura.check.branch_rate if cobertura.check.branch_rate
+                params[:linerate] = cobertura.check.line_rate if cobertura.check.line_rate
+                params[:totalbranchrate] = cobertura.check.total_branch_rate if cobertura.check.total_branch_rate
+                params[:totallinerate] = cobertura.check.total_line_rate if cobertura.check.total_line_rate
+                params[:packagebranchrate] = cobertura.check.package_branch_rate if cobertura.check.package_branch_rate
+                params[:packagelinerate] = cobertura.check.package_line_rate if cobertura.check.package_line_rate
+
+                ant.send("cobertura-check", params) do
+                end
+              end
+            end
+
+          end
+        end
+
+        project.clean do
+          rm_rf [cobertura.report_to, cobertura.data_file, cobertura.instrumented_dir]
+        end
+
+      end
+
+    end
+
+    class Buildr::Project
+      include CoberturaExtension
+    end
+
+    namespace "cobertura" do
+
+      task "instrument" do
+        Buildr.projects.each do |project|
+          project.cobertura.data_file = data_file
+          project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = data_file
+          instrument_task ="#{project.name}:cobertura:instrument"
+          task(instrument_task).invoke if Rake::Task.task_defined?(instrument_task)
+        end
+      end
+
+      [:xml, :html].each do |format|
+        report_target = report_to(format)
+        desc "Run the test cases and produce code coverage reports in #{report_target}"
+        task format => ["instrument", "test"] do
+          if Buildr.projects.detect { |project| !project.compile.sources.empty? }
+            info "Creating test coverage reports in #{report_target}"
+            Buildr.ant "cobertura" do |ant|
+              ant.taskdef :resource=>"tasks.properties",
+                :classpath=>Buildr.artifacts(Cobertura.dependencies).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+              ant.send "cobertura-report", :destdir=>report_target, :format=>format, :datafile=>data_file do
+                Buildr.projects.map(&:cobertura).map(&:sources).flatten.each do |src|
+                  ant.fileset :dir=>src.to_s if File.exist?(src.to_s)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      task "clean" do
+        rm_rf [report_to, data_file]
+      end
+    end
+
+    task "clean" do
+      task("cobertura:clean").invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end

data/vendor/buildr/lib/buildr/java/commands.rb

@@ -0,0 +1,223 @@
+# 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.
+      #
+      # Each argument should be provided as separate array value, e.g.
+      #
+      #  java("-jar", "yuicompressor-2.4.2.jar", "--type","css",
+      #       "src/main/webapp/styles/styles-all.css",
+      #       "-o", "src/main/webapp/styles/styles-all-min.css")
+      #
+      # 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] ||= trace?(:java)
+        rake_check_options options, :classpath, :java_args, :properties, :name, :verbose
+
+        name = options[:name]
+        if name.nil?
+          name = "java #{args.first}"
+        end
+
+        cmd_args = [path_to_bin('java')]
+        cp = classpath_from(options)
+        cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.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
+          info "Running #{name}" if name && options[:verbose]
+          block = lambda { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok } unless block
+          cmd_args = cmd_args.map(&:inspect).join(' ') if Util.win_os?
+          sh(*cmd_args) do |ok, ps|
+            block.call ok, ps
+          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 = [ trace?(:apt) ? '-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]
+        cp = classpath_from(options)
+        cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
+        cmd_args += files
+        unless Buildr.application.options.dryrun
+          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'
+        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["#{File.expand_path(arg)}/**/*.java"] : File.expand_path(arg) }.flatten
+        name = options[:name] || Dir.pwd
+
+        cmd_args = []
+        cp = classpath_from(options)
+        cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
+        cmd_args << '-sourcepath' << [options[:sourcepath]].flatten.join(File::PATH_SEPARATOR) if options[:sourcepath]
+        cmd_args << '-d' << File.expand_path(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
+          mkdir_p options[:output] if options[:output]
+          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'
+        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 : {}
+        fail "No output defined for javadoc" if options[:output].nil?
+        options[:output] = File.expand_path(options[:output].to_s)
+        cmd_args = [ '-d', options[:output], trace?(:javadoc) ? '-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
+        files = args.each {|arg| arg.invoke if arg.respond_to?(:invoke)}.collect {|arg| arg.is_a?(Project) ? arg.compile.sources.collect{|dir| Dir["#{File.expand_path(dir.to_s)}/**/*.java"]} : File.expand_path(arg.to_s) }
+        cmd_args += files.flatten.uniq.map(&:to_s)
+        name = options[:name] || Dir.pwd
+        unless Buildr.application.options.dryrun
+          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'
+        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.'
+        bin = Util.normalize_path(File.join(home, 'bin'))
+        fail 'JAVA_HOME environment variable does not point to a valid JRE/JDK installation.' unless File.exist? bin
+        Util.normalize_path(File.join(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
+