buildr 1.2.10 → 1.3.0

data/lib/{tasks → buildr/packaging}/tar.rb

@@ -1,6 +1,23 @@
-require 'tasks/zip'
+# 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.
+
+
+require 'buildr/packaging/zip'
 require 'archive/tar/minitar'
 
+
 module Buildr
 
   # The TarTask creates a new Tar file. You can include any number of files and and directories,

data/lib/{tasks → buildr/packaging}/zip.rb

@@ -1,5 +1,21 @@
-require "zip/zip"
-require "zip/zipfilesystem"
+# 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.
+
+
+require 'zip/zip'
+require 'zip/zipfilesystem'
 
 
 module Buildr
@@ -16,7 +32,7 @@ module Buildr
       
       def initialize(root, path)
         @root = root
-        @path = path.blank? ? path : "#{path}/"
+        @path = path.empty? ? path : "#{path}/"
         @includes = FileList[]
         @excludes = []
         # Expand source files added to this path.
@@ -29,11 +45,11 @@ module Buildr
               if File.directory?(path)
                 in_directory path do |file, rel_path|
                   dest = "#{@path}#{rel_path}"
-                  puts "Adding #{dest}" if Rake.application.options.trace
+                  puts "Adding #{dest}" if Buildr.application.options.trace
                   file_map[dest] = file
                 end
               else
-                puts "Adding #{@path}#{File.basename(path)}" if Rake.application.options.trace
+                puts "Adding #{@path}#{File.basename(path)}" if Buildr.application.options.trace
                 file_map["#{@path}#{File.basename(path)}"] = path
               end
             end
@@ -57,22 +73,23 @@ module Buildr
           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
+          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, "." }
+          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
+          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(", ")}"
+          raise "Unrecognized option #{options.keys.join(', ')}"
         end
         self
       end
       alias :add :include
+      alias :<< :include
 
       # :call-seq:
       #   exclude(*files) => self
@@ -87,28 +104,23 @@ module Buildr
       #   merge(*files) => Merge
       #   merge(*files, :path=>name) => Merge
       def merge(*args)
-        options = args.pop if Hash === args.last
+        options = Hash === args.last ? args.pop : {}
         files = args.flatten
-
-        if options.nil? || options.empty?
-          files.collect do |file|
-            @sources << proc { file.to_s }
-            expander = ZipExpander.new(file)
-            @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(", ")}"
+        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.blank?
+        return self if path.nil?
         return root.path(path[1..-1]) if path[0] == ?/
         root.path("#{@path}#{path}")
       end
@@ -135,14 +147,14 @@ module Buildr
           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 == "."
+                path = rel_path.split('/')[1..-1]
+                path.unshift as unless as == '.'
                 dest = "#{@path}#{path.join('/')}"
-                puts "Adding #{dest}" if Rake.application.options.trace
+                puts "Adding #{dest}" if Buildr.application.options.trace
                 file_map[dest] = file
               end
             else
-              puts "Adding #{@path}#{as}" if Rake.application.options.trace
+              puts "Adding #{@path}#{as}" if Buildr.application.options.trace
               file_map["#{@path}#{as}"] = file
             end
           end
@@ -150,17 +162,34 @@ module Buildr
       end
 
       def in_directory(dir)
-        prefix = Regexp.new("^" + Regexp.escape(File.dirname(dir) + File::SEPARATOR))
-        FileList.recursive(dir).reject { |file| excluded?(file) }.
-          each { |file| yield file, file.sub(prefix, "") }
+        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) }
+        @excludes.any? { |exclude| File.fnmatch(exclude, file, File::FNM_PATHNAME) }
       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:
@@ -175,6 +204,7 @@ module Buildr
         @includes |= files
         self
       end
+      alias :<< :include
 
       def exclude(*files)
         @excludes |= files
@@ -182,13 +212,13 @@ module Buildr
       end
 
       def expand(file_map, path)
-        @includes = ["*"] if @includes.empty?
+        @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}"
-              puts "Adding #{dest}" if Rake.application.options.trace
+            if @includes.any? { |pattern| File.fnmatch(pattern, entry.name, File::FNM_PATHNAME) } &&
+               !@excludes.any? { |pattern| File.fnmatch(pattern, entry.name, File::FNM_PATHNAME) }
+              dest = path =~ /^\/?$/ ? entry.name : Util.relative_path(path + "/" + entry.name)
+              puts "Adding #{dest}" if Buildr.application.options.trace
               file_map[dest] = lambda { |output| output.write source.read(entry) }
             end
           end
@@ -200,14 +230,13 @@ module Buildr
 
     def initialize(*args) #:nodoc:
       super
-      @paths = { ""=>Path.new(self, "") }
-      @prepares = []
+      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)
+          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.
@@ -215,7 +244,7 @@ module Buildr
           mkpath File.dirname(name), :verbose=>false
           begin
             @paths.each do |name, object|
-              @file_map[name] = nil unless name.blank?
+              @file_map[name] = nil unless name.empty?
               object.add_files(@file_map)
             end
             create_from @file_map
@@ -227,6 +256,22 @@ module Buildr
       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
@@ -238,39 +283,40 @@ module Buildr
     #
     # 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/*")
+    #   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")
+    #   zip(..).include('foo', :path=>'bar')
     # The :path option is the same as using the path method:
-    #   zip(..).path("bar").include("foo")
+    #   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")
+    #   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.
+    #   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")
+    #   zip(..).include('foo.zip', :merge=>true).include('bar.zip')
     # You can also use the method #merge.
     def include(*files)
-      @paths[""].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
+      @paths[''].exclude *files
       self
     end 
 
@@ -282,34 +328,34 @@ module Buildr
     #
     # 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/*")
+    #   zip(..).merge('src.zip').include('module1/*')
     def merge(*files)
-      @paths[""].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")
+    # 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
+    #   path('foo').path('bar') == path('foo/bar')
+    #   path('foo').root == root
     def path(name)
-      return @paths[""] if name.blank?
-      normalized = name.split("/").inject([]) do |path, part|
+      return @paths[''] if name.nil?
+      normalized = name.split('/').inject([]) do |path, part|
         case part
-        when ".", nil, ""
+        when '.', nil, ''
           path
-        when ".."
+        when '..'
           path[0...-1]
         else
           path << part
         end
-      end.join("/")
+      end.join('/')
       @paths[normalized] ||= Path.new(self, normalized)
     end
 
@@ -328,24 +374,19 @@ module Buildr
     # the WarTask supports options like :manifest, :libs and :classes.
     #
     # For example:
-    #   package(:jar).with(:manifest=>"MANIFEST_MF")
+    #   package(:jar).with(:manifest=>'MANIFEST_MF')
     def with(options)
       options.each do |key, value|
         begin
           send "#{key}=", value
-        rescue NameError
-          if respond_to?(:[]=) # Backward compatible with Buildr 1.1.
-            warn_deprecated "The []= method is deprecated, please use attribute accessors instead."
-            self[key] = value
-          else
-            raise ArgumentError, "This task does not support the option #{key}."
-          end
+        rescue NoMethodError
+          raise ArgumentError, "#{self.class.name} does not support the option #{key}"
         end
       end
       self
     end
 
-    def invoke_prerequisites() #:nodoc:
+    def invoke_prerequisites(args, chain) #:nodoc:
       @prepares.each { |prepare| prepare.call(self) }
       @prepares.clear
       @prerequisites |= @paths.collect { |name, path| path.sources }.flatten
@@ -355,8 +396,8 @@ module Buildr
     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")
+      #   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.
       #
@@ -365,7 +406,7 @@ module Buildr
       # 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.
-        each { |src| File.directory?(src) ? FileList.recursive(src) | [src] : src }.flatten.
+        each { |src| File.directory?(src) ? Util.recursive_with_dot_files(src) | [src] : src }.flatten.
         select { |file| File.exist?(file) }.collect { |file| File.stat(file).mtime }.max
       File.stat(name).mtime < (most_recent || Rake::EARLY) || super
     end
@@ -390,37 +431,45 @@ module Buildr
   # use exclusion patterns, and include files into specific directories.
   #
   # For example:
-  #   zip("test.zip").tap do |task|
-  #     task.include "srcs"
-  #     task.include "README", "LICENSE"
+  #   zip('test.zip').tap do |task|
+  #     task.include 'srcs'
+  #     task.include 'README', 'LICENSE'
   #   end
   #
   # See Buildr#zip and ArchiveTask.
   class ZipTask < ArchiveTask
 
+    # Compression leve for this Zip.
+    attr_accessor :compression_level
+
+    def initialize(*args) #:nodoc:
+      self.compression_level = Zlib::NO_COMPRESSION
+      super
+    end
+
   private
 
     def create_from(file_map)
       Zip::ZipOutputStream.open name do |zip|
         seen = {}
         mkpath = lambda do |dir|
-          unless dir == "." || seen[dir]
+          unless dir == '.' || seen[dir]
             mkpath.call File.dirname(dir)
-            zip.put_next_entry dir + '/'
+            zip.put_next_entry(dir + '/', compression_level)
             seen[dir] = true
           end
         end
-      
+
         file_map.each do |path, content|
           mkpath.call File.dirname(path)
           if content.respond_to?(:call)
-            zip.put_next_entry path
+            zip.put_next_entry(path, compression_level)
             content.call zip
           elsif content.nil? || File.directory?(content.to_s)
             mkpath.call path
           else
-            zip.put_next_entry path
-            File.open content.to_s, "rb" do |is|
+            zip.put_next_entry(path, compression_level)
+            File.open content.to_s, 'rb' do |is|
               while data = is.read(4096)
                 zip << data
               end
@@ -441,9 +490,9 @@ module Buildr
   # directories.
   #
   # For example:
-  #   zip("test.zip").tap do |task|
-  #     task.include "srcs"
-  #     task.include "README", "LICENSE"
+  #   zip('test.zip').tap do |task|
+  #     task.include 'srcs'
+  #     task.include 'README', 'LICENSE'
   #   end
   def zip(file)
     ZipTask.define_task(file)
@@ -467,7 +516,7 @@ module Buildr
 
     # Initialize with hash argument of the form target=>zip_file.
     def initialize(args)
-      @target, @zip_file = Rake.application.resolve_args(args)
+      @target, arg_names, @zip_file = Buildr.application.resolve_args([args])
       @paths = {}
     end
 
@@ -487,7 +536,6 @@ module Buildr
       # specified. Nothing will happen unless we include all files.
       if @paths.empty?
         @paths[nil] = FromPath.new(self, nil)
-        @paths[nil].include "*"
       end
 
       # Otherwise, empty unzip creates target as a file when touching.
@@ -498,7 +546,7 @@ module Buildr
           patterns.map(entries).each do |dest, entry|
             next if entry.directory?
             dest = File.expand_path(dest, target.to_s)
-            puts "Extracting #{dest}" if Rake.application.options.trace
+            puts "Extracting #{dest}" if Buildr.application.options.trace
             mkpath File.dirname(dest), :verbose=>false rescue nil
             entry.extract(dest) { true }
           end
@@ -551,11 +599,11 @@ module Buildr
     # Expands the file relative to that path.
     #
     # For example:
-    #   unzip(Dir.pwd=>"test.jar").from_path("etc").include("LICENSE")
+    #   unzip(Dir.pwd=>'test.jar').from_path('etc').include('LICENSE')
     # will unzip etc/LICENSE into ./LICENSE.
     #
     # This is different from:
-    #  unzip(Dir.pwd=>"test.jar").include("etc/LICENSE")
+    #  unzip(Dir.pwd=>'test.jar').include('etc/LICENSE')
     # which unzips etc/LICENSE into ./etc/LICENSE.
     def from_path(name)
       @paths[name] ||= FromPath.new(self, name)
@@ -581,9 +629,9 @@ module Buildr
       def initialize(unzip, path)
         @unzip = unzip
         if path
-          @path = path[-1] == ?/ ? path : path + "/"
+          @path = path[-1] == ?/ ? path : path + '/'
         else
-          @path = ""
+          @path = ''
         end
       end
 
@@ -602,12 +650,12 @@ module Buildr
       end
 
       def map(entries)
-        includes = @include || ["*"]
+        includes = @include || ['**/*']
         excludes = @exclude || []
         entries.inject({}) do |map, entry|
-          short = entry.name.sub(@path, "")
-          if includes.any? { |pat| File.fnmatch(pat, short) } &&
-             !excludes.any? { |pat| File.fnmatch(pat, short) }
+          short = entry.name.sub(@path, '')
+          if includes.any? { |pat| File.fnmatch(pat, short, File::FNM_PATHNAME) } &&
+             !excludes.any? { |pat| File.fnmatch(pat, short, File::FNM_PATHNAME) }
             map[short] = entry
           end
           map
@@ -643,11 +691,11 @@ module Buildr
   # you overlay additional work on top of the file task.
   #
   # For example:
-  #   unzip("all"=>"test.zip")
-  #   unzip("src"=>"test.zip").include("README", "LICENSE") 
-  #   unzip("libs"=>"test.zip").from_path("libs")
+  #   unzip('all'=>'test.zip')
+  #   unzip('src'=>'test.zip').include('README', 'LICENSE') 
+  #   unzip('libs'=>'test.zip').from_path('libs')
   def unzip(args)
-    target, zip_file = Rake.application.resolve_args(args)
+    target, arg_names, zip_file = Buildr.application.resolve_args([args])
     task = file(File.expand_path(target.to_s)=>zip_file)
     Unzip.new(task=>zip_file).tap do |setup|
       task.enhance { setup.extract }