buildr 0.15.0 → 0.16.0

data/lib/core/transports.rb

@@ -1,5 +1,7 @@
+require "net/http"
 require "net/ssh"
 require "net/sftp"
+require "uri"
 require "uri/sftp"
 require "digest/md5"
 require "digest/sha1"

data/lib/java/compile.rb

@@ -100,7 +100,7 @@ module Buildr
             puts "All source files are up to date" if Rake.application.options.trace && !sources.empty?
           elsif target
             mkpath target, :verbose=>false
-            Java.javac files, :sourcepath=>sourcepath, :classpath=>classpath,
+            Java.javac files, :sourcepath=>sourcepath, :classpath=>real_classpath,
               :output=>target, :javac_args=>options.javac_args, :name=>task.name
             # By touching the target we let other tasks know we did something,
             # and also prevent recompiling again for classpath dependencies.
@@ -176,6 +176,10 @@ module Buildr
         @files && !@files.empty?
       end
 
+      def timestamp()
+        File.exist?(target) ? File.stat(target).mtime : Rake::EARLY
+      end
+
     protected
 
       # Returns the real classpath. Uses the values of #classpath, but resolves
@@ -295,20 +299,21 @@ module Buildr
   end
 
 
-  Project.on_create do |project|
+  Project.on_define do |project|
     # Prepare is prerequisite for compile, resources follows compile.
     project.compile.enhance([project.prepare]) { |task| project.resources.invoke }
     project.recursive_task("compile")
     task("build").enhance [ project.compile ]
     task("clean") { rm_rf project.path_to(:target_dir), :verbose=>false }
 
-    project.enhance do |project|
+    project.after_block do |project|
       # Automagic compilation only if the source directory exists.
       project.compile.sources << project.path_to(:java_src_dir) if File.exist?(project.path_to(:java_src_dir))
       project.compile.target ||= project.path_to(:java_target_dir)
       project.resources.include project.path_to(:resources_dir, "*") if File.exist?(project.path_to(:resources_dir))
       project.resources.target ||= project.compile.target
-      file(project.compile.target).enhance([ project.compile, project.resources ])
+      file(project.compile.target).enhance [ project.compile ]
+      file(project.resources.target).enhance [ project.resources ]
     end
 
   end

data/lib/java/java.rb

@@ -11,12 +11,12 @@ module Buildr
       name = options[:name] || "java #{args.first}"
       cmd_args = []
       classpath = classpath_from(options)
-      cmd_args << "-cp" << classpath unless classpath.empty?
+      cmd_args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
       cmd_args += options[:java_args].flatten if options[:java_args]
       cmd_args += args.flatten.compact
       cmd_args << { :verbose=>options[:verbose] }
       unless options[:noop]
-        verbose { puts "Running #{name}" }
+        puts "Running #{name}" if verbose
         sh(path_to_bin("java"), *cmd_args) { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok }
       end
     end
@@ -24,7 +24,7 @@ module Buildr
     def self.apt(*args)
       options = Hash === args.last ? args.pop : {}
       options[:verbose] ||= Rake.application.options.trace || false
-      fu_check_options options, :verbose, :noop, :compile, :source, :output, :cp, :classpath, :sourcepath
+      fu_check_options options, :verbose, :noop, :compile, :source, :output, :cp, :classpath
 
       files = args.collect { |arg| File.directory?(arg) ? FileList[File.join(arg, "**", "*.java")] : arg }.flatten
       args = [ options[:verbose] ? "-verbose" : "-nowarn" ]
@@ -35,13 +35,11 @@ module Buildr
       end
       args << "-source" << options[:source] if options[:source]
       classpath = classpath_from(options)
-      args << "-cp" << classpath unless classpath.empty?
-      sourcepath = (options[:sourcepath] || []).collect.join(File::PATH_SEPARATOR)
-      args << "-sourcepath" << sourcepath unless sourcepath.empty?
+      args << "-cp" << classpath.join(File::PATH_SEPARATOR) unless classpath.empty?
       args += files
       args << { :verbose=>options[:verbose] }
       unless options[:noop]
-        verbose { puts "Running apt" }
+        puts "Running apt" if verbose
         sh(path_to_bin("apt"), *args) { |ok, res| fail "Failed to execute apt, see errors above" unless ok }
       end
     end
@@ -84,14 +82,14 @@ module Buildr
       cmd_args = []
       classpath = classpath_from(options)
       #classpath += options[:output] if options[:output]
-      cmd_args << "-cp" << classpath unless classpath.empty?
+      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] if options[:output]
       cmd_args += options[:javac_args].flatten if options[:javac_args]
       cmd_args += files
       cmd_args << { :verbose=>options[:verbose] }
       unless options[:noop] || files.empty?
-        verbose { puts "Compiling #{files.size} source files in #{name}" }
+        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 }
       end
     end
@@ -104,8 +102,7 @@ module Buildr
 
     def self.classpath_from(options)
       classpath = (options[:classpath] || []).collect | (options[:cp] || []).collect
-      artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.
-        map(&:to_s).join(File::PATH_SEPARATOR)
+      artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
     end
 
   end

data/lib/java/openjpa.rb

@@ -21,7 +21,8 @@ module Buildr
       fu_check_options options, *OPTIONS + [:output]
 
       runtool options.merge(:class=>"org.apache.openjpa.enhance.PCEnhancer", :name=>"Enhancer",
-        :args=>{ "-p"=>options[:properties], "-d"=>options[:output] })
+        :args=>{ "-p"=>options[:properties], "-d"=>options[:output] },
+        :classpath=>options[:classpath] + [options[:output]])
     end
 
     def self.mapping_tool(options)

data/lib/java/packaging.rb

@@ -80,17 +80,6 @@ module Buildr
   end
 
 
-  # Global task packages all projects.
-  desc "Package all projects"
-  LocalDirectoryTask.define_task "package"
-  desc "Install packages created by this project"
-  LocalDirectoryTask.define_task "install"
-  desc "Uninstall packages created by this project"
-  LocalDirectoryTask.define_task "uninstall"
-  desc "Deploy packages created by this project"
-  LocalDirectoryTask.define_task "deploy"
-
-
   class Project
 
     # Group used for packaging. Inherited from parent project.
@@ -98,6 +87,12 @@ module Buildr
     # Version used for packaging. Inherited from parent project.
     inherited_attr :version
 
+    # The project ID is the project name, and for a sub-project the
+    # parent project ID followed by the project name, separated with a
+    # hyphen. For example, "foo" and "foo-bar".
+    def id()
+      name.gsub(":", "-")
+    end
     inherited_attr :webapp_src_dir do File.join(src_dir, "main", "webapp") end
 
     def package(*args)
@@ -106,7 +101,7 @@ module Buildr
       else
         options = {}
       end
-      options[:type] = args.shift if Symbol === args.first
+      options[:type] = args.shift.to_s if Symbol === args.first
       fail "No packaging type specified" unless options[:type]
       options[:group] ||= self.group
       options[:version] ||= self.version
@@ -133,15 +128,15 @@ module Buildr
 
       task "uninstall" do |task|
         verbose(Rake.application.options.trace) do
-          rm repositories.locate(package)
-          rm repositories.locate(package.pom)
+          [ package, package.pom ].map { |artifact| repositories.locate(artifact) }.
+            each { |file| rm file if File.exist?(file) } 
         end
       end
 
       task("deploy") { deploy(package, package.pom) }
 
       packages << package
-      Artifact.register package
+      Artifact.register package, package.pom
       package
     end
 
@@ -202,16 +197,4 @@ module Buildr
   end
 
 
-  Project.on_create do |project|
-    # Recursive tasks must be defined in before_create.
-    desc "Create packages in this project"
-    project.recursive_task "package"=>"build"
-    desc "Install packages created by this project"
-    project.recursive_task "install"=>"package"
-    desc "Uninstall packages created by this project"
-    project.recursive_task "uninstall"
-    desc "Deploy packages created by this project"
-    project.recursive_task "deploy"=>"package"
-  end
-
 end

data/lib/java/test.rb

@@ -0,0 +1,105 @@
+module Buildr
+
+  class JUnitTask < Rake::Task
+
+    attr_accessor :base_dir
+    attr_accessor :target
+    attr_accessor :classpath
+
+    def initialize(*args)
+      super
+      @classpath = []
+      enhance do |task|
+        test_cases.each do |test|
+          Dir.chdir base_dir
+          java "junit.textui.TestRunner", test, :classpath=>real_classpath, :name=>"tests in #{test}"
+        end
+      end
+    end
+
+    def test_cases()
+      target = File.expand_path(self.target)
+      return [] unless File.exist?(target)
+      prefix = Regexp.new("^" + Regexp.escape(target) + "/")
+      FileList[File.join(target, "**", "*Test.class")].
+        map { |path| path.sub(prefix, "").ext("").gsub(File::SEPARATOR, ".") }.sort
+    end
+
+    def real_classpath()
+      @real_classpath ||= artifacts(@classpath).map(&:to_s)
+    end
+
+  end
+
+  class Tests
+    def prepare(*tasks, &block)
+      returning(@prepare_task ||= task("prepare")) { |task| task.enhance tasks, &block }
+    end
+
+    def compile(*sources, &block)
+      unless @compile_task
+        @compile_task = Java::CompileTask.define_task("compile"=>prepare) { |task| resources.invoke }
+      end
+      returning(@compile_task) { |task| task.sources |= sources ; task.enhance &block }
+    end
+
+    def resources(*tasks, &block)
+      returning(@resources_task ||= Filter.define_task("resources")) { |task| task.enhance tasks, &block }
+    end
+
+    def junit(*tasks, &block)
+      unless @junit_task
+        @junit_task = JUnitTask.define_task("junit"=>compile)
+      end
+      returning(@junit_task) { |task| task.enhance tasks, &block }
+    end
+  end
+
+  class Project
+    inherited_attr :test_src_dir do File.join(src_dir, "test", "java") end
+    inherited_attr :test_resources_dir do File.join(src_dir, "test", "resources") end
+    inherited_attr :test_target_dir do File.join(target_dir, "test-classes") end
+
+    def tests()
+      @tests ||= Tests.new
+    end
+
+    def test(*tasks, &block)
+      @tests.junit *tasks, &block
+    end
+  end
+      
+  # Global task compiles all projects.
+  desc "Run all test cases"
+  LocalDirectoryTask.define_task "test"
+
+  Project.on_define do |project|
+    tests = nil
+    namespace "test" do
+      tests = project.tests
+    #tests.compile.enhance([tests.prepare]) { |task| tests.resources.invoke }
+      tests.compile.classpath += [ "junit:junit:jar:3.8.1", "jmock:jmock:jar:1.1.0" ]
+      tests.junit
+    end
+    tests.compile.enhance [ project.compile ]
+    project.recursive_task("test"=>project.test)
+
+    #project.recursive_task("compile")
+    #task("build").enhance [ project.compile ]
+    #task("clean") { rm_rf project.path_to(:target_dir), :verbose=>false }
+
+    project.after_block do |project|
+      tests.compile.sources << project.path_to(:test_src_dir) if File.exist?(project.path_to(:test_src_dir))
+      tests.compile.target ||= project.path_to(:test_target_dir)
+      tests.compile.classpath << project.compile.target
+      tests.resources.include project.path_to(:test_resources_dir, "*") if File.exists?(project.path_to(:test_resources_dir))
+      tests.resources.target ||= tests.compile.target
+      tests.junit.target = tests.compile.target
+      tests.junit.classpath += tests.compile.classpath
+      tests.junit.classpath += [ tests.compile.target, project.compile.target ]
+      tests.junit.base_dir = project.base_dir
+      file(tests.compile.target).enhance [ tests.compile ]
+      file(tests.resources.target).enhance [ tests.resources ]
+    end
+  end
+end

data/lib/tasks/zip.rb

@@ -9,11 +9,136 @@ module Buildr
   # directories.
   class ZipTask < Rake::FileTask
 
+    # :nodoc:
+    module IncludeFiles
+
+      # Include the specified files or directories.
+      def include(*files)
+        if Hash === files.last
+          options = files.pop
+        else
+          options = {}
+        end
+
+        if options[:path]
+          path(options[:path]).include *files +[ options.reject { |k,v| k == :path } ]
+        elsif options[:as]
+          raise "You can only use the :as option in combination with the :path option" unless options.keys.size == 1
+          raise "You can only use one file with the :as option" unless files.size == 1
+          include_as(files.first, options[:as])
+        elsif options[:merge]
+          raise "You can only use the :merge option in combination with the :path option" unless options.keys.size == 1
+          files.each { |file| merge file }
+        elsif options.keys.empty?
+          (@files ||= FileList[]).include *files
+        else
+          raise "Unrecognized option #{options.keys.join(", ")}"
+        end
+        self
+      end
+
+      # Exclude the specified file or directories.
+      def exclude(*files)
+        (@files ||= FileList[]).exclude *files
+        self
+      end
+      alias :add :include
+
+      def merge(*files)
+        if Hash === files.last
+          options = files.pop
+        else
+          options = {}
+        end
+
+        if options[:path]
+          path(options[:path]).merge *files +[ options.reject { |k,v| k == :path } ]
+        elsif options.keys.empty?
+          files.collect do |file|
+            @expand_sources << proc { artifacts(file).map(&:to_s) }
+            expander = ZipExpander.new(file)
+            @add_files << proc { |zip| expander.expand(zip, @path) }
+            expander
+          end.first
+        else
+          raise "Unrecognized option #{options.keys.join(", ")}"
+        end
+      end
+
+    protected
+
+      def setup_path(path = nil)
+        @path = "#{path}/" if path
+        expand_src = proc { artifacts(*@files || []).map(&:to_s) }
+        @expand_sources = [ expand_src ]
+        @add_files = [] << proc do |zip|
+          expand_src.call.each do |file|
+            if File.directory?(file)
+              in_directory(file, @files) do |file, rel_path|
+                puts "Adding #{@path}#{rel_path}" if Rake.application.options.trace
+                zip.add "#{@path}#{rel_path}", file
+              end
+            else
+              puts "Adding #{@path}#{File.basename(file)}" if Rake.application.options.trace
+              zip.add "#{@path}#{File.basename(file)}", file
+            end
+          end
+        end
+      end
+
+      def include_as(source, as)
+        @expand_sources << proc { artifacts(source).map(&:to_s) }
+        @add_files << proc do |zip|
+          file = artifacts(source).first.to_s
+          if File.directory?(file)
+            in_directory(file) do |file, rel_path|
+              puts "Adding #{@path}#{as}/#{rel_path}" if Rake.application.options.trace
+              zip.add file, "#{@path}#{as}/#{rel_path}"
+            end
+          else
+            puts "Adding #{@path}#{as}" if Rake.application.options.trace
+            zip.add "#{@path}#{as}", file
+          end
+        end
+      end
+
+      def in_directory(dir, excludes = nil)
+        prefix = Regexp.new("^" + Regexp.escape(File.dirname(dir) + File::SEPARATOR))
+        Dir[File.join(dir, "**", "*")].
+          reject { |file| File.directory?(file) || (excludes && excludes.exclude?(file)) }.
+          each { |file| yield file, file.sub(prefix, "") }
+      end
+
+      def expand_sources()
+        @expand_sources.map(&:call).flatten
+      end
+
+      def add_file(zip)
+        @add_files.each { |action| action.call zip }
+      end
+
+    end
+
+
+    # Which files go where.
+    class Path
+
+      include IncludeFiles
+      
+      def initialize(path)
+        setup_path path
+      end
+  
+    end
+
+    include IncludeFiles
+
     def initialize(*args)
       super
-      @paths = {}
+      @paths = { nil=>self }
+      setup_path
       enhance do |task|
-        verbose { puts "Creating #{task.name}" }
+        puts "Creating #{task.name}" if verbose
         # We're here because the Zip file does not exist, or one of the files is
         # newer than the Zip contents; in the later case, opening the Zip file
         # will add to its contents instead of replacing it, so we want the Zip
@@ -29,38 +154,50 @@ module Buildr
       end
     end
 
-    # Include the specified files and directories. Returns self.
-    #
-    # You can specify a path for inclusion by passing :path=> as the
-    # last argument. For example:
-    #   task.include "src"  # Include the src directory
-    #   task.include foobar, :path=>"libs"  # Include under /libs/
-    def include(*files)
-      if Hash === files.last
-        path = files.pop[:path]
+
+    class ZipExpander
+
+      def initialize(zip_file)
+        @zip_file = zip_file
       end
-      (@paths[path] ||= FileList[]).include *files
-      self
-    end
-    alias :add :include
 
-    # Excludes the specified files and directories. Returns self. Use this
-    # in combination with include; make sure to use the same path.
-    def exclude(*files)
-      if Hash === files.last
-        path = files.pop[:path]
+      def include(*files)
+        (@includes ||= [])
+        @includes |= files
+        self
       end
-      (@paths[path] ||= FileList[]).exclude *files
-      self
+
+      def exclude(*files)
+        (@excludes ||= []) 
+        @excludes |= files
+        self
+      end
+
+      def expand(zip, path)
+        @includes ||= ["*"]
+        @excludes ||= []
+        Zip::ZipFile.open(artifacts(@zip_file).map(&:to_s).first) do |source|
+          source.entries.reject { |entry| entry.directory? }.each do |entry|
+            if @includes.any? { |pattern| File.fnmatch(pattern, entry.name) } &&
+               !@excludes.any? { |pattern| File.fnmatch(pattern, entry.name) }
+              puts "Adding #{path}#{entry.name}" if Rake.application.options.trace
+              zip.get_output_stream("#{path}#{entry.name}") { |output| output.write source.read(entry) }
+              # TODO: read and write file
+            end
+          end
+        end
+      end
+
     end
 
+
     # Returns a path to which you can include/exclude files.
     #
     #   zip(..).include("foo", :path=>"bar")
     # is equivalen to:
     #   zip(..).path("bar").include("foo")
     def path(path)
-      @paths[path] ||= FileList[]
+      path.blank? ? @paths[nil] : (@paths[path] ||= Path.new(path))
     end
 
     # Pass options to the task. Returns self.
@@ -77,34 +214,31 @@ module Buildr
     
     def invoke_prerequisites()
       super
-      @paths.each { |p, files| artifacts(*files).each { |f| file(f).invoke } }
+      @paths.collect { |name, path| path.expand_sources }.flatten.each { |src| file(src).invoke }
     end
 
     def needed?()
+      return true unless File.exist?(name)
       # You can do something like:
       #   include("foo", :path=>"foo").exclude("foo/bar", path=>"foo").
       #     include("foo/bar", :path=>"foo/bar")
       # This will play havoc if we handled all the prerequisites together
       # under the task, so instead we handle them individually for each path.
-      #@paths.collect{ |p, files| files }.flatten.each { |f| file(f).invoke }
-      return true unless File.exist?(name)
+      #
       # We need to check that any file we include is not newer than the
       # contents of the ZIP. The file itself but also the directory it's
       # coming from, since some tasks touch the directory, e.g. when the
       # content of target/classes is included into a WAR.
-      files = @paths.collect { |path, files| files.map(&:to_s) }.flatten
-      files = files.collect { |f| File.directory?(f) ? FileList[File.join(f, "**", "*")].collect | [f] : f }.flatten
-      most_recent = files.select { |f| File.exist?(f) }.collect { |f| File.stat(f).mtime }.max
+      most_recent = @paths.collect { |name, path| path.expand_sources }.flatten.
+        each { |src| File.directory?(src) ? FileList[File.join(src, "**", "*")] | [src] : src }.flatten.
+        select { |file| File.exist?(file) }.collect { |file| File.stat(file).mtime }.max
       File.stat(name).mtime < (most_recent || Rake::EARLY)
     end
 
   protected
 
     def create(zip)
-      zip_map.keys.sort.each do |path|
-        puts "Adding #{path}" if Rake.application.options.trace
-        zip.add path, zip_map[path]
-      end
+      @paths.each { |name, obj| obj.add_file zip }
     end
 
     def zip_map()
@@ -244,9 +378,10 @@ module Buildr
     end
 
     def needed?()
-      return true unless target && File.exist?(target)
-      return true if prerequisites.any? { |prereq| File.stat(prereq).mtime > File.stat(target).mtime }
-      false
+      #return true unless target && File.exist?(target)
+      #return true if prerequisites.any? { |prereq| File.stat(prereq).mtime > File.stat(target).mtime }
+      #false
+      true
     end
 
     # :nodoc: