rwdmovies 0.90 → 0.91

data/extras/zip/ioextras.rb

@@ -0,0 +1,114 @@
+module IOExtras
+  module FakeIO
+    def kind_of?(object)
+      object == IO || super
+    end
+  end
+
+  # Implements many of the convenience methods of IO
+  # such as gets, getc, readline and readlines 
+  # depends on: input_finished?, produce_input and read
+  module AbstractInputStream  
+    include Enumerable
+    include FakeIO
+
+    def initialize
+      super
+      @lineno = 0
+      @outputBuffer = ""
+    end
+
+    attr_accessor :lineno
+
+    def readlines(aSepString = $/)
+      retVal = []
+      each_line(aSepString) { |line| retVal << line }
+      return retVal
+    end
+    
+    def gets(aSepString=$/)
+      @lineno = @lineno.next
+      return read if aSepString == nil
+      aSepString="#{$/}#{$/}" if aSepString == ""
+      
+      bufferIndex=0
+      while ((matchIndex = @outputBuffer.index(aSepString, bufferIndex)) == nil)
+	bufferIndex=@outputBuffer.length
+	if input_finished?
+	  return @outputBuffer.empty? ? nil : flush 
+	end
+	@outputBuffer << produce_input
+      end
+      sepIndex=matchIndex + aSepString.length
+      return @outputBuffer.slice!(0...sepIndex)
+    end
+    
+    def flush
+      retVal=@outputBuffer
+      @outputBuffer=""
+      return retVal
+    end
+    
+    def readline(aSepString = $/)
+      retVal = gets(aSepString)
+      raise EOFError if retVal == nil
+      return retVal
+    end
+    
+    def each_line(aSepString = $/)
+      while true
+	yield readline(aSepString)
+      end
+    rescue EOFError
+    end
+    
+    alias_method :each, :each_line
+  end
+
+
+  #relies on <<
+  module AbstractOutputStream 
+    include FakeIO
+
+    def write(data)
+      self << data
+      data.to_s.length
+    end
+
+
+    def print(*params)
+      self << params.to_s << $\.to_s
+    end
+
+    def printf(aFormatString, *params)
+      self << sprintf(aFormatString, *params)
+    end
+
+    def putc(anObject)
+      self << case anObject
+	      when Fixnum then anObject.chr
+	      when String then anObject
+	      else raise TypeError, "putc: Only Fixnum and String supported"
+	      end
+      anObject
+    end
+    
+    def puts(*params)
+      params << "\n" if params.empty?
+      params.flatten.each {
+	|element|
+	val = element.to_s
+	self << val
+	self << "\n" unless val[-1,1] == "\n"
+      }
+    end
+
+  end
+
+end # IOExtras namespace module
+
+
+
+# Copyright (C) 2002-2004 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/extras/zip/stdrubyext.rb

@@ -0,0 +1,111 @@
+unless Enumerable.method_defined?(:inject)
+  module Enumerable  #:nodoc:all
+    def inject(n = 0)
+      each { |value| n = yield(n, value) }
+      n
+    end
+  end
+end
+
+module Enumerable #:nodoc:all
+  # returns a new array of all the return values not equal to nil
+  # This implementation could be faster
+  def select_map(&aProc)
+    map(&aProc).reject { |e| e.nil? }
+  end
+end
+
+unless Object.method_defined?(:object_id)
+  class Object
+    # Using object_id which is the new thing, so we need
+    # to make that work in versions prior to 1.8.0
+    alias object_id id
+  end
+end
+
+unless File.respond_to?(:read)
+  class File
+    # singleton method read does not exist in 1.6.x
+    def self.read(fileName)
+      open(fileName) { |f| f.read }
+    end
+  end
+end
+
+class String
+  def starts_with(aString)
+    rindex(aString, 0) == 0
+  end
+
+  def ends_with(aString)
+    index(aString, -aString.size)
+  end
+
+  def ensure_end(aString)
+    ends_with(aString) ? self : self + aString
+  end
+
+  def lchop
+    slice(1, length)
+  end
+end
+
+class Time
+  
+  #MS-DOS File Date and Time format as used in Interrupt 21H Function 57H:
+  # 
+  # Register CX, the Time:
+  # Bits 0-4  2 second increments (0-29)
+  # Bits 5-10 minutes (0-59)
+  # bits 11-15 hours (0-24)
+  # 
+  # Register DX, the Date:
+  # Bits 0-4 day (1-31)
+  # bits 5-8 month (1-12)
+  # bits 9-15 year (four digit year minus 1980)
+  
+  
+  def to_binary_dos_time
+    (sec/2) +
+      (min  << 5) +
+      (hour << 11)
+  end
+
+  def to_binary_dos_date
+    (day) +
+      (month << 5) +
+      ((year - 1980) << 9)
+  end
+
+  # Dos time is only stored with two seconds accuracy
+  def dos_equals(other)
+    to_i/2 == other.to_i/2
+  end
+
+  def self.parse_binary_dos_format(binaryDosDate, binaryDosTime)
+    second = 2 * (       0b11111 & binaryDosTime)
+    minute = (     0b11111100000 & binaryDosTime) >> 5 
+    hour   = (0b1111100000000000 & binaryDosTime) >> 11
+    day    = (           0b11111 & binaryDosDate) 
+    month  = (       0b111100000 & binaryDosDate) >> 5
+    year   = ((0b1111111000000000 & binaryDosDate) >> 9) + 1980
+    begin
+      return Time.local(year, month, day, hour, minute, second)
+    end
+  end
+end
+
+class Module
+  def forward_message(forwarder, *messagesToForward)
+    methodDefs = messagesToForward.map { 
+      |msg| 
+      "def #{msg}; #{forwarder}(:#{msg}); end"
+    }
+    module_eval(methodDefs.join("\n"))
+  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/extras/zip/tempfile_bugfixed.rb

@@ -0,0 +1,195 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id: tempfile_bugfixed.rb,v 1.2 2004/03/28 12:46:36 thomas Exp $
+#
+
+require 'delegate'
+require 'tmpdir'
+
+module BugFix
+
+# A class for managing temporary files.  This library is written to be
+# thread safe.
+class Tempfile < DelegateClass(File)
+  MAX_TRY = 10
+  @@cleanlist = []
+
+  # Creates a temporary file of mode 0600 in the temporary directory
+  # whose name is basename.pid.n and opens with mode "w+".  A Tempfile
+  # object works just like a File object.
+  #
+  # If tmpdir is omitted, the temporary directory is determined by
+  # Dir::tmpdir provided by 'tmpdir.rb'.
+  # When $SAFE > 0 and the given tmpdir is tainted, it uses
+  # /tmp. (Note that ENV values are tainted by default)
+  def initialize(basename, tmpdir=Dir::tmpdir)
+    if $SAFE > 0 and tmpdir.tainted?
+      tmpdir = '/tmp'
+    end
+
+    lock = nil
+    n = failure = 0
+    
+    begin
+      Thread.critical = true
+
+      begin
+	tmpname = sprintf('%s/%s%d.%d', tmpdir, basename, $$, n)
+	lock = tmpname + '.lock'
+	n += 1
+      end while @@cleanlist.include?(tmpname) or
+	File.exist?(lock) or File.exist?(tmpname)
+
+      Dir.mkdir(lock)
+    rescue
+      failure += 1
+      retry if failure < MAX_TRY
+      raise "cannot generate tempfile `%s'" % tmpname
+    ensure
+      Thread.critical = false
+    end
+
+    @data = [tmpname]
+    @clean_proc = Tempfile.callback(@data)
+    ObjectSpace.define_finalizer(self, @clean_proc)
+
+    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+    @tmpname = tmpname
+    @@cleanlist << @tmpname
+    @data[1] = @tmpfile
+    @data[2] = @@cleanlist
+
+    super(@tmpfile)
+
+    # Now we have all the File/IO methods defined, you must not
+    # carelessly put bare puts(), etc. after this.
+
+    Dir.rmdir(lock)
+  end
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, 'r+')
+    @data[1] = @tmpfile
+    __setobj__(@tmpfile)
+  end
+
+  def _close	# :nodoc:
+    @tmpfile.close if @tmpfile
+    @data[1] = @tmpfile = nil
+  end    
+  protected :_close
+
+  # Closes the file.  If the optional flag is true, unlinks the file
+  # after closing.
+  #
+  # If you don't explicitly unlink the temporary file, the removal
+  # will be delayed until the object is finalized.
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  # Closes and unlinks the file.
+  def close!
+    _close
+    @clean_proc.call
+    ObjectSpace.undefine_finalizer(self)
+  end
+
+  # Unlinks the file.  On UNIX-like systems, it is often a good idea
+  # to unlink a temporary file immediately after creating and opening
+  # it, because it leaves other programs zero chance to access the
+  # file.
+  def unlink
+    # keep this order for thread safeness
+    File.unlink(@tmpname) if File.exist?(@tmpname)
+    @@cleanlist.delete(@tmpname) if @@cleanlist
+  end
+  alias delete unlink
+
+  if RUBY_VERSION > '1.8.0'
+    def __setobj__(obj)
+      @_dc_obj = obj
+    end
+  else
+    def __setobj__(obj)
+      @obj = obj
+    end
+  end
+
+  # Returns the full path name of the temporary file.
+  def path
+    @tmpname
+  end
+
+  # Returns the size of the temporary file.  As a side effect, the IO
+  # buffer is flushed before determining the size.
+  def size
+    if @tmpfile
+      @tmpfile.flush
+      @tmpfile.stat.size
+    else
+      0
+    end
+  end
+  alias length size
+
+  class << self
+    def callback(data)	# :nodoc:
+      pid = $$
+      lambda{
+	if pid == $$ 
+	  path, tmpfile, cleanlist = *data
+
+	  print "removing ", path, "..." if $DEBUG
+
+	  tmpfile.close if tmpfile
+
+	  # keep this order for thread safeness
+	  File.unlink(path) if File.exist?(path)
+	  cleanlist.delete(path) if cleanlist
+
+	  print "done\n" if $DEBUG
+	end
+      }
+    end
+
+    # If no block is given, this is a synonym for new().
+    #
+    # If a block is given, it will be passed tempfile as an argument,
+    # and the tempfile will automatically be closed when the block
+    # terminates.  In this case, open() returns nil.
+    def open(*args)
+      tempfile = new(*args)
+
+      if block_given?
+	begin
+	  yield(tempfile)
+	ensure
+	  tempfile.close
+	end
+
+	nil
+      else
+	tempfile
+      end
+    end
+  end
+end
+
+end # module BugFix
+if __FILE__ == $0
+#  $DEBUG = true
+  f = Tempfile.new("foo")
+  f.print("foo\n")
+  f.close
+  f.open
+  p f.gets # => "foo\n"
+  f.close!
+end

data/extras/zip/zip.rb

@@ -0,0 +1,1377 @@
+
+require 'delegate'
+require 'singleton'
+require 'tempfile'
+require 'ftools'
+require 'zlib'
+require 'extras/zip/stdrubyext'
+require 'extras/zip/ioextras'
+
+if Tempfile.superclass == SimpleDelegator
+  require 'zip/tempfile_bugfixed'
+  Tempfile = BugFix::Tempfile
+end
+
+module Zlib
+  if ! const_defined? :MAX_WBITS
+    MAX_WBITS = Zlib::Deflate.MAX_WBITS
+  end
+end
+
+module Zip
+
+  RUBY_MINOR_VERSION = RUBY_VERSION.split(".")[1].to_i
+
+  # Ruby 1.7.x compatibility
+  # In ruby 1.6.x and 1.8.0 reading from an empty stream returns 
+  # an empty string the first time and then nil.
+  #  not so in 1.7.x
+  EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST = RUBY_MINOR_VERSION != 7
+  
+  class ZipInputStream 
+    include IOExtras::AbstractInputStream
+
+    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
+    
+    def ZipInputStream.open(filename)
+      return new(filename) unless block_given?
+      
+      zio = new(filename)
+      yield zio
+    ensure
+      zio.close if zio
+    end
+
+    def get_next_entry
+      @archiveIO.seek(@currentEntry.next_header_offset, 
+		      IO::SEEK_SET) if @currentEntry
+      open_entry
+    end
+
+    def rewind
+      return if @currentEntry.nil?
+      @lineno = 0
+      @archiveIO.seek(@currentEntry.localHeaderOffset, 
+		      IO::SEEK_SET)
+      open_entry
+    end
+
+    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 read(numberOfBytes = nil)
+      @decompressor.read(numberOfBytes)
+    end
+    protected
+    def produce_input
+      @decompressor.produce_input
+    end
+    
+    def input_finished?
+      @decompressor.input_finished?
+    end
+  end
+  
+  
+  
+  class Decompressor  #:nodoc:all
+    CHUNK_SIZE=32768
+    def initialize(inputStream)
+      super()
+      @inputStream=inputStream
+    end
+  end
+  
+  class Inflater < Decompressor  #:nodoc:all
+    def initialize(inputStream)
+      super
+      @zlibInflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+      @outputBuffer=""
+      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+    end
+    
+    def read(numberOfBytes = nil)
+      readEverything = (numberOfBytes == nil)
+      while (readEverything || @outputBuffer.length < numberOfBytes)
+	break if internal_input_finished?
+	@outputBuffer << internal_produce_input
+      end
+      return value_when_finished if @outputBuffer.length==0 && input_finished?
+      endIndex= numberOfBytes==nil ? @outputBuffer.length : numberOfBytes
+      return @outputBuffer.slice!(0...endIndex)
+    end
+    
+    def produce_input
+      if (@outputBuffer.empty?)
+	return internal_produce_input
+      else
+	return @outputBuffer.slice!(0...(@outputBuffer.length))
+      end
+    end
+
+    # to be used with produce_input, not read (as read may still have more data cached)
+    def input_finished?
+      @outputBuffer.empty? && internal_input_finished?
+    end
+
+    private
+
+    def internal_produce_input
+      @zlibInflater.inflate(@inputStream.read(Decompressor::CHUNK_SIZE))
+    end
+
+    def internal_input_finished?
+      @zlibInflater.finished?
+    end
+
+    # TODO: Specialize to handle different behaviour in ruby > 1.7.0 ?
+    def value_when_finished   # mimic behaviour of ruby File object.
+      return nil if @hasReturnedEmptyString
+      @hasReturnedEmptyString=true
+      return ""
+    end
+  end
+  
+  class PassThruDecompressor < Decompressor  #:nodoc:all
+    def initialize(inputStream, charsToRead)
+      super inputStream
+      @charsToRead = charsToRead
+      @readSoFar = 0
+      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+    end
+    
+    # TODO: Specialize to handle different behaviour in ruby > 1.7.0 ?
+    def read(numberOfBytes = nil)
+      if input_finished?
+	hasReturnedEmptyStringVal=@hasReturnedEmptyString
+	@hasReturnedEmptyString=true
+	return "" unless hasReturnedEmptyStringVal
+	return nil
+      end
+      
+      if (numberOfBytes == nil || @readSoFar+numberOfBytes > @charsToRead)
+	numberOfBytes = @charsToRead-@readSoFar
+      end
+      @readSoFar += numberOfBytes
+      @inputStream.read(numberOfBytes)
+    end
+    
+    def produce_input
+      read(Decompressor::CHUNK_SIZE)
+    end
+    
+    def input_finished?
+      (@readSoFar >= @charsToRead)
+    end
+  end
+  
+  class NullDecompressor  #:nodoc:all
+    include Singleton
+    def read(numberOfBytes = nil)
+      nil
+    end
+    
+    def produce_input
+      nil
+    end
+    
+    def input_finished?
+      true
+    end
+  end
+  
+  class NullInputStream < NullDecompressor  #:nodoc:all
+    include IOExtras::AbstractInputStream
+  end
+  
+  class ZipEntry
+    STORED = 0
+    DEFLATED = 8
+    
+    attr_accessor  :comment, :compressed_size, :crc, :extra, :compression_method, 
+      :name, :size, :localHeaderOffset, :zipfile, :fstype, :externalFileAttributes
+    
+    def initialize(zipfile = "", name = "", comment = "", extra = "", 
+                   compressed_size = 0, crc = 0, 
+		   compression_method = ZipEntry::DEFLATED, size = 0,
+		   time  = Time.now)
+      super()
+      if name.starts_with("/")
+	raise ZipEntryNameError, "Illegal ZipEntry name '#{name}', name must not start with /" 
+      end
+      @localHeaderOffset = 0
+      @internalFileAttributes = 1
+      @externalFileAttributes = 0
+      @version = 52 # this library's version
+      @fstype  = 0  # default is fat
+      @zipfile, @comment, @compressed_size, @crc, @extra, @compression_method, 
+	@name, @size = zipfile, comment, compressed_size, crc, 
+	extra, compression_method, name, size
+      @time = time
+      unless ZipExtraField === @extra
+        @extra = ZipExtraField.new(@extra.to_s)
+      end
+    end
+
+    def time
+      if @extra["UniversalTime"]
+        @extra["UniversalTime"].mtime
+      else
+        # Atandard time field in central directory has local time
+        # under archive creator. Then, we can't get timezone.
+        @time
+      end
+    end
+    alias :mtime :time
+    
+    def time=(aTime)
+      unless @extra.member?("UniversalTime")
+        @extra.create("UniversalTime")
+      end
+      @extra["UniversalTime"].mtime = aTime
+      @time = aTime
+    end
+
+    def directory?
+      return (%r{\/$} =~ @name) != nil
+    end
+    alias :is_directory :directory?
+
+    def file?
+      ! directory?
+    end
+
+    def local_entry_offset  #:nodoc:all
+      localHeaderOffset + local_header_size
+    end
+    
+    def local_header_size  #:nodoc:all
+      LOCAL_ENTRY_STATIC_HEADER_LENGTH + (@name ?  @name.size : 0) + (@extra ? @extra.local_size : 0)
+    end
+
+    def cdir_header_size  #:nodoc:all
+      CDIR_ENTRY_STATIC_HEADER_LENGTH  + (@name ?  @name.size : 0) + 
+	(@extra ? @extra.c_dir_size : 0) + (@comment ? @comment.size : 0)
+    end
+    
+    def next_header_offset  #:nodoc:all
+      local_entry_offset + self.compressed_size
+    end
+    
+    def to_s
+      @name
+    end
+    
+    protected
+    
+    def ZipEntry.read_zip_short(io)
+      io.read(2).unpack('v')[0]
+    end
+    
+    def ZipEntry.read_zip_long(io)
+      io.read(4).unpack('V')[0]
+    end
+    public
+    
+    LOCAL_ENTRY_SIGNATURE = 0x04034b50
+    LOCAL_ENTRY_STATIC_HEADER_LENGTH = 30
+    
+    def read_local_entry(io)  #:nodoc:all
+      @localHeaderOffset = io.tell
+      staticSizedFieldsBuf = io.read(LOCAL_ENTRY_STATIC_HEADER_LENGTH)
+      unless (staticSizedFieldsBuf.size==LOCAL_ENTRY_STATIC_HEADER_LENGTH)
+	raise ZipError, "Premature end of file. Not enough data for zip entry local header"
+      end
+      
+      localHeader       ,
+        @version          ,
+	@fstype           ,
+	@gpFlags          ,
+	@compression_method,
+	lastModTime       ,
+	lastModDate       ,
+	@crc              ,
+	@compressed_size   ,
+	@size             ,
+	nameLength        ,
+	extraLength       = staticSizedFieldsBuf.unpack('VCCvvvvVVVvv') 
+
+      unless (localHeader == LOCAL_ENTRY_SIGNATURE)
+	raise ZipError, "Zip local header magic not found at location '#{localHeaderOffset}'"
+      end
+      set_time(lastModDate, lastModTime)
+      
+      @name              = io.read(nameLength)
+      extra              = io.read(extraLength)
+
+      if (extra && extra.length != extraLength)
+	raise ZipError, "Truncated local zip entry header"
+      else
+        if ZipExtraField === @extra
+          @extra.merge(extra)
+        else
+          @extra = ZipExtraField.new(extra)
+        end
+      end
+    end
+    
+    def ZipEntry.read_local_entry(io)
+      entry = new(io.path)
+      entry.read_local_entry(io)
+      return entry
+    rescue ZipError
+      return nil
+    end
+  
+    def write_local_entry(io)   #:nodoc:all
+      @localHeaderOffset = io.tell
+      
+      io << 
+	[LOCAL_ENTRY_SIGNATURE    ,
+	0                  ,
+	0                         , # @gpFlags                  ,
+	@compression_method        ,
+	@time.to_binary_dos_time     , # @lastModTime              ,
+	@time.to_binary_dos_date     , # @lastModDate              ,
+	@crc                      ,
+	@compressed_size           ,
+	@size                     ,
+	@name ? @name.length   : 0,
+	@extra? @extra.local_length : 0 ].pack('VvvvvvVVVvv')
+      io << @name
+      io << (@extra ? @extra.to_local_bin : "")
+    end
+    
+    CENTRAL_DIRECTORY_ENTRY_SIGNATURE = 0x02014b50
+    CDIR_ENTRY_STATIC_HEADER_LENGTH = 46
+    
+    def read_c_dir_entry(io)  #:nodoc:all
+      staticSizedFieldsBuf = io.read(CDIR_ENTRY_STATIC_HEADER_LENGTH)
+      unless (staticSizedFieldsBuf.size == CDIR_ENTRY_STATIC_HEADER_LENGTH)
+	raise ZipError, "Premature end of file. Not enough data for zip cdir entry header"
+      end
+      
+      cdirSignature          ,
+	@version               , # version of encoding software
+        @fstype                , # filesystem type
+	@versionNeededToExtract,
+	@gpFlags               ,
+	@compression_method     ,
+	lastModTime            ,
+	lastModDate            ,
+	@crc                   ,
+	@compressed_size        ,
+	@size                  ,
+	nameLength             ,
+	extraLength            ,
+	commentLength          ,
+	diskNumberStart        ,
+	@internalFileAttributes,
+	@externalFileAttributes,
+	@localHeaderOffset     ,
+	@name                  ,
+	@extra                 ,
+	@comment               = staticSizedFieldsBuf.unpack('VCCvvvvvVVVvvvvvVV')
+
+      unless (cdirSignature == CENTRAL_DIRECTORY_ENTRY_SIGNATURE)
+	raise ZipError, "Zip local header magic not found at location '#{localHeaderOffset}'"
+      end
+      set_time(lastModDate, lastModTime)
+      
+      @name                  = io.read(nameLength)
+      if ZipExtraField === @extra
+        @extra.merge(io.read(extraLength))
+      else
+        @extra = ZipExtraField.new(io.read(extraLength))
+      end
+      @comment               = io.read(commentLength)
+      unless (@comment && @comment.length == commentLength)
+	raise ZipError, "Truncated cdir zip entry header"
+      end
+    end
+    
+    def ZipEntry.read_c_dir_entry(io)  #:nodoc:all
+      entry = new(io.path)
+      entry.read_c_dir_entry(io)
+      return entry
+    rescue ZipError
+      return nil
+    end
+
+
+    def write_c_dir_entry(io)  #:nodoc:all
+      io << 
+	[CENTRAL_DIRECTORY_ENTRY_SIGNATURE,
+        @version                          , # version of encoding software
+	@fstype                           , # filesystem type
+	0                                 , # @versionNeededToExtract           ,
+	0                                 , # @gpFlags                          ,
+	@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_length : 0  ,
+	@comment ? comment.length : 0     ,
+	0                                 , # disk number start
+	@internalFileAttributes           , # file type (binary=0, text=1)
+	@externalFileAttributes           , # native filesystem attributes
+	@localHeaderOffset                ,
+	@name                             ,
+	@extra                            ,
+	@comment                          ].pack('VCCvvvvvVVVvvvvvVV')
+
+      io << @name
+      io << (@extra ? @extra.to_c_dir_bin : "")
+      io << @comment
+    end
+    
+    def == (other)
+      return false unless other.class == ZipEntry
+      # Compares contents of local entry and exposed fields
+      (@compression_method == other.compression_method &&
+       @crc               == other.crc		     &&
+       @compressed_size    == other.compressed_size    &&
+       @size              == other.size	             &&
+       @name              == other.name	             &&
+       @extra             == other.extra             &&
+       self.time.dos_equals(other.time))
+    end
+
+    def <=> (other)
+      return to_s <=> other.to_s
+    end
+
+    def get_input_stream
+      zis = ZipInputStream.new(@zipfile, localHeaderOffset)
+      zis.get_next_entry
+      if block_given?
+	begin
+	  return yield(zis)
+	ensure
+	  zis.close
+	end
+      else
+	return zis
+      end
+    end
+
+
+    def write_to_zip_output_stream(aZipOutputStream)  #:nodoc:all
+      aZipOutputStream.copy_raw_entry(self)
+    end
+
+    def parent_as_string
+      entry_name = name.chomp("/")
+      slash_index = entry_name.rindex("/")
+      slash_index ? entry_name.slice(0, slash_index+1) : nil
+    end
+
+    def get_raw_input_stream(&aProc)
+      File.open(@zipfile, "rb", &aProc)
+    end
+
+    private
+    def set_time(binaryDosDate, binaryDosTime)
+      @time = Time.parse_binary_dos_format(binaryDosDate, binaryDosTime)
+    rescue ArgumentError
+      puts "Invalid date/time in zip entry"
+    end
+  end
+
+
+  class ZipOutputStream
+    include IOExtras::AbstractOutputStream
+
+    attr_accessor :comment
+
+    def initialize(fileName)
+      super()
+      @fileName = fileName
+      @outputStream = File.new(@fileName, "wb")
+      @entrySet = ZipEntrySet.new
+      @compressor = NullCompressor.instance
+      @closed = false
+      @currentEntry = nil
+      @comment = nil
+    end
+
+    def ZipOutputStream.open(fileName)
+      return new(fileName) unless block_given?
+      zos = new(fileName)
+      yield zos
+    ensure
+      zos.close if zos
+    end
+
+    def close
+      return if @closed
+      finalize_current_entry
+      update_local_headers
+      write_central_directory
+      @outputStream.close
+      @closed = true
+    end
+
+    def put_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
+      raise ZipError, "zip stream is closed" if @closed
+      newEntry = entry.kind_of?(ZipEntry) ? entry : ZipEntry.new(@fileName, entry.to_s)
+      init_next_entry(newEntry)
+      @currentEntry=newEntry
+    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
+      @outputStream << entry.get_raw_input_stream { 
+	|is| 
+	is.seek(src_pos, IO::SEEK_SET)
+	is.read(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.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
+    def << (data)
+      @compressor << data
+    end
+  end
+  
+  
+  class Compressor #:nodoc:all
+    def finish
+    end
+  end
+  
+  class PassThruCompressor < Compressor #:nodoc:all
+    def initialize(outputStream)
+      super()
+      @outputStream = outputStream
+      @crc = Zlib::crc32
+      @size = 0
+    end
+    
+    def << (data)
+      val = data.to_s
+      @crc = Zlib::crc32(val, @crc)
+      @size += val.size
+      @outputStream << val
+    end
+
+    attr_reader :size, :crc
+  end
+
+  class NullCompressor < Compressor #:nodoc:all
+    include Singleton
+
+    def << (data)
+      raise IOError, "closed stream"
+    end
+
+    attr_reader :size, :compressed_size
+  end
+
+  class Deflater < Compressor #:nodoc:all
+    def initialize(outputStream, level = Zlib::DEFAULT_COMPRESSION)
+      super()
+      @outputStream = outputStream
+      @zlibDeflater = Zlib::Deflate.new(level, -Zlib::MAX_WBITS)
+      @size = 0
+      @crc = Zlib::crc32
+    end
+    
+    def << (data)
+      val = data.to_s
+      @crc = Zlib::crc32(val, @crc)
+      @size += val.size
+      @outputStream << @zlibDeflater.deflate(data)
+    end
+
+    def finish
+      until @zlibDeflater.finished?
+	@outputStream << @zlibDeflater.finish
+      end
+    end
+
+    attr_reader :size, :crc
+  end
+  
+
+  class ZipEntrySet
+    include Enumerable
+    
+    def initialize(anEnumerable = [])
+      super()
+      @entrySet = {}
+      anEnumerable.each { |o| push(o) }
+    end
+
+    def include?(entry)
+      @entrySet.include?(entry.to_s)
+    end
+
+    def <<(entry)
+      @entrySet[entry.to_s] = entry
+    end
+    alias :push :<<
+
+    def size
+      @entrySet.size
+    end
+    alias :length :size
+
+    def delete(entry)
+      @entrySet.delete(entry.to_s) ? entry : nil
+    end
+
+    def each(&aProc)
+      @entrySet.values.each(&aProc)
+    end
+
+    def entries
+      @entrySet.values
+    end
+
+    # deep clone
+    def dup
+      newZipEntrySet = ZipEntrySet.new(@entrySet.values.map { |e| e.dup })
+    end
+
+    def == (other)
+      return false unless other.kind_of?(ZipEntrySet)
+      return @entrySet == other.entrySet      
+    end
+
+    def parent(entry)
+      @entrySet[entry.parent_as_string]
+    end
+
+#TODO    attr_accessor :auto_create_directories
+    protected
+    attr_accessor :entrySet
+  end
+
+
+  class ZipCentralDirectory #:nodoc:all
+    include Enumerable
+    
+    END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50
+    MAX_END_OF_CENTRAL_DIRECTORY_STRUCTURE_SIZE = 65536 + 18
+    STATIC_EOCD_SIZE = 22
+
+    attr_reader :comment
+    
+    def entries
+      @entrySet.entries
+    end
+
+    def initialize(entries = ZipEntrySet.new, comment = "")
+      super()
+      @entrySet = entries.kind_of?(ZipEntrySet) ? entries : ZipEntrySet.new(entries)
+      @comment = comment
+    end
+
+    def write_to_stream(io)
+      offset = io.tell
+      @entrySet.each { |entry| entry.write_c_dir_entry(io) }
+      write_e_o_c_d(io, offset)
+    end
+
+    def write_e_o_c_d(io, offset)
+      io <<
+	[END_OF_CENTRAL_DIRECTORY_SIGNATURE,
+        0                                  , # @numberOfThisDisk
+	0                                  , # @numberOfDiskWithStartOfCDir
+	@entrySet? @entrySet.size : 0        ,
+	@entrySet? @entrySet.size : 0        ,
+	cdir_size                           ,
+	offset                             ,
+	@comment ? @comment.length : 0     ].pack('VvvvvVVv')
+      io << @comment
+    end
+    private :write_e_o_c_d
+
+    def cdir_size
+      # does not include eocd
+      @entrySet.inject(0) { |value, entry| entry.cdir_header_size + value }
+    end
+    private :cdir_size
+
+    def read_e_o_c_d(io)
+      buf = get_e_o_c_d(io)
+      @numberOfThisDisk                     = ZipEntry::read_zip_short(buf)
+      @numberOfDiskWithStartOfCDir          = ZipEntry::read_zip_short(buf)
+      @totalNumberOfEntriesInCDirOnThisDisk = ZipEntry::read_zip_short(buf)
+      @size                                 = ZipEntry::read_zip_short(buf)
+      @sizeInBytes                          = ZipEntry::read_zip_long(buf)
+      @cdirOffset                           = ZipEntry::read_zip_long(buf)
+      commentLength                         = ZipEntry::read_zip_short(buf)
+      @comment                              = buf.read(commentLength)
+      raise ZipError, "Zip consistency problem while reading eocd structure" unless buf.size == 0
+    end
+    
+    def read_central_directory_entries(io)
+      begin
+	io.seek(@cdirOffset, IO::SEEK_SET)
+      rescue Errno::EINVAL
+	raise ZipError, "Zip consistency problem while reading central directory entry"
+      end
+      @entrySet = ZipEntrySet.new
+      @size.times {
+	@entrySet << ZipEntry.read_c_dir_entry(io)
+      }
+    end
+    
+    def read_from_stream(io)
+      read_e_o_c_d(io)
+      read_central_directory_entries(io)
+    end
+    
+    def get_e_o_c_d(io)
+      begin
+	io.seek(-MAX_END_OF_CENTRAL_DIRECTORY_STRUCTURE_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+	io.seek(0, IO::SEEK_SET)
+      rescue Errno::EFBIG # FreeBSD 4.9 returns Errno::EFBIG instead of Errno::EINVAL
+	io.seek(0, IO::SEEK_SET)
+      end
+      buf = io.read
+      sigIndex = buf.rindex([END_OF_CENTRAL_DIRECTORY_SIGNATURE].pack('V'))
+      raise ZipError, "Zip end of central directory signature not found" unless sigIndex
+      buf=buf.slice!((sigIndex+4)...(buf.size))
+      def buf.read(count)
+	slice!(0, count)
+      end
+      return buf
+    end
+    
+    def each(&proc)
+      @entrySet.each(&proc)
+    end
+
+    def size
+      @entrySet.size
+    end
+
+    def ZipCentralDirectory.read_from_stream(io)
+      cdir  = new
+      cdir.read_from_stream(io)
+      return cdir
+    rescue ZipError
+      return nil
+    end
+
+    def == (other)
+      return false unless other.kind_of?(ZipCentralDirectory)
+      @entrySet.entries.sort == other.entries.sort && comment == other.comment
+    end
+  end
+  
+  
+  class ZipError < StandardError ; end
+
+  class ZipEntryExistsError            < ZipError; end
+  class ZipDestinationFileExistsError  < ZipError; end
+  class ZipCompressionMethodError      < ZipError; end
+  class ZipEntryNameError              < ZipError; end
+
+  class ZipFile < ZipCentralDirectory
+
+    CREATE = 1
+
+    attr_reader :name
+
+    def initialize(fileName, create = nil)
+      super()
+      @name = fileName
+      @comment = ""
+      if (File.exists?(fileName))
+	File.open(name, "rb") { |f| read_from_stream(f) }
+      elsif (create == ZipFile::CREATE)
+	@entrySet = ZipEntrySet.new
+      else
+	raise ZipError, "File #{fileName} not found"
+      end
+      @create = create
+      @storedEntries = @entrySet.dup
+    end
+    
+    def ZipFile.open(fileName, create = nil)
+      zf = ZipFile.new(fileName, create)
+      if block_given?
+	begin
+	  yield zf
+	ensure
+	  zf.close
+	end
+      else
+	zf
+      end
+    end
+
+    attr_accessor :comment
+
+    def ZipFile.foreach(aZipFileName, &block)
+      ZipFile.open(aZipFileName) {
+	|zipFile|
+	zipFile.each(&block)
+      }
+    end
+    
+    def get_input_stream(entry, &aProc)
+      get_entry(entry).get_input_stream(&aProc)
+    end
+
+    def get_output_stream(entry, &aProc)
+      newEntry = entry.kind_of?(ZipEntry) ? entry : ZipEntry.new(@name, entry.to_s)
+      if newEntry.directory?
+	raise ArgumentError,
+	  "cannot open stream to directory entry - '#{newEntry}'"
+      end
+      zipStreamableEntry = ZipStreamableStream.new(newEntry)
+      @entrySet << zipStreamableEntry
+      zipStreamableEntry.get_output_stream(&aProc)      
+    end
+
+    def to_s
+      @name
+    end
+
+    def read(entry)
+      get_input_stream(entry) { |is| is.read } 
+    end
+
+    def add(entry, srcPath, &continueOnExistsProc)
+      continueOnExistsProc ||= proc { false }
+      check_entry_exists(entry, continueOnExistsProc, "add")
+      newEntry = entry.kind_of?(ZipEntry) ? entry : ZipEntry.new(@name, entry.to_s)
+      if is_directory(newEntry, srcPath)
+	@entrySet << ZipStreamableDirectory.new(newEntry)
+      else
+	@entrySet << ZipStreamableFile.new(newEntry, srcPath)
+      end
+    end
+    
+    def remove(entry)
+      @entrySet.delete(get_entry(entry))
+    end
+    
+    def rename(entry, newName, &continueOnExistsProc)
+      foundEntry = get_entry(entry)
+      check_entry_exists(newName, continueOnExistsProc, "rename")
+      foundEntry.name=newName
+    end
+
+    def replace(entry, srcPath)
+      check_file(srcPath)
+      add(remove(entry), srcPath)
+    end
+    
+    def extract(entry, destPath, &onExistsProc)
+      onExistsProc ||= proc { false }
+      foundEntry = get_entry(entry)
+      if foundEntry.is_directory
+	create_directory(foundEntry, destPath, &onExistsProc)
+      else
+	write_file(foundEntry, destPath, &onExistsProc) 
+      end
+    end
+    
+    def commit
+     return if ! commit_required?
+      on_success_replace(name) {
+	|tmpFile|
+	ZipOutputStream.open(tmpFile) {
+	  |zos|
+
+	  @entrySet.each { |e| e.write_to_zip_output_stream(zos) }
+	  zos.comment = comment
+	}
+	true
+      }
+      initialize(name)
+    end
+    
+    def close
+      commit
+    end
+
+    def commit_required?
+      return @entrySet != @storedEntries || @create == ZipFile::CREATE
+    end
+
+    def find_entry(entry)
+      @entrySet.detect { 
+	|e| 
+	e.name.sub(/\/$/, "") == entry.to_s.sub(/\/$/, "")
+      }
+    end
+    
+    def get_entry(entry)
+      selectedEntry = find_entry(entry)
+      unless selectedEntry
+	raise Errno::ENOENT, entry
+      end
+      return selectedEntry
+    end
+
+    def mkdir(entryName, permissionInt = 0) #permissionInt ignored
+      if find_entry(entryName)
+        raise Errno::EEXIST, "File exists - #{entryName}"
+      end
+      @entrySet << ZipStreamableDirectory.new(ZipEntry.new(name, entryName.to_s.ensure_end("/")))
+    end
+
+    private
+
+    def create_directory(entry, destPath)
+      if File.directory? destPath
+	return
+      elsif File.exists? destPath
+	if block_given? && yield(entry, destPath)
+	  File.rm_f destPath
+	else
+	  raise ZipDestinationFileExistsError,
+	    "Cannot create directory '#{destPath}'. "+
+	    "A file already exists with that name"
+	end
+      end
+      Dir.mkdir destPath
+    end
+
+    def is_directory(newEntry, srcPath)
+      srcPathIsDirectory = File.directory?(srcPath)
+      if newEntry.is_directory && ! srcPathIsDirectory
+	raise ArgumentError,
+	  "entry name '#{newEntry}' indicates directory entry, but "+
+	  "'#{srcPath}' is not a directory"
+      elsif ! newEntry.is_directory && srcPathIsDirectory
+	newEntry.name += "/"
+      end
+      return newEntry.is_directory && srcPathIsDirectory
+    end
+
+    def check_entry_exists(entryName, continueOnExistsProc, procedureName)
+      continueOnExistsProc ||= proc { false }
+      if @entrySet.detect { |e| e.name == entryName }
+	if continueOnExistsProc.call
+	  remove get_entry(entryName)
+	else
+	  raise ZipEntryExistsError, 
+	    procedureName+" failed. Entry #{entryName} already exists"
+	end
+      end
+    end
+
+    def write_file(entry, destPath, continueOnExistsProc = proc { false })
+      if File.exists?(destPath) && ! yield(entry, destPath)
+	raise ZipDestinationFileExistsError,
+	  "Destination '#{destPath}' already exists"
+      end
+      File.open(destPath, "wb") { 
+	  |os|
+	  entry.get_input_stream { |is| os << is.read }
+	}
+    end
+    
+    def check_file(path)
+      unless File.readable? path
+	raise Errno::ENOENT, path
+      end
+    end
+    
+    def on_success_replace(aFilename)
+      tmpfile = get_tempfile
+      tmpFilename = tmpfile.path
+      tmpfile.close
+      if yield tmpFilename
+	File.move(tmpFilename, name)
+      end
+    end
+    
+    def get_tempfile
+      tempFile = Tempfile.new(File.basename(name), File.dirname(name))
+      tempFile.binmode
+      tempFile
+    end
+    
+  end
+
+  class ZipStreamableFile < DelegateClass(ZipEntry) #:nodoc:all
+    def initialize(entry, filepath)
+      super(entry)
+      @delegate = entry
+      @filepath = filepath
+    end
+
+    def get_input_stream(&aProc)
+      File.open(@filepath, "rb", &aProc)
+    end
+    
+    def write_to_zip_output_stream(aZipOutputStream)
+      aZipOutputStream.put_next_entry(self)
+      aZipOutputStream << get_input_stream { |is| is.read }
+    end
+
+    def == (other)
+      return false unless other.class == ZipStreamableFile
+      @filepath == other.filepath && super(other.delegate)
+    end
+
+    protected
+    attr_reader :filepath, :delegate
+  end
+
+  class ZipStreamableDirectory < DelegateClass(ZipEntry) #:nodoc:all
+    def initialize(entry)
+      super(entry)
+    end
+
+    def get_input_stream(&aProc)
+      return yield(NullInputStream.instance) if block_given?
+      NullInputStream.instance
+    end
+    
+    def write_to_zip_output_stream(aZipOutputStream)
+      aZipOutputStream.put_next_entry(self)
+    end
+  end
+
+  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
+      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)
+      aZipOutputStream << get_input_stream { |is| is.read }
+    end
+  end
+
+  class ZipExtraField < Hash
+    ID_MAP = {}
+
+    # Meta class for extra fields
+    class Generic
+      def self.register_map
+        if self.const_defined?(:HEADER_ID)
+          ID_MAP[self.const_get(:HEADER_ID)] = self
+        end
+      end
+
+      def self.name
+        self.to_s.split("::")[-1]
+      end
+
+      # return field [size, content] or false
+      def initial_parse(binstr)
+        if ! binstr
+          # If nil, start with empty.
+          return false
+        elsif binstr[0,2] != self.class.const_get(:HEADER_ID)
+          $stderr.puts "Warning: weired extra feild header ID. skip parsing"
+          return false
+        end
+        [binstr[2,2].unpack("v")[0], binstr[4..-1]]
+      end
+
+      def ==(other)
+        self.class != other.class and return false
+        each { |k, v|
+          v != other[k] and return false
+        }
+        true
+      end
+
+      def to_local_bin
+        s = pack_for_local
+        self.class.const_get(:HEADER_ID) + [s.length].pack("v") + s
+      end
+
+      def to_c_dir_bin
+        s = pack_for_c_dir
+        self.class.const_get(:HEADER_ID) + [s.length].pack("v") + s
+      end
+    end
+
+    # Info-ZIP Additional timestamp field
+    class UniversalTime < Generic
+      HEADER_ID = "UT"
+      register_map
+
+      def initialize(binstr = nil)
+        @ctime = nil
+        @mtime = nil
+        @atime = nil
+        @flag  = nil
+        binstr and merge(binstr)
+      end
+      attr_accessor :atime, :ctime, :mtime, :flag
+
+      def merge(binstr)
+        binstr == "" and return
+        size, content = initial_parse(binstr)
+        size or return
+        @flag, mtime, atime, ctime = content.unpack("CVVV")
+        mtime and @mtime ||= Time.at(mtime)
+        atime and @atime ||= Time.at(atime)
+        ctime and @ctime ||= Time.at(ctime)
+      end
+
+      def ==(other)
+        @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+      end
+
+      def pack_for_local
+        s = [@flag].pack("C")
+        @flag & 1 != 0 and s << [@mtime.to_i].pack("V")
+        @flag & 2 != 0 and s << [@atime.to_i].pack("V")
+        @flag & 4 != 0 and s << [@ctime.to_i].pack("V")
+        s
+      end
+
+      def pack_for_c_dir
+        s = [@flag].pack("C")
+        @flag & 1 == 1 and s << [@mtime.to_i].pack("V")
+        s
+      end
+    end
+
+    # Info-ZIP Extra for UNIX uid/gid
+    class IUnix < Generic
+      HEADER_ID = "Ux"
+      register_map
+
+      def initialize(binstr = nil)
+        @uid = nil
+        @gid = nil
+        binstr and merge(binstr)
+      end
+      attr_accessor :uid, :gid
+
+      def merge(binstr)
+        binstr == "" and return
+        size, content = initial_parse(binstr)
+        # size: 0 for central direcotry. 4 for local header
+        return if(! size || size == 0)
+        uid, gid = content.unpack("vv")
+        @uid ||= uid
+        @gid ||= gid
+      end
+
+      def ==(other)
+        @uid == other.uid &&
+        @gid == other.gid
+      end
+
+      def pack_for_local
+        [@uid, @gid].pack("vv")
+      end
+
+      def pack_for_c_dir
+        ""
+      end
+    end
+
+    ## start main of ZipExtraField < Hash
+    def initialize(binstr = nil)
+      binstr and merge(binstr)
+    end
+
+    def merge(binstr)
+      binstr == "" and return
+      i = 0 
+      while i < binstr.length
+        id = binstr[i,2]
+        len = binstr[i+2,2].to_s.unpack("v")[0] 
+        if id && ID_MAP.member?(id)
+          field_name = ID_MAP[id].name
+          if self.member?(field_name)
+            self[field_name].mergea(binstr[i, len+4])
+          else
+            field_obj = ID_MAP[id].new(binstr[i, len+4])
+            self[field_name] = field_obj
+          end
+        elsif id
+          unless self["Unknown"]
+            s = ""
+            class << s
+              alias_method :to_c_dir_bin, :to_s
+              alias_method :to_local_bin, :to_s
+            end
+            self["Unknown"] = s
+          end
+          if ! len || len+4 > binstr[i..-1].length
+            self["Unknown"] << binstr[i..-1]
+            break;
+          end
+          self["Unknown"] << binstr[i, len+4]
+        end
+        i += len+4
+      end
+    end
+
+    def create(name)
+      field_class = nil
+      ID_MAP.each { |id, klass|
+        if klass.name == name
+          field_class = klass
+          break
+        end
+      }
+      if ! field_class
+	raise ZipError, "Unknown extra field '#{name}'"
+      end
+      self[name] = field_class.new()
+    end
+
+    def to_local_bin
+      s = ""
+      each { |k, v|
+        s << v.to_local_bin
+      }
+      s
+    end
+    alias :to_s :to_local_bin
+
+    def to_c_dir_bin
+      s = ""
+      each { |k, v|
+        s << v.to_c_dir_bin
+      }
+      s
+    end
+
+    def c_dir_length
+      to_c_dir_bin.length
+    end
+    def local_length
+      to_local_bin.length
+    end
+    alias :c_dir_size :c_dir_length
+    alias :local_size :local_length
+    alias :length     :local_length
+    alias :size       :local_length
+  end # end ZipExtraField
+
+end # Zip namespace module
+
+
+
+# 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.