buildr 1.2.2 → 1.2.3

data/CHANGELOG

@@ -1,3 +1,10 @@
+1.2.3 (7/26/2007)
+* Added: Get your buildfile created form existing POM, just run buildr on existing Maven project (Anatol Pomozov). 
+* Added: package(:tar), package(:tgz), TarballTask dn TarTask (Tommy Knowlton).
+* Changed: The ArchiveTask needs no introduction: it's a base task that provides common functionality for ZipTask, TarTask and friends. 
+* Fixed: Release runs buildr instead of buildr.cmd on Windows (Chris Power).
+* Fixed: Cobertura reports broken (Anatol Pomozov).
+
 1.2.2 (7/18/2007)
 * Added: resources.using and filter.using now accepts a format as the first argument, default being :maven, but you can also use :ant, :ruby or pass a regular expression (http://groups.google.com/group/buildr-talk/browse_thread/thread/5216d5ae8bfff29b).
 * Fixed: Sleek upload with changelog for each release courtesy of Anatol Pomozov.

data/Rakefile

@@ -26,16 +26,18 @@ spec = Gem::Specification.new do |spec|
   spec.executables = ["buildr"]
 
   # Tested against these dependencies.
-  spec.add_dependency "rake",     "= 0.7.3"
-  spec.add_dependency "facets",   "= 1.8.54"
-  spec.add_dependency "builder",  "= 2.1.2"
-  spec.add_dependency "net-ssh",  "= 1.1.2"
-  spec.add_dependency "net-sftp", "= 1.1.0"
-  spec.add_dependency "rubyzip",  "= 0.9.1"
-  spec.add_dependency "highline", "= 1.2.9"
-  spec.add_dependency "rjb",      "= 1.0.6"
-  spec.add_dependency "Antwrap",  "= 0.6.0"
-  spec.add_dependency "rspec",    "= 1.0.5"
+  spec.add_dependency "rake",                 "= 0.7.3"
+  spec.add_dependency "facets",               "= 1.8.54"
+  spec.add_dependency "builder",              "= 2.1.2"
+  spec.add_dependency "net-ssh",              "= 1.1.2"
+  spec.add_dependency "net-sftp",             "= 1.1.0"
+  spec.add_dependency "rubyzip",              "= 0.9.1"
+  spec.add_dependency "highline",             "= 1.2.9"
+  spec.add_dependency "rjb",                  "= 1.0.6"
+  spec.add_dependency "Antwrap",              "= 0.6.0"
+  spec.add_dependency "rspec",                "= 1.0.5"
+  spec.add_dependency "xml-simple",           "= 1.0.11"
+  spec.add_dependency "archive-tar-minitar",  "= 0.5.1"
 end
 
 

data/lib/buildr.rb

@@ -18,12 +18,13 @@ require "facet/array/head"
 require "facet/string/starts_with"
 require "facet/openobject"
 require "facets/core/kernel/tap"
+require "facets/core/enumerable/uniq_by"
 # A different kind of buildr, one we use to create XML.
 require "builder"
 
 
 module Buildr
-  VERSION = "1.2.2".freeze
+  VERSION = "1.2.3".freeze
 end
 
 
@@ -118,9 +119,7 @@ unless defined?(Rake)
           if Dir.pwd == here || options.nosearch
             error = "No Buildfile found (looking for: #{@rakefiles.join(', ')})"
             if STDIN.isatty
-              if $terminal.agree("To use Buildr you need a buildfile. Do you want me to create one? (yes/no)")
-                chdir(original_dir) { task("generate").invoke }
-              end
+              chdir(original_dir) { task("generate").invoke }
               exit 1
             else
               raise error

data/lib/buildr/cobertura.rb

@@ -51,11 +51,10 @@ module Buildr
       desc "Run the test cases and produce code coverage reports in #{report_to(:html)}"
       task "html"=>["instrument", "test:all"] do
         puts "Creating test coverage reports in #{report_to(:html)}"
-        projects = Buildr.projects
         Buildr.ant "cobertura" do |ant|
           ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
           ant.send "cobertura-report", :destdir=>report_to(:html), :format=>"html", :datafile=>data_file do
-            ant.projects.map(&:compile).map(&:sources).flatten.each do |src|
+            Buildr.projects.map(&:compile).map(&:sources).flatten.each do |src|
               ant.fileset(:dir=>src.to_s) { ant.include :name=>"**/*.java" } if File.exist?(src.to_s)
             end
           end
@@ -65,11 +64,10 @@ module Buildr
       desc "Run the test cases and produce code coverage reports in #{report_to(:xml)}"
       task "xml"=>["instrument", "test:all"] do
         puts "Creating test coverage reports in #{report_to(:xml)}"
-        projects = Buildr.projects
         Buildr.ant "cobertura" do |ant|
           ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
           ant.send "cobertura-report", :destdir=>report_to(:xml), :format=>"xml", :datafile=>data_file do
-            ant.projects.map(&:compile).map(&:sources).flatten.each do |src|
+            Buildr.projects.map(&:compile).map(&:sources).flatten.each do |src|
               ant.fileset :dir=>src.to_s if File.exist?(src.to_s)
             end
           end

data/lib/core/build.rb

@@ -113,13 +113,17 @@ module Buildr
       # Make a release.
       def make()
         check
-        version = with_next_version { |filename, version| sh "buildr clean upload DEBUG=no --buildfile #{filename}" }
+        version = with_next_version { |filename, version| sh "#{command} clean upload DEBUG=no --buildfile #{filename}" }
         tag version
         commit version + "-SNAPSHOT"
       end
 
     protected
 
+      def command() #:nodoc:
+        Config::CONFIG["arch"] =~ /dos|win32/i ? $PROGRAM_NAME.ext("cmd") : $PROGRAM_NAME
+      end
+
       # :call-seq:
       #   check()
       #

data/lib/core/checks.rb

@@ -269,7 +269,7 @@ end
 
 
 module Buildr
-  class ZipTask
+  class ArchiveTask
 
     class Path
 
@@ -279,7 +279,7 @@ module Buildr
       # Returns true if this path exists. This only works if the path has any entries in it,
       # so exist on path happens to be the opposite of empty.
       def exist?()
-        !empty?
+        !entries.empty?
       end
 
       # :call-seq:
@@ -287,7 +287,7 @@ module Buildr
       #
       # Returns true if this path is empty (has no other entries inside).
       def empty?()
-        check { |entries| entries.empty? }
+        entries.all? { |entry| entry.empty? }
       end
 
       # :call-seq:
@@ -296,9 +296,7 @@ module Buildr
       # Returns true if this ZIP file path contains all the specified files. You can use relative
       # file names and glob patterns (using *, **, etc).
       def contain?(*files)
-        check do |entries|
-          files.all? { |file| entries.detect { |entry| File.fnmatch(file, entry.to_s) } }
-        end
+        files.all? { |file| entries.detect { |entry| File.fnmatch(file, entry.to_s) } }
       end
 
       # :call-seq:
@@ -308,21 +306,17 @@ module Buildr
       # for example:
       #   package(:jar).path("META-INF").entry("LICENSE").should contain(/Apache Software License/)
       def entry(name)
-        ::Zip::ZipEntry.new(root.name, "#{@path}#{name}")
+        root.entry("#{@path}#{name}")
       end
 
     protected
 
-      def check() #:nodoc:
-        unless @cached_entries
-          if @path
-            base = Regexp.new("^" + Regexp.escape(@path || ""))
-            @cached_entries = root.path(nil).check.select { |entry| entry.name =~ base }.map { |entry| entry.name.sub(base, "") }
-          else
-            @cached_entries = Zip::ZipFile.open(root.name) { |zip| zip.entries }
-          end
-        end
-        block_given? ? yield(@cached_entries) : @cached_entries
+      def entries() #:nodoc:
+        return root.entries unless @path
+        @entries ||= root.entries.inject([]) { |selected, entry|
+          selected << entry.name.sub(@path, "") if entry.name.starts_with?(@path)
+          selected
+        }
       end
 
     end
@@ -344,14 +338,23 @@ module Buildr
       path("").contain?(*files)
     end
 
+  end
+
+
+  class ZipTask
+
     # :call-seq:
     #   entry(name) => Entry
     #
     # Returns a ZIP file entry. You can use this to check if the entry exists and its contents,
     # for example:
     #   package(:jar).entry("META-INF/LICENSE").should contain(/Apache Software License/)
-    def entry(name)
-      path("").entry(name)
+    def entry(entry_name)
+      ::Zip::ZipEntry.new(name, entry_name)
+    end
+
+    def entries() #:nodoc:
+      @entries ||= Zip::ZipFile.open(name) { |zip| zip.entries }
     end
 
   end

data/lib/core/generate.rb

@@ -2,20 +2,33 @@ module Buildr
   module Generate #:nodoc:
 
     task "generate" do
-      script = Generate.from_directory(true).join("\n")
-      buildfile = File.expand_path("buildfile")
-      File.open(buildfile, "w") { |file| file.write script }
-      puts "Created #{buildfile}"
+      script = nil 
+      HighLine.new.choose do |menu|
+        menu.header = "To use Buildr you need a buildfile. Do you want me to create one?"
+
+        menu.choice("From maven2 pom file") { script = Generate.from_maven2_pom(true).join("\n") } if File.exists?("pom.xml")
+        menu.choice("From directory structure") { script = Generate.from_directory(true).join("\n") }
+        menu.choice("Skip") { }
+      end
+       
+      if script    
+        buildfile = File.expand_path("buildfile")
+        File.open(buildfile, "w") { |file| file.write script }
+        puts "Created #{buildfile}"
+      end        
     end
 
     class << self
 
+
+      HEADER = "# Generated by Buildr #{Buildr::VERSION}, change to your liking\n\n"
+
+
       def from_directory(root = false)
         name = File.basename(Dir.pwd)
         if root
+          script = HEADER.split("\n")
           header = <<-EOF
-# Generated by Buildr #{Buildr::VERSION}, change to your liking
-
 # Version number for this release
 VERSION_NUMBER = "1.0.0"
 # Version number for the next release
@@ -34,7 +47,7 @@ define "#{name}" do
   project.group = GROUP
   manifest["Implementation-Vendor"] = COPYRIGHT
 EOF
-          script = header.split("\n")
+          script += header.split("\n")
         else
           script = [ %{define "#{name}" do} ]
         end
@@ -59,7 +72,95 @@ EOF
         script.flatten
       end
 
-    end
+      def from_maven2_pom(root = false)
+        pom = Buildr::POM.load('pom.xml')
+        project = pom.project
+
+        artifactId = project['artifactId']
+        description = project['name'] || "The #{artifactId} project"
+
+        if root
+          script = HEADER.split("\n")
+
+          settings_file = ENV["m2_settings"] || File.join(Gem::user_home, ".m2/settings.xml")
+          settings = XmlSimple.xml_in(IO.read(settings_file)) if File.exists?(settings_file)
+
+          if settings
+            proxy = settings['proxies'].first['proxy'].find { |proxy|
+              proxy["active"].nil? || proxy["active"].to_s =~ /true/
+            } rescue nil
+            
+            if proxy
+              url = %{#{proxy["protocol"].first}://#{proxy["host"].first}:#{proxy["port"].first}}
+              exclude = proxy["nonProxyHosts"].to_s.gsub("|", ",") if proxy["nonProxyHosts"]
+              script << "options.proxy.http = '#{url}'"
+              script << "options.proxy.exclude << '#{exclude}'" if exclude
+              script << ''
+              # In addition, we need to use said proxies to download artifacts.
+              options.proxy.http = url
+              options.proxy.exclude << exclude if exclude
+            end
+          end
+
+          repositories = project["repositories"].first["repository"].select { |repository|
+            legacy = repository["layout"].to_s =~ /legacy/
+            !legacy
+          } rescue nil
+          unless repositories.nil? || repositories.empty?
+            repositories.each do |repository|
+              name, url = repository["name"], repository["url"]
+              script << "# #{name}"
+              script << "repositories.remote << '#{url}'"
+              # In addition we need to use said repositores to download artifacts.
+              Buildr.repositories.remote << url.to_s
+            end
+            script << ""
+          end
+        else
+          script = []
+        end
 
+        script << "desc '#{description}'"
+        script << "define '#{artifactId}' do"
+
+        groupId = project['groupId']
+        script << "  project.group = '#{groupId}'" if groupId
+
+        version = project['version']
+        script << "  project.version = '#{version}'" if version
+
+        #get plugins configurations
+        plugins = project['build'].first['plugins'].first['plugin'] rescue {}
+        compile_plugin = plugins.find{|pl| (pl['groupId'].nil? or pl['groupId'].first == 'org.apache.maven.plugins') and pl['artifactId'].first == 'maven-compiler-plugin'}
+        if compile_plugin
+          source = compile_plugin.first['configuration'].first['source'] rescue nil
+          target = compile_plugin.first['configuration'].first['target'] rescue nil
+
+          script << "  compile.options.source = '#{source}'" if source
+          script << "  compile.options.target = '#{target}'" if target
+        end
+
+        dependencies = pom.dependencies.map{|d| "'#{d}'"}.join(', ')
+        script <<  "  compile.with #{dependencies}" unless dependencies.empty?
+
+        test_dependencies = pom.dependencies(['test']).map{|d| "'#{d}'"}.join(', ')
+        script <<  "  test.compile.with #{test_dependencies}" unless test_dependencies.empty?
+
+        packaging = project['packaging'].first
+        if %w(jar war).include?(packaging)
+          script <<  "  package :#{packaging}, :id => '#{artifactId}'"
+        end
+
+        modules = project['modules'].first['module'] rescue nil
+        if modules
+          modules.each do |mod|
+            chdir(mod) { script << from_maven2_pom.flatten.map { |line| "  " + line } << "" }
+          end
+        end
+        script << "end"
+        script.flatten
+      end
+       
+    end
   end
 end 

data/lib/java/packaging.rb

@@ -4,6 +4,7 @@ require "java/java"
 require "java/compile"
 require "java/test"
 require "tasks/zip"
+require "tasks/tar"
 
 
 module Buildr
@@ -23,8 +24,6 @@ module Buildr
         protected
           def included(mod)
             mod.alias_method_chain :initialize, :manifest
-            mod.alias_method_chain :invoke_prerequisites, :manifest
-            mod.alias_method_chain :create, :manifest
           end
         end
 
@@ -34,42 +33,41 @@ module Buildr
         # Specifies files to include in the META-INF directory.
         attr_accessor :meta_inf
 
-      private
-
-        def invoke_prerequisites_with_manifest()
-          prerequisites << file(manifest.to_s) if String === manifest || Rake::Task === manifest
-          [meta_inf].flatten.each { |file| prerequisites << file(file.to_s) }
-          invoke_prerequisites_without_manifest
-        end
-
-        def initialize_with_manifest(*args)
+        def initialize_with_manifest(*args) #:nodoc:
+          initialize_without_manifest *args
           @manifest = false
           @meta_inf = []
-          initialize_without_manifest *args
-        end
 
-        def create_with_manifest(zip) #:nodoc:
-          [meta_inf].flatten.map(&:to_s).uniq.each { |file| zip.add "META-INF/#{File.basename(file)}", file }
-          unless manifest == false
-            zip.file.open("META-INF/MANIFEST.MF", "w") do |output|
-              output << MANIFEST_HEADER
-              if manifest
+          meta_inf_path = path("META-INF")
+          prepare do
+            @prerequisites << manifest if String === manifest || Rake::Task === manifest
+            [meta_inf].flatten.map { |file| file.to_s }.uniq.each { |file| meta_inf_path.include file }
+          end
+
+          enhance do
+            if manifest
+              # Tempfiles gets deleted on garbage collection, so we're going to hold on to it
+              # through instance variable not closure variable.
+              Tempfile.open "MANIFEST.MF" do |@manifest_tmp|
+                @manifest_tmp.write MANIFEST_HEADER
                 case manifest
                 when Hash
-                  output << manifest.map { |pair| pair.map(&:to_s).join(": ") }.sort.join("\n") << "\n"
+                  @manifest_tmp.write(manifest.map { |pair| pair.map{ |s| s.to_s }.join(": ") }.sort.join("\n") << "\n")
                 when Array
-                  output << manifest.reject { |section| section.empty? }.map { |section|
+                  @manifest_tmp.write(manifest.reject { |section| section.empty? }.map { |section|
                       section.map { |pair| pair.join(": ") }.sort.join("\n").concat("\n")
-                    }.join("\n") << "\n"
+                    }.join("\n") << "\n")
                 when Proc, Method
-                  output << manifest.call 
+                  @manifest_tmp.write manifest.call
                 when String, Rake::Task
-                  output << File.read(manifest.to_s)
+                  @manifest_tmp.write File.read(manifest.to_s)
+                else
+                  fail "Invalid manifest, expecting Hash, Array, file name/task or proc/method."
                 end
+                meta_inf_path.include @manifest_tmp.path, :as=>"MANIFEST.MF"
               end
             end
           end
-          create_without_manifest zip
         end
 
       end
@@ -142,12 +140,10 @@ module Buildr
           super
           @classes = []
           @libs = []
-        end
-
-        def invoke_prerequisites() #:nodoc:
-          @classes.to_a.flatten.each { |classes| path("WEB-INF/classes").include classes, :as=>"." }
-          path("WEB-INF/lib").include Buildr.artifacts(@libs.to_a.flatten)
-          super
+          prepare do
+            @classes.to_a.flatten.each { |classes| path("WEB-INF/classes").include classes, :as=>"." }
+            path("WEB-INF/lib").include Buildr.artifacts(@libs) unless @libs.nil? || @libs.empty?
+          end
         end
 
         def libs=(value) #:nodoc:
@@ -157,7 +153,7 @@ module Buildr
         def classes=(value) #:nodoc:
           @classes |= [value].flatten.map { |dir| file(dir.to_s) }
         end
-
+  
       end
 
     end
@@ -415,6 +411,20 @@ module Buildr
       file(file_name)
     end
 
+    def package_as_tar(file_name, options) #:nodoc:
+      unless Rake::Task.task_defined?(file_name)
+        TarballTask.define_task(file_name).with(options)
+      end
+      file(file_name)
+    end
+
+    def package_as_tgz(file_name, options) #:nodoc:
+      unless Rake::Task.task_defined?(file_name)
+        TarballTask.define_task(file_name).with(options)
+      end
+      file(file_name)
+    end
+
     def package_as_sources(file_name, options) #:nodoc:
       rake_check_options options, *PACKAGE_OPTIONS
       options.merge!(:type=>:zip, :classifier=>"sources")

data/lib/java/pom.rb

@@ -0,0 +1,157 @@
+require "xmlsimple"
+require "java/artifact"
+
+
+module Buildr
+  class POM
+
+    POM_TO_SPEC_MAP = { :group=>"groupId", :id=>"artifactId", :type=>"type",
+      :version=>"version", :classifier=>"classifier", :scope=>"scope" }
+    SCOPES_TRANSITIVE = [nil, "compile", "runtime"]
+    SCOPES_WE_USE = SCOPES_TRANSITIVE + ["provided"]
+
+    # POM project as Hash (using XmlSimple).
+    attr_reader :project
+    # Parent POM if referenced by this POM.
+    attr_reader :parent
+
+    class << self
+      
+      # :call-seq:
+      #   POM.load(arg)
+      #
+      # Load new POM object form various kind of sources such as artifact, hash representing spec, filename, XML.
+      def load(source)
+        case source
+        when Hash
+          load(Buildr.artifact(source).pom)
+        when Artifact
+          load(source.pom.to_s)
+        when String, Rake::FileTask
+          filename = File.expand_path(source)
+          file(filename).invoke
+          unless pom = cache[filename]
+            puts "Loading m2 pom file from #{filename}" if Rake.application.options.trace
+            pom = POM.new(IO.read(filename))
+            cache[filename] = pom
+          end
+          pom
+        else
+          raise ArgumentError, "Expecting Hash spec, Artifact, file name or file task"
+        end
+      end
+
+    private
+
+      def cache()
+        @cache ||= {}
+      end
+
+    end
+
+    def initialize(xml) #:nodoc:
+      @project = XmlSimple.xml_in(xml)
+      @parent = POM.load(pom_to_hash(project["parent"].first)) if project["parent"]
+    end
+
+    # :call-seq:
+    #   dependencies(scopes?) => artifacts
+    #
+    # Returns list of required dependencies as specified by the POM. You can specify which scopes
+    # to use (e.g. "compile", "runtime"); use +nil+ for dependencies with unspecified scope.
+    # The default scopes are +nil+, "compile" and "runtime" (aka SCOPES_WE_USE).
+    def dependencies(scopes = SCOPES_WE_USE)
+      #try to cache dependencies also
+      @depends_for_scopes ||= {}
+      unless depends = @depends_for_scopes[scopes]
+        declared = project["dependencies"].first["dependency"] rescue nil
+        depends = (declared || []).reject { |dep| value_of(dep["optional"]) =~ /true/ }.
+          map { |dep| 
+            spec = pom_to_hash(dep, properties) 
+            apply = managed(spec)
+            spec = apply.merge(spec) if apply
+
+            #calculate transitive dependencies
+            if scopes.include?(spec[:scope])
+              spec.delete(:scope)
+
+              exclusions = dep["exclusions"]["exclusion"] rescue nil
+              transitive_deps = POM.load(spec).dependencies(SCOPES_TRANSITIVE)
+              transitive_deps = transitive_deps.reject{|dep| 
+                exclusions.find {|ex| dep.index("#{dep['groupdId'].first}:#{dep['artifactId'].first}:") == 0}
+              } if exclusions
+
+              [Artifact.to_spec(spec.except(:scope))] + transitive_deps
+            else
+              nil
+            end
+          }.flatten.compact.uniq_by{|spec| art = spec.split(':'); "#{art[0]}:#{art[1]}"}
+
+        @depends_for_scopes[scopes] = depends
+      end
+      depends
+    end
+
+    # :call-seq:
+    #   properties() => hash
+    #
+    # Returns properties available to this POM as hash. Includes explicit properties and pom.xxx/project.xxx
+    # properties for groupId, artifactId, version and packaging.
+    def properties()
+      @properties ||= begin
+        pom = ["groupId", "artifactId", "version", "packaging"].inject({}) { |hash, key|
+          value = project[key] || (parent ? parent.project[key] : nil)
+          hash["pom.#{key}"] = hash["project.#{key}"] = value_of(value) if value
+          hash
+        }
+        props = project["properties"].first rescue {}
+        props = props.inject({}) { |mapped, pair| mapped[pair.first] = value_of(pair.last, pom) ; mapped }
+        (parent ? parent.properties.merge(props) : props).merge(pom)
+      end
+    end
+
+    # :call-seq:
+    #    managed() => hash
+    #    managed(hash) => hash
+    #
+    # The first form returns all the managed dependencies specified by this POM in dependencyManagement.
+    # The second form uses a single spec hash and expands it from the current/parent POM. Used to determine
+    # the version number if specified in dependencyManagement instead of dependencies.
+    def managed(spec = nil)
+      return managed.detect { |dep| [:group, :id, :type, :classifier].all? { |key| spec[key] == dep[key] } } ||
+        (parent ? parent.managed(spec) : nil) if spec
+      @managed ||= begin
+        managed = project["dependencyManagement"].first["dependencies"].first["dependency"] rescue []
+        managed.map { |dep| pom_to_hash(dep, properties) } 
+      end
+    end
+
+  private
+
+    # :call-seq:
+    #    value_of(element) => string
+    #    value_of(element, true) => string
+    #
+    # Returns the normalized text value of an element from its XmlSimple value. The second form performs
+    # property substitution.
+    def value_of(element, substitute = nil)
+      value = element.to_a.join.strip
+      substitute ? value.gsub(/\$\{([^}]+)\}/) { |key| substitute[$1] } : value
+    end
+
+    # :call-seq:
+    #    pom_to_hash(element) => hash
+    #    pom_to_hash(element, true) => hash
+    #
+    # Return the spec hash from an XmlSimple POM referencing element (e.g. project, parent, dependency).
+    # The second form performs property substitution.
+    def pom_to_hash(element, substitute = nil)
+      hash = POM_TO_SPEC_MAP.inject({}) { |spec, pair|
+        spec[pair.first] = value_of(element[pair.last], substitute) if element[pair.last]
+        spec
+      }
+      { :type=>"jar" }.merge(hash)
+    end
+
+  end
+end

data/lib/tasks/tar.rb

@@ -0,0 +1,112 @@
+require 'buildr'
+require 'archive/tar/minitar'
+
+module Buildr
+  class TarTask < Rake::FileTask
+
+    attr_reader :included
+
+    def initialize(*args)
+      super
+      @included = {}
+      enhance do
+        $stdout << "Creating #{t.name}.\n" if verbose
+        rm(name, :verbose=>false) rescue nil
+        mkdir_p(File.dirname(name), :verbose=>false)
+        begin
+          out = File.new(name, "w+")
+          out = Zlib::GzipWriter.new(out) if (/.tgz$/ =~ name)
+          create_tar_internal(out)
+        rescue
+          rm(name, :verbose=>false) rescue nil
+          raise
+        end
+      end
+    end
+
+    def with(options)
+      options.each do |k,v|
+        send "#{k}=", v
+      end
+    end
+
+    def include(*args)
+      options = (Hash === args.last) ? args.pop : {}
+      args = args.flatten
+      options[:path] ||= "/"
+      check_add_path_internal options
+      if options[:as]
+        raise "Only use :as with one include file at a time" if args.length > 1
+        dest_file = File.join(options[:path], options[:as])
+        include_internal(dest_file, args.pop, options)
+      else
+        args.each do |f|
+          dest_file = File.join(options[:path], File.basename(f.to_s))
+          include_internal(dest_file, f, options)
+        end
+      end
+    end
+
+  private
+
+    def check_add_path_internal(opts)
+      unless @included.has_key?(opts[:path])
+        include_internal(opts[:path], :mkdir_in_tar, opts)
+      end
+    end
+
+    def include_internal(dst, src, opts)
+      raise %Q("#{dst}" was already included in the archive with source path "#{@included[dst][:source_path]}".) if @included[dst]
+      @included[dst] = opts.merge({:source_path => src})
+      enhance([src]) unless :mkdir_in_tar == src
+    end
+
+    def create_tar_internal(out)
+      begin
+        Archive::Tar::Minitar::Writer.open(out) do |tar|
+          @included.keys.sort.each do |dst|
+            opts = @included[dst]
+            src = opts[:source_path]
+            if :mkdir_in_tar == src
+              $stdout << "adding directory #{dst}.\n" if verbose
+              tar.mkdir(dst, {:mode=>"0755", :mtime=>Time.now}.merge(opts.reject{|k,v| not [:mode, :uid, :gid, :mtime].include?(k)}))
+            else
+              $stdout << "adding #{dst} from #{src}\n" if verbose
+              is = File.new(src, "rb")
+              opts[:size] = is.stat.size
+              opts[:mode] ||= is.stat.mode
+              opts[:mtime] ||= is.stat.mtime
+              opts[:uid] ||= 80
+              opts[:gid] ||= 80
+              tar.add_file_simple(dst, opts.reject{|k,v| not [:size, :mode, :uid, :gid, :mtime].include?(k)}) do |os|
+                while data = is.read(4096)
+                  os.write(data)
+                  $stdout << "." if verbose
+                end
+              end
+              $stdout << "\n" if verbose
+            end
+          end
+        end
+      ensure out.close
+      end
+    end
+  end
+
+  class TarballTask < TarTask
+
+    def initialize(*args)
+      super
+    end
+
+    def include(*args)
+      options = (Hash === args.last) ? args.pop : {}
+      args = args.flatten
+      options[:path] ||= "/"
+      options[:path] = File.join(name.pathmap("%n"), options[:path])
+      super args, options
+    end
+
+  end
+
+end

data/lib/tasks/zip.rb

@@ -4,69 +4,67 @@ require "zip/zipfilesystem"
 
 module Buildr
 
-  # The ZipTask creates a new ZIP file. You can include any number of files and
-  # and directories, use exclusion patterns, and include files into specific
-  # directories.
-  #
-  # For example:
-  #   zip("test.zip").tap do |task|
-  #     task.include "srcs"
-  #     task.include "README", "LICENSE"
-  #   end
-  #
-  # See Buildr#zip.
-  class ZipTask < Rake::FileTask
+  # Base class for ZipTask, TarTask and other archives.
+  class ArchiveTask < Rake::FileTask
 
     # Which files go where. All the rules for including, excluding and merging files
-    # are handled by this object. A zip has at least one path.
+    # are handled by this object.
     class Path #:nodoc:
 
-      attr_reader :actions
+      # Returns the archive from this path.
+      attr_reader :root
       
-      def initialize(zip, path)
-        @zip = zip
+      def initialize(root, path)
+        @root = root
         @path = "#{path}/" if path
-        expand_src = proc { (@files || []).map(&:to_s).uniq }
+        @files = FileList[]
+        # Expand source files added to this path.
+        expand_src = proc { @files.map{ |file| file.to_s }.uniq }
         @sources = [ expand_src ]
-        @actions = [] << proc do |zip|
+        # Add files and directories added to this path.
+        @actions = [] << proc do |file_map|
+          file_map[@path] = nil if @path
           expand_src.call.each do |path|
             if File.directory?(path)
               in_directory(path, @files) do |file, rel_path|
-                puts "Adding #{@path}#{rel_path}" if Rake.application.options.trace
-                zip.add("#{@path}#{rel_path}", file) { true }
+                dest = "#{@path}#{rel_path}"
+                puts "Adding #{dest}" if Rake.application.options.trace
+                file_map[dest] = file
               end
             else
               puts "Adding #{@path}#{File.basename(path)}" if Rake.application.options.trace
-              zip.add("#{@path}#{File.basename(path)}", path) { true }
+              file_map["#{@path}#{File.basename(path)}"] = path
             end
           end
         end
       end
 
-      # Documented in ZipTask.
-      def include(*files)
-        if Hash === files.last
-          options = files.pop
-        else
-          options = {}
-        end
-        files = files.flatten
-
-        if options[:path]
-          path(options[:path]).include *files +[ options.reject { |k,v| k == :path } ]
+      # :call-seq:
+      #   include(*files) => self
+      #   include(*files, :path=>path) => self
+      #   include(file, :as=>name) => self
+      #   include(:from=>path) => self
+      #   include(*files, :merge=>true) => self
+      def include(*args)
+        options = args.pop if Hash === args.last
+        files = args.flatten
+
+        if options.nil? || options.empty?
+          @files.include *files.map { |file| file.to_s }
+        elsif options[:path]
+          sans_path = options.reject { |k,v| k == :path }
+          path(options[:path]).include *files + [sans_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 the :as option in combination with the :path option" unless options.size == 1
           raise "You can only use one file with the :as option" unless files.size == 1
-          include_as(files.first.to_s, options[:as])
+          include_as files.first.to_s, options[:as]
         elsif options[:from]
-          raise "You can only use the :from option in combination with the :path option" unless options.keys.size == 1
+          raise "You can only use the :from option in combination with the :path option" unless options.size == 1
           raise "You canont use the :from option with file names" unless files.empty?
-          [options[:from]].flatten.each { |path| include_as(path.to_s, ".") }
+          [options[:from]].flatten.each { |path| include_as path.to_s, "." }
         elsif options[:merge]
-          raise "You can only use the :merge option in combination with the :path option" unless options.keys.size == 1
+          raise "You can only use the :merge option in combination with the :path option" unless options.size == 1
           files.each { |file| merge file }
-        elsif options.keys.empty?
-          (@files ||= FileList[]).include files.map(&:to_s)
         else
           raise "Unrecognized option #{options.keys.join(", ")}"
         end
@@ -74,43 +72,48 @@ module Buildr
       end
       alias :add :include
 
-      # Documented in ZipTask.
+      # :call-seq:
+      #   exclude(*files) => self
       def exclude(*files)
-        (@files ||= FileList[]).exclude *files
+        @files.exclude *files
         self
       end
 
-      # Documented in ZipTask.
-      def merge(*files)
-        options = files.pop if Hash === files.last
+      # :call-seq:
+      #   merge(*files) => Merge
+      #   merge(*files, :path=>name) => Merge
+      def merge(*args)
+        options = args.pop if Hash === args.last
+        files = args.flatten
 
-        if options && options[:path]
-          path(options[:path]).merge *files +[ options.reject { |k,v| k == :path } ]
-        elsif options.nil? || options.keys.empty?
+        if options.nil? || options.empty?
           files.collect do |file|
             @sources << proc { file.to_s }
             expander = ZipExpander.new(file)
-            @actions << proc { |zip| expander.expand(zip, @path) }
+            @actions << proc { |file_map| expander.expand(file_map, @path) }
             expander
           end.first
+        elsif options[:path]
+          sans_path = options.reject { |k,v| k == :path }
+          path(options[:path]).merge *files + [sans_path]
+          self
         else
           raise "Unrecognized option #{options.keys.join(", ")}"
         end
       end
 
-      # Documented in ZipTask.
+      # Returns a Path relative to this one.
       def path(path)
-        path.blank? ? self : @zip.path("#{@path}#{path}")
+        path.blank? ? self : @root.path("#{@path}#{path}")
       end
 
-      # Documented in ZipTask.
-      def root()
-        @zip
+      # Returns all the source files.
+      def sources() #:nodoc:
+        @sources.map{ |source| source.call }.flatten
       end
 
-      # Returns all the source files.
-      def sources()
-        @sources.map(&:call).flatten
+      def add_files(file_map) #:nodoc:
+        @actions.each { |action| action.call(file_map) }
       end
 
       def to_s()
@@ -121,62 +124,60 @@ module Buildr
 
       def include_as(source, as)
         @sources << proc { source }
-        @actions << proc do |zip|
+        @actions << proc do |file_map|
           file = source.to_s
+          file_map[@path] = nil if @path
           if File.directory?(file)
             in_directory(file) do |file, rel_path|
-              if as == "."
-                dest = (@path || "") + rel_path.split("/")[1..-1].join("/")
-              else
-                dest = "#{@path}#{as}#{rel_path}"
-              end
+              dest = as == "." ? (@path || "") + rel_path.split("/")[1..-1].join("/") : "#{@path}#{as}#{rel_path}"
               puts "Adding #{dest}" if Rake.application.options.trace
-              zip.add(dest, file) { true }
+              file_map[dest] = file
             end
           else
             puts "Adding #{@path}#{as}" if Rake.application.options.trace
-            zip.add("#{@path}#{as}", file) { true }
+            file_map["#{@path}#{as}"] = file
           end
         end
       end
 
       def in_directory(dir, excludes = nil)
         prefix = Regexp.new("^" + Regexp.escape(File.dirname(dir) + File::SEPARATOR))
-        Dir["#{dir}/**/*"].
+        FileList["#{dir}/**/*"].
           reject { |file| File.directory?(file) || (excludes && excludes.exclude?(file)) }.
           each { |file| yield file, file.sub(prefix, "") }
       end
 
     end
 
+
     # Extend one Zip file into another.
     class ZipExpander #:nodoc:
 
       def initialize(zip_file)
         @zip_file = zip_file.to_s
+        @includes = []
+        @excludes = []
       end
 
       def include(*files)
-        (@includes ||= [])
         @includes |= files
         self
       end
 
       def exclude(*files)
-        (@excludes ||= []) 
         @excludes |= files
         self
       end
 
-      def expand(zip, path)
-        @includes ||= ["*"]
-        @excludes ||= []
+      def expand(file_map, path)
+        @includes = ["*"] if @includes.empty?
         Zip::ZipFile.open(@zip_file) 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) }
+              dest = "#{path}#{entry.name}"
+              puts "Adding #{dest}" if Rake.application.options.trace
+              file_map[dest] = lambda { |output| output.write source.read(entry) }
             end
           end
         end
@@ -184,25 +185,29 @@ module Buildr
 
     end
 
+
     def initialize(*args) #:nodoc:
       super
       @paths = { nil=>Path.new(self, nil) }
-      enhance do |task|
-        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
-        # gone before we change it. We also don't want to see any partial updates.
-        rm task.name, :verbose=>false rescue nil
-        mkpath File.dirname(task.name), :verbose=>false
-        begin
-          Zip::ZipFile.open(task.name, Zip::ZipFile::CREATE) do |zip|
-            zip.restore_permissions = true
-            create zip
+      @prepares = []
+
+      # Make sure we're the last enhancements, so other enhancements can add content.
+      enhance do
+        @file_map = {}
+        enhance do
+          send "create" if respond_to?(:create)
+          # We're here because the archive file does not exist, or one of the files is newer than the archive contents;
+          # we need to make sure the archive doesn't exist (e.g. opening an existing Zip will add instead of create).
+          # We also want to protect against partial updates.
+          rm name, :verbose=>false rescue nil
+          mkpath File.dirname(name), :verbose=>false
+          begin
+            @paths.each { |name, object| object.add_files(@file_map) }
+            create_from @file_map
+          rescue
+            rm name, :verbose=>false rescue nil
+            raise
           end
-        rescue
-          rm task.name, :verbose=>false rescue nil
-          raise
         end
       end
     end
@@ -211,30 +216,34 @@ module Buildr
     #   include(*files) => self
     #   include(*files, :path=>path) => self
     #   include(file, :as=>name) => self
-    #   include(*zips, :merge=>true) => self
+    #   include(:from=>path) => self
+    #   include(*files, :merge=>true) => self
+    #
+    # Include files in this archive, or when called on a path, within that path. Returns self.
     #
-    # Include files in the ZIP (or current path) and returns self.
+    # The first form accepts a list of files, directories and glob patterns and adds them to the archive.
+    # For example, to include the file foo, directory bar (including all files in there) and all files under baz:
+    #   zip(..).include("foo", "bar", "baz/*")
     #
-    # This method accepts three options. You can use :path to include files under
-    # a specific path, for example:
+    # The second form is similar but adds files/directories under the specified path. For example,
+    # to add foo as bar/foo:
     #   zip(..).include("foo", :path=>"bar")
-    # includes the file bar as bar/foo. See also #path.
+    # The :path option is the same as using the path method:
+    #   zip(..).path("bar").include("foo")
+    # All other options can be used in combination with the :path option.
     #
-    # You can use :as to include a file under a different name, for example:
+    # The third form adds a file or directory under a different name. For example, to add the file foo under the
+    # name bar:
     #   zip(..).include("foo", :as=>"bar")
-    # You can use the :as option in combination with the :path option, but only with
-    # a single file at a time.
     #
-    # As a special case, you can include the entire contents of a directory by including
-    # the directory and using :as=>".". This:
-    #   zip(..).include("srcs", :as=>".")
-    # will include all the source files, using the directory as a prerequisite. This:
-    #   zip(..).include("srcs/*")
-    # includes all the same source files, using the source files as a prerequisite.
+    # The fourth form adds the contents of a directory using the directory as a prerequisite:
+    #   zip(..).include(:from=>"foo")
+    # Unlike <code>include("foo")</code> it includes the contents of the directory, not the directory itself.
+    # Unlike <code>include("foo/*")</code>, it uses the directory timestamp for dependency management.
     #
-    # You can use :merge option to include the contents of another ZIP file, for example:
-    #   zip(..).include("foo.zip", :merge=>true)
-    # You can use the :merge option in combination with the :path option. See also #merge.
+    # The fifth form includes the contents of another archive by expanding it into this archive. For example:
+    #   zip(..).include("foo.zip", :merge=>true).include("bar.zip")
+    # You can also use the method #merge.
     def include(*files)
       @paths[nil].include *files
       self
@@ -244,8 +253,7 @@ module Buildr
     # :call-seq:
     #   exclude(*files) => self
     # 
-    # Excludes files and returns self. Can be used in combination with include to
-    # prevent some files from being included.
+    # Excludes files and returns self. Can be used in combination with include to prevent some files from being included.
     def exclude(*files)
       @paths[nil].exclude *files
       self
@@ -255,14 +263,11 @@ module Buildr
     #   merge(*files) => Merge
     #   merge(*files, :path=>name) => Merge
     #
-    # Merges ZIP files and returns a merge object. The contents of the merged ZIP file is
-    # extracted into this ZIP file (or current path).
+    # Merges another archive into this one by including the individual files from the merged archive.
     #
-    # The returned object supports two methods: include and exclude. You can use these to
-    # merge only specific files from the ZIP. For example:
+    # Returns an object that supports two methods: include and exclude. You can use these methods to merge
+    # only specific files. For example:
     #   zip(..).merge("src.zip").include("module1/*")
-    #
-    # This differs from include with the :merge option, which returns self.
     def merge(*files)
       @paths[nil].merge *files
     end 
@@ -270,25 +275,23 @@ module Buildr
     # :call-seq:
     #   path(name) => Path
     #
-    # Returns a path object. You can use the path object to include files in a given
-    # path inside the ZIP file. The path object implements the include, exclude, merge,
-    # path and root methods.
-    #
-    # For example:
+    # Returns a path object. Use the path object to include files under a path, for example, to include
+    # the file "foo" as "bar/foo":
     #   zip(..).path("bar").include("foo")
-    # Will add the file foo under the name bar/foo.
     #
-    # As a shorthand, you can also use the :path option:
-    #   zip(..).include("foo", :path=>"bar")
+    # Returns a Path object. The Path object implements all the same methods, like include, exclude, merge
+    # and so forth. It also implements path and root, so that:
+    #   path("foo").path("bar") == path("foo/bar")
+    #   path("foo").root == root
     def path(name)
-      name.blank? ? @paths[nil] : (@paths[name] ||= Path.new(self, name))
+      return @paths[nil] if name.blank?
+      @paths[name] ||= Path.new(self, name)
     end
 
     # :call-seq:
-    #   root() => ZipTask
+    #   root() => ArchiveTask
     #
-    # Returns the root path, essentially the ZipTask object itself. In case you are wondering
-    # down paths and want to go back.
+    # Call this on an archive to return itself, and on a path to return the archive.
     def root()
       self
     end
@@ -296,8 +299,8 @@ module Buildr
     # :call-seq:
     #   with(options) => self
     #
-    # Pass options to the task. Returns self. ZipTask itself does not support any options,
-    # but other tasks (e.g. JarTask, WarTask) do.
+    # Passes options to the task and returns self. Some tasks support additional options, for example,
+    # the WarTask supports options like :manifest, :libs and :classes.
     #
     # For example:
     #   package(:jar).with(:manifest=>"MANIFEST_MF")
@@ -318,7 +321,9 @@ module Buildr
     end
 
     def invoke_prerequisites() #:nodoc:
-      prerequisites.concat @paths.collect { |name, path| path.sources }.flatten
+      @prepares.each { |prepare| prepare.call(self) }
+      @prepares.clear
+      @prerequisites |= @paths.collect { |name, path| path.sources }.flatten
       super
     end
     
@@ -331,7 +336,7 @@ module Buildr
       # under the task, so instead we handle them individually for each path.
       #
       # 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
+      # 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.
       most_recent = @paths.collect { |name, path| path.sources }.flatten.
@@ -342,10 +347,12 @@ module Buildr
 
   protected
 
-    # Sub-classes override this method to perform additional creation tasks,
-    # e.g. creating a manifest file in a JAR.
-    def create(zip)
-      @paths.each { |name, obj| obj.actions.each { |action| action[zip] } }
+    # Adds a prepare block. These blocks are called early on for adding more content to
+    # the archive, before invoking prerequsities. Anything you add here will be invoked
+    # as a prerequisite and used to determine whether or not to generate this archive.
+    # In contrast, enhance blocks are evaluated after it was decided to create this archive.
+    def prepare(&block)
+      @prepares << block
     end
 
     def []=(key, value) #:nodoc:
@@ -354,10 +361,40 @@ module Buildr
 
   end
 
+
+
+  # The ZipTask creates a new Zip file. You can include any number of files and and directories,
+  # use exclusion patterns, and include files into specific directories.
+  #
+  # For example:
+  #   zip("test.zip").tap do |task|
+  #     task.include "srcs"
+  #     task.include "README", "LICENSE"
+  #   end
+  #
+  # See Buildr#zip and ArchiveTask.
+  class ZipTask < ArchiveTask
+
+  private
+
+    def create_from(file_map)
+      Zip::ZipFile.open(name, Zip::ZipFile::CREATE) do |zip|
+        zip.restore_permissions = true
+        file_map.each do |path, content|
+          zip.mkdir path unless content || zip.find_entry(path)
+          zip.add path, content if String === content
+          zip.get_output_stream(path) { |output| content.call(output) } if content.respond_to?(:call)
+        end
+      end
+    end
+
+  end
+
+
   # :call-seq:
   #    zip(file) => ZipTask
   #
-  # The ZipTask creates a new ZIP file. You can include any number of files and
+  # The ZipTask creates a new Zip file. You can include any number of files and
   # and directories, use exclusion patterns, and include files into specific
   # directories.
   #

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: buildr
 version: !ruby/object:Gem::Version 
-  version: 1.2.2
-date: 2007-07-18 00:00:00 -07:00
+  version: 1.2.3
+date: 2007-07-26 00:00:00 -07:00
 summary: A build system that doesn't suck
 require_paths: 
 - lib
@@ -30,6 +30,7 @@ authors:
 - Assaf Arkin
 files: 
 - lib/tasks
+- lib/tasks/tar.rb
 - lib/tasks/concat.rb
 - lib/tasks/zip.rb
 - lib/core
@@ -59,6 +60,7 @@ files:
 - lib/java/test.rb
 - lib/java/idea.rb
 - lib/java/eclipse.rb
+- lib/java/pom.rb
 - lib/java/java.rb
 - lib/java/ant.rb
 - lib/java/artifact.rb
@@ -179,3 +181,21 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.5
     version: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.0.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: archive-tar-minitar
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.5.1
+    version: