rubyzip 1.0.0 → 1.1.0

data/lib/zip/extra_field/zip64.rb

@@ -2,10 +2,13 @@ module Zip
   # Info-ZIP Extra for Zip64 size
   class ExtraField::Zip64 < ExtraField::Generic
     attr_accessor :original_size, :compressed_size, :relative_header_offset, :disk_start_number
-    HEADER_ID = "\001\000"
+    HEADER_ID = ['0100'].pack('H*')
     register_map
 
     def initialize(binstr = nil)
+      @content = nil # unparsed binary; we don't actually know what this contains
+                     # without looking for FFs in the associated file header
+                     # call parse after initializing with a binary string
       @original_size          = nil
       @compressed_size        = nil
       @relative_header_offset = nil
@@ -13,18 +16,52 @@ module Zip
       binstr and merge(binstr)
     end
 
+    def ==(other)
+      other.original_size == @original_size &&
+        other.compressed_size == @compressed_size &&
+          other.relative_header_offset == @relative_header_offset &&
+            other.disk_start_number == @disk_start_number
+    end
+
     def merge(binstr)
       return if binstr.empty?
-      id, size, @original_size, @compressed_size, @relative_header_offset, @disk_start_number = binstr.to_s.unpack("vvQQQV")
+      _, @content = initial_parse(binstr)
+    end
+
+    # pass the values from the base entry (if applicable)
+    # wider values are only present in the extra field for base values set to all FFs
+    # returns the final values for the four attributes (from the base or zip64 extra record)
+    def parse(original_size, compressed_size, relative_header_offset = nil, disk_start_number = nil)
+      @original_size = extract(8, 'Q<') if original_size == 0xFFFFFFFF
+      @compressed_size = extract(8, 'Q<') if compressed_size == 0xFFFFFFFF
+      @relative_header_offset = extract(8, 'Q<') if relative_header_offset && relative_header_offset == 0xFFFFFFFF
+      @disk_start_number = extract(4, 'V') if disk_start_number && disk_start_number == 0xFFFF
+      @content = nil
+      [@original_size || original_size,
+       @compressed_size || compressed_size,
+       @relative_header_offset || relative_header_offset,
+       @disk_start_number || disk_start_number]
+    end
+
+    def extract(size, format)
+      @content.slice!(0, size).unpack(format)[0]
     end
+    private :extract
 
     def pack_for_local
-      return '' unless @original_size && @compressed_sie && @relative_header_offset && @disk_start_number
-      [1, 16, @original_size, @compressed_size, @relative_header_offset, @disk_start_number].pack("vvQQQV")
+      # local header entries must contain original size and compressed size; other fields do not apply
+      return '' unless @original_size && @compressed_size
+      [@original_size, @compressed_size].pack("Q<Q<")
     end
 
     def pack_for_c_dir
-      pack_for_local
+      # central directory entries contain only fields that didn't fit in the main entry part
+      packed = ''.force_encoding('BINARY')
+      packed << [@original_size].pack("Q<") if @original_size
+      packed << [@compressed_size].pack("Q<") if @compressed_size
+      packed << [@relative_header_offset].pack("Q<") if @relative_header_offset
+      packed << [@disk_start_number].pack("V") if @disk_start_number
+      packed
     end
   end
 end

data/lib/zip/extra_field/zip64_placeholder.rb

@@ -0,0 +1,16 @@
+module Zip
+  # placeholder to reserve space for a Zip64 extra information record, for the
+  # local file header only, that we won't know if we'll need until after
+  # we write the file data
+  class ExtraField::Zip64Placeholder < ExtraField::Generic
+    HEADER_ID = ['9999'].pack('H*') # this ID is used by other libraries such as .NET's Ionic.zip
+    register_map
+
+    def initialize(binstr = nil)
+    end
+
+    def pack_for_local
+      "\x00" * 16
+    end
+  end
+end

data/lib/zip/file.rb

@@ -44,12 +44,12 @@ module Zip
 
   class File < CentralDirectory
 
-    CREATE           = 1
-    SPLIT_SIGNATURE  = 0x08074b50
+    CREATE               = 1
+    SPLIT_SIGNATURE      = 0x08074b50
     ZIP64_EOCD_SIGNATURE = 0x06064b50
-    MAX_SEGMENT_SIZE = 3221225472
-    MIN_SEGMENT_SIZE = 65536
-    DATA_BUFFER_SIZE = 8192
+    MAX_SEGMENT_SIZE     = 3221225472
+    MIN_SEGMENT_SIZE     = 65536
+    DATA_BUFFER_SIZE     = 8192
 
     attr_reader :name
 
@@ -64,35 +64,36 @@ module Zip
 
     # Opens a zip archive. Pass true as the second parameter to create
     # a new archive if it doesn't exist already.
-    def initialize(fileName, create = nil, buffer = false)
+    def initialize(file_name, create = nil, buffer = false, options = {})
       super()
-      @name    = fileName
+      @name    = file_name
       @comment = ''
-      @create = create
+      @create  = create
       case
-      when ::File.exists?(fileName) && !buffer
+      when ::File.exists?(file_name) && !buffer
         @create = nil
+        @exist_file_perms = ::File.stat(file_name).mode
         ::File.open(name, 'rb') do |f|
           read_from_stream(f)
         end
       when create
         @entry_set = EntrySet.new
       else
-        raise ZipError, "File #{fileName} not found"
+        raise ZipError, "File #{file_name} not found"
       end
-      @storedEntries       = @entry_set.dup
-      @storedComment       = @comment
-      @restore_ownership   = false
-      @restore_permissions = false
-      @restore_times       = true
+      @stored_entries      = @entry_set.dup
+      @stored_comment      = @comment
+      @restore_ownership   = options[:restore_ownership]    || false
+      @restore_permissions = options[:restore_permissions]  || true
+      @restore_times       = options[:restore_times]        || true
     end
 
     class << self
       # Same as #new. If a block is passed the ZipFile object is passed
       # to the block and is automatically closed afterwards just as with
       # ruby's builtin File.open method.
-      def open(fileName, create = nil)
-        zf = ::Zip::File.new(fileName, create)
+      def open(file_name, create = nil)
+        zf = ::Zip::File.new(file_name, create)
         if block_given?
           begin
             yield zf
@@ -115,12 +116,12 @@ module Zip
       # stream, and outputs data to a buffer.
       # (This can be used to extract data from a 
       # downloaded zip archive without first saving it to disk.)
-      def open_buffer(io)
-        unless io.is_a?(IO) && io.is_a?(String)
-          raise "Zip::ZipFile.open_buffer expects an argument of class String or IO. Found: #{io.class}"
+      def open_buffer(io, options = {})
+        unless io.is_a?(IO) || io.is_a?(String)
+          raise "Zip::File.open_buffer expects an argument of class String or IO. Found: #{io.class}"
         end
-        zf = ::Zip::File.new('', true, true)
-        if io.is_a(::String)
+        zf = ::Zip::File.new('', true, true, options)
+        if io.is_a?(::String)
           require 'stringio'
           io = ::StringIO.new(io)
         end
@@ -173,8 +174,8 @@ module Zip
       # TODO: Make the code more understandable
       #
       def save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count)
-        ssegment_size = zip_file_size - zip_file.pos
-        ssegment_size = segment_size if ssegment_size > segment_size
+        ssegment_size  = zip_file_size - zip_file.pos
+        ssegment_size  = segment_size if ssegment_size > segment_size
         szip_file_name = "#{partial_zip_file_name}.#{'%03d'%(szip_file_index)}"
         ::File.open(szip_file_name, 'wb') do |szip_file|
           if szip_file_index == 1
@@ -224,11 +225,18 @@ module Zip
       get_entry(entry).get_input_stream(&aProc)
     end
 
-    # Returns an output stream to the specified entry. If a block is passed
-    # the stream object is passed to the block and the stream is automatically
-    # closed afterwards just as with ruby's builtin File.open method.
-    def get_output_stream(entry, permissionInt = nil, &aProc)
-      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
+    # Returns an output stream to the specified entry. If entry is not an instance
+    # of Zip::Entry, a new Zip::Entry will be initialized using the arguments
+    # specified. If a block is passed the stream object is passed to the block and 
+    # the stream is automatically closed afterwards just as with ruby's builtin 
+    # File.open method.
+    def get_output_stream(entry, permissionInt = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil,  &aProc)
+      newEntry =
+        if entry.kind_of?(Entry)
+          entry
+        else
+          Entry.new(@name, entry.to_s, comment, extra, compressed_size, crc, compression_method, size, time)
+        end
       if newEntry.directory?
         raise ArgumentError,
               "cannot open stream to directory entry - '#{newEntry}'"
@@ -291,30 +299,25 @@ module Zip
     # the zip archive.
     def commit
       return if !commit_required?
-      on_success_replace(name) {
-        |tmpFile|
-        OutputStream.open(tmpFile) {
-          |zos|
-
-          @entry_set.each {
-            |e|
+      on_success_replace do |tmpFile|
+        ::Zip::OutputStream.open(tmpFile) do |zos|
+          @entry_set.each do |e|
             e.write_to_zip_output_stream(zos)
             e.dirty = false
-          }
+          end
           zos.comment = comment
-        }
+        end
         true
-      }
+      end
       initialize(name)
     end
 
     # Write buffer write changes to buffer and return
     def write_buffer
-      buffer = OutputStream.write_buffer do |zos|
+      OutputStream.write_buffer do |zos|
         @entry_set.each { |e| e.write_to_zip_output_stream(zos) }
         zos.comment = comment
       end
-      return buffer
     end
 
     # Closes the zip file committing any changes that has been made.
@@ -328,7 +331,7 @@ module Zip
       @entry_set.each do |e|
         return true if e.dirty
       end
-      @comment != @storedComment || @entry_set != @storedEntries || @create == File::CREATE
+      @comment != @stored_comment || @entry_set != @stored_entries || @create == File::CREATE
     end
 
     # Searches for entry with the specified name. Returns nil if
@@ -345,14 +348,14 @@ module Zip
     # Searches for an entry just as find_entry, but throws Errno::ENOENT
     # if no entry is found.
     def get_entry(entry)
-      selectedEntry = find_entry(entry)
-      unless selectedEntry
+      selected_entry = find_entry(entry)
+      unless selected_entry
         raise Errno::ENOENT, entry
       end
-      selectedEntry.restore_ownership   = @restore_ownership
-      selectedEntry.restore_permissions = @restore_permissions
-      selectedEntry.restore_times       = @restore_times
-      selectedEntry
+      selected_entry.restore_ownership   = @restore_ownership
+      selected_entry.restore_permissions = @restore_permissions
+      selected_entry.restore_times       = @restore_times
+      selected_entry
     end
 
     # Creates a directory
@@ -362,7 +365,7 @@ module Zip
       end
       entryName = entryName.dup.to_s
       entryName << '/' unless entryName.end_with?('/')
-      @entry_set << StreamableDirectory.new(@name, entryName, nil, permissionInt)
+      @entry_set << ::Zip::StreamableDirectory.new(@name, entryName, nil, permissionInt)
     end
 
     private
@@ -397,19 +400,22 @@ module Zip
       end
     end
 
-    def on_success_replace(aFilename)
+    def on_success_replace
       tmpfile     = get_tempfile
-      tmpFilename = tmpfile.path
+      tmp_filename = tmpfile.path
       tmpfile.close
-      if yield tmpFilename
-        ::File.rename(tmpFilename, name)
+      if yield tmp_filename
+        ::File.rename(tmp_filename, self.name)
+        if defined?(@exist_file_perms)
+          ::File.chmod(@exist_file_perms, self.name)
+        end
       end
     end
 
     def get_tempfile
-      tempFile = Tempfile.new(::File.basename(name), ::File.dirname(name))
-      tempFile.binmode
-      tempFile
+      temp_file = Tempfile.new(::File.basename(name), ::File.dirname(name))
+      temp_file.binmode
+      temp_file
     end
 
   end

data/lib/zip/filesystem.rb

@@ -6,8 +6,8 @@ module Zip
   # 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.
+  # Requiring 'zip/filesystem' includes this module in Zip::File
+  # making the methods in this module available on Zip::File objects.
   #
   # Using this API the following example creates a new zip file 
   # <code>my.zip</code> containing a normal entry with the name
@@ -16,7 +16,7 @@ module Zip
   #
   #   require 'zip/filesystem'
   #   
-  #   Zip::File.open("my.zip", Zip::ZipFile::CREATE) {
+  #   Zip::File.open("my.zip", Zip::File::CREATE) {
   #     |zipfile|
   #     zipfile.file.open("first.txt", "w") { |f| f.puts "Hello world" }
   #     zipfile.dir.mkdir("mydir")
@@ -45,22 +45,22 @@ module Zip
     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
+    # object, except it works on the Zip::File 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
+    # object, except it works on the Zip::File 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.
+    # Zip::File::file. An instance of ZipFsFile behaves like ruby's
+    # builtin File (class) object, except it works on Zip::File entries.
     #
     # The individual methods are not documented due to their
     # similarity with the methods in File
@@ -543,7 +543,7 @@ module Zip
       end
     end
 
-    # All access to ZipFile from ZipFsFile and ZipFsDir goes through a
+    # All access to Zip::File from ZipFsFile and ZipFsDir goes through a
     # ZipFileNameMapper, which has one responsibility: ensure
     class ZipFileNameMapper # :nodoc:all
       include Enumerable

data/lib/zip/inflater.rb

@@ -7,9 +7,9 @@ module Zip
       @has_returned_empty_string = false
     end
 
-    def sysread(number_of_bytes = nil, buf = nil)
+    def sysread(number_of_bytes = nil, buf = '')
       readEverything = number_of_bytes.nil?
-      while (readEverything || @output_buffer.bytesize < number_of_bytes)
+      while readEverything || @output_buffer.bytesize < number_of_bytes
         break if internal_input_finished?
         @output_buffer << internal_produce_input(buf)
       end
@@ -37,7 +37,7 @@ module Zip
 
     private
 
-    def internal_produce_input(buf = nil)
+    def internal_produce_input(buf = '')
       retried = 0
       begin
         @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))

data/lib/zip/input_stream.rb

@@ -1,41 +1,39 @@
 module Zip
-  # ZipInputStream is the basic class for reading zip entries in a 
-  # zip file. It is possible to create a ZipInputStream object directly, 
+  # InputStream is the basic class for reading zip entries in a
+  # zip file. It is possible to create a InputStream 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 
+  # the InputStream will be obtained from a File (perhaps using the
   # ZipFileSystem interface) object for a particular entry in the zip 
   # archive.
   #
-  # A ZipInputStream inherits IOExtras::AbstractInputStream in order
+  # A InputStream 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.
+  # an archive. get_next_entry returns a Entry object that describes
+  # the zip entry the InputStream is currently reading from.
   #
   # Example that creates a zip archive with ZipOutputStream and reads it 
-  # back again with a ZipInputStream.
+  # back again with a InputStream.
   #
-  #   require 'zip/zip'
+  #   require 'zip'
   #   
-  #   Zip::ZipOutputStream::open("my.zip") { 
-  #     |io|
+  #   Zip::OutputStream.open("my.zip") do |io|
   #   
   #     io.put_next_entry("first_entry.txt")
   #     io.write "Hello world!"
   #   
   #     io.put_next_entry("adir/first_entry.txt")
   #     io.write "Hello again!"
-  #   }
+  #   end
   #
   #   
-  #   Zip::ZipInputStream::open("my.zip") {
-  #     |io|
+  #   Zip::InputStream.open("my.zip") do |io|
   #   
   #     while (entry = io.get_next_entry)
   #       puts "Contents of #{entry.name}: '#{io.read}'"
   #     end
-  #   }
+  #   end
   #
   # java.util.zip.ZipInputStream is the original inspiration for this 
   # class.
@@ -46,88 +44,101 @@ module Zip
     # 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, io = nil)
+    #
+    # @param context [String||IO||StringIO] file path or IO/StringIO object
+    # @param offset [Integer] offset in the IO/StringIO
+    def initialize(context, offset = 0)
       super()
-      if (io.nil?) 
-        @archiveIO = ::File.open(filename, "rb")
-        @archiveIO.seek(offset, IO::SEEK_SET)
-      else
-        @archiveIO = io
-      end
-      @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 InputStream.open(filename)
-      return new(filename) unless block_given?
-      
-      zio = new(filename)
-      yield zio
-    ensure
-      zio.close if zio
+      @archive_io = get_io(context, offset)
+      @decompressor  = ::Zip::NullDecompressor
+      @current_entry = nil
     end
 
-    def InputStream.open_buffer(io)
-      return new('',0,io) unless block_given?
-      zio = new('',0,io)
-      yield zio
-    ensure
-      zio.close if zio
+    def close
+      @archive_io.close
     end
 
-    # Returns a ZipEntry object. It is necessary to call this
-    # method on a newly created ZipInputStream before reading from 
+    # Returns a Entry object. It is necessary to call this
+    # method on a newly created InputStream 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
+      @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET) if @current_entry
       open_entry
     end
 
     # Rewinds the stream to the beginning of the current entry
     def rewind
-      return if @currentEntry.nil?
+      return if @current_entry.nil?
       @lineno = 0
-      @pos = 0
-      @archiveIO.seek(@currentEntry.local_header_offset,
-		      IO::SEEK_SET)
+      @pos    = 0
+      @archive_io.seek(@current_entry.local_header_offset, IO::SEEK_SET)
       open_entry
     end
 
     # Modeled after IO.sysread
-    def sysread(numberOfBytes = nil, buf = nil)
-      @decompressor.sysread(numberOfBytes, buf)
+    def sysread(number_of_bytes = nil, buf = nil)
+      @decompressor.sysread(number_of_bytes, buf)
     end
 
     def eof
       @output_buffer.empty? && @decompressor.eof
     end
+
     alias :eof? :eof
 
+    class << self
+      # Same as #initialize but if a block is passed the opened
+      # stream is passed to the block and closed when the block
+      # returns.
+      def open(filename_or_io, offset = 0)
+        zio = self.new(filename_or_io, offset)
+        return zio unless block_given?
+        begin
+          yield zio
+        ensure
+          zio.close if zio
+        end
+      end
+
+      def open_buffer(filename_or_io, offset = 0)
+        puts "open_buffer is deprecated!!! Use open instead!"
+        self.open(filename_or_io, offset)
+      end
+    end
+
     protected
 
-    def open_entry
-      @currentEntry = Entry.read_local_entry(@archiveIO)
-      if @currentEntry.nil?
-	      @decompressor = NullDecompressor.instance
-      elsif @currentEntry.compression_method == Entry::STORED
-	      @decompressor = PassThruDecompressor.new(@archiveIO, @currentEntry.size)
-      elsif @currentEntry.compression_method == Entry::DEFLATED
-	      @decompressor = Inflater.new(@archiveIO)
+    def get_io(io_or_file, offset = 0)
+      case io_or_file
+      when IO, StringIO
+        io_or_file
       else
-	      raise ZipCompressionMethodError,
-              "Unsupported compression method #{@currentEntry.compression_method}"
+        file = ::File.open(io_or_file, 'rb')
+        file.seek(offset, ::IO::SEEK_SET)
+        file
       end
+    end
+
+    def open_entry
+      @current_entry = ::Zip::Entry.read_local_entry(@archive_io)
+      @decompressor  = get_decompressor
       flush
-      return @currentEntry
+      @current_entry
+    end
+
+    def get_decompressor
+      case
+      when @current_entry.nil?
+        ::Zip::NullDecompressor
+      when @current_entry.compression_method == ::Zip::Entry::STORED
+        ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
+      when @current_entry.compression_method == ::Zip::Entry::DEFLATED
+        ::Zip::Inflater.new(@archive_io)
+      else
+        raise ZipCompressionMethodError,
+              "Unsupported compression method #{@current_entry.compression_method}"
+      end
     end
 
     def produce_input