mezza-rubyzip 0.9.4.1

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,171 @@
+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.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

@@ -0,0 +1,610 @@
+require 'zip/zip'
+
+module Zip
+
+  # The ZipFileSystem API provides an API for accessing entries in 
+  # a zip archive that is similar to ruby's builtin File and Dir 
+  # classes.
+  #
+  # Requiring 'zip/zipfilesystem' includes this module in ZipFile
+  # making the methods in this module available on ZipFile objects.
+  #
+  # Using this API the following example creates a new zip file 
+  # <code>my.zip</code> containing a normal entry with the name
+  # <code>first.txt</code>, a directory entry named <code>mydir</code>
+  # and finally another normal entry named <code>second.txt</code>
+  #
+  #   require 'zip/zipfilesystem'
+  #   
+  #   Zip::ZipFile.open("my.zip", Zip::ZipFile::CREATE) {
+  #     |zipfile|
+  #     zipfile.file.open("first.txt", "w") { |f| f.puts "Hello world" }
+  #     zipfile.dir.mkdir("mydir")
+  #     zipfile.file.open("mydir/second.txt", "w") { |f| f.puts "Hello again" }
+  #   }
+  #
+  # Reading is as easy as writing, as the following example shows. The 
+  # example writes the contents of <code>first.txt</code> from zip archive
+  # <code>my.zip</code> to standard out.
+  #
+  #   require 'zip/zipfilesystem'
+  #   
+  #   Zip::ZipFile.open("my.zip") {
+  #     |zipfile|
+  #     puts zipfile.file.read("first.txt")
+  #   }
+
+  module ZipFileSystem
+
+    def initialize # :nodoc:
+      mappedZip = ZipFileNameMapper.new(self)
+      @zipFsDir  = ZipFsDir.new(mappedZip)
+      @zipFsFile = ZipFsFile.new(mappedZip)
+      @zipFsDir.file = @zipFsFile
+      @zipFsFile.dir = @zipFsDir
+    end
+
+    # Returns a ZipFsDir which is much like ruby's builtin Dir (class)
+    # object, except it works on the ZipFile on which this method is
+    # invoked
+    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
+    def file
+      @zipFsFile
+    end
+
+    # Instances of this class are normally accessed via the accessor
+    # ZipFile::file. An instance of ZipFsFile behaves like ruby's
+    # builtin File (class) object, except it works on ZipFile entries.
+    #
+    # The individual methods are not documented due to their
+    # similarity with the methods in File
+    class ZipFsFile
+
+      attr_writer :dir
+#      protected :dir
+
+      class ZipFsStat
+        def initialize(zipFsFile, entryName)
+          @zipFsFile = zipFsFile
+          @entryName = entryName
+        end
+        
+        def forward_invoke(msg)
+          @zipFsFile.send(msg, @entryName)
+        end
+
+        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?
+        forward_message :forward_invoke, :writable?, :writable_real?
+        forward_message :forward_invoke, :executable?, :executable_real?
+        forward_message :forward_invoke, :sticky?, :owned?, :grpowned?
+        forward_message :forward_invoke, :setuid?, :setgid?
+        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
+          @zipFsFile.__send__(:get_entry, @entryName)
+        end
+        private :get_entry
+
+        def gid
+          e = get_entry
+          if e.extra.member? "IUnix"
+            e.extra["IUnix"].gid || 0
+          else
+            0
+          end
+        end
+
+        def uid
+          e = get_entry
+          if e.extra.member? "IUnix"
+            e.extra["IUnix"].uid || 0
+          else
+            0
+          end
+        end
+
+        def ino; 0; end
+
+        def dev; 0; end
+
+        def rdev; 0; end
+
+        def rdev_major; 0; end
+
+        def rdev_minor; 0; end
+
+        def ftype
+          if file?
+            return "file"
+          elsif directory?
+            return "directory"
+          else
+            raise StandardError, "Unknown file type"
+          end
+        end
+
+        def nlink; 1; end
+        
+        def blksize; nil; end
+
+        def mode
+          e = get_entry
+          if e.fstype == 3
+            e.externalFileAttributes >> 16
+          else
+            33206 # 33206 is equivalent to -rw-rw-rw-
+          end
+        end
+      end
+
+      def initialize(mappedZip)
+	@mappedZip = mappedZip
+      end
+
+      def get_entry(fileName)
+        if ! exists?(fileName)
+          raise Errno::ENOENT, "No such file or directory - #{fileName}"
+        end
+        @mappedZip.find_entry(fileName)
+      end
+      private :get_entry
+
+      def unix_mode_cmp(fileName, mode)
+        begin
+          e = get_entry(fileName)
+          e.fstype == 3 && ((e.externalFileAttributes >> 16) & mode ) != 0
+        rescue Errno::ENOENT
+          false
+        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?
+
+      def readable?(fileName)
+        unix_mode_cmp(fileName, 0444)
+      end
+      alias readable_real?   readable?
+
+      def writable?(fileName)
+        unix_mode_cmp(fileName, 0222)
+      end
+      alias writable_real?   writable?
+
+      def executable?(fileName)
+        unix_mode_cmp(fileName, 0111)
+      end
+      alias executable_real? executable?
+
+      def setuid?(fileName)
+        unix_mode_cmp(fileName, 04000)
+      end
+
+      def setgid?(fileName)
+        unix_mode_cmp(fileName, 02000)
+      end
+      
+      def sticky?(fileName)
+        unix_mode_cmp(fileName, 01000)
+      end
+
+      def umask(*args)
+        ::File.umask(*args)
+      end
+
+      def truncate(fileName, len)
+        raise StandardError, "truncate not supported"
+      end
+
+      def directory?(fileName)
+	entry = @mappedZip.find_entry(fileName)
+	expand_path(fileName) == "/" || (entry != nil && entry.directory?)
+      end
+      
+      def open(fileName, openMode = "r", &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"
+        end
+      end
+
+      def new(fileName, openMode = "r")
+	open(fileName, openMode)
+      end
+      
+      def size(fileName)
+	@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
+      end
+      
+      def chown(ownerInt, groupInt, *filenames)
+        filenames.each { |fileName|
+          e = get_entry(fileName)
+          unless e.extra.member?("IUnix")
+            e.extra.create("IUnix")
+          end
+          e.extra["IUnix"].uid = ownerInt
+          e.extra["IUnix"].gid = groupInt
+        }
+        filenames.size
+      end
+
+      def chmod (modeInt, *filenames)
+        filenames.each { |fileName|
+          e = get_entry(fileName)
+          e.fstype = 3 # force convertion filesystem type to unix
+          e.externalFileAttributes = modeInt << 16
+        }
+        filenames.size
+      end
+
+      def zero?(fileName)
+	sz = size(fileName)
+	sz == nil || sz == 0
+      rescue Errno::ENOENT
+	false
+      end
+      
+      def file?(fileName)
+	entry = @mappedZip.find_entry(fileName)
+	entry != nil && entry.file?
+      end      
+      
+      def dirname(fileName)
+	::File.dirname(fileName)
+      end
+      
+      def basename(fileName)
+	::File.basename(fileName)
+      end
+      
+      def split(fileName)
+	::File.split(fileName)
+      end
+      
+      def join(*fragments)
+	::File.join(*fragments)
+      end
+      
+      def utime(modifiedTime, *fileNames)
+        fileNames.each { |fileName|
+          get_entry(fileName).time = modifiedTime
+        }
+      end
+
+      def mtime(fileName)
+	@mappedZip.get_entry(fileName).mtime
+      end
+      
+      def atime(fileName)
+        e = get_entry(fileName)
+        if e.extra.member? "UniversalTime"
+          e.extra["UniversalTime"].atime
+        else
+          nil
+        end
+      end
+      
+      def ctime(fileName)
+        e = get_entry(fileName)
+        if e.extra.member? "UniversalTime"
+          e.extra["UniversalTime"].ctime
+        else
+          nil
+        end
+      end
+
+      def pipe?(filename)
+	false
+      end
+      
+      def blockdev?(filename)
+	false
+      end
+      
+      def chardev?(filename)
+	false
+      end
+      
+      def symlink?(fileName)
+	false
+      end
+      
+      def socket?(fileName)
+	false
+      end
+      
+      def ftype(fileName)
+	@mappedZip.get_entry(fileName).directory? ? "directory" : "file"
+      end
+      
+      def readlink(fileName)
+	raise NotImplementedError, "The readlink() function is not implemented"
+      end
+      
+      def symlink(fileName, symlinkName)
+	raise NotImplementedError, "The symlink() function is not implemented"
+      end
+
+      def link(fileName, symlinkName)
+	raise NotImplementedError, "The link() function is not implemented"
+      end
+
+      def pipe
+	raise NotImplementedError, "The pipe() function is not implemented"
+      end
+
+      def stat(fileName)
+        if ! exists?(fileName)
+          raise Errno::ENOENT, fileName
+        end
+        ZipFsStat.new(self, fileName)
+      end
+
+      alias lstat stat
+
+      def readlines(fileName)
+	open(fileName) { |is| is.readlines }
+      end
+
+      def read(fileName)
+        @mappedZip.read(fileName)
+      end
+
+      def popen(*args, &aProc)
+	File.popen(*args, &aProc)
+      end
+
+      def foreach(fileName, 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) 
+	}
+      end
+
+      def rename(fileToRename, newName)
+        @mappedZip.rename(fileToRename, newName) { true }
+      end
+
+      alias :unlink :delete
+
+      def expand_path(aPath)
+        @mappedZip.expand_path(aPath)
+      end
+    end
+
+    # Instances of this class are normally accessed via the accessor
+    # ZipFile::dir. An instance of ZipFsDir behaves like ruby's
+    # builtin Dir (class) object, except it works on ZipFile entries.
+    #
+    # 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)
+        ZipFsDirIterator.new(entries(aDirectoryName))
+      end
+
+      def open(aDirectoryName)
+        dirIt = new(aDirectoryName)
+        if block_given?
+          begin
+            yield(dirIt)
+            return nil
+          ensure
+            dirIt.close
+          end
+        end
+        dirIt
+      end
+
+      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 }
+        entries
+      end
+
+      def foreach(aDirectoryName)
+        unless @file.stat(aDirectoryName).directory?
+          raise Errno::ENOTDIR, aDirectoryName
+        end
+        path = @file.expand_path(aDirectoryName).ensure_end("/")
+
+        subDirEntriesRegex = Regexp.new("^#{path}([^/]+)$")
+        @mappedZip.each { 
+          |fileName|
+          match = subDirEntriesRegex.match(fileName)
+          yield(match[1]) unless match == nil
+        }
+      end
+
+      def delete(entryName)
+        unless @file.stat(entryName).directory?
+          raise Errno::EINVAL, "Invalid argument - #{entryName}"
+        end
+        @mappedZip.remove(entryName)
+      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"
+      end
+
+    end
+
+    class ZipFsDirIterator # :nodoc:all
+      include Enumerable
+
+      def initialize(arrayOfFileNames)
+        @fileNames = arrayOfFileNames
+        @index = 0
+      end
+
+      def close
+        @fileNames = nil
+      end
+
+      def each(&aProc)
+        raise IOError, "closed directory" if @fileNames == nil
+        @fileNames.each(&aProc)
+      end
+
+      def read
+        raise IOError, "closed directory" if @fileNames == nil
+        @fileNames[(@index+=1)-1]
+      end
+
+      def rewind
+        raise IOError, "closed directory" if @fileNames == nil
+        @index = 0
+      end
+
+      def seek(anIntegerPosition)
+        raise IOError, "closed directory" if @fileNames == nil
+        @index = anIntegerPosition
+      end
+
+      def tell
+        raise IOError, "closed directory" if @fileNames == nil
+        @index
+      end
+    end
+
+    # All access to ZipFile from ZipFsFile and ZipFsDir goes through a
+    # ZipFileNameMapper, which has one responsibility: ensure
+    class ZipFileNameMapper # :nodoc:all
+      include Enumerable
+
+      def initialize(zipFile)
+        @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
+
+      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)
+      end
+
+      def read(fileName)
+        @zipFile.read(expand_to_entry(fileName))
+      end
+      
+      def remove(fileName)
+        @zipFile.remove(expand_to_entry(fileName))
+      end
+
+      def rename(fileName, newName, &continueOnExistsProc)
+        @zipFile.rename(expand_to_entry(fileName), expand_to_entry(newName), 
+                        &continueOnExistsProc)
+      end
+
+      def mkdir(fileName, permissionInt = 0755)
+        @zipFile.mkdir(expand_to_entry(fileName), permissionInt)
+      end
+
+      # Turns entries into strings and adds leading /
+      # and removes trailing slash on directories
+      def each
+        @zipFile.each {
+          |e|
+          yield("/"+e.to_s.chomp("/"))
+        }
+      end
+      
+      def expand_path(aPath)
+        expanded = aPath.starts_with("/") ? aPath : @pwd.ensure_end("/") + aPath
+        expanded.gsub!(/\/\.(\/|$)/, "")
+        expanded.gsub!(/[^\/]+\/\.\.(\/|$)/, "")
+        expanded.empty? ? "/" : expanded
+      end
+
+      private
+
+      def expand_to_entry(aPath)
+        expand_path(aPath).lchop
+      end
+    end
+  end
+
+  class ZipFile
+    include ZipFileSystem
+  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.