realityforge-buildr 1.5.9

data/lib/buildr/packaging/zip.rb

@@ -0,0 +1,189 @@
+# 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'
+
+if RUBY_VERSION >= '1.9.0' # Required to properly load RubyZip under Ruby 1.9
+  $LOADED_FEATURES.unshift 'ftools'
+  require 'fileutils'
+
+  def File.move(source, dest)
+    FileUtils.move source, dest
+  end
+
+  def File.rm_rf(path)
+    FileUtils.rm_rf path
+  end
+end
+
+module Zip #:nodoc:
+
+  class CentralDirectory #:nodoc:
+    # Patch to add entries in alphabetical order.
+    def write_to_stream(io)
+      offset = io.tell
+      @entry_set.sort { |a,b| a.name <=> b.name }.each { |entry| entry.write_c_dir_entry(io) }
+      eocd_offset = io.tell
+      cdir_size = eocd_offset - offset
+      write_e_o_c_d(io, offset, cdir_size)
+    end
+  end
+
+  class File
+
+    # :call-seq:
+    #   exist() => boolean
+    #
+    # Returns true if this entry exists.
+    def exist?(entry_name)
+      !!find_entry(entry_name)
+    end
+  end
+
+
+  class Entry
+
+    # :call-seq:
+    #   exist() => boolean
+    #
+    # Returns true if this entry exists.
+    def exist?()
+      File.open(zipfile) { |zip| zip.exist?(@name) }
+    end
+
+    # :call-seq:
+    #   empty?() => boolean
+    #
+    # Returns true if this entry is empty.
+    def empty?()
+      File.open(zipfile) { |zip| zip.read(@name) }.empty?
+    end
+
+    # :call-seq:
+    #   contain(patterns*) => boolean
+    #
+    # Returns true if this ZIP file entry matches against all the arguments. An argument may be
+    # a string or regular expression.
+    def contain?(*patterns)
+      content = File.open(zipfile) { |zip| zip.read(@name) }
+      patterns.map { |pattern| Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern.to_s)) }.
+        all? { |pattern| content =~ pattern }
+    end
+
+    # Override of write_c_dir_entry to fix comments being set to a fixnum instead of string
+    def write_c_dir_entry(io) #:nodoc:all
+      case @fstype
+        when FSTYPE_UNIX
+          ft = nil
+          case @ftype
+            when :file
+              ft = 010
+              @unix_perms ||= 0644
+            when :directory
+              ft = 004
+              @unix_perms ||= 0755
+            when :symlink
+              ft = 012
+              @unix_perms ||= 0755
+            else
+              raise ZipInternalError, "unknown file type #{self.inspect}"
+          end
+
+          @external_file_attributes = (ft << 12 | (@unix_perms & 07777)) << 16
+      end
+
+      io <<
+        [0x02014b50,
+         @version,                  # version of encoding software
+         @fstype,                   # filesystem type
+         10,                        # @versionNeededToExtract
+         0,                         # @gp_flags
+         @compression_method,
+         @time.to_binary_dos_time,  # @lastModTime
+         @time.to_binary_dos_date,  # @lastModDate
+         @crc,
+         @compressed_size,
+         @size,
+         @name ? @name.length : 0,
+         @extra ? @extra.c_dir_size : 0,
+         @comment ? comment.to_s.length : 0,
+         0,                         # disk number start
+         @internal_file_attributes,   # file type (binary=0, text=1)
+         @external_file_attributes,   # native filesystem attributes
+         @local_header_offset,
+         @name,
+         @extra,
+         @comment
+      ].pack('VCCvvvvvVVVvvvvvVV')
+
+      io << @name
+      io << (@extra ? @extra.to_c_dir_bin : "")
+      io << @comment
+    end
+
+    # Override write_c_dir_entry to fix comments being set to a fixnum instead of string
+    def write_c_dir_entry(io) #:nodoc:all
+      @comment = "" if @comment.nil? || @comment == -1  # Hack fix @comment being nil or fixnum -1
+
+      case @fstype
+        when FSTYPE_UNIX
+          ft = nil
+          case @ftype
+            when :file
+              ft = 010
+              @unix_perms ||= 0644
+            when :directory
+              ft = 004
+              @unix_perms ||= 0755
+            when :symlink
+              ft = 012
+              @unix_perms ||= 0755
+            else
+              raise ZipInternalError, "unknown file type #{self.inspect}"
+          end
+
+          @external_file_attributes = (ft << 12 | (@unix_perms & 07777)) << 16
+      end
+
+      io <<
+        [0x02014b50,
+         @version,                  # version of encoding software
+         @fstype,                   # filesystem type
+         10,                        # @versionNeededToExtract
+         0,                         # @gp_flags
+         @compression_method,
+         @time.to_binary_dos_time,  # @lastModTime
+         @time.to_binary_dos_date,  # @lastModDate
+         @crc,
+         @compressed_size,
+         @size,
+         @name ? @name.length : 0,
+         @extra ? @extra.c_dir_size : 0,
+         @comment ? @comment.length : 0,
+         0,                         # disk number start
+         @internal_file_attributes,   # file type (binary=0, text=1)
+         @external_file_attributes,   # native filesystem attributes
+         @local_header_offset,
+         @name,
+         @extra,
+         @comment].pack('VCCvvvvvVVVvvvvvVV')
+
+      io << @name
+      io << (@extra ? @extra.to_c_dir_bin : "")
+      io << @comment
+
+    end
+  end
+end

data/lib/buildr/packaging/ziptask.rb

@@ -0,0 +1,387 @@
+# 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 #:nodoc:
+
+  # 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 level for this Zip.
+    attr_accessor :compression_level
+
+    def initialize(*args) #:nodoc:
+      self.compression_level = Zlib::DEFAULT_COMPRESSION
+      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)
+      ::Zip::Entry.new(name, entry_name)
+    end
+
+    def entries #:nodoc:
+      @entries ||= Zip::File.open(name) { |zip| zip.entries }
+    end
+
+    private
+
+    def create_from(file_map, transform_map)
+      Zip::OutputStream.open name do |zip|
+        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
+
+        paths = file_map.keys.sort
+        paths.each do |path|
+          contents = file_map[path]
+          warn "Warning:  Path in zipfile #{name} contains backslash: #{path}" if path =~ /\\/
+
+          # Must ensure that the directory entry is created for intermediate paths, otherwise
+          # zips can be created without entries for directories which can break some tools
+          mkpath.call File.dirname(path)
+
+          entry_created = false
+          to_transform = []
+          transform = transform_map.key?(path)
+          [contents].flatten.each do |content|
+            if content.respond_to?(:call)
+              unless entry_created
+                entry = zip.put_next_entry(path, compression_level)
+                entry.unix_perms = content.mode & 07777 if content.respond_to?(:mode)
+                entry_created = true
+              end
+              if transform
+                output = StringIO.new
+                content.call output
+                to_transform << output.string
+              else
+                content.call zip
+              end
+            elsif content.nil? || File.directory?(content.to_s)
+              mkpath.call path
+            else
+              File.open content.to_s, 'rb' do |is|
+                unless entry_created
+                  entry = zip.put_next_entry(path, compression_level)
+                  entry.unix_perms = is.stat.mode & 07777
+                  entry_created = true
+                end
+                if transform
+                  output = StringIO.new
+                  while data = is.read(4096)
+                    output << data
+                  end
+                  to_transform << output.string
+                else
+                  while data = is.read(4096)
+                    zip << data
+                  end
+                end
+              end
+            end
+          end
+          if transform_map.key?(path)
+            zip << transform_map[path].call(to_transform)
+          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)
+    ZipTask.define_task(file)
+  end
+
+
+  # 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
+    # The target directory to extract to.
+    attr_accessor :target
+
+    # Initialize with hash argument of the form target=>zip_file.
+    def initialize(args)
+      @target, arg_names, zip_file = Buildr.application.resolve_args([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
+      # If no paths specified, then no include/exclude patterns
+      # 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
+                  File.open(dest, 'wb', entry.mode) {|f| f.write entry.read}
+                  File.chmod(entry.mode, dest)
+                end
+              end
+            end
+          end
+        }
+      else
+        Zip::File.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)
+      @paths.each do |path, patterns|
+        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)
+      if Hash === files.last
+        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)
+      if Hash === files.last
+        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)
+      @paths[name] ||= FromPath.new(self, name)
+    end
+    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
+      self
+    end
+
+    # Returns the path to the target directory.
+    def to_s
+      target.to_s
+    end
+
+    class FromPath #:nodoc:
+
+      def initialize(unzip, path)
+        @unzip = unzip
+        if path
+          @path = path[-1] == ?/ ? path : path + '/'
+        else
+          @path = ''
+        end
+      end
+
+      # See UnzipTask#include
+      def include(*files) #:doc:
+        @include ||= []
+        @include |= files
+        self
+      end
+
+      # See UnzipTask#exclude
+      def exclude(*files) #:doc:
+        @exclude ||= []
+        @exclude |= files
+        self
+      end
+
+      def map(entries)
+        includes = @include || ['*']
+        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
+        @unzip
+      end
+
+      # The target directory to extract to.
+      def target
+        @unzip.target
+      end
+
+    end
+
+  end
+
+  # :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)
+    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 }
+    end
+  end
+
+end