buildr 0.21.0 → 0.22.0

data/lib/java/compile.rb

@@ -159,7 +159,7 @@ module Buildr
       # For example:
       #   compile.with("module1.jar", "log4j:log4j:jar:1.0", project("foo"))
       def with(*specs)
-        @classpath |= artifacts(specs.flatten).uniq
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
         self
       end
 
@@ -368,7 +368,7 @@ module Buildr
       #
       # Adds files and artifacts as classpath dependencies, and returns self.
       def with(*specs)
-        @classpath |= artifacts(specs.flatten).uniq
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
         self
       end
 
@@ -538,7 +538,7 @@ module Buildr
     resources = Java::ResourcesTask.define_task("resources")
     resources.filter.from project.path_to("src/main/resources")
     # Compile task requires prepare and performs resources, if anything compiled.
-    compile = Java::CompileTask.define_task("compile"=>[prepare, resources]) { |task| project.resources.invoke }
+    compile = Java::CompileTask.define_task("compile"=>[prepare, resources])
     project.path_to("src/main/java").tap { |dir| compile.from dir if File.exist?(dir) }
     compile.into project.path_to("target/classes")
     resources.filter.into project.compile.target

data/lib/java/eclipse.rb

@@ -24,7 +24,7 @@ module Buildr
       sources << File.expand_path(Rake.application.rakefile, root_path) if Rake.application.rakefile
 
       # Only for projects that are Eclipse packagable.
-      if project.packages.detect { |pkg| pkg.type =~ /(jar)|(war)|(rar)|(mar)|(aar)/ }
+      if project.packages.detect { |pkg| pkg.type.to_s =~ /(jar)|(war)|(rar)|(mar)|(aar)/ }
         eclipse.enhance [ file(project.path_to(".classpath")), file(project.path_to(".project")) ]
 
         # The only thing we need to look for is a change in the Rakefile.

data/lib/java/java.rb

@@ -7,7 +7,7 @@ module Buildr
   module Java
 
     # Options accepted by #java and other methods here.
-    JAVA_OPTIONS = [ :verbose, :classpath, :name, :java_args ]
+    JAVA_OPTIONS = [ :verbose, :classpath, :name, :java_args, :properties ]
     # Classpath dependencies available when running JUnit.
     JUNIT_REQUIRES = [ "junit:junit:jar:3.8.1", "jmock:jmock:jar:1.1.0" ]
 
@@ -26,11 +26,13 @@ module Buildr
       include Singleton
 
       def initialize() #:nodoc:
-        @classpath = []
+        @classpath = [Java.tools_jar]
         @onload = []
         onload do
-          Rjb.load(artifacts(classpath).each { |task| task.invoke if task.respond_to?(:invoke) }.
-            map(&:to_s).join(File::PATH_SEPARATOR))
+          onload do
+            Rjb.load(Buildr.artifacts(classpath).each { |task| task.invoke if task.respond_to?(:invoke) }.
+              map(&:to_s).join(File::PATH_SEPARATOR))
+          end
         end
       end
 
@@ -99,6 +101,7 @@ module Buildr
       # * :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)
@@ -110,6 +113,7 @@ module Buildr
         cmd_args = []
         classpath = classpath_from(options)
         cmd_args << "-cp" << 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].flatten if options[:java_args]
         cmd_args += args.flatten.compact
         cmd_args << { :verbose=>options[:verbose] }
@@ -131,29 +135,29 @@ module Buildr
       #   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.
-      # * :verbose -- If true, prints the command and all its argument and also runs
-      #   Apt in verbose mode (the default is -nowarn).
       def apt(*args)
         options = Hash === args.last ? args.pop : {}
-        options[:verbose] ||= Rake.application.options.trace || false
-        fu_check_options options, :verbose, :compile, :source, :output, :classpath
+        fu_check_options options, :compile, :source, :output, :classpath
 
         files = args.flatten.map(&:to_s).
           collect { |arg| File.directory?(arg) ? FileList["#{arg}/**/*.java"] : arg }.flatten
-        args = [ options[:verbose] ? "-verbose" : "-nowarn" ]
+        cmd_args = [ Rake.application.options.trace ? "-verbose" : "-nowarn" ]
         if options[:compile]
-          args << "-d" << options[:output].to_s
+          cmd_args << "-d" << options[:output].to_s
         else
-          args << "-nocompile" << "-s" << options[:output].to_s
+          cmd_args << "-nocompile" << "-s" << options[:output].to_s
         end
-        args << "-source" << options[:source] if options[:source]
+        cmd_args << "-source" << options[:source] if options[:source]
         classpath = classpath_from(options)
-        args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
-        args += files
-        args << { :verbose=>options[:verbose] }
+        cmd_args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
+        cmd_args += files
         unless Rake.application.options.dryrun
           puts "Running apt" if verbose
-          sh(path_to_bin("apt"), *args) { |ok, res| fail "Failed to execute apt, see errors above" unless ok }
+          puts (["apt"] + cmd_args).join(" ") if Rake.application.options.trace
+          Java.rjb do |rjb|
+            rjb.import("com.sun.tools.apt.Main").process(cmd_args) == 0 or
+              fail "Failed to process annotations, see errors above"
+          end
         end
       end
 
@@ -169,11 +173,9 @@ module Buildr
       # * :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.
-      # * :verbose -- If true, prints the command and all its argument.
       def javac(*args)
         options = Hash === args.last ? args.pop : {}
-        options[:verbose] ||= Rake.application.options.trace || false
-        fu_check_options options, :verbose, :classpath, :sourcepath, :output, :javac_args, :name
+        fu_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
@@ -181,16 +183,18 @@ module Buildr
 
         cmd_args = []
         classpath = classpath_from(options)
-        #classpath += options[:output] if options[:output]
         cmd_args << "-cp" << 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
-        cmd_args << { :verbose=>options[:verbose] }
         unless Rake.application.options.dryrun
           puts "Compiling #{files.size} source files in #{name}" if verbose
-          sh(path_to_bin("javac"), *cmd_args) { |ok, res| fail "Failed to compile, see errors above" unless ok }
+          puts (["javac"] + cmd_args).join(" ") if Rake.application.options.trace
+          Java.rjb do |rjb|
+            rjb.import("com.sun.tools.javac.Main").compile(cmd_args) == 0 or
+              fail "Failed to compile, see errors above"
+          end
         end
       end
 
@@ -204,7 +208,6 @@ module Buildr
       # * :classpath -- Array of classpath dependencies.
       # * :sourcepath -- Array of sourcepaths (paths or tasks).
       # * :name -- Shows this name, otherwise shows the working directory.
-      # * :verbose -- If you want an overload of details.
       #
       # All other options are passed to Javadoc as following:
       # * true -- As is, for example, :author=>true becomes -author
@@ -213,39 +216,38 @@ module Buildr
       # * array -- Option with set of values separated by spaces.
       def javadoc(*args)
         options = Hash === args.last ? args.pop : {}
-        options[:verbose] ||= Rake.application.options.trace || false
 
-        Tempfile.open("javadoc") do |opt_file|
-          options.reject { |key, value| [:output, :verbose, :name, :sourcepath, :classpath].include?(key) }.
-            each { |key, value| value.invoke if value.respond_to?(:invoke) }.
-            each do |key, value|
-              case value
-              when true, nil
-                opt_file.puts "-#{key}"
-              when false
-                opt_file.puts "-no#{key}"
-              when Array
-                opt_file.puts "-#{key} " << value.map { |val| %q{"#{val}"} }.join(" ")
-              when Hash
-                value.each { |k,v| opt_file.puts "-#{key} #{k} #{v}" }
-              else
-                opt_file.puts "-#{key} \"#{value}\""
-              end
-            end
-          [:sourcepath, :classpath].each do |option|
-            options[option].to_a.flatten.tap do |paths|
-              opt_file.puts "-#{option} " << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+        cmd_args = [ "-d", options[:output], Rake.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 Array
+              cmd_args << "-#{key}"
+              cmd_args += value.map(&:to_s)
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args << "-#{key}" << value.to_s
             end
           end
-          opt_file.puts args.flatten.uniq.join(" ")
-          opt_file.flush
-          cmd_args = [ "-d", options[:output], options[:verbose] ? "-verbose" : "-quiet", "@#{opt_file.path}"]
-          cmd_args << { :verbose=>options[:verbose] }
-          name = options[:name] || Dir.pwd
-          unless Rake.application.options.dryrun
-            puts "Generating Javadoc for #{name}" if verbose
-            puts File.read(opt_file.path) if options[:verbose]
-            sh(path_to_bin("javadoc"), *cmd_args) { |ok, res| fail "Failed to generate Javadocs, see errors above" unless ok }
+        [: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 Rake.application.options.dryrun
+          puts "Generating Javadoc for #{name}" if verbose
+          puts (["javadoc"] + cmd_args).join(" ") if Rake.application.options.trace
+          Java.rjb do |rjb|
+            rjb.import("com.sun.tools.javadoc.Main").execute(cmd_args) == 0 or
+              fail "Failed to generate Javadocs, see errors above"
           end
         end
       end
@@ -260,17 +262,19 @@ module Buildr
       # 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.
+      # * :properties -- Hash of system properties (e.g. "path"=>base_dir).
       # * :verbose -- If true, prints the command and all its argument.
       def junit(*args)
         options = Hash === args.last ? args.pop : {}
         options[:verbose] ||= Rake.application.options.trace || false
-        fu_check_options options, :verbose, :classpath
+        fu_check_options options, :verbose, :classpath, :properties
 
         classpath = classpath_from(options) + junit_artifacts
         tests = args.flatten
         failed = tests.inject([]) do |failed, test|
           begin
-            java "junit.textui.TestRunner", test, :classpath=>classpath, :name=>"tests in #{test}", :verbose=>options[:verbose]
+            java "junit.textui.TestRunner", test, :classpath=>classpath, :properties=>options[:properties],
+              :name=>"#{test}", :verbose=>options[:verbose]
             failed
           rescue
             failed << test
@@ -299,7 +303,7 @@ module Buildr
       def rjb()
         if block_given?
           RjbWrapper.instance.load
-          yield
+          yield RjbWrapper.instance
         else
           RjbWrapper.instance
         end
@@ -323,7 +327,7 @@ module Buildr
       # each of the artifacts and returns an array of paths.
       def classpath_from(options)
         classpath = (options[:classpath] || []).collect
-        artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+        Buildr.artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
       end
 
       # :call-seq:
@@ -331,7 +335,7 @@ module Buildr
       #
       # Returns the JUnit artifacts as paths, after downloading and installing them (if necessary).
       def junit_artifacts()
-        @junit_artifacts ||= artifacts(JUNIT_REQUIRES).each { |task| task.invoke }.map(&:to_s)
+        @junit_artifacts ||= Buildr.artifacts(JUNIT_REQUIRES).each { |task| task.invoke }.map(&:to_s)
       end
 
     end
@@ -360,7 +364,6 @@ module Buildr
 
   end
 
-  class Project
-    include Java
-  end
+  include Java
+
 end

data/lib/java/packaging.rb

@@ -106,7 +106,7 @@ module Buildr
         def []=(key, value) #:nodoc:
           case key.to_sym
           when :libs
-            self.include artifacts(value), :path=>"WEB-INF/lib"
+            self.include Buildr.artifacts(value), :path=>"WEB-INF/lib"
           when :classes
             self.include value, :path=>"WEB-INF/classes", :as=>"."
           else
@@ -241,17 +241,22 @@ module Buildr
         # Make it an artifact using the specifications, and tell it how to create a POM.
         package.extend ActsAsArtifact
         package.send :apply_spec, options
-        package.pom.enhance do |pom|
+        # Another task to create the POM file.
+        pom_spec = package.to_spec_hash.merge(:type=>:pom)
+        pom = file(Buildr.repositories.locate(pom_spec))
+        pom.extend ActsAsArtifact
+        pom.send :apply_spec, pom_spec
+        pom.enhance do
           mkpath File.dirname(pom.name), :verbose=>false
           File.open(pom.name, "w") do |file|
             xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
             xml.instruct!
             xml.project do
               xml.modelVersion  "4.0.0"
-              xml.groupId       options[:group]
-              xml.artifactId    options[:id]
-              xml.version       options[:version]
-              xml.classifier    options[:classifier] if options[:classifier]
+              xml.groupId       pom.group
+              xml.artifactId    pom.id
+              xml.version       pom.version
+              xml.classifier    pom.classifier if pom.classifier
             end
           end
         end
@@ -264,27 +269,27 @@ module Buildr
         # in the target directory, we need to copy it into the local repository. However, the
         # POM artifact (created by calling artifact on its spec) is already mapped to its right
         # place in the local repository, so we only need to invoke it.
-        installed = file(repositories.locate(package)=>package) { |task|
+        installed = file(Buildr.repositories.locate(package)=>package) { |task|
           verbose(Rake.application.options.trace || false) do
             mkpath File.dirname(task.name), :verbose=>false
             cp package.name, task.name
           end
           puts "Installed #{task.name}" if verbose
         }
-        task "install"=>[installed, package.pom]
+        task "install"=>[installed, pom]
         task "uninstall" do |task|
           verbose(Rake.application.options.trace || false) do
-            [ installed, package.pom ].map(&:to_s).each { |file| rm file if File.exist?(file) } 
+            [ installed, pom ].map(&:to_s).each { |file| rm file if File.exist?(file) } 
           end
         end
-        task("deploy") { deploy(package, package.pom) }
+        task("deploy") { deploy(package, pom) }
 
         # Add the package to the list of packages created by this project, and
         # register it as an artifact. The later is required so if we look up the spec
         # we find the package in the project's target directory, instead of finding it
         # in the local repository and attempting to install it.
         packages << package
-        Artifact.register package, package.pom
+        Artifact.register package, pom
       end
     end
 

data/lib/java/test.rb

@@ -21,10 +21,11 @@ module Buildr
         @paths = []
         @include = ["*Test", "*Suite"]
         @exclude = []
+        @options = {}
         enhance do |task|
           unless test_cases.empty?
             puts "Running tests in #{name}" if verbose
-            passed, failed = Java.junit(test_cases, :classpath=>classpath + @paths)
+            passed, failed = Java.junit(test_cases, @options.merge(:classpath=>classpath + @paths))
             fail "The following tests failed:\n#{failed.join("\n")}" unless failed.empty?
           end
         end
@@ -76,7 +77,22 @@ module Buildr
       # Specify artifacts (specs, tasks, files, etc) to include in the classpath when running
       # the test cases.
       def with(*files)
-        @classpath |= artifacts(files.flatten).uniq
+        @classpath |= Buildr.artifacts(files.flatten).uniq
+        self
+      end
+
+      # Returns the JUnit options.
+      attr_reader :options
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the JUnit options from a hash and returns self. Right now supports passing properties to JUnit.
+      #
+      # For example:
+      #   test.junit.using :properties=>{ "root"=>base_dir }
+      def using(options)
+        options.each { |k,v| @options[k.to_sym] = v }
         self
       end
 
@@ -168,6 +184,9 @@ module Buildr
       #
       # You can also include only specific test cases, or exclude otherwise included test cases
       # using #include and #exclude.
+      #
+      # The Java property baseDir is set to the classes directory, you can use it to pick up test resources
+      # that you cannot access using getResources().
       def junit()
         @project.task("test:junit")
       end
@@ -225,6 +244,7 @@ module Buildr
 
   end
 
+
   class Project
 
     # :call-seq:
@@ -268,7 +288,6 @@ module Buildr
     resources.filter.from project.path_to("src/test/resources")
     # Similar to the regular compile task but using different paths.
     compile = Java::CompileTask.define_task("test:compile"=>[project.compile, project.test.prepare, project.test.resources])
-    compile.enhance { project.test.resources.invoke }
     project.path_to("src/test/java").tap { |dir| compile.from dir if File.exist?(dir) }
     compile.into project.path_to("target/test-classes")
     resources.filter.into compile.target
@@ -285,6 +304,11 @@ module Buildr
       project.test.junit.with project.test.compile.classpath
       # Tell the JUnit task where to pick the test cases from.
       project.test.junit.from project.test.compile.target
+      project.test.junit.options[:properties] ||= {}
+      project.test.junit.options.tap do |options|
+        options[:properties] ||= {}
+        options[:properties]["baseDir"] ||= project.test.compile.target.to_s
+      end
     end
   end
 
@@ -294,7 +318,8 @@ module Buildr
   rule /^test:.*$/ do |task|
     test = task.name.scan(/test:(.*)/)[0][0]
     Project.projects.select { |project| project.base_dir == Rake.application.original_dir }.
-      map { |project| project.test }.each { |task| task.include("*#{test}").invoke }
+      map { |project| project.test }.each { |task| task.junit.instance_eval { @include = ["*#{test}"] ; @exclude.clear } }.
+      each(&:invoke)
   end
 
   # Require tests after build unless TEST option is off.

data/lib/tasks/concat.rb

@@ -31,4 +31,5 @@ module Buildr
     file, deps = Rake.application.resolve_args(args)
     ConcatTask.define_task File.expand_path(file)=>deps
   end
+
 end

data/lib/tasks/zip.rb

@@ -78,15 +78,11 @@ module Buildr
 
       # Documented in ZipTask.
       def merge(*files)
-        if Hash === files.last
-          options = files.pop
-        else
-          options = {}
-        end
+        options = files.pop if Hash === files.last
 
-        if options[:path]
+        if options && options[:path]
           path(options[:path]).merge *files +[ options.reject { |k,v| k == :path } ]
-        elsif options.keys.empty?
+        elsif options.nil? || options.keys.empty?
           files.collect do |file|
             @sources << proc { file.to_s }
             expander = ZipExpander.new(file)