zip_tricks 2.8.1 → 3.0.0

data/spec/zip_tricks/streamer_spec.rb

@@ -1,6 +1,4 @@
 require_relative '../spec_helper'
-require 'fileutils'
-require 'shellwords'
 
 describe ZipTricks::Streamer do
   let(:test_text_file_path) {
@@ -30,7 +28,7 @@ describe ZipTricks::Streamer do
   it 'returns the position in the IO at every call' do
     io = StringIO.new
     zip = described_class.new(io)
-    pos = zip.add_compressed_entry('file.jpg', 182919, 8921, 8912)
+    pos = zip.add_compressed_entry(filename: 'file.jpg', uncompressed_size: 182919, compressed_size: 8912, crc32: 8912)
     expect(pos).to eq(io.tell)
     expect(pos).to eq(38)
 
@@ -38,17 +36,14 @@ describe ZipTricks::Streamer do
     expect(retval).to eq(zip)
     expect(io.tell).to eq(8950)
 
-    pos = zip.add_stored_entry('filf.jpg', 8921, 182919)
+    pos = zip.add_stored_entry(filename: 'filf.jpg', size: 8921, crc32: 182919)
     expect(pos).to eq(8988)
     zip << SecureRandom.random_bytes(8921)
     expect(io.tell).to eq(17909)
 
-    pos = zip.write_central_directory!
+    pos = zip.close
     expect(pos).to eq(io.tell)
-    expect(pos).to eq(18039)
-
-    pos_after_close = zip.close
-    expect(pos_after_close).to eq(pos)
+    expect(pos).to eq(18068)
   end
 
   it 'can write and then read the block-deflated files' do
@@ -73,7 +68,8 @@ describe ZipTricks::Streamer do
     zip_file.binmode
 
     described_class.open(zip_file) do |zip|
-      zip.add_compressed_entry("compressed-file.bin", f.size, crc, compressed_blockwise.size)
+      zip.add_compressed_entry(filename: "compressed-file.bin", uncompressed_size: f.size,
+        crc32: crc, compressed_size: compressed_blockwise.size)
       zip << compressed_blockwise.read
     end
     zip_file.flush
@@ -112,11 +108,12 @@ describe ZipTricks::Streamer do
       end
 
       # Add this file compressed...
-      zip.add_compressed_entry('war-and-peace.txt', source_f.size, crc32, compressed_buffer.size)
+      zip.add_compressed_entry(filename: 'war-and-peace.txt', uncompressed_size: source_f.size,
+        crc32: crc32, compressed_size: compressed_buffer.size)
       zip << compressed_buffer.string
 
       # ...and stored.
-      zip.add_stored_entry('war-and-peace-raw.txt', source_f.size, crc32)
+      zip.add_stored_entry(filename: 'war-and-peace-raw.txt', size: source_f.size, crc32: crc32)
       zip << source_f.read
 
       zip.close
@@ -154,9 +151,9 @@ describe ZipTricks::Streamer do
 
     # Perform the zipping
     zip = described_class.new(output_io)
-    zip.add_stored_entry("first-file.bin", raw_file_1.size, Zlib.crc32(raw_file_1))
+    zip.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size, crc32: Zlib.crc32(raw_file_1))
     zip << raw_file_1
-    zip.add_stored_entry("second-file.bin", raw_file_2.size, Zlib.crc32(raw_file_2))
+    zip.add_stored_entry(filename: "second-file.bin", size: raw_file_2.size, crc32: Zlib.crc32(raw_file_2))
     zip << raw_file_2
     zip.close
 
@@ -193,9 +190,9 @@ describe ZipTricks::Streamer do
 
     # Perform the zipping
     zip = described_class.new(zip_buf)
-    zip.add_stored_entry("first-file.bin", raw_file_1.size, Zlib.crc32(raw_file_1))
+    zip.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size, crc32: Zlib.crc32(raw_file_1))
     zip << raw_file_1
-    zip.add_stored_entry("второй-файл.bin", raw_file_2.size, Zlib.crc32(raw_file_2))
+    zip.add_stored_entry(filename: "второй-файл.bin", size: raw_file_2.size, crc32: Zlib.crc32(raw_file_2))
     IO.copy_stream(StringIO.new(raw_file_2), zip)
     zip.close
 
@@ -215,28 +212,54 @@ describe ZipTricks::Streamer do
       expect(second_entry.name).to eq("второй-файл.bin".force_encoding(Encoding::BINARY))
     end
   end
-
-  it 'raises when the actual bytes written for a stored entry does not match the entry header' do
-    expect {
-      ZipTricks::Streamer.open(StringIO.new) do | zip |
-        zip.add_stored_entry('file', 123, 0)
-        zip << 'xx'
+  
+  it 'creates an archive with data descriptors that can be opened by Rubyzip, with a small number of very tiny text files' do
+    tf = ManagedTempfile.new('zip')
+    z = described_class.open(tf) do |zip|
+      zip.write_stored_file('deflated.txt') do |sink|
+        sink << File.read(__dir__ + '/war-and-peace.txt')
       end
-    }.to raise_error {|e|
-      expect(e).to be_kind_of(ZipTricks::Streamer::EntryBodySizeMismatch)
-      expect(e.message).to eq('Wrong number of bytes written for entry (expected 123, got 2)')
-    }
+      zip.write_deflated_file('stored.txt') do |sink|
+        sink << File.read(__dir__ + '/war-and-peace.txt')
+      end
+    end
+    tf.flush
+    
+    pending 'https://github.com/rubyzip/rubyzip/issues/295'
+    
+    Zip::File.foreach(tf.path) do |entry|
+      # Make sure it is tagged as UNIX
+      expect(entry.fstype).to eq(3)
+
+       # The CRC
+      expect(entry.crc).to eq(Zlib.crc32(File.read(__dir__ + '/war-and-peace.txt')))
+
+      # Check the name
+      expect(entry.name).to match(/\.txt$/)
+
+      # Check the right external attributes (non-executable on UNIX)
+      expect(entry.external_file_attributes).to eq(2175008768)
+      
+      # Check the file contents
+      readback = entry.get_input_stream.read
+      readback.force_encoding(Encoding::BINARY)
+      expect(readback[0..10]).to eq(File.read(__dir__ + '/war-and-peace.txt')[0..10])
+    end
+
+    inspect_zip_with_external_tool(tf.path)
   end
 
-  it 'raises when the actual bytes written for a compressed entry does not match the entry header' do
-    expect {
-      ZipTricks::Streamer.open(StringIO.new) do | zip |
-        zip.add_compressed_entry('file', 1898121, 0, 123)
-        zip << 'xx'
-      end
-    }.to raise_error {|e|
-      expect(e).to be_kind_of(ZipTricks::Streamer::EntryBodySizeMismatch)
-      expect(e.message).to eq('Wrong number of bytes written for entry (expected 123, got 2)')
-    }
+  it 'can create a valid ZIP archive without any files' do
+    tf = ManagedTempfile.new('zip')
+    
+    described_class.open(tf) do |zip|
+    end
+
+    tf.flush
+    tf.rewind
+
+    expect { |b|
+      Zip::File.foreach(tf.path, &b)
+    }.not_to yield_control
   end
 end

data/spec/zip_tricks/zip_writer_spec.rb

@@ -0,0 +1,408 @@
+require_relative '../spec_helper'
+require_relative '../../testing/support'
+
+describe ZipTricks::ZipWriter do
+  class ByteReader < Struct.new(:io)
+    def initialize(io)
+      super(io).tap { io.rewind }
+    end
+    
+    def read_2b
+      read_n(2).unpack('v').first
+    end
+
+    def read_2c
+      read_n(2).unpack('CC').first
+    end
+
+    def read_4b
+      read_n(4).unpack('V').first
+    end
+
+    def read_8b
+      read_n(8).unpack('Q<').first
+    end
+
+    def read_n(n)
+      io.read(n).tap {|r|
+        raise "Expected to read #{n} bytes, but read() returned nil" if r.nil?
+        raise "Expected to read #{n} bytes, but read #{r.bytesize} instead" if r.bytesize != n
+      }
+    end
+    
+    # For conveniently going to a specific signature
+    def seek_to_start_of_signature(signature)
+      io.rewind
+      signature_encoded = [signature].pack('V')
+      idx = io.read.index(signature_encoded)
+      raise "Could not find the signature #{signature} in the buffer" unless idx
+      io.seek(idx, IO::SEEK_SET)
+    end
+  end
+
+  describe '#write_local_file_header' do
+    it 'writes the local file header for an entry that does not require Zip64' do
+      buf = StringIO.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      
+      subject = ZipTricks::ZipWriter.new
+      subject.write_local_file_header(io: buf, gp_flags: 12, crc32: 456, compressed_size: 768, uncompressed_size: 901, mtime: mtime, filename: 'foo.bin', storage_mode: 8)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50)   # Signature
+      expect(br.read_2b).to eq(20)           # Version needed to extract
+      expect(br.read_2b).to eq(12)           # gp flags
+      expect(br.read_2b).to eq(8)            # storage mode
+      expect(br.read_2b).to eq(28160)        # DOS time
+      expect(br.read_2b).to eq(18673)        # DOS date
+      expect(br.read_4b).to eq(456)          # CRC32
+      expect(br.read_4b).to eq(768)          # compressed size
+      expect(br.read_4b).to eq(901)          # uncompressed size
+      expect(br.read_2b).to eq(7)            # filename size
+      expect(br.read_2b).to eq(0)            # extra fields size
+      expect(br.read_n(7)).to eq('foo.bin')  # extra fields size
+      expect(buf).to be_eof
+    end
+    
+    it 'writes the local file header for an entry that does require Zip64 based on uncompressed size (with the Zip64 extra)' do
+      buf = StringIO.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      
+      subject = ZipTricks::ZipWriter.new
+      subject.write_local_file_header(io: buf, gp_flags: 12, crc32: 456, compressed_size: 768, uncompressed_size: 0xFFFFFFFF+1, mtime: mtime, filename: 'foo.bin', storage_mode: 8)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50)   # Signature
+      expect(br.read_2b).to eq(45)           # Version needed to extract
+      expect(br.read_2b).to eq(12)           # gp flags
+      expect(br.read_2b).to eq(8)            # storage mode
+      expect(br.read_2b).to eq(28160)        # DOS time
+      expect(br.read_2b).to eq(18673)        # DOS date
+      expect(br.read_4b).to eq(456)          # CRC32
+      expect(br.read_4b).to eq(0xFFFFFFFF)   # compressed size
+      expect(br.read_4b).to eq(0xFFFFFFFF)   # uncompressed size
+      expect(br.read_2b).to eq(7)            # filename size
+      expect(br.read_2b).to eq(20)           # extra fields size
+      expect(br.read_n(7)).to eq('foo.bin')  # extra fields size
+      
+      expect(buf).not_to be_eof
+      
+      expect(br.read_2b).to eq(1)            # Zip64 extra tag
+      expect(br.read_2b).to eq(16)           # Size of the Zip64 extra payload
+      expect(br.read_8b).to eq(0xFFFFFFFF+1) # uncompressed size
+      expect(br.read_8b).to eq(768)          # compressed size
+    end
+    
+    it 'writes the local file header for an entry that does require Zip64 based on compressed size (with the Zip64 extra)' do
+      buf = StringIO.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      
+      subject = ZipTricks::ZipWriter.new
+      subject.write_local_file_header(io: buf, gp_flags: 12, crc32: 456, compressed_size: 0xFFFFFFFF+1, uncompressed_size: 768, mtime: mtime, filename: 'foo.bin', storage_mode: 8)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50)   # Signature
+      expect(br.read_2b).to eq(45)           # Version needed to extract
+      expect(br.read_2b).to eq(12)           # gp flags
+      expect(br.read_2b).to eq(8)            # storage mode
+      expect(br.read_2b).to eq(28160)        # DOS time
+      expect(br.read_2b).to eq(18673)        # DOS date
+      expect(br.read_4b).to eq(456)          # CRC32
+      expect(br.read_4b).to eq(0xFFFFFFFF)   # compressed size
+      expect(br.read_4b).to eq(0xFFFFFFFF)   # uncompressed size
+      expect(br.read_2b).to eq(7)            # filename size
+      expect(br.read_2b).to eq(20)           # extra fields size
+      expect(br.read_n(7)).to eq('foo.bin')  # extra fields size
+      
+      expect(buf).not_to be_eof
+      
+      expect(br.read_2b).to eq(1)            # Zip64 extra tag
+      expect(br.read_2b).to eq(16)           # Size of the Zip64 extra payload
+      expect(br.read_8b).to eq(768)          # uncompressed size
+      expect(br.read_8b).to eq(0xFFFFFFFF+1) # compressed size
+    end
+  end
+  
+  describe '#write_data_descriptor' do
+    it 'writes 4-byte sizes into the data descriptor for standard file sizes' do
+      buf = StringIO.new
+      
+      subject.write_data_descriptor(io: buf, crc32: 123, compressed_size: 89821, uncompressed_size: 990912)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x08074b50)   # Signature
+      expect(br.read_4b).to eq(123)          # CRC32
+      expect(br.read_4b).to eq(89821)        # compressed size
+      expect(br.read_4b).to eq(990912)        # uncompressed size
+      expect(buf).to be_eof
+    end
+    
+    it 'writes 8-byte sizes into the data descriptor for Zip64 compressed file size' do
+      buf = StringIO.new
+      
+      subject.write_data_descriptor(io: buf, crc32: 123, compressed_size: 0xFFFFFFFF + 1, uncompressed_size: 990912)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x08074b50)      # Signature
+      expect(br.read_4b).to eq(123)             # CRC32
+      expect(br.read_8b).to eq(0xFFFFFFFF + 1)  # compressed size
+      expect(br.read_8b).to eq(990912)          # uncompressed size
+      expect(buf).to be_eof
+    end
+    
+    it 'writes 8-byte sizes into the data descriptor for Zip64 uncompressed file size' do
+      buf = StringIO.new
+      
+      subject.write_data_descriptor(io: buf, crc32: 123, compressed_size: 123, uncompressed_size: 0xFFFFFFFF + 1)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x08074b50)      # Signature
+      expect(br.read_4b).to eq(123)             # CRC32
+      expect(br.read_8b).to eq(123)             # compressed size
+      expect(br.read_8b).to eq(0xFFFFFFFF + 1)  # uncompressed size
+      expect(buf).to be_eof
+    end
+  end
+  
+  describe '#write_central_directory_file_header' do
+    it 'writes the file header for a small-ish entry' do
+      buf = StringIO.new
+      
+      subject.write_central_directory_file_header(io: buf, local_file_header_location: 898921,
+        gp_flags: 555, storage_mode: 23,
+        compressed_size: 901, uncompressed_size: 909102,
+        mtime: Time.utc(2016, 2, 2, 14, 00), crc32: 89765,
+        filename: 'a-file.txt', external_attrs: 123) 
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x02014b50) # Central directory entry sig
+      expect(br.read_2b).to eq(820)        # version made by
+      expect(br.read_2b).to eq(20)         # version need to extract
+      expect(br.read_2b).to eq(555)        # general purpose bit flag (explicitly set to bogus value to ensure we pass it through)
+      expect(br.read_2b).to eq(23)         # compression method (explicitly set to bogus value)
+      expect(br.read_2b).to eq(28672)      # last mod file time
+      expect(br.read_2b).to eq(18498)      # last mod file date
+      expect(br.read_4b).to eq(89765)      # crc32
+      expect(br.read_4b).to eq(901)        # compressed size
+      expect(br.read_4b).to eq(909102)     # uncompressed size
+      expect(br.read_2b).to eq(10)         # filename length
+      expect(br.read_2b).to eq(0)          # extra field length
+      expect(br.read_2b).to eq(0)          # file comment
+      expect(br.read_2b).to eq(0)          # disk number, must be blanked to the maximum value because of The Unarchiver bug
+      expect(br.read_2b).to eq(0)          # internal file attributes
+      expect(br.read_4b).to eq(2175008768) # external file attributes
+      expect(br.read_4b).to eq(898921)     # relative offset of local header
+      expect(br.read_n(10)).to eq('a-file.txt') # the filename
+    end
+    
+    it 'writes the file header for an entry that requires Zip64 extra because of the uncompressed size' do
+      buf = StringIO.new
+      
+      subject.write_central_directory_file_header(io: buf, local_file_header_location: 898921,
+        gp_flags: 555, storage_mode: 23,
+        compressed_size: 901, uncompressed_size: 0xFFFFFFFFF + 3,
+        mtime: Time.utc(2016, 2, 2, 14, 00), crc32: 89765,
+        filename: 'a-file.txt', external_attrs: 123) 
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x02014b50) # Central directory entry sig
+      expect(br.read_2b).to eq(820)        # version made by
+      expect(br.read_2b).to eq(45)         # version need to extract
+      expect(br.read_2b).to eq(555)        # general purpose bit flag (explicitly set to bogus value to ensure we pass it through)
+      expect(br.read_2b).to eq(23)         # compression method (explicitly set to bogus value)
+      expect(br.read_2b).to eq(28672)      # last mod file time
+      expect(br.read_2b).to eq(18498)      # last mod file date
+      expect(br.read_4b).to eq(89765)      # crc32
+      expect(br.read_4b).to eq(0xFFFFFFFF) # compressed size
+      expect(br.read_4b).to eq(0xFFFFFFFF) # uncompressed size
+      expect(br.read_2b).to eq(10)         # filename length
+      expect(br.read_2b).to eq(32)         # extra field length
+      expect(br.read_2b).to eq(0)          # file comment
+      expect(br.read_2b).to eq(0xFFFF)     # disk number, must be blanked to the maximum value because of The Unarchiver bug
+      expect(br.read_2b).to eq(0)          # internal file attributes
+      expect(br.read_4b).to eq(2175008768) # external file attributes
+      expect(br.read_4b).to eq(0xFFFFFFFF) # relative offset of local header
+      expect(br.read_n(10)).to eq('a-file.txt') # the filename
+      
+      expect(buf).not_to be_eof
+      expect(br.read_2b).to eq(1)               # Zip64 extra tag
+      expect(br.read_2b).to eq(28)              # Size of the Zip64 extra payload
+      expect(br.read_8b).to eq(0xFFFFFFFFF + 3) # uncompressed size
+      expect(br.read_8b).to eq(901)             # compressed size
+      expect(br.read_8b).to eq(898921)          # local file header location
+    end
+    
+    it 'writes the file header for an entry that requires Zip64 extra because of the compressed size' do
+      buf = StringIO.new
+      
+      subject.write_central_directory_file_header(io: buf, local_file_header_location: 898921,
+        gp_flags: 555, storage_mode: 23,
+        compressed_size: 0xFFFFFFFFF + 3, uncompressed_size: 901, # the worst compression scheme in the universe
+        mtime: Time.utc(2016, 2, 2, 14, 00), crc32: 89765,
+        filename: 'a-file.txt', external_attrs: 123) 
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x02014b50) # Central directory entry sig
+      expect(br.read_2b).to eq(820)        # version made by
+      expect(br.read_2b).to eq(45)         # version need to extract
+      expect(br.read_2b).to eq(555)        # general purpose bit flag (explicitly set to bogus value to ensure we pass it through)
+      expect(br.read_2b).to eq(23)         # compression method (explicitly set to bogus value)
+      expect(br.read_2b).to eq(28672)      # last mod file time
+      expect(br.read_2b).to eq(18498)      # last mod file date
+      expect(br.read_4b).to eq(89765)      # crc32
+      expect(br.read_4b).to eq(0xFFFFFFFF) # compressed size
+      expect(br.read_4b).to eq(0xFFFFFFFF) # uncompressed size
+      expect(br.read_2b).to eq(10)         # filename length
+      expect(br.read_2b).to eq(32)         # extra field length
+      expect(br.read_2b).to eq(0)          # file comment
+      expect(br.read_2b).to eq(0xFFFF)     # disk number, must be blanked to the maximum value because of The Unarchiver bug
+      expect(br.read_2b).to eq(0)          # internal file attributes
+      expect(br.read_4b).to eq(2175008768) # external file attributes
+      expect(br.read_4b).to eq(0xFFFFFFFF) # relative offset of local header
+      expect(br.read_n(10)).to eq('a-file.txt') # the filename
+      
+      expect(buf).not_to be_eof
+      expect(br.read_2b).to eq(1)               # Zip64 extra tag
+      expect(br.read_2b).to eq(28)              # Size of the Zip64 extra payload
+      expect(br.read_8b).to eq(901)             # uncompressed size
+      expect(br.read_8b).to eq(0xFFFFFFFFF + 3) # compressed size
+      expect(br.read_8b).to eq(898921)          # local file header location
+    end
+    
+    it 'writes the file header for an entry that requires Zip64 extra because of the local file header offset being beyound 4GB' do
+      buf = StringIO.new
+      
+      subject.write_central_directory_file_header(io: buf, local_file_header_location: 0xFFFFFFFFF + 1,
+        gp_flags: 555, storage_mode: 23,
+        compressed_size: 8981, uncompressed_size: 819891, # the worst compression scheme in the universe
+        mtime: Time.utc(2016, 2, 2, 14, 00), crc32: 89765,
+        filename: 'a-file.txt', external_attrs: 123) 
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x02014b50) # Central directory entry sig
+      expect(br.read_2b).to eq(820)        # version made by
+      expect(br.read_2b).to eq(45)         # version need to extract
+      expect(br.read_2b).to eq(555)        # general purpose bit flag (explicitly set to bogus value to ensure we pass it through)
+      expect(br.read_2b).to eq(23)         # compression method (explicitly set to bogus value)
+      expect(br.read_2b).to eq(28672)      # last mod file time
+      expect(br.read_2b).to eq(18498)      # last mod file date
+      expect(br.read_4b).to eq(89765)      # crc32
+      expect(br.read_4b).to eq(0xFFFFFFFF) # compressed size
+      expect(br.read_4b).to eq(0xFFFFFFFF) # uncompressed size
+      expect(br.read_2b).to eq(10)         # filename length
+      expect(br.read_2b).to eq(32)         # extra field length
+      expect(br.read_2b).to eq(0)          # file comment
+      expect(br.read_2b).to eq(0xFFFF)     # disk number, must be blanked to the maximum value because of The Unarchiver bug
+      expect(br.read_2b).to eq(0)          # internal file attributes
+      expect(br.read_4b).to eq(2175008768) # external file attributes
+      expect(br.read_4b).to eq(0xFFFFFFFF) # relative offset of local header
+      expect(br.read_n(10)).to eq('a-file.txt') # the filename
+      
+      expect(buf).not_to be_eof
+      expect(br.read_2b).to eq(1)               # Zip64 extra tag
+      expect(br.read_2b).to eq(28)              # Size of the Zip64 extra payload
+      expect(br.read_8b).to eq(819891)          # uncompressed size
+      expect(br.read_8b).to eq(8981)            # compressed size
+      expect(br.read_8b).to eq(0xFFFFFFFFF + 1) # local file header location
+    end
+  end
+  
+  describe '#write_end_of_central_directory' do
+    it 'writes out the EOCD with all markers for a small ZIP file with just a few entries' do
+      buf = StringIO.new
+    
+      num_files = rand(8..190)
+      subject.write_end_of_central_directory(io: buf, start_of_central_directory_location: 9091211,
+        central_directory_size: 9091, num_files_in_archive: num_files)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x06054b50) # EOCD signature
+      expect(br.read_2b).to eq(0) # number of this disk
+      expect(br.read_2b).to eq(0) # number of the disk with the EOCD record
+      expect(br.read_2b).to eq(num_files) # number of files on this disk
+      expect(br.read_2b).to eq(num_files) # number of files in central directory total (for all disks)
+      expect(br.read_4b).to eq(9091) # size of the central directory (cdir records for all files)
+      expect(br.read_4b).to eq(9091211) # start of central directory offset from the beginning of file/disk
+      
+      comment_length = br.read_2b
+      expect(comment_length).not_to be_zero
+      
+      expect(br.read_n(comment_length)).to match(/ZipTricks/)
+    end
+    
+    it 'writes out the Zip64 EOCD as well if the central directory is located beyound 4GB in the archive' do
+      buf = StringIO.new
+    
+      num_files = rand(8..190)
+      subject.write_end_of_central_directory(io: buf, start_of_central_directory_location: 0xFFFFFFFF + 3,
+        central_directory_size: 9091, num_files_in_archive: num_files)
+      
+      br = ByteReader.new(buf)
+      
+      expect(br.read_4b).to eq(0x06064b50)      # Zip64 EOCD signature
+      expect(br.read_8b).to eq(44)              # Zip64 EOCD record size
+      expect(br.read_2b).to eq(820)             # Version made by
+      expect(br.read_2b).to eq(45)              # Version needed to extract
+      expect(br.read_4b).to eq(0)               # Number of this disk
+      expect(br.read_4b).to eq(0)               # Number of the disk with the Zip64 EOCD record
+      expect(br.read_8b).to eq(num_files)       # Number of entries in the central directory of this disk
+      expect(br.read_8b).to eq(num_files)       # Number of entries in the central directories of all disks
+      expect(br.read_8b).to eq(9091)            # Central directory size
+      expect(br.read_8b).to eq(0xFFFFFFFF + 3)  # Start of central directory location
+      
+      expect(br.read_4b).to eq(0x07064b50)      # Zip64 EOCD locator signature
+      expect(br.read_4b).to eq(0)               # Number of the disk with the EOCD locator signature
+      expect(br.read_8b).to eq((0xFFFFFFFF + 3) + 9091) # Where the Zip64 EOCD record starts
+      expect(br.read_4b).to eq(1)               # Total number of disks
+      
+      # Then the usual EOCD record
+      expect(br.read_4b).to eq(0x06054b50)  # EOCD signature
+      expect(br.read_2b).to eq(0)           # number of this disk
+      expect(br.read_2b).to eq(0)           # number of the disk with the EOCD record
+      expect(br.read_2b).to eq(0xFFFF)      # number of files on this disk
+      expect(br.read_2b).to eq(0xFFFF)      # number of files in central directory total (for all disks)
+      expect(br.read_4b).to eq(0xFFFFFFFF)  # size of the central directory (cdir records for all files)
+      expect(br.read_4b).to eq(0xFFFFFFFF)  # start of central directory offset from the beginning of file/disk
+      
+      comment_length = br.read_2b
+      expect(comment_length).not_to be_zero
+      expect(br.read_n(comment_length)).to match(/ZipTricks/)
+    end
+    
+    it 'writes out the Zip64 EOCD if the archive has more than 0xFFFF files' do
+      buf = StringIO.new
+    
+      subject.write_end_of_central_directory(io: buf, start_of_central_directory_location: 123,
+        central_directory_size: 9091, num_files_in_archive: 0xFFFF + 1)
+      
+      br = ByteReader.new(buf)
+      
+      expect(br.read_4b).to eq(0x06064b50)      # Zip64 EOCD signature
+      br.read_8b
+      br.read_2b
+      br.read_2b
+      br.read_4b
+      br.read_4b
+      expect(br.read_8b).to eq(0xFFFF + 1)      # Number of entries in the central directory of this disk
+      expect(br.read_8b).to eq(0xFFFF + 1)      # Number of entries in the central directories of all disks
+    end
+    
+    it 'writes out the Zip64 EOCD if the central directory size exceeds 0xFFFFFFFF' do
+      buf = StringIO.new
+    
+      subject.write_end_of_central_directory(io: buf, start_of_central_directory_location: 123,
+        central_directory_size: 0xFFFFFFFF + 2, num_files_in_archive: 5)
+      
+      br = ByteReader.new(buf)
+      
+      expect(br.read_4b).to eq(0x06064b50)      # Zip64 EOCD signature
+      br.read_8b
+      br.read_2b
+      br.read_2b
+      br.read_4b
+      br.read_4b
+      expect(br.read_8b).to eq(5)               # Number of entries in the central directory of this disk
+      expect(br.read_8b).to eq(5)               # Number of entries in the central directories of all disks
+    end
+  end
+end

data/zip_tricks.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: zip_tricks 2.8.1 ruby lib
+# stub: zip_tricks 3.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "zip_tricks"
-  s.version = "2.8.1"
+  s.version = "3.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2016-07-22"
+  s.date = "2016-08-03"
   s.description = "Makes rubyzip stream, for real"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
@@ -35,30 +35,33 @@ Gem::Specification.new do |s|
     "lib/zip_tricks.rb",
     "lib/zip_tricks/block_deflate.rb",
     "lib/zip_tricks/block_write.rb",
-    "lib/zip_tricks/manifest.rb",
-    "lib/zip_tricks/microzip.rb",
+    "lib/zip_tricks/file_reader.rb",
     "lib/zip_tricks/null_writer.rb",
     "lib/zip_tricks/rack_body.rb",
     "lib/zip_tricks/remote_io.rb",
     "lib/zip_tricks/remote_uncap.rb",
-    "lib/zip_tricks/stored_size_estimator.rb",
+    "lib/zip_tricks/size_estimator.rb",
     "lib/zip_tricks/stream_crc32.rb",
     "lib/zip_tricks/streamer.rb",
+    "lib/zip_tricks/streamer/deflated_writer.rb",
+    "lib/zip_tricks/streamer/entry.rb",
+    "lib/zip_tricks/streamer/stored_writer.rb",
+    "lib/zip_tricks/streamer/writable.rb",
     "lib/zip_tricks/write_and_tell.rb",
+    "lib/zip_tricks/zip_writer.rb",
     "spec/spec_helper.rb",
     "spec/zip_tricks/block_deflate_spec.rb",
     "spec/zip_tricks/block_write_spec.rb",
-    "spec/zip_tricks/manifest_spec.rb",
-    "spec/zip_tricks/microzip_interop_spec.rb",
-    "spec/zip_tricks/microzip_spec.rb",
+    "spec/zip_tricks/file_reader_spec.rb",
     "spec/zip_tricks/rack_body_spec.rb",
     "spec/zip_tricks/remote_io_spec.rb",
     "spec/zip_tricks/remote_uncap_spec.rb",
-    "spec/zip_tricks/stored_size_estimator_spec.rb",
+    "spec/zip_tricks/size_estimator_spec.rb",
     "spec/zip_tricks/stream_crc32_spec.rb",
     "spec/zip_tricks/streamer_spec.rb",
     "spec/zip_tricks/war-and-peace.txt",
     "spec/zip_tricks/write_and_tell_spec.rb",
+    "spec/zip_tricks/zip_writer_spec.rb",
     "zip_tricks.gemspec"
   ]
   s.homepage = "http://github.com/wetransfer/zip_tricks"
@@ -70,33 +73,36 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rubyzip>, [">= 1.1.7", "~> 1.1"])
-      s.add_runtime_dependency(%q<very_tiny_state_machine>, ["~> 2"])
+      s.add_development_dependency(%q<rubyzip>, [">= 1.1.7", "~> 1.1"])
+      s.add_development_dependency(%q<terminal-table>, [">= 0"])
       s.add_development_dependency(%q<range_utils>, [">= 0"])
       s.add_development_dependency(%q<rack>, ["~> 1.6"])
       s.add_development_dependency(%q<rake>, ["~> 10.4"])
       s.add_development_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+      s.add_development_dependency(%q<coderay>, [">= 0"])
       s.add_development_dependency(%q<yard>, ["~> 0.8"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
     else
       s.add_dependency(%q<rubyzip>, [">= 1.1.7", "~> 1.1"])
-      s.add_dependency(%q<very_tiny_state_machine>, ["~> 2"])
+      s.add_dependency(%q<terminal-table>, [">= 0"])
       s.add_dependency(%q<range_utils>, [">= 0"])
       s.add_dependency(%q<rack>, ["~> 1.6"])
       s.add_dependency(%q<rake>, ["~> 10.4"])
       s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+      s.add_dependency(%q<coderay>, [">= 0"])
       s.add_dependency(%q<yard>, ["~> 0.8"])
       s.add_dependency(%q<bundler>, ["~> 1.0"])
       s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
     end
   else
     s.add_dependency(%q<rubyzip>, [">= 1.1.7", "~> 1.1"])
-    s.add_dependency(%q<very_tiny_state_machine>, ["~> 2"])
+    s.add_dependency(%q<terminal-table>, [">= 0"])
     s.add_dependency(%q<range_utils>, [">= 0"])
     s.add_dependency(%q<rack>, ["~> 1.6"])
     s.add_dependency(%q<rake>, ["~> 10.4"])
     s.add_dependency(%q<rspec>, ["< 3.3", "~> 3.2.0"])
+    s.add_dependency(%q<coderay>, [">= 0"])
     s.add_dependency(%q<yard>, ["~> 0.8"])
     s.add_dependency(%q<bundler>, ["~> 1.0"])
     s.add_dependency(%q<jeweler>, ["~> 2.0.1"])