buildr 1.3.3 → 1.3.4

data/lib/buildr/java/packaging.rb

@@ -18,14 +18,14 @@ require 'buildr/packaging'
 
 
 module Buildr
-  module Packaging
+  module Packaging #:nodoc:
 
     # Adds packaging for Java projects: JAR, WAR, AAR, EAR, Javadoc.
     module Java
 
       class Manifest
 
-        STANDARD_HEADER = "Manifest-Version: 1.0\nCreated-By: Buildr\n"
+        STANDARD_HEADER = { 'Manifest-Version'=>'1.0', 'Created-By'=>'Buildr' }
         LINE_SEPARATOR = /\r\n|\n|\r[^\n]/ #:nodoc:
         SECTION_SEPARATOR = /(#{LINE_SEPARATOR}){2}/ #:nodoc:
 
@@ -57,8 +57,7 @@ module Buildr
           # Parse the MANIFEST.MF entry of a ZIP (or JAR) file and return a new Manifest.
           def from_zip(file)
             Zip::ZipFile.open(file.to_s) do |zip|
-              return Manifest.new unless zip.get_entry('META-INF/MANIFEST.MF')
-              Manifest.parse zip.read('META-INF/MANIFEST.MF')
+              Manifest.parse zip.read('META-INF/MANIFEST.MF') rescue Manifest.new
             end
           end
 
@@ -97,6 +96,10 @@ module Buildr
           else
             fail 'Invalid manifest, expecting Hash, Array, file name/task or proc/method.'
           end
+          # Add Manifest-Version and Created-By, if not specified.
+          STANDARD_HEADER.each do |name, value|
+            sections.first[name] ||= value
+          end
         end
 
         # The sections of this manifest.
@@ -171,7 +174,7 @@ module Buildr
               @manifest_tmp = Tempfile.new('MANIFEST.MF')
               self.manifest = File.read(manifest.to_s) if String === manifest || Rake::Task === manifest
               self.manifest = Manifest.new(manifest) unless Manifest === manifest
-              @manifest_tmp.write Manifest::STANDARD_HEADER
+              #@manifest_tmp.write Manifest::STANDARD_HEADER
               @manifest_tmp.write manifest.to_s
               @manifest_tmp.write "\n"
               @manifest_tmp.rewind
@@ -453,8 +456,8 @@ module Buildr
 
         def component_clone(component)
           file(path_to(component[:path], component[:artifact].to_s.pathmap('%f')) => component[:artifact]) do |task|
-            mkpath task.to_s.pathmap('%d'), :verbose => false
-            cp component[:artifact].to_s, task.to_s, :verbose => false
+            mkpath task.to_s.pathmap('%d')
+            cp component[:artifact].to_s, task.to_s
             Manifest.update_manifest(task) do |manifest|
               class_path = manifest.main['Class-Path'].to_s.split
               included_libs = class_path.map { |fn| fn.pathmap('%f') }
@@ -547,7 +550,7 @@ module Buildr
           descriptor_path = path_to('META-INF/application.xml')
           @descriptor = file(descriptor_path) do |task|
             trace "Creating EAR Descriptor: #{task.to_s}"
-            mkpath File.dirname(task.name), :verbose=>false
+            mkpath File.dirname(task.name)
             File.open(task.name, 'w') { |file| file.print task.xml }
           end
           class << @descriptor

data/lib/buildr/java/pom.rb

@@ -14,10 +14,6 @@
 # the License.
 
 
-require 'xmlsimple'
-require 'buildr/packaging'
-
-
 module Buildr
   class POM
 

data/lib/buildr/java/rjb.rb

@@ -134,7 +134,7 @@ module Java
 
     def __package__(name) #:nodoc:
       const = name.split('.').map { |part| part.gsub(/^./) { |char| char.upcase } }.join
-      return const_get(const) if const_defined?(const)
+      return const_get(const) if constants.include?(const)
       package = Module.new
       package.extend Package
       package.instance_variable_set :@name, name

data/lib/buildr/java/test_result.rb

@@ -13,8 +13,7 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'yaml'
-
+require 'fileutils'
 module Buildr #:nodoc:
   module TestFramework
     
@@ -31,16 +30,15 @@ module Buildr #:nodoc:
         end
 
         def self.dump_yaml(file, e)
-          require 'fileutils'
-          FileUtils.mkdir_p(File.dirname(file))
+          FileUtils.mkdir_p File.dirname(file)
           File.open(file, 'w') { |f| f.puts(YAML.dump(Error.new(e.message, e.backtrace))) }
         end
 
         def self.guard(file)
           begin 
             yield
-          rescue
-            dump_yaml(file)
+          rescue => e
+            dump_yaml(file, e)
           end
         end
       end
@@ -107,7 +105,7 @@ module Buildr #:nodoc:
           files = options.files
           result.succeeded = files - result.failed
           
-          FileUtils.mkdir_p(File.dirname(where))
+          FileUtils.mkdir_p File.dirname(where)
           File.open(where, 'w') { |f| f.puts YAML.dump(result) }
         end
       end # YamlFormatter

data/lib/buildr/java/tests.rb

@@ -52,7 +52,7 @@ module Buildr
       target = task.compile.target.to_s
       candidates = Dir["#{target}/**/*.class"].
         map { |file| Util.relative_path(file, target).ext('').gsub(File::SEPARATOR, '.') }.
-        reject { |name| name =~ /\$/ }
+        reject { |name| name =~ /\$./ }
       result = []
       if criteria[:class_names]
         result.concat candidates.select { |name| criteria[:class_names].flatten.any? { |pat| pat === name } }
@@ -74,7 +74,8 @@ module Buildr
         info "#{ex.class}: #{ex.message}"
         raise
       end
-      result.uniq
+      # We strip Scala singleton objects whose .class ends with $
+      result.map { |c| (c =~ /\$$/) ? c[0..(c.size - 2)] : c  }.uniq
     end
     
   end
@@ -301,17 +302,22 @@ module Buildr
     end
 
     def run(tests, dependencies) #:nodoc:
-      cmd_args = [ 'org.testng.TestNG', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.send(:project).name ]
+      cmd_args = [ 'org.testng.TestNG', '-log', '2', '-sourcedir', task.compile.sources.join(';'), '-suitename', task.project.id ]
       cmd_args << '-d' << task.report_to.to_s
+      # run all tests in the same suite
+      cmd_args << '-testclass' << tests
       cmd_options = { :properties=>options[:properties], :java_args=>options[:java_args],
-                      :classpath=>dependencies }
-      tests.inject([]) do |passed, test|
-        begin
-          Java::Commands.java cmd_args, '-testclass', test, cmd_options.merge(:name=>test)
-          passed << test
-        rescue
-          passed
-        end
+        :classpath=>dependencies, :name => "TestNG in #{task.send(:project).name}" }
+
+      begin
+        Java::Commands.java cmd_args, cmd_options
+        return tests
+      rescue
+        # testng-failed.xml contains the list of failed tests *only*
+        report = File.read(File.join(task.report_to.to_s, 'testng-failed.xml'))
+        failed = report.scan(/<class name="(.*)">/im).flatten
+        # return the list of passed tests
+        return tests - failed
       end
     end
 

data/lib/buildr/packaging.rb

@@ -14,8 +14,11 @@
 # the License.
 
 
-require 'buildr/packaging/zip'
-require 'buildr/packaging/tar'
 require 'buildr/packaging/artifact'
 require 'buildr/packaging/package'
+require 'buildr/packaging/archive'
+require 'buildr/packaging/ziptask'
+require 'buildr/packaging/tar'
 require 'buildr/packaging/gems'
+autoload :Zlib, 'zlib'
+autoload :Zip, 'buildr/packaging/zip'

data/lib/buildr/packaging/archive.rb

@@ -0,0 +1,488 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+module Buildr
+
+  # 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.
+    class Path #:nodoc:
+
+      # Returns the archive from this path.
+      attr_reader :root
+      
+      def initialize(root, path)
+        @root = root
+        @path = path.empty? ? path : "#{path}/"
+        @includes = FileList[]
+        @excludes = []
+        # Expand source files added to this path.
+        expand_src = proc { @includes.map{ |file| file.to_s }.uniq }
+        @sources = [ expand_src ]
+        # Add files and directories added to this path.
+        @actions = [] << proc do |file_map|
+          expand_src.call.each do |path|
+            unless excluded?(path)
+              if File.directory?(path)
+                in_directory path do |file, rel_path|
+                  dest = "#{@path}#{rel_path}"
+                  trace "Adding #{dest}"
+                  file_map[dest] = file
+                end
+              else
+                trace "Adding #{@path}#{File.basename(path)}"
+                file_map["#{@path}#{File.basename(path)}"] = path
+              end
+            end
+          end
+        end
+      end
+
+      # :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?
+          @includes.include *files.flatten
+        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.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]
+        elsif options[:from]
+          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, '.' }
+        elsif options[:merge]
+          raise 'You can only use the :merge option in combination with the :path option' unless options.size == 1
+          files.each { |file| merge file }
+        else
+          raise "Unrecognized option #{options.keys.join(', ')}"
+        end
+        self
+      end
+      alias :add :include
+      alias :<< :include
+
+      # :call-seq:
+      #   exclude(*files) => self
+      def exclude(*files)
+        files = files.flatten.map(&:to_s) 
+        @excludes |= files
+        @excludes |= files.reject { |f| f =~ /\*$/ }.map { |f| "#{f}/*" }
+        self
+      end
+
+      # :call-seq:
+      #   merge(*files) => Merge
+      #   merge(*files, :path=>name) => Merge
+      def merge(*args)
+        options = Hash === args.last ? args.pop : {}
+        files = args.flatten
+        rake_check_options options, :path
+        raise ArgumentError, "Expected at least one file to merge" if files.empty?
+        path = options[:path] || @path
+        expanders = files.collect do |file|
+          @sources << proc { file.to_s }
+          expander = ZipExpander.new(file)
+          @actions << proc { |file_map| expander.expand(file_map, path) }
+          expander
+        end
+        Merge.new(expanders)
+      end
+
+      # Returns a Path relative to this one.
+      def path(path)
+        return self if path.nil?
+        return root.path(path[1..-1]) if path[0] == ?/
+        root.path("#{@path}#{path}")
+      end
+
+      # Returns all the source files.
+      def sources #:nodoc:
+        @sources.map{ |source| source.call }.flatten
+      end
+
+      def add_files(file_map) #:nodoc:
+        @actions.each { |action| action.call(file_map) }
+      end
+
+      # :call-seq:
+      #   exist => boolean
+      #
+      # 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?
+        !entries.empty?
+      end
+
+      # :call-seq:
+      #   empty? => boolean
+      #
+      # Returns true if this path is empty (has no other entries inside).
+      def empty?
+        entries.all? { |entry| entry.empty? }
+      end
+
+      # :call-seq:
+      #   contain(file*) => boolean
+      #
+      # 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)
+        files.all? { |file| entries.detect { |entry| File.fnmatch(file, entry.to_s) } }
+      end
+
+      # :call-seq:
+      #   entry(name) => ZipEntry
+      #
+      # Returns a ZIP file entry. You can use this to check if the entry exists and its contents,
+      # for example:
+      #   package(:jar).path("META-INF").entry("LICENSE").should contain(/Apache Software License/)
+      def entry(name)
+        root.entry("#{@path}#{name}")
+      end
+
+      def to_s
+        @path
+      end
+
+    protected
+
+      def include_as(source, as)
+        @sources << proc { source }
+        @actions << proc do |file_map|
+          file = source.to_s
+          unless excluded?(file)
+            if File.directory?(file)
+              in_directory file do |file, rel_path|
+                path = rel_path.split('/')[1..-1]
+                path.unshift as unless as == '.'
+                dest = "#{@path}#{path.join('/')}"
+                trace "Adding #{dest}"
+                file_map[dest] = file
+              end
+            else
+              trace "Adding #{@path}#{as}"
+              file_map["#{@path}#{as}"] = file
+            end
+          end
+        end
+      end
+
+      def in_directory(dir)
+        prefix = Regexp.new('^' + Regexp.escape(File.dirname(dir) + File::SEPARATOR))
+        Util.recursive_with_dot_files(dir).reject { |file| excluded?(file) }.
+          each { |file| yield file, file.sub(prefix, '') }
+      end
+
+      def excluded?(file)
+        @excludes.any? { |exclude| File.fnmatch(exclude, file) }
+      end
+
+      def entries #:nodoc:
+        return root.entries unless @path
+        @entries ||= root.entries.inject([]) { |selected, entry|
+          selected << entry.name.sub(@path, "") if entry.name.index(@path) == 0
+          selected
+        }
+      end
+
+    end
+
+
+    class Merge
+      def initialize(expanders)
+        @expanders = expanders
+      end
+
+      def include(*files)
+        @expanders.each { |expander| expander.include(*files) }
+        self
+      end
+      alias :<< :include
+
+      def exclude(*files)
+        @expanders.each { |expander| expander.exclude(*files) }
+        self
+      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 |= files
+        self
+      end
+      alias :<< :include
+
+      def exclude(*files)
+        @excludes |= files
+        self
+      end
+
+      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) }
+              dest = path =~ /^\/?$/ ? entry.name : Util.relative_path(path + "/" + entry.name)
+              trace "Adding #{dest}"
+              file_map[dest] = lambda { |output| output.write source.read(entry) }
+            end
+          end
+        end
+      end
+
+    end
+
+
+    def initialize(*args) #:nodoc:
+      super
+      clean
+
+      # 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 rescue nil
+          mkpath File.dirname(name)
+          begin
+            @paths.each do |name, object|
+              @file_map[name] = nil unless name.empty?
+              object.add_files(@file_map)
+            end
+            create_from @file_map
+          rescue
+            rm name rescue nil
+            raise
+          end
+        end
+      end
+    end
+
+    # :call-seq:
+    #   clean => self
+    # 
+    # Removes all previously added content from this archive. 
+    # Use this method if you want to remove default content from a package.
+    # For example, package(:jar) by default includes compiled classes and resources,
+    # using this method, you can create an empty jar and afterwards add the
+    # desired content to it.
+    # 
+    #    package(:jar).clean.include path_to('desired/content')
+    def clean
+      @paths = { '' => Path.new(self, '') }
+      @prepares = []
+      self
+    end
+
+    # :call-seq:
+    #   include(*files) => self
+    #   include(*files, :path=>path) => self
+    #   include(file, :as=>name) => 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.
+    #
+    # 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/*')
+    #
+    # 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')
+    # 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.
+    #
+    # 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')
+    #
+    # 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.
+    #
+    # 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[''].include *files
+      self
+    end 
+    alias :add :include
+    alias :<< :include
+   
+    # :call-seq:
+    #   exclude(*files) => self
+    # 
+    # Excludes files and returns self. Can be used in combination with include to prevent some files from being included.
+    def exclude(*files)
+      @paths[''].exclude *files
+      self
+    end 
+
+    # :call-seq:
+    #   merge(*files) => Merge
+    #   merge(*files, :path=>name) => Merge
+    #
+    # Merges another archive into this one by including the individual files from the merged archive.
+    #
+    # 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/*')
+    def merge(*files)
+      @paths[''].merge *files
+    end 
+
+    # :call-seq:
+    #   path(name) => Path
+    #
+    # 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')
+    #
+    # 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)
+      return @paths[''] if name.nil?
+      normalized = name.split('/').inject([]) do |path, part|
+        case part
+        when '.', nil, ''
+          path
+        when '..'
+          path[0...-1]
+        else
+          path << part
+        end
+      end.join('/')
+      @paths[normalized] ||= Path.new(self, normalized)
+    end
+
+    # :call-seq:
+    #   root => ArchiveTask
+    #
+    # Call this on an archive to return itself, and on a path to return the archive.
+    def root
+      self
+    end
+
+    # :call-seq:
+    #   with(options) => self
+    #
+    # 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')
+    def with(options)
+      options.each do |key, value|
+        begin
+          send "#{key}=", value
+        rescue NoMethodError
+          raise ArgumentError, "#{self.class.name} does not support the option #{key}"
+        end
+      end
+      self
+    end
+
+    def invoke_prerequisites(args, chain) #:nodoc:
+      @prepares.each { |prepare| prepare.call(self) }
+      @prepares.clear
+      @prerequisites |= @paths.collect { |name, path| path.sources }.flatten
+      super
+    end
+    
+    def needed? #:nodoc:
+      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.
+      #
+      # 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.
+      most_recent = @paths.collect { |name, path| path.sources }.flatten.
+        select { |file| File.exist?(file) }.collect { |file| File.stat(file).mtime }.max
+      File.stat(name).mtime < (most_recent || Rake::EARLY) || super
+    end
+
+    # :call-seq:
+    #   empty? => boolean
+    #
+    # Returns true if this ZIP file is empty (has no other entries inside).
+    def empty?
+      path("").empty
+    end
+
+    # :call-seq:
+    #   contain(file*) => boolean
+    #
+    # Returns true if this ZIP file contains all the specified files. You can use absolute
+    # file names and glob patterns (using *, **, etc).
+    def contain?(*files)
+      path("").contain?(*files)
+    end
+
+  protected
+
+    # 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:
+      raise ArgumentError, "This task does not support the option #{key}."
+    end
+
+  end
+
+
+end