rubyzip 0.9.4 → 0.9.5

data/lib/zip/zip_input_stream.rb

@@ -0,0 +1,134 @@
+module Zip
+  # ZipInputStream is the basic class for reading zip entries in a 
+  # zip file. It is possible to create a ZipInputStream object directly, 
+  # passing the zip file name to the constructor, but more often than not 
+  # the ZipInputStream will be obtained from a ZipFile (perhaps using the 
+  # ZipFileSystem interface) object for a particular entry in the zip 
+  # archive.
+  #
+  # A ZipInputStream inherits IOExtras::AbstractInputStream in order
+  # to provide an IO-like interface for reading from a single zip 
+  # entry. Beyond methods for mimicking an IO-object it contains 
+  # the method get_next_entry for iterating through the entries of 
+  # an archive. get_next_entry returns a ZipEntry object that describes
+  # the zip entry the ZipInputStream is currently reading from.
+  #
+  # Example that creates a zip archive with ZipOutputStream and reads it 
+  # back again with a ZipInputStream.
+  #
+  #   require 'zip/zip'
+  #   
+  #   Zip::ZipOutputStream::open("my.zip") { 
+  #     |io|
+  #   
+  #     io.put_next_entry("first_entry.txt")
+  #     io.write "Hello world!"
+  #   
+  #     io.put_next_entry("adir/first_entry.txt")
+  #     io.write "Hello again!"
+  #   }
+  #
+  #   
+  #   Zip::ZipInputStream::open("my.zip") {
+  #     |io|
+  #   
+  #     while (entry = io.get_next_entry)
+  #       puts "Contents of #{entry.name}: '#{io.read}'"
+  #     end
+  #   }
+  #
+  # java.util.zip.ZipInputStream is the original inspiration for this 
+  # class.
+
+  class ZipInputStream 
+    include IOExtras::AbstractInputStream
+
+    # Opens the indicated zip file. An exception is thrown
+    # if the specified offset in the specified filename is
+    # not a local zip entry header.
+    def initialize(filename, offset = 0)
+      super()
+      @archiveIO = File.open(filename, "rb")
+      @archiveIO.seek(offset, IO::SEEK_SET)
+      @decompressor = NullDecompressor.instance
+      @currentEntry = nil
+    end
+    
+    def close
+      @archiveIO.close
+    end
+
+    # Same as #initialize but if a block is passed the opened
+    # stream is passed to the block and closed when the block
+    # returns.    
+    def ZipInputStream.open(filename)
+      return new(filename) unless block_given?
+      
+      zio = new(filename)
+      yield zio
+    ensure
+      zio.close if zio
+    end
+
+    # Returns a ZipEntry object. It is necessary to call this
+    # method on a newly created ZipInputStream before reading from 
+    # the first entry in the archive. Returns nil when there are 
+    # no more entries.
+
+    def get_next_entry
+      @archiveIO.seek(@currentEntry.next_header_offset, 
+                      IO::SEEK_SET) if @currentEntry
+      open_entry
+    end
+
+    # Rewinds the stream to the beginning of the current entry
+    def rewind
+      return if @currentEntry.nil?
+      @lineno = 0
+      @archiveIO.seek(@currentEntry.localHeaderOffset, 
+		      IO::SEEK_SET)
+      open_entry
+    end
+
+    # Modeled after IO.sysread
+    def sysread(numberOfBytes = nil, buf = nil)
+      @decompressor.sysread(numberOfBytes, buf)
+    end
+
+    def eof
+      @outputBuffer.empty? && @decompressor.eof
+    end
+    alias :eof? :eof
+
+    protected
+
+    def open_entry
+      @currentEntry = ZipEntry.read_local_entry(@archiveIO)
+      if (@currentEntry == nil) 
+	@decompressor = NullDecompressor.instance
+      elsif @currentEntry.compression_method == ZipEntry::STORED
+	@decompressor = PassThruDecompressor.new(@archiveIO, 
+						 @currentEntry.size)
+      elsif @currentEntry.compression_method == ZipEntry::DEFLATED
+	@decompressor = Inflater.new(@archiveIO)
+      else
+	raise ZipCompressionMethodError,
+	  "Unsupported compression method #{@currentEntry.compression_method}"
+      end
+      flush
+      return @currentEntry
+    end
+
+    def produce_input
+      @decompressor.produce_input
+    end
+
+    def input_finished?
+      @decompressor.input_finished?
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/zip_output_stream.rb

@@ -0,0 +1,172 @@
+module Zip
+  # ZipOutputStream is the basic class for writing zip files. It is
+  # possible to create a ZipOutputStream object directly, passing
+  # the zip file name to the constructor, but more often than not
+  # the ZipOutputStream will be obtained from a ZipFile (perhaps using the
+  # ZipFileSystem interface) object for a particular entry in the zip
+  # archive.
+  #
+  # A ZipOutputStream inherits IOExtras::AbstractOutputStream in order
+  # to provide an IO-like interface for writing to a single zip
+  # entry. Beyond methods for mimicking an IO-object it contains
+  # the method put_next_entry that closes the current entry
+  # and creates a new.
+  #
+  # Please refer to ZipInputStream for example code.
+  #
+  # java.util.zip.ZipOutputStream is the original inspiration for this
+  # class.
+
+  class ZipOutputStream
+    include IOExtras::AbstractOutputStream
+
+    attr_accessor :comment
+
+    # Opens the indicated zip file. If a file with that name already
+    # exists it will be overwritten.
+    def initialize(fileName, stream=false)
+      super()
+      @fileName = fileName
+      if stream
+        @outputStream = StringIO.new
+      else
+        @outputStream = File.new(@fileName, "wb")
+      end
+      @entrySet = ZipEntrySet.new
+      @compressor = NullCompressor.instance
+      @closed = false
+      @currentEntry = nil
+      @comment = nil
+    end
+
+    # Same as #initialize but if a block is passed the opened
+    # stream is passed to the block and closed when the block
+    # returns.
+    def ZipOutputStream.open(fileName)
+      return new(fileName) unless block_given?
+      zos = new(fileName)
+      yield zos
+    ensure
+      zos.close if zos
+    end
+
+	# Same as #open but writes to a filestream instead
+    def ZipOutputStream.write_buffer
+      zos = new('', true)
+      yield zos
+      return zos.close_buffer
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close
+      return if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @outputStream.close
+      @closed = true
+    end
+
+    # Closes the stream and writes the central directory to the zip file
+    def close_buffer
+      return @outputStream if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @closed = true
+      return @outputStream
+    end
+
+	  # Closes the current entry and opens a new for writing.
+    # +entry+ can be a ZipEntry object or a string.
+    def put_next_entry(entryname, comment = nil, extra = nil, compression_method = ZipEntry::DEFLATED,  level = Zlib::DEFAULT_COMPRESSION)
+      raise ZipError, "zip stream is closed" if @closed
+      new_entry = ZipEntry.new(@fileName, entryname.to_s)
+      new_entry.unix_perms = entryname.unix_perms if entryname.respond_to? :unix_perms
+      new_entry.comment = comment if !comment.nil?
+      if (!extra.nil?)
+        new_entry.extra = ZipExtraField === extra ? extra : ZipExtraField.new(extra.to_s)
+      end
+      new_entry.compression_method = compression_method
+      init_next_entry(new_entry, level)
+      @currentEntry = new_entry
+    end
+
+    def copy_raw_entry(entry)
+      entry = entry.dup
+      raise ZipError, "zip stream is closed" if @closed
+      raise ZipError, "entry is not a ZipEntry" if !entry.kind_of?(ZipEntry)
+      finalize_current_entry
+      @entrySet << entry
+      src_pos = entry.local_entry_offset
+      entry.write_local_entry(@outputStream)
+      @compressor = NullCompressor.instance
+      entry.get_raw_input_stream {
+        |is|
+        is.seek(src_pos, IO::SEEK_SET)
+        IOExtras.copy_stream_n(@outputStream, is, entry.compressed_size)
+      }
+      @compressor = NullCompressor.instance
+      @currentEntry = nil
+    end
+
+    private
+    def finalize_current_entry
+      return unless @currentEntry
+      finish
+      @currentEntry.compressed_size = @outputStream.tell - @currentEntry.localHeaderOffset -
+	    @currentEntry.calculate_local_header_size
+      @currentEntry.size = @compressor.size
+      @currentEntry.crc = @compressor.crc
+      @currentEntry = nil
+      @compressor = NullCompressor.instance
+    end
+
+    def init_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
+      finalize_current_entry
+      @entrySet << entry
+      entry.write_local_entry(@outputStream)
+      @compressor = get_compressor(entry, level)
+    end
+
+    def get_compressor(entry, level)
+      case entry.compression_method
+        when ZipEntry::DEFLATED then Deflater.new(@outputStream, level)
+        when ZipEntry::STORED   then PassThruCompressor.new(@outputStream)
+      else raise ZipCompressionMethodError,
+        "Invalid compression method: '#{entry.compression_method}'"
+      end
+    end
+
+    def update_local_headers
+      pos = @outputStream.tell
+      @entrySet.each {
+        |entry|
+        @outputStream.pos = entry.localHeaderOffset
+        entry.write_local_entry(@outputStream)
+      }
+      @outputStream.pos = pos
+    end
+
+    def write_central_directory
+      cdir = ZipCentralDirectory.new(@entrySet, @comment)
+      cdir.write_to_stream(@outputStream)
+    end
+
+    protected
+
+    def finish
+      @compressor.finish
+    end
+
+    public
+    # Modeled after IO.<<
+    def << (data)
+      @compressor << data
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/zip_streamable_directory.rb

@@ -0,0 +1,15 @@
+module Zip
+  class ZipStreamableDirectory < ZipEntry
+    def initialize(zipfile, entry, srcPath = nil, permissionInt = nil)
+      super(zipfile, entry)
+
+      @ftype = :directory
+      entry.get_extra_attributes_from_path(srcPath) if (srcPath)
+      @unix_perms = permissionInt if (permissionInt)
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/zip_streamable_stream.rb

@@ -0,0 +1,47 @@
+module Zip
+  class ZipStreamableStream < DelegateClass(ZipEntry) #nodoc:all
+    def initialize(entry)
+      super(entry)
+      @tempFile = Tempfile.new(File.basename(name), File.dirname(zipfile))
+      @tempFile.binmode
+    end
+
+    def get_output_stream
+      if block_given?
+        begin
+          yield(@tempFile)
+        ensure
+          @tempFile.close
+        end
+      else
+        @tempFile
+      end
+    end
+
+    def get_input_stream
+      if ! @tempFile.closed?
+        raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
+      end
+      @tempFile.open # reopens tempfile from top
+      @tempFile.binmode
+      if block_given?
+        begin
+          yield(@tempFile)
+        ensure
+          @tempFile.close
+        end
+      else
+        @tempFile
+      end
+    end
+    
+    def write_to_zip_output_stream(aZipOutputStream)
+      aZipOutputStream.put_next_entry(self)
+      get_input_stream { |is| IOExtras.copy_stream(aZipOutputStream, is) } 
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/zipfilesystem.rb

@@ -50,7 +50,7 @@ module Zip
     def dir
       @zipFsDir
     end
-    
+
     # Returns a ZipFsFile which is much like ruby's builtin File (class)
     # object, except it works on the ZipFile on which this method is
     # invoked
@@ -74,7 +74,7 @@ module Zip
           @zipFsFile = zipFsFile
           @entryName = entryName
         end
-        
+
         def forward_invoke(msg)
           @zipFsFile.send(msg, @entryName)
         end
@@ -82,7 +82,7 @@ module Zip
         def kind_of?(t)
           super || t == ::File::Stat 
         end
-        
+
         forward_message :forward_invoke, :file?, :directory?, :pipe?, :chardev?
         forward_message :forward_invoke, :symlink?, :socket?, :blockdev?
         forward_message :forward_invoke, :readable?, :readable_real?
@@ -93,7 +93,7 @@ module Zip
         forward_message :forward_invoke, :zero?
         forward_message :forward_invoke, :size, :size?
         forward_message :forward_invoke, :mtime, :atime, :ctime
-        
+
         def blocks; nil; end
 
         def get_entry
@@ -140,7 +140,7 @@ module Zip
         end
 
         def nlink; 1; end
-        
+
         def blksize; nil; end
 
         def mode
@@ -154,7 +154,7 @@ module Zip
       end
 
       def initialize(mappedZip)
-	@mappedZip = mappedZip
+        @mappedZip = mappedZip
       end
 
       def get_entry(fileName)
@@ -174,12 +174,12 @@ module Zip
         end
       end
       private :unix_mode_cmp
-      
+
       def exists?(fileName)
         expand_path(fileName) == "/" || @mappedZip.find_entry(fileName) != nil
       end
       alias :exist? :exists?
-      
+
       # Permissions not implemented, so if the file exists it is accessible
       alias owned?           exists?
       alias grpowned?        exists?
@@ -206,7 +206,7 @@ module Zip
       def setgid?(fileName)
         unix_mode_cmp(fileName, 02000)
       end
-      
+
       def sticky?(fileName)
         unix_mode_cmp(fileName, 01000)
       end
@@ -220,36 +220,36 @@ module Zip
       end
 
       def directory?(fileName)
-	entry = @mappedZip.find_entry(fileName)
-	expand_path(fileName) == "/" || (entry != nil && entry.directory?)
+        entry = @mappedZip.find_entry(fileName)
+        expand_path(fileName) == "/" || (entry != nil && entry.directory?)
       end
-      
-      def open(fileName, openMode = "r", &block)
+
+      def open(fileName, openMode = "r", permissionInt = 0644, &block)
         openMode.gsub!("b", "") # ignore b option
         case openMode
-        when "r" 
-          @mappedZip.get_input_stream(fileName, &block)
-        when "w"
-          @mappedZip.get_output_stream(fileName, &block)
-        else
-          raise StandardError, "openmode '#{openMode} not supported" unless openMode == "r"
+          when "r"
+            @mappedZip.get_input_stream(fileName, &block)
+          when "w"
+            @mappedZip.get_output_stream(fileName, permissionInt, &block)
+          else
+            raise StandardError, "openmode '#{openMode} not supported" unless openMode == "r"
         end
       end
 
       def new(fileName, openMode = "r")
-	open(fileName, openMode)
+        open(fileName, openMode)
       end
-      
+
       def size(fileName)
-	@mappedZip.get_entry(fileName).size
+        @mappedZip.get_entry(fileName).size
       end
-      
+
       # Returns nil for not found and nil for directories
       def size?(fileName)
-	entry = @mappedZip.find_entry(fileName)
-	return (entry == nil || entry.directory?) ? nil : entry.size
+        entry = @mappedZip.find_entry(fileName)
+        return (entry == nil || entry.directory?) ? nil : entry.size
       end
-      
+
       def chown(ownerInt, groupInt, *filenames)
         filenames.each { |fileName|
           e = get_entry(fileName)
@@ -266,39 +266,41 @@ module Zip
         filenames.each { |fileName|
           e = get_entry(fileName)
           e.fstype = 3 # force convertion filesystem type to unix
+          e.unix_perms = modeInt
           e.externalFileAttributes = modeInt << 16
+          e.dirty = true
         }
         filenames.size
       end
 
       def zero?(fileName)
-	sz = size(fileName)
-	sz == nil || sz == 0
+        sz = size(fileName)
+        sz == nil || sz == 0
       rescue Errno::ENOENT
-	false
+        false
       end
-      
+
       def file?(fileName)
-	entry = @mappedZip.find_entry(fileName)
-	entry != nil && entry.file?
+        entry = @mappedZip.find_entry(fileName)
+        entry != nil && entry.file?
       end      
-      
+
       def dirname(fileName)
-	::File.dirname(fileName)
+        ::File.dirname(fileName)
       end
-      
+
       def basename(fileName)
-	::File.basename(fileName)
+        ::File.basename(fileName)
       end
-      
+
       def split(fileName)
-	::File.split(fileName)
+        ::File.split(fileName)
       end
-      
+
       def join(*fragments)
-	::File.join(*fragments)
+        ::File.join(*fragments)
       end
-      
+
       def utime(modifiedTime, *fileNames)
         fileNames.each { |fileName|
           get_entry(fileName).time = modifiedTime
@@ -306,9 +308,9 @@ module Zip
       end
 
       def mtime(fileName)
-	@mappedZip.get_entry(fileName).mtime
+        @mappedZip.get_entry(fileName).mtime
       end
-      
+
       def atime(fileName)
         e = get_entry(fileName)
         if e.extra.member? "UniversalTime"
@@ -317,7 +319,7 @@ module Zip
           nil
         end
       end
-      
+
       def ctime(fileName)
         e = get_entry(fileName)
         if e.extra.member? "UniversalTime"
@@ -328,43 +330,43 @@ module Zip
       end
 
       def pipe?(filename)
-	false
+        false
       end
-      
+
       def blockdev?(filename)
-	false
+        false
       end
-      
+
       def chardev?(filename)
-	false
+        false
       end
-      
+
       def symlink?(fileName)
-	false
+        false
       end
-      
+
       def socket?(fileName)
-	false
+        false
       end
-      
+
       def ftype(fileName)
-	@mappedZip.get_entry(fileName).directory? ? "directory" : "file"
+        @mappedZip.get_entry(fileName).directory? ? "directory" : "file"
       end
-      
+
       def readlink(fileName)
-	raise NotImplementedError, "The readlink() function is not implemented"
+        raise NotImplementedError, "The readlink() function is not implemented"
       end
-      
+
       def symlink(fileName, symlinkName)
-	raise NotImplementedError, "The symlink() function is not implemented"
+        raise NotImplementedError, "The symlink() function is not implemented"
       end
 
       def link(fileName, symlinkName)
-	raise NotImplementedError, "The link() function is not implemented"
+        raise NotImplementedError, "The link() function is not implemented"
       end
 
       def pipe
-	raise NotImplementedError, "The pipe() function is not implemented"
+        raise NotImplementedError, "The pipe() function is not implemented"
       end
 
       def stat(fileName)
@@ -377,7 +379,7 @@ module Zip
       alias lstat stat
 
       def readlines(fileName)
-	open(fileName) { |is| is.readlines }
+        open(fileName) { |is| is.readlines }
       end
 
       def read(fileName)
@@ -385,21 +387,21 @@ module Zip
       end
 
       def popen(*args, &aProc)
-	File.popen(*args, &aProc)
+        File.popen(*args, &aProc)
       end
 
       def foreach(fileName, aSep = $/, &aProc)
-	open(fileName) { |is| is.each_line(aSep, &aProc) }
+        open(fileName) { |is| is.each_line(aSep, &aProc) }
       end
 
       def delete(*args)
-	args.each { 
-	  |fileName|
-	  if directory?(fileName)
-	    raise Errno::EISDIR, "Is a directory - \"#{fileName}\""
-	  end
-	  @mappedZip.remove(fileName) 
-	}
+        args.each {
+          |fileName|
+          if directory?(fileName)
+            raise Errno::EISDIR, "Is a directory - \"#{fileName}\""
+          end
+          @mappedZip.remove(fileName)
+        }
       end
 
       def rename(fileToRename, newName)
@@ -420,11 +422,11 @@ module Zip
     # The individual methods are not documented due to their
     # similarity with the methods in Dir
     class ZipFsDir
-      
+
       def initialize(mappedZip)
         @mappedZip = mappedZip
       end
-      
+
       attr_writer :file
 
       def new(aDirectoryName)
@@ -446,14 +448,14 @@ module Zip
 
       def pwd; @mappedZip.pwd; end
       alias getwd pwd
-      
+
       def chdir(aDirectoryName)
         unless @file.stat(aDirectoryName).directory?
           raise Errno::EINVAL, "Invalid argument - #{aDirectoryName}"
         end
         @mappedZip.pwd = @file.expand_path(aDirectoryName)
       end
-      
+
       def entries(aDirectoryName)
         entries = []
         foreach(aDirectoryName) { |e| entries << e }
@@ -465,7 +467,7 @@ module Zip
           raise Errno::ENOTDIR, aDirectoryName
         end
         path = @file.expand_path(aDirectoryName).ensure_end("/")
-
+        path = Regexp.escape(path)
         subDirEntriesRegex = Regexp.new("^#{path}([^/]+)$")
         @mappedZip.each { 
           |fileName|
@@ -482,13 +484,13 @@ module Zip
       end
       alias rmdir  delete
       alias unlink delete
-      
+
       def mkdir(entryName, permissionInt = 0755)
         @mappedZip.mkdir(entryName, permissionInt)
       end
-      
+
       def chroot(*args)
-      	raise NotImplementedError, "The chroot() function is not implemented"
+        raise NotImplementedError, "The chroot() function is not implemented"
       end
 
     end
@@ -540,13 +542,13 @@ module Zip
         @zipFile = zipFile
         @pwd = "/"
       end
-      
+
       attr_accessor :pwd
-      
+
       def find_entry(fileName)
         @zipFile.find_entry(expand_to_entry(fileName))
       end
-      
+
       def get_entry(fileName)
         @zipFile.get_entry(expand_to_entry(fileName))
       end
@@ -554,15 +556,15 @@ module Zip
       def get_input_stream(fileName, &aProc)
         @zipFile.get_input_stream(expand_to_entry(fileName), &aProc)
       end
-      
-      def get_output_stream(fileName, &aProc)
-        @zipFile.get_output_stream(expand_to_entry(fileName), &aProc)
+
+      def get_output_stream(fileName, permissionInt = nil, &aProc)
+        @zipFile.get_output_stream(expand_to_entry(fileName), permissionInt, &aProc)
       end
 
       def read(fileName)
         @zipFile.read(expand_to_entry(fileName))
       end
-      
+
       def remove(fileName)
         @zipFile.remove(expand_to_entry(fileName))
       end
@@ -584,9 +586,9 @@ module Zip
           yield("/"+e.to_s.chomp("/"))
         }
       end
-      
+
       def expand_path(aPath)
-        expanded = aPath.starts_with("/") ? aPath : @pwd.ensure_end("/") + aPath
+        expanded = aPath.start_with?("/") ? aPath : @pwd.ensure_end("/") + aPath
         expanded.gsub!(/\/\.(\/|$)/, "")
         expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, "")
         expanded.empty? ? "/" : expanded