buildr 1.1.1 → 1.1.2

data/CHANGELOG

@@ -1,3 +1,11 @@
+1.1.2 (5/29/2007)
+* Added: Allow passing :java_args option to the junit task
+* Added: Hibernate XDoclet and SchemaExport tasks. (Requires buildr/hibernate)
+* Added: JDepend UI for seeing depenencies across all projects. (Requires buildr/jdepend)
+* Added: Cobertura test coverage tasks, reporting both html and xml. (Requires buildr/cobertura)
+* Changed: tools_jar now returns empty array on OS/X, part of the ongoing Write Once/Test Everywere effort. (Credit Paul Brown)
+* Fixed: Work around keep_alive bug in Net::HTTP. (http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/10818)
+
 1.1.1 (5/16/2007)
 * Changed: Test case class names must end with Test, TestCase, Suite or TestSuite.
 * Changed: You can now run rake test:{foo,bar} to match against either foo or bar (requires \{..\} on UNIX).

data/lib/buildr.rb

@@ -32,7 +32,7 @@ end
 
 
 module Buildr
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end
 
 $LOAD_PATH.unshift __DIR__

data/lib/buildr/cobertura.rb

@@ -0,0 +1,82 @@
+module Buildr
+  module Cobertura
+
+    class << self
+
+      REQUIRES = ["cobertura:cobertura:jar:1.8", "log4j:log4j:jar:1.2.9", "asm:asm:jar:2.2.1", "oro:oro:jar:2.0.8"]
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
+      end
+
+      def ant_project()
+        @ant_project ||= Buildr::Ant.executable("cobertura") { |ant|
+          ant.taskdef(:classpath=>requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties" ) }
+      end
+
+      def report_to(file = nil)
+        File.expand_path(File.join(*["cobertura", file.to_s].compact))
+      end
+
+      def data_file()
+        File.expand_path("cobertura.ser")
+      end
+
+    end
+
+    namespace "cobertura" do
+
+      task "instrument" do
+        Buildr.projects.each do |project|
+          unless project.compile.sources.empty?
+            # 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(project.path_to(:target, "instrumented")=>project.compile.target) do |task|
+              ant_project.send "cobertura-instrument", :todir=>task.to_s, :datafile=>data_file do
+                fileset(:dir=>project.compile.target.to_s) { include :name=>"**/*.class" }
+              end
+              touch task.to_s, :verbose=>false
+            end
+            # 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.junit.classpath.unshift file(instrumented)
+            project.test.junit.with requires
+            project.clean { rm_rf instrumented.to_s, :verbose=>false }
+          end
+        end
+      end
+
+      desc "Run the test cases and produce code coverage reports in #{report_to(:html)}"
+      task "html"=>["instrument", "build"] do
+        puts "Creating test coverage reports in #{report_to(:html)}"
+        projects = Buildr.projects
+        ant_project.send "cobertura-report", :destdir=>report_to(:html), :format=>"html", :datafile=>data_file do
+          projects.map(&:compile).map(&:sources).flatten.each do |src|
+            fileset(:dir=>src.to_s) { include :name=>"**/*.java" } if File.exist?(src.to_s)
+          end
+        end
+      end
+
+      desc "Run the test cases and produce code coverage reports in #{report_to(:xml)}"
+      task "xml"=>["instrument", "build"] do
+        puts "Creating test coverage reports in #{report_to(:xml)}"
+        projects = Buildr.projects
+        ant_project.send "cobertura-report", :destdir=>report_to(:xml), :format=>"xml", :datafile=>data_file do
+          projects.map(&:compile).map(&:sources).flatten.each do |src|
+            fileset :dir=>src.to_s if File.exist?(src.to_s)
+          end
+        end
+      end
+
+      task "clean" do
+        rm_rf [report_to, data_file], :verbose=>false
+      end
+    end
+
+    task "clean" do
+      task("cobertura:clean").invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end

data/lib/buildr/hibernate.rb

@@ -0,0 +1,123 @@
+require "java/java"
+require "java/ant"
+
+module Buildr
+  module Hibernate
+
+    REQUIRES = Buildr.struct(
+      :collections  => "commons-collections:commons-collections:jar:3.1",
+      :logging      => "commons-logging:commons-logging:jar:1.0.3",
+      :dom4j        => "dom4j:dom4j:jar:1.6.1",
+      :hibernate    => "org.hibernate:hibernate:jar:3.1.2",
+      :xdoclet      => Buildr.group("xdoclet", "xdoclet-xdoclet-module", "xdoclet-hibernate-module",
+                         :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1-j5"]
+    )
+
+    class << self
+      include Buildr::Ant
+
+      # :call-seq:
+      #    doclet(options) => AntProject
+      #
+      # Uses XDoclet to generate HBM files form annotated source files.
+      # Options include:
+      # * :sources -- Directory (or directories) containing source files.
+      # * :target -- The target directory.
+      # * :excludetags -- Tags to exclude (see HibernateDocletTask)
+      #
+      # For example:
+      #  doclet :sources=>compile.sources, :target=>compile.target, :excludedtags=>"@version,@author,@todo"
+      def doclet(options)
+        options[:sources].each { |src| file(src).invoke }
+        ant("hibernatedoclet") do |doclet|
+          doclet.taskdef :name=>"hibernatedoclet", :classname=>"xdoclet.modules.hibernate.HibernateDocletTask", :classpath=>requires
+          doclet.hibernatedoclet :destdir=>options[:target].to_s, :excludedtags=>options[:excludedtags], :force=>"true" do
+            hibernate :version=>"3.0"
+            options[:sources].map(&:to_s).each do |source|
+              fileset :dir=>source.to_s, :includes=>"**/*.java"
+            end
+          end
+        end
+      end
+
+      # :call-seq:
+      #   schemaexport(properties) { ... } => AntProject
+      #
+      # Runs the Hibernate SchemaExportTask with the specified properties. For example:
+      #   Buildr::Hibernate.schemaexport(:properties=>properties.to_s, :quiet=>"yes", :text=>"yes", :delimiter=>";",
+      #     :drop=>"no", :create=>"yes", :output=>target) do
+      #     fileset :dir=>source.to_s, :includes=>"**/*.hbm.xml"
+      #   end
+      def schemaexport(options = nil, &block)
+        ant("schemaexport") do |ant|
+          ant.taskdef :name=>"schemaexport", :classname=>"org.hibernate.tool.hbm2ddl.SchemaExportTask", :classpath=>requires
+          ant.schemaexport options, &block if options
+        end
+      end
+
+    protected
+
+      # This will download all the required artifacts before returning a classpath, and we want to do this only once.
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES.to_a).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+      end
+
+    end
+
+    # :call-seq:
+    #   hibernate_doclet(options?) => task
+    #
+    # Runs the hibernate doclet on the source files and creates HBM files in the target directory.
+    # By default runs on all source files, but you can limit it to a given package using the :package
+    # options. You can also pass other options to the doclet task.
+    #
+    # For example:
+    #   resources hibernate_doclet(:package=>"org.apache.ode.store.hib", :excludedtags=>"@version,@author,@todo")
+    def hibernate_doclet(options = {})
+      if options[:package]
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, options[:package].gsub(".", "/"), "*.java")] }.flatten
+      else
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, "**/*.java")] }.flatten
+      end
+      file("target/hbm.timestamp"=>depends) do |task|
+        Hibernate.doclet({ :sources=>compile.sources, :target=>compile.target }.merge(options))
+        write task.name
+      end
+    end
+
+    # :call-seq:
+    #   hibernate_schemaexport(path) => task
+    #   hibernate_schemaexport(path) { |task, ant| .. } => task
+    #
+    # Returns an new file task with an accessor (ant) to an AntProject that defines the schemaexport task.
+    # If called with a block, the task will yield to the block passing both itself and the Ant project.
+    #
+    # See #schemaexport.
+    #
+    # For example:
+    #   hibernate_schemaexport "derby.sql" do |task, ant|
+    #     ant.schemaexport :properties=>"derby.properties", :output=>task.name,
+    #       :delimiter=>";", :drop=>"no", :create=>"yes" do
+    #       fileset(:dir=>path_to(:java_src_dir)) { include :name=>"**/*.hbm.xml" } }
+    #     end
+    #   end
+    def hibernate_schemaexport(args, &block)
+      path, deps = Rake.application.resolve_args(args)
+      unless Rake::Task.task_defined?(path)
+        class << file(path) ; attr_accessor :ant ; end
+        file(path).enhance { |task| task.ant = Hibernate.schemaexport }
+      end
+      if block
+        file(path).enhance(deps) { |task| block.call task, task.ant }
+      else
+        file(path).enhance deps
+      end
+    end
+
+  end
+
+  class Project
+    include Hibernate
+  end
+
+end

data/lib/buildr/jdepend.rb

@@ -0,0 +1,13 @@
+module Buildr
+  module Jdepend
+
+    REQUIRES = ["jdepend:jdepend:jar:2.9.1"]
+
+    desc "Runs JDepend on all your projects"
+    task "jdepend" do
+      paths = Project.projects.map(&:compile).each(&:invoke).map(&:target).map(&:to_s).select { |path| File.exist?(path) }
+      Buildr.java "jdepend.swingui.JDepend", paths, :classpath=>REQUIRES
+    end
+
+  end
+end

data/lib/core/transports.rb

@@ -27,6 +27,21 @@ module Net #:nodoc:all
   end
 end
 
+# Monkeypatching Net::HTTP to solve keep_alive bug, see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/10818
+module Net
+  class HTTP
+    def keep_alive?(req, res)
+      return false if /close/i =~ req['connection'].to_s
+      return false if @seems_1_0_server
+      return false if /close/i      =~ res['connection'].to_s
+      return true  if /keep-alive/i =~ res['connection'].to_s
+      return false if /close/i      =~ res['proxy-connection'].to_s
+      return true  if /keep-alive/i =~ res['proxy-connection'].to_s
+      (@curr_http_version == '1.1')
+    end
+  end
+end
+
 
 module Buildr
 
@@ -74,11 +89,11 @@ module Buildr
       #
       # Convenience method for downloading a single file from the specified
       # URL to the target file.
-      def download(url, target, options = nil)
+      def download(url, target, options = nil, &block)
         uri = URI.parse(url.to_s)
         path, uri.path = uri.path, ""
         const_get(uri.scheme.upcase).perform(uri, options) do |transport|
-          transport.download(path, target)
+          transport.download(path, target, &block)
         end
       end
 
@@ -238,7 +253,9 @@ module Buildr
       class Digester #:nodoc:
 
         def initialize(types)
-          types ||= [ "md5", "sha1" ]
+          # Digests disabled for now, we have a keep-alive problem with Net::HTTP.
+          #types ||= [ "md5", "sha1" ]
+          types ||= []
           @digests = types.inject({}) do |hash, type|
             hash[type.to_s.downcase] = Digest.const_get(type.to_s.upcase).new
             hash
@@ -304,7 +321,7 @@ module Buildr
           when Net::HTTPRedirection
             # Try to download from the new URI, handle relative redirects.
             puts "Redirected to #{response['Location']}" if Rake.application.options.trace
-            last_modified = Transports.download(@uri + URI.parse(response["location"]), target, @options)
+            last_modified = Transports.download(@uri + URI.parse(response["location"]), target, @options, &block)
 
           when Net::HTTPOK
             puts "Downloading #{@uri}/#{path}" if verbose

data/lib/java/artifact.rb

@@ -381,6 +381,8 @@ module Buildr
           Transports.perform URI.parse(repo_url.to_s), :proxy=>proxy do |http|
             mkpath File.dirname(path), :verbose=>false
             http.download(rel_path, path)
+          end
+          Transports.perform URI.parse(repo_url.to_s), :proxy=>proxy do |http|
             begin
               http.download(rel_path.ext("pom"), path.ext("pom"))
             rescue Transports::NotFound

data/lib/java/eclipse.rb

@@ -76,8 +76,8 @@ module Buildr
               end
 
               # Classpath elements from other projects
-              project_libs.map(&:name).sort.uniq.each do |prj_name|
-                xml.classpathentry :kind=>'src', :combineaccessrules=>"false", :path=>"/#{prj_name}"
+              project_libs.map(&:id).sort.uniq.each do |project_id|
+                xml.classpathentry :kind=>'src', :combineaccessrules=>"false", :path=>"/#{project_id}"
               end
 
               # Main resources implicitly copied into project.compile.target
@@ -113,7 +113,7 @@ module Buildr
           File.open(task.name, "w") do |file|
             xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
             xml.projectDescription do
-              xml.name project.name.tr(":", "-")
+              xml.name project.id
               xml.projects
               xml.buildSpec do
                 xml.buildCommand do

data/lib/java/java.rb

@@ -2,7 +2,7 @@ require "rjb"
 require "core/project"
 
 module Buildr
-  
+
   # Base module for all things Java.
   module Java
 
@@ -82,13 +82,13 @@ module Buildr
       # :call-seq:
       #   tools_jar() => path
       #
-      # Returns a path to tools.jar. Returns nil if tools.jar not found, which may be a problem,
-      # unless you're running OS/X.
+      # Returns a path to tools.jar. On OS/X which has not tools.jar, returns an empty array,
+      # on all other platforms, fails if it doesn't find tools.jar.
       def tools_jar()
-        return nil if darwin?
-        @tools ||= File.join(home, "lib/tools.jar") or raise "I need tools.jar to compile, can't find it in #{home}/lib"
+        return [] if darwin?
+        @tools ||= [File.join(home, "lib/tools.jar")] or raise "I need tools.jar to compile, can't find it in #{home}/lib"
       end
-  
+
       # :call-seq:
       #   home() => path
       #
@@ -275,7 +275,7 @@ module Buildr
       def junit(*args)
         options = Hash === args.last ? args.pop : {}
         options[:verbose] ||= Rake.application.options.trace || false
-        rake_check_options options, :verbose, :classpath, :properties
+        rake_check_options options, :verbose, :classpath, :properties, :java_args
 
         classpath = classpath_from(options) + junit_artifacts
         tests = args.flatten

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.3
+rubygems_version: 0.9.4
 specification_version: 1
 name: buildr
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
-date: 2007-05-16 00:00:00 -07:00
+  version: 1.1.2
+date: 2007-05-29 00:00:00 -07:00
 summary: A build system that doesn't suck
 require_paths: 
 - lib
@@ -42,8 +42,11 @@ files:
 - lib/core/rake_ext.rb
 - lib/core/common.rb
 - lib/buildr/jetty.rb
+- lib/buildr/hibernate.rb
 - lib/buildr/xmlbeans.rb
 - lib/buildr/javacc.rb
+- lib/buildr/cobertura.rb
+- lib/buildr/jdepend.rb
 - lib/buildr/openjpa.rb
 - lib/buildr/jetty
 - lib/buildr/jetty/JettyWrapper.java