rubyzip 1.0.0 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NjQ3YjE3YmQ0MDUyYzViOThmNDBjNGVhYTRmNDdiNzAzZjYzNjZkOA==
-  data.tar.gz: !binary |-
-    OGI5ZjFlYTk3NmQwMGY2NmM2NmVkYWI3ZjczMTVjNDAxYzg0YzY3Zg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ODI3NzAwZDg5NzYyZDdjZTNlNDUyOWJjYmY0YTU0MGEzMjUwOTE5MjdkOTM3
-    ZjkzMTFjNzQzZmRlZDA4MTllZmU2N2NjMDQyMDM5NTRjMjg5ODVmMzUyODMw
-    ZGExYjk3MDkwNzRmYTJkYjhhYjNmMmY4YTIyYTQ2ODA4MDdiNzk=
-  data.tar.gz: !binary |-
-    MWM5ODRlNzdmNDNiOGE4ZjkzMWYzZTIxZTE4OTU1ZTVhZmQ4YzhhZGQ0ZWNi
-    N2Q4N2NhZmE1ZmJiZjFjMzcxMWI3YzgzNmRiNDVlZGYwZmYyZTJiNTljY2Yx
-    MTY4NGM1YjNhOGJiZmE2MGUyZTBjYTc2YzdjMzc0ZTE3NTIyZDc=
+SHA1:
+  metadata.gz: 68e2727c6e1f49edc93c3081e74a8b8dd6cf8ea8
+  data.tar.gz: c6e0a74722936557ccec3a74f3d2efcf2e4a21b1
+SHA512:
+  metadata.gz: 77c0f46c33bfe45177adcc0bddf68fc3ae55624ed5fc95163eaf0546c028fd204fdf8167a2ce041389c4c9fe4961868dfd0ed79dfe3ea3439634542db9aecd1d
+  data.tar.gz: 7a2a4164ce2591204f30a36b337a4e1ce5907b3649487c9a366aff6d366b68cb61b15136cb2c0015845239a40d99158aabba2d635e7b46e5e508813dc1512aae

data/README.md

@@ -9,6 +9,17 @@ rubyzip is a ruby library for reading and writing zip files.
 
 Rubyzip interface changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
 
+If you have issues with any third-party gems what required rubyzip you can use next temporary fix:
+
+```ruby
+# Place this line before your library or on the head of your Gemfile
+gem 'rubyzip', '< 1.0.0'
+```
+
+## Requirements
+
+* Ruby 1.9.2 or greater
+
 ## Installation
 rubyzip is available on RubyGems, so:
 
@@ -61,6 +72,24 @@ Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
 end
 ```
 
+### Save zip archive entries in sorted by name state
+
+To saving zip archives in sorted order like below you need to set `::Zip.sort_entries` to `true`
+
+```
+Vegetable/
+Vegetable/bean
+Vegetable/carrot
+Vegetable/celery
+fruit/
+fruit/apple
+fruit/kiwi
+fruit/mango
+fruit/orange
+```
+
+After this entries in zip archive will be saved in ordered state.
+
 ## Known issues
 
 ### Modify docx file with rubyzip

data/Rakefile

@@ -8,6 +8,12 @@ Rake::TestTask.new(:test) do |test|
   test.libs << File.join(File.dirname(__FILE__), 'test')
   test.pattern = File.join(File.dirname(__FILE__), 'test/alltests.rb')
   test.verbose = true
+end
 
+Rake::TestTask.new(:zip64_full_test) do |test|
+  test.libs << File.join(File.dirname(__FILE__), 'lib')
+  test.libs << File.join(File.dirname(__FILE__), 'test')
+  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
+  test.verbose = true
 end
 

data/lib/zip.rb

@@ -27,16 +27,21 @@ require 'zip/streamable_stream'
 require 'zip/streamable_directory'
 require 'zip/constants'
 require 'zip/errors'
+if defined? JRUBY_VERSION
+  require 'jruby'
+  JRuby.objectspace = true
+end
 
 module Zip
   extend self
-  attr_accessor :unicode_names, :on_exists_proc, :continue_on_exists_proc
+  attr_accessor :unicode_names, :on_exists_proc, :continue_on_exists_proc, :sort_entries
 
   def reset!
     @_ran_once = false
     @unicode_names = false
     @on_exists_proc = false
     @continue_on_exists_proc = false
+    @sort_entries = false
   end
 
   def setup
@@ -49,4 +54,4 @@ 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.
+# modify it under the terms of the ruby license.

data/lib/zip/central_directory.rb

@@ -22,20 +22,27 @@ module Zip
     end
 
     def write_to_stream(io) #:nodoc:
-      offset = io.tell
+      cdir_offset = io.tell
       @entry_set.each { |entry| entry.write_c_dir_entry(io) }
-      write_e_o_c_d(io, offset)
+      eocd_offset = io.tell
+      cdir_size = eocd_offset - cdir_offset
+      has_zip64_entry = @entry_set.any? { |entry| entry.extra['Zip64'] }
+      if has_zip64_entry || cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
+        write_64_e_o_c_d(io, cdir_offset, cdir_size)
+        write_64_eocd_locator(io, eocd_offset)
+      end
+      write_e_o_c_d(io, cdir_offset, cdir_size)
     end
 
-    def write_e_o_c_d(io, offset) #:nodoc:
+    def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
       tmp = [
         END_OF_CDS,
         0, # @numberOfThisDisk
         0, # @numberOfDiskWithStartOfCDir
-        @entry_set ? @entry_set.size : 0,
-        @entry_set ? @entry_set.size : 0,
-        cdir_size,
-        offset,
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        [cdir_size, 0xFFFFFFFF].min,
+        [offset, 0xFFFFFFFF].min,
         @comment ? @comment.length : 0
       ]
       io << tmp.pack('VvvvvVVv')
@@ -44,14 +51,35 @@ module Zip
 
     private :write_e_o_c_d
 
-    def cdir_size #:nodoc:
-      # does not include eocd
-      @entry_set.inject(0) do |value, entry|
-        entry.cdir_header_size + value
-      end
+    def write_64_e_o_c_d(io, offset, cdir_size) #:nodoc:
+      tmp = [
+        ZIP64_END_OF_CDS,
+        44, # size of zip64 end of central directory record (excludes signature and field itself)
+        VERSION_MADE_BY,
+        VERSION_NEEDED_TO_EXTRACT_ZIP64,
+        0, # @numberOfThisDisk
+        0, # @numberOfDiskWithStartOfCDir
+        @entry_set ? @entry_set.size : 0, # number of entries on this disk
+        @entry_set ? @entry_set.size : 0, # number of entries total
+        cdir_size, # size of central directory
+        offset, # offset of start of central directory in its disk
+      ]
+      io << tmp.pack('VQ<vvVVQ<Q<Q<Q<')
+    end
+
+    private :write_64_e_o_c_d
+
+    def write_64_eocd_locator(io, zip64_eocd_offset)
+      tmp = [
+        ZIP64_EOCD_LOCATOR,
+        0, # number of disk containing the start of zip64 eocd record
+        zip64_eocd_offset, # offset of the start of zip64 eocd record in its disk
+        1 # total number of disks
+      ]
+      io << tmp.pack('VVQ<V')
     end
 
-    private :cdir_size
+    private :write_64_eocd_locator
 
     def read_64_e_o_c_d(buf) #:nodoc:
       buf                                           = get_64_e_o_c_d(buf)

data/lib/zip/constants.rb

@@ -7,7 +7,9 @@ module Zip
   LOCAL_ENTRY_SIGNATURE                  = 0x04034b50
   LOCAL_ENTRY_STATIC_HEADER_LENGTH       = 30
   LOCAL_ENTRY_TRAILING_DESCRIPTOR_LENGTH = 4+4+4
+  VERSION_MADE_BY                        = 52 # this library's version
   VERSION_NEEDED_TO_EXTRACT              = 20
+  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
 
   FILE_TYPE_FILE    = 010
   FILE_TYPE_DIR     = 004

data/lib/zip/entry.rb

@@ -21,7 +21,7 @@ module Zip
       @header_signature         = ::Zip::CENTRAL_DIRECTORY_ENTRY_SIGNATURE
 
       @version_needed_to_extract = VERSION_NEEDED_TO_EXTRACT
-      @version                   = 52 # this library's version
+      @version                   = VERSION_MADE_BY
 
       @ftype           = nil          # unspecified or unknown
       @filepath        = nil
@@ -124,10 +124,17 @@ module Zip
     end
 
     def calculate_local_header_size #:nodoc:all
-      fix_zip64_sizes!
       LOCAL_ENTRY_STATIC_HEADER_LENGTH + name_size + extra_size
     end
 
+    # check before rewriting an entry (after file sizes are known)
+    # that we didn't change the header size (and thus clobber file data or something)
+    def verify_local_header_size!
+      return if @local_header_size == 0
+      new_size = calculate_local_header_size
+      raise ZipError, "local header size changed (#{@local_header_size} -> #{new_size})" if @local_header_size != new_size
+    end
+
     def cdir_header_size #:nodoc:all
       CDIR_ENTRY_STATIC_HEADER_LENGTH + name_size +
         (@extra ? @extra.c_dir_size : 0) + comment_size
@@ -166,7 +173,7 @@ module Zip
       end
 
       def read_zip_64_long(io) # :nodoc:
-        io.read(8).unpack('V')[0]
+        io.read(8).unpack('Q<')[0]
       end
 
       def read_c_dir_entry(io) #:nodoc:all
@@ -178,7 +185,7 @@ module Zip
       end
 
       def read_local_entry(io)
-        entry = new(io.path)
+        entry = self.new
         entry.read_local_entry(io)
         entry
       rescue ZipError
@@ -234,10 +241,12 @@ module Zip
           @extra = ::Zip::ExtraField.new(extra)
         end
       end
+      parse_zip64_extra(true)
       @local_header_size = calculate_local_header_size
     end
 
     def pack_local_entry
+      zip64 = @extra['Zip64']
       [::Zip::LOCAL_ENTRY_SIGNATURE,
        @version_needed_to_extract, # version needed to extract
        @gp_flags, # @gp_flags                  ,
@@ -245,19 +254,22 @@ module Zip
        @time.to_binary_dos_time, # @last_mod_time              ,
        @time.to_binary_dos_date, # @last_mod_date              ,
        @crc,
-       @compressed_size,
-       @size,
+       (zip64 && zip64.compressed_size) ? 0xFFFFFFFF : @compressed_size,
+       (zip64 && zip64.original_size) ? 0xFFFFFFFF : @size,
        name_size,
        @extra ? @extra.local_size : 0].pack('VvvvvvVVVvv')
     end
 
-    def write_local_entry(io) #:nodoc:all
+    def write_local_entry(io, rewrite = false) #:nodoc:all
+      prep_zip64_extra(true)
+      verify_local_header_size! if rewrite
       @local_header_offset = io.tell
 
       io << pack_local_entry
 
       io << @name
       io << (@extra ? @extra.to_local_bin : '')
+      @local_header_size = io.tell - @local_header_offset
     end
 
     def unpack_c_dir_entry(buf)
@@ -350,6 +362,7 @@ module Zip
       @comment = io.read(@comment_length)
       check_c_dir_entry_comment_size
       set_ftype_from_c_dir_entry
+      parse_zip64_extra(false)
       @local_header_size = calculate_local_header_size
     end
 
@@ -390,6 +403,7 @@ module Zip
     end
 
     def pack_c_dir_entry
+      zip64 = @extra['Zip64']
       [
         @header_signature,
         @version, # version of encoding software
@@ -400,22 +414,20 @@ module Zip
         @time.to_binary_dos_time, # @last_mod_time                      ,
         @time.to_binary_dos_date, # @last_mod_date                      ,
         @crc,
-        @compressed_size,
-        @size,
+        (zip64 && zip64.compressed_size) ? 0xFFFFFFFF : @compressed_size,
+        (zip64 && zip64.original_size) ? 0xFFFFFFFF : @size,
         name_size,
         @extra ? @extra.c_dir_size : 0,
         comment_size,
-        0, # disk number start
+        (zip64 && zip64.disk_start_number) ? 0xFFFF : 0, # disk number start
         @internal_file_attributes, # file type (binary=0, text=1)
         @external_file_attributes, # native filesystem attributes
-        @local_header_offset,
-        @name,
-        @extra,
-        @comment
+        (zip64 && zip64.relative_header_offset) ? 0xFFFFFFFF : @local_header_offset
       ].pack('VCCvvvvvVVVvvvvvVV')
     end
 
     def write_c_dir_entry(io) #:nodoc:all
+      prep_zip64_extra(false)
       case @fstype
       when ::Zip::FSTYPE_UNIX
         ft = case @ftype
@@ -459,8 +471,8 @@ module Zip
     # Warning: may behave weird with symlinks.
     def get_input_stream(&block)
       if @ftype == :directory
-        yield(::Zip::NullInputStream.instance) if block_given?
-        ::Zip::NullInputStream.instance
+        yield ::Zip::NullInputStream if block_given?
+        ::Zip::NullInputStream
       elsif @filepath
         case @ftype
         when :file
@@ -607,10 +619,50 @@ module Zip
       ::File.symlink(linkto, dest_path)
     end
 
-    def fix_zip64_sizes! #:nodoc:all
-      if zip64 = @extra["Zip64"]
-        @size = zip64.original_size
-        @compressed_size = zip64.compressed_size
+    # apply missing data from the zip64 extra information field, if present
+    # (required when file sizes exceed 2**32, but can be used for all files)
+    def parse_zip64_extra(for_local_header) #:nodoc:all
+      if zip64 = @extra['Zip64']
+        if for_local_header
+          @size, @compressed_size = zip64.parse(@size, @compressed_size)
+        else
+          @size, @compressed_size, @local_header_offset = zip64.parse(@size, @compressed_size, @local_header_offset)
+        end
+      end
+    end
+
+    # create a zip64 extra information field if we need one
+    def prep_zip64_extra(for_local_header) #:nodoc:all
+      need_zip64 = @size >= 0xFFFFFFFF || @compressed_size >= 0xFFFFFFFF
+      unless for_local_header
+        need_zip64 ||= @local_header_offset >= 0xFFFFFFFF
+      end
+
+      if need_zip64
+        @version_needed_to_extract = VERSION_NEEDED_TO_EXTRACT_ZIP64
+        @extra.delete('Zip64Placeholder')
+        zip64 = @extra.create('Zip64')
+        if for_local_header
+          # local header always includes size and compressed size
+          zip64.original_size = @size
+          zip64.compressed_size = @compressed_size
+        else
+          # central directory entry entries include whichever fields are necessary
+          zip64.original_size = @size if @size >= 0xFFFFFFFF
+          zip64.compressed_size = @compressed_size if @compressed_size >= 0xFFFFFFFF
+          zip64.relative_header_offset = @local_header_offset if @local_header_offset >= 0xFFFFFFFF
+        end
+      else
+        @extra.delete('Zip64')
+
+        # if this is a local header entry, create a placeholder
+        # so we have room to write a zip64 extra field afterward
+        # (we won't know if it's needed until the file data is written)
+        if for_local_header
+          @extra.create('Zip64Placeholder')
+        else
+          @extra.delete('Zip64Placeholder')
+        end
       end
     end
 

data/lib/zip/entry_set.rb

@@ -6,7 +6,6 @@ module Zip
     def initialize(an_enumerable = [])
       super()
       @entry_set   = {}
-      @entry_order = []
       an_enumerable.each { |o| push(o) }
     end
 
@@ -19,8 +18,6 @@ module Zip
     end
 
     def <<(entry)
-      @entry_order.delete(to_key(entry))
-      @entry_order << to_key(entry)
       @entry_set[to_key(entry)] = entry
     end
 
@@ -33,7 +30,7 @@ module Zip
     alias :length :size
 
     def delete(entry)
-      if @entry_order.delete(to_key(entry)) && @entry_set.delete(to_key(entry))
+      if @entry_set.delete(to_key(entry))
         entry
       else
         nil
@@ -41,23 +38,27 @@ module Zip
     end
 
     def each(&block)
-      @entry_order.each do |key|
-        block.call @entry_set[key]
+      @entry_set = @entry_set.dup.each do |_, value|
+        block.call(value)
       end
     end
 
     def entries
-      @entry_order.map { |key| @entry_set[key] }
+      if ::Zip.sort_entries == true
+        @entry_set.values.sort_by{|x| x.name}
+      else
+        @entry_set.values
+      end
     end
 
     # deep clone
     def dup
-      EntrySet.new(@entry_order.map { |key| @entry_set[key].dup })
+      EntrySet.new(@entry_set.map { |key, value| value.dup })
     end
 
     def ==(other)
       return false unless other.kind_of?(EntrySet)
-      @entry_set == other.entry_set && @entry_order == other.entry_order
+      @entry_set.values == other.entry_set.values
     end
 
     def parent(entry)

data/lib/zip/extra_field.rb

@@ -57,14 +57,20 @@ module Zip
       self[name] = field_class.new
     end
 
+    # place Unknown last, so "extra" data that is missing the proper signature/size
+    # does not prevent known fields from being read back in
+    def ordered_values
+      self.keys.sort_by { |k| k == 'Unknown' ? 1 : 0 }.map { |k| self[k] }
+    end
+
     def to_local_bin
-      self.map { |_, v| v.to_local_bin }.join
+      ordered_values.map { |v| v.to_local_bin.force_encoding('BINARY') }.join
     end
 
     alias :to_s :to_local_bin
 
     def to_c_dir_bin
-      self.map { |_, v| v.to_c_dir_bin }.join
+      ordered_values.map { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
     end
 
     def c_dir_size
@@ -83,6 +89,8 @@ end
 require 'zip/extra_field/generic'
 require 'zip/extra_field/universal_time'
 require 'zip/extra_field/unix'
+require 'zip/extra_field/zip64'
+require 'zip/extra_field/zip64_placeholder'
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard
 # rubyzip is free software; you can redistribute it and/or