Buildr C0 Coverage Information - RCov

 # 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/archive'

 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 and ArchiveTask.

   class ZipTask < ArchiveTask

     # Compression leve for this Zip.

     attr_accessor :compression_level

     def initialize(*args) #:nodoc:

       super

     end

     # :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(entry_name)

     def entries #:nodoc:

   private

     def create_from(file_map)

         seen = {}

         mkpath = lambda do |dir|

           dirname = (dir[-1..-1] =~ /\/$/) ? dir : dir + '/'

           unless dir == '.' || seen[dirname]

             mkpath.call File.dirname(dirname)

             zip.put_next_entry(dirname, compression_level)

             seen[dirname] = true

           end

         end

         file_map.each do |path, content|

           warn "Warning:  Path in zipfile #{name} contains backslash: #{path}" if path =~ /\\/

           mkpath.call File.dirname(path)

           if content.respond_to?(:call)

             zip.put_next_entry(path, compression_level)

             content.call zip

           elsif content.nil? || File.directory?(content.to_s)

             mkpath.call path

           else

             entry = zip.put_next_entry(path, compression_level)

             File.open content.to_s, 'rb' do |is|

               entry.unix_perms = is.stat.mode & 07777

               while data = is.read(4096)

                 zip << data

               end

             end

           end

         end

       end

     end

   end

   # :call-seq:

   #    zip(file) => ZipTask

   #

   # 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

   def zip(file)

   # An object for unzipping/untarring a file into a target directory. You can tell it to include

   # or exclude only specific files and directories, and also to map files from particular

   # paths inside the zip file into the target directory. Once ready, call #extract.

   #

   # Usually it is more convenient to create a file task for extracting the zip file

   # (see #unzip) and pass this object as a prerequisite to other tasks.

   #

   # See Buildr#unzip.

   class Unzip

     # The zip file to extract.

     attr_accessor :zip_file

     attr_accessor :target

     # Initialize with hash argument of the form target=>zip_file.

     def initialize(args)

       @zip_file = zip_file.first

       @paths = {}

     end

     # :call-seq:

     #   extract

     #

     # Extract the zip/tgz file into the target directory.

     #

     # You can call this method directly. However, if you are using the #unzip method,

     # it creates a file task for the target directory: use that task instead as a

     # prerequisite. For example:

     #   build unzip(dir=>zip_file)

     # Or:

     #   unzip(dir=>zip_file).target.invoke

     def extract

       # specified. Nothing will happen unless we include all files.

       if @paths.empty?

         @paths[nil] = FromPath.new(self, nil)

       end

       # Otherwise, empty unzip creates target as a file when touching.

       mkpath target.to_s

       if zip_file.to_s.match /\.t?gz$/

         #un-tar.gz

         Zlib::GzipReader.open(zip_file.to_s) { |tar|

           Archive::Tar::Minitar::Input.open(tar) do |inp|

             inp.each do |tar_entry|

               @paths.each do |path, patterns|

                 patterns.map([tar_entry]).each do |dest, entry|

                   next if entry.directory?

                   dest = File.expand_path(dest, target.to_s)

                   trace "Extracting #{dest}"

                   mkpath File.dirname(dest) rescue nil

                   #entry.restore_permissions = true

                   File.open(dest, 'wb') {|f| f.write entry.read}

                 end

               end

             end

           end

         }

       else

         Zip::ZipFile.open(zip_file.to_s) do |zip|

           entries = zip.collect

           @paths.each do |path, patterns|

             patterns.map(entries).each do |dest, entry|

               next if entry.directory?

               dest = File.expand_path(dest, target.to_s)

               trace "Extracting #{dest}"

               mkpath File.dirname(dest) rescue nil

               entry.restore_permissions = true

               entry.extract(dest) { true }

             end

           end

         end

       end

       # Let other tasks know we updated the target directory.

       touch target.to_s

     end

     #reads the includes/excludes and apply them to the entry_name

     def included?(entry_name)

         return true if path.nil?

         if entry_name =~ /^#{path}/

           short = entry_name.sub(path, '')

           if patterns.include.any? { |pattern| File.fnmatch(pattern, entry_name) } &&

             !patterns.exclude.any? { |pattern| File.fnmatch(pattern, entry_name) }

             # trace "tar_entry.full_name " + entry_name + " is included"

             return true

           end

         end

       end

       # trace "tar_entry.full_name " + entry_name + " is excluded"

       return false

     end

     # :call-seq:

     #   include(*files) => self

     #   include(*files, :path=>name) => self

     #

     # Include all files that match the patterns and returns self.

     #

     # Use include if you only want to unzip some of the files, by specifying

     # them instead of using exclusion. You can use #include in combination

     # with #exclude.

     def include(*files)

         from_path(files.pop[:path]).include *files

       else

         from_path(nil).include *files

       end

       self

     end

     alias :add :include

     # :call-seq:

     #   exclude(*files) => self

     #

     # Exclude all files that match the patterns and return self.

     #

     # Use exclude to unzip all files except those that match the pattern.

     # You can use #exclude in combination with #include.

     def exclude(*files)

         from_path(files.pop[:path]).exclude *files

       else

         from_path(nil).exclude *files

       end

       self

     end

     # :call-seq:

     #   from_path(name) => Path

     #

     # Allows you to unzip from a path. Returns an object you can use to

     # specify which files to include/exclude relative to that path.

     # Expands the file relative to that path.

     #

     # For example:

     #   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')

     # which unzips etc/LICENSE into ./etc/LICENSE.

     def from_path(name)

     alias :path :from_path

     # :call-seq:

     #   root => Unzip

     #

     # Returns the root path, essentially the Unzip object itself. In case you are wondering

     # down paths and want to go back.

     def root

     # Returns the path to the target directory.

     def to_s

     class FromPath #:nodoc:

       def initialize(unzip, path)

         if path

           @path = path[-1] == ?/ ? path : path + '/'

         else

           @path = ''

         end

       end

       # See UnzipTask#include

       def include(*files) #:doc:

         @include |= files

         self

       end

       # See UnzipTask#exclude

       def exclude(*files) #:doc:

         @exclude |= files

         self

       end

       def map(entries)

         excludes = @exclude || []

         entries.inject({}) do |map, entry|

           if entry.name =~ /^#{@path}/

             short = entry.name.sub(@path, '')

             if includes.any? { |pat| File.fnmatch(pat, short) } &&

                !excludes.any? { |pat| File.fnmatch(pat, short) }

               map[short] = entry

             end

           end

           map

         end

       end

       # Documented in Unzip.

       def root

       # The target directory to extract to.

       def target

   # :call-seq:

   #    unzip(to_dir=>zip_file) => Zip

   #

   # Creates a task that will unzip a file into the target directory. The task name

   # is the target directory, the prerequisite is the file to unzip.

   #

   # This method creates a file task to expand the zip file. It returns an Unzip object

   # that specifies how the file will be extracted. You can include or exclude specific

   # files from within the zip, and map to different paths.

   #

   # The Unzip object's to_s method return the path to the target directory, so you can

   # use it as a prerequisite. By keeping the Unzip object separate from the file task,

   # 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')

   def unzip(args)

     task = file(File.expand_path(target.to_s)=>zip_file)

     Unzip.new(task=>zip_file).tap do |setup|

       task.enhance { setup.extract }

     end

   end

 end