ittayd-buildr 1.3.4

data/lib/buildr/java/emma.rb

@@ -0,0 +1,238 @@
+# 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
+
+    class << self
+
+      REQUIRES = ['emma:emma_ant:jar:2.0.5312', 'emma:emma:jar:2.0.5312'] unless const_defined?('REQUIRES')
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
+      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 :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>'emma_ant.properties'
+            ant.emma :verbosity=>(Buildr.application.options.trace ? '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, :verbose=>false
+              end
+            end
+            
+            task 'instrument' => instrumented
+            
+            # We now have two target directories with bytecode.
+            project.test.dependencies.unshift emma.instrumented_dir
+            project.test.with Emma.requires
+            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, :verbose=>false
+                  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], :verbose=>false
+        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), :verbose=>false
+          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], :verbose=>false
+      end
+      end
+
+    task :clean do
+      task('emma:clean').invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end

data/lib/buildr/java/jruby.rb

@@ -0,0 +1,117 @@
+# 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
+
+  # Since we already have a JVM loaded, we can use it to guess where JAVA_HOME is.
+  # We set JAVA_HOME early so we can use it without calling Java.load first.
+  ENV['JAVA_HOME'] ||= java.lang.System.getProperty("java.home")
+
+  class << self
+
+    # Returns the classpath, an array listing directories, JAR files and
+    # 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
+    
+    # Most platforms requires tools.jar to be on the classpath, tools.jar contains the
+    # Java compiler (OS X and AIX are two exceptions we know about, may be more).
+    # Guess where tools.jar is from JAVA_HOME, which hopefully points to the JDK,
+    # but maybe the JRE.  Return nil if not found.
+    def tools_jar #:nodoc:
+      @tools_jar ||= ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, ENV['JAVA_HOME']) }.
+        find { |path| File.exist?(path) }
+    end
+
+    # Loads the JVM and all the libraries listed on the classpath.  Call this
+    # method before accessing any Java class, but only call it from methods
+    # 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
+
+      # Adding jars to the jruby's $CLASSPATH should be the correct thing, however it
+      # seems like some tools require their jars on system class loader (javadoc, junit, etc)
+      # cp.each { |path| $CLASSPATH << path }
+
+      # Use system ClassLoader to add classpath
+      sysloader = java.lang.ClassLoader.getSystemClassLoader
+      add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
+        getDeclaredMethod('addURL', [java.net.URL.java_class].to_java(java.lang.Class))
+      add_url_method.setAccessible(true)
+      add_path = lambda { |path| add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL)) }
+
+      # Most platforms requires tools.jar to be on the classpath.
+      add_path[tools_jar] if tools_jar
+      
+      classpath.map! { |path| Proc === path ? path.call : path }      
+      Buildr.artifacts(classpath).map(&:to_s).each do |path|
+        file(path).invoke
+        add_path[path]
+      end
+      
+      @loaded = true
+      self
+    end
+
+  end
+
+end

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

@@ -0,0 +1,116 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+#  ___   ___     _  _  ___ _____    ___ ___ ___ _____    _____ _  _ ___ ___ 
+# |   \ / _ \   | \| |/ _ \_   _|  | __|   \_ _|_   _|  |_   _| || |_ _/ __|
+# | |) | (_) |  | .` | (_) || |    | _|| |) | |  | |      | | | __ || |\__ \
+# |___/ \___/   |_|\_|\___/ |_|    |___|___/___| |_|      |_| |_||_|___|___/
+#                                                                          
+#  ___ ___ _    ___ 
+# | __|_ _| |  | __|  CHANGES TO THIS FILE WILL BE LOST
+# | _| | || |__| _|   AUTO-GENERATED BY BUILDR on <%= Time.now %>
+# |_| |___|____|___|  PREFER TO EDIT JtestR CONFIGURATION FILE:
+#
+# <%= user_config %>
+
+begin
+
+  <%= jruby_gem %>
+  <%= dependencies.map(&:to_s).inspect %>.each { |dep| $CLASSPATH << dep }
+  <%= runner.gems.inspect %>.each { |ary| JRuby.gem(*ary.flatten) }
+  <%= runner.requires.inspect %>.each { |rb| Kernel.require rb }
+  
+  jtestr = JtestR::TestRunner.new
+  
+  class << jtestr
+    def config(&block)
+      @config_blocks ||= []
+      @config_blocks << block if block
+      @config_blocks
+    end
+    
+    def load_configuration
+      super
+      config.each { |block| @configuration.instance_eval(&block) }
+    end
+  end
+  
+  jtestr.config do 
+    classpath [] # already loaded
+    add_common_classpath false
+    
+    <% ts = ( @jtestr_tests[:junit] & tests ).map { |c| 'Java.' + c } %>
+    junit [<%= ts.join(', ') %>]
+    
+    <% ts = ( @jtestr_tests[:testng] & tests ).map { |c| 'Java.' + c } %>
+    testng [<%= ts.join(', ') %>]
+    
+    <% ts = @jtestr_tests[:testunit] & tests %>
+    test_unit <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:story] & tests %>
+    story <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:rspec] & tests %>
+    rspec <%= ts.inspect %>
+      
+    <% ts = @jtestr_tests[:expect] & tests %>
+    expectations <%= ts.inspect %>
+      
+    ignore __FILE__
+  
+    if File.file?(<%= user_config.inspect %>)
+      ignore <%= user_config.inspect %>
+      load <%= user_config.inspect %>
+    end
+  end # config
+
+  fake_out = StringIO.new
+
+  <% if runner.output == false %>
+     output = fake_out
+  <% elsif runner.output.kind_of?(String) %>
+     output = File.open(<%= result.output.inspect %>, 'w')
+  <% else %>
+     output = STDOUT
+  <% end %>
+  
+  
+  args = [ '<%= spec_dir %>', # the directory to search for jtestr files
+           JtestR::SimpleLogger::ERR, # log level
+           JtestR::GenericResultHandler::QUIET, #output level 
+           fake_out, # output STDOUT
+           [], # groups to run 
+           Buildr::TestFramework::TestResult::RSpecResultHandler, # result handler
+           []  # classpath
+         ]
+  
+  argv = <%= runner.rspec.inspect %> || []
+  argv.push *<%= tests.inspect %>
+  Buildr::TestFramework::TestResult::RSpecResultHandler.init(argv, output, output)
+  
+  jtestr.run *args
+
+rescue => e
+  Buildr::TestFramework::TestResult::Error.dump_yaml('<%= runner.result %>', e) rescue \
+  puts "-[--- ERROR ---]-", e.class, e.message, *e.backtrace
+end
+
+exit 0 # let buildr find the erros from the result yaml
+  
+# Local Variables:
+# mode: ruby
+# End:
+  

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

@@ -0,0 +1,119 @@
+/* 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.lang.reflect.Modifier;
+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 (Modifier.isAbstract(cls.getModifiers()) || !Modifier.isPublic(cls.getModifiers()))
+      return false;
+    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:
+ */