zip_tricks 2.7.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cd89ab487709ccaf797ab39fa9507ee0ac793e1
-  data.tar.gz: 8c21a1106a9398dca0d4bb2e32bcb4a9f9b8b1ac
+  metadata.gz: 84302e70bc873418b8a458456a75e0da7b5bc67d
+  data.tar.gz: 06f81fc860d5cf77fdbd4b570602ae4984297d43
 SHA512:
-  metadata.gz: d1bf6cfe7579dc8d0e21c625b135b06dcc036acb148ed197a0f1657f673bf5a77ce826a6df445b902a6dd556287c68cce7ce9aca080fe735cb405ceb5ac8f2bc
-  data.tar.gz: 9717bf12a2559c743b2855ce9ab78279968ff12c1b6036df07fb7db0d1b052955f3bd7b6e9faec6d608a84cbbe08e26eb81fc817ea2090d516a3ea83f9632811
+  metadata.gz: 932fe6e3a095f43996505c642fce11009efba4298302e958f5fdf7649cd3ca9fd28ab1de6a33d1e20be2955a7efd58b4d432486d3004ab70437a55413c27934d
+  data.tar.gz: b9d43dbf16156cd3c877a8353dd0dd4a34e4c8b2e43664e34c4c3f2562c3a9937390bf398b0278449bf338f89337c348f30da637414e61b17eab58a939b05fc5

data/.travis.yml

@@ -6,4 +6,5 @@ sudo: false
 cache: bundler
 matrix:
   allow_failures:
-    - rvm: jruby-9.0
+    - rvm: jruby-9.0
+script: bundle exec rspec

data/Rakefile

@@ -22,6 +22,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Makes rubyzip stream, for real}
   gem.email = "me@julik.nl"
   gem.authors = ["Julik Tarkhanov"]
+  gem.files.exclude "testing/**/*"
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/lib/zip_tricks/microzip.rb

@@ -0,0 +1,367 @@
+# A replacement for RubyZip for streaming, with a couple of small differences.
+# The first difference is that it is verbosely-written-to-the-spec and you can actually
+# follow what is happening. It does not support quite a few fancy features of Rubyzip,
+# but instead it can be digested in one reading, and has solid Zip64 support. It also does
+# not attempt any tricks with Zip64 placeholder extra fields because the ZipTricks streaming
+# engine assumes you _know_ how large your file is (both compressed and uncompressed) _and_
+# you have the file's CRC32 checksum upfront.
+#
+# Just like Rubyzip it will switch to Zip64 automatically if required, but there is no global
+# setting to enable that behavior - it is always on.
+class ZipTricks::Microzip
+  STORED   = 0
+  DEFLATED = 8
+
+  TooMuch = Class.new(StandardError)
+  DuplicateFilenames = Class.new(StandardError)
+  UnknownMode = Class.new(StandardError)
+  
+  FOUR_BYTE_MAX_UINT = 0xFFFFFFFF
+  TWO_BYTE_MAX_UINT = 0xFFFF
+  
+  VERSION_MADE_BY                        = 52
+  VERSION_NEEDED_TO_EXTRACT              = 20
+  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
+  DEFAULT_EXTERNAL_ATTRS = begin
+    # These need to be set so that the unarchived files do not become executable on UNIX, for
+    # security purposes. Strictly speaking we would want to make this user-customizable,
+    # but for now just putting in sane defaults will do. For example, Trac with zipinfo does this:
+    # zipinfo.external_attr = 0644 << 16L # permissions -r-wr--r--.
+    # We snatch the incantations from Rubyzip for this.
+    unix_perms = 0644
+    file_type_file = 010
+    external_attrs = (file_type_file << 12 | (unix_perms & 07777)) << 16
+  end
+  MADE_BY_SIGNATURE = begin
+    # A combination of the VERSION_MADE_BY low byte and the OS type high byte
+    os_type = 3 # UNIX
+    [VERSION_MADE_BY, os_type].pack('CC')
+  end
+
+  C_V = 'V'.freeze
+  C_v = 'v'.freeze
+  C_Qe = 'Q<'.freeze
+
+  module Bytesize
+    def bytesize_of
+      ''.force_encoding(Encoding::BINARY).tap {|b| yield(b) }.bytesize
+    end
+  end
+  include Bytesize
+  
+  class Entry < Struct.new(:filename, :crc32, :compressed_size, :uncompressed_size, :storage_mode, :mtime)
+    include Bytesize
+    def initialize(*)
+      super
+      @requires_zip64 = (compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT)
+      if filename.bytesize > TWO_BYTE_MAX_UINT
+        raise TooMuch, "The given filename is too long to fit (%d bytes)" % filename.bytesize
+      end
+    end
+
+    def requires_zip64?
+      @requires_zip64
+    end
+    
+    # Set the general purpose flags for the entry. The only flag we care about is the EFS
+    # bit (bit 11) which should be set if the filename is UTF8. If it is, we need to set the
+    # bit so that the unarchiving application knows that the filename in the archive is UTF-8
+    # encoded, and not some DOS default. For ASCII entries it does not matter.
+    #
+    # Now, strictly speaking, if a diacritic-containing character (such as å) does fit into the DOS-437
+    # codepage, it should be encodable as such. This would, in theory, let older Windows tools
+    # decode the filename correctly. However, this kills the filename decoding for the OSX builtin
+    # archive utility (it assumes the filename to be UTF-8, regardless). So if we allow filenames
+    # to be encoded in DOS-437, we _potentially_ have support in Windows but we upset everyone on Mac.
+    # If we just use UTF-8 and set the right EFS bit in general purpose flags, we upset Windows users
+    # because most of the Windows unarchive tools (at least the builtin ones) do not give a flying eff
+    # about the EFS support bit being set.
+    #
+    # Additionally, if we use Unarchiver on OSX (which is our recommended unpacker for large files),
+    # it will (very rightfully) ask us how we should decode each filename that does not have the EFS bit,
+    # but does contain something non-ASCII-decodable. This is horrible UX for users.
+    #
+    # So, basically, we have 2 choices, for filenames containing diacritics (for bona-fide UTF-8 you do not
+    # even get those choices, you _have_ to use UTF-8):
+    #
+    # * Make life easier for Windows users by setting stuff to DOS, not care about the standard _and_ make
+    #   most of Mac users upset
+    # * Make life easy for Mac users and conform to the standard, and tell Windows users to get a _decent_
+    #   ZIP unarchiving tool.
+    #
+    # We are going with option 2, and this is well-thought-out. Trust me. If you want the crazytown
+    # filename encoding scheme that is described here http://stackoverflow.com/questions/13261347
+    # you can try this:
+    #
+    #  [Encoding::CP437, Encoding::ISO_8859_1, Encoding::UTF_8]
+    #
+    # We don't want no such thing, and sorry Windows users, you are going to need a decent unarchiver
+    # that honors the standard. Alas, alas.
+    def gp_flags_based_on_filename
+      filename.encode(Encoding::ASCII)
+      0b00000000000
+    rescue EncodingError
+      0b00000000000 | 0b100000000000
+    end
+
+    def write_local_file_header(io)
+      # TBD: caveat. If this entry _does_ fit into a standard zip segment (both compressed and
+      # uncompressed size at or below 0xFFFF etc), but it is _located_ at an offset that requires
+      # Zip64 to be used (beyound 4GB), we are going to be omitting the Zip64 extras in the local
+      # file header, but we will be enabling them when writing the central directory. Then the
+      # CD record for the file _will_ have Zip64 extra, but the local file header won't. In theory,
+      # this should not pose a problem, but then again... life in this world can be harsh.
+      #
+      # If it turns out that it _does_ pose a problem, we can always do:
+      #
+      #   @requires_zip64 = true if io.tell > FOUR_BYTE_MAX_UINT
+      #
+      # right here, and have the data written regardless even if the file fits.
+      io << [0x04034b50].pack(C_V)                        # local file header signature     4 bytes  (0x04034b50)
+
+      if @requires_zip64                                  # version needed to extract       2 bytes
+        io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v)
+      else
+        io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)
+      end
+
+      io << [gp_flags_based_on_filename].pack("v")        # general purpose bit flag        2 bytes
+      io << [storage_mode].pack("v")                      # compression method              2 bytes
+      io << [to_binary_dos_time(mtime)].pack(C_v)         # last mod file time              2 bytes
+      io << [to_binary_dos_date(mtime)].pack(C_v)         # last mod file date              2 bytes
+      io << [crc32].pack(C_V)                             # crc-32                          4 bytes
+
+      if @requires_zip64
+        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # compressed size              4 bytes
+        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # uncompressed size            4 bytes
+      else
+        io << [compressed_size].pack(C_V)                 # compressed size              4 bytes
+        io << [uncompressed_size].pack(C_V)               # uncompressed size            4 bytes
+      end
+
+      # Filename should not be longer than 0xFFFF otherwise this wont fit here
+      io << [filename.bytesize].pack(C_v)                 # file name length             2 bytes
+
+      extra_size = 0
+      if @requires_zip64
+        extra_size += bytesize_of {|buf| write_zip_64_extra_for_local_file_header(buf) }
+      end
+      io << [extra_size].pack(C_v)                      # extra field length              2 bytes
+
+      io << filename                                    # file name (variable size)
+
+      # Interesting tidbit:
+      # https://social.technet.microsoft.com/Forums/windows/en-US/6a60399f-2879-4859-b7ab-6ddd08a70948
+      # TL;DR of it is: Windows 7 Explorer _will_ open Zip64 entries. However, it desires to have the
+      # Zip64 extra field as _the first_ extra field. If we decide to add the Info-ZIP UTF-8 field...
+      write_zip_64_extra_for_local_file_header(io) if @requires_zip64
+    end
+
+    def write_zip_64_extra_for_local_file_header(io)
+      io << [0x0001].pack(C_v)                        # 2 bytes    Tag for this "extra" block type
+      io << [16].pack(C_v)                            # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
+      io << [uncompressed_size].pack(C_Qe)            # 8 bytes    Original uncompressed file size
+      io << [compressed_size].pack(C_Qe)              # 8 bytes    Size of compressed data
+    end
+
+    def write_zip_64_extra_for_central_directory_file_header(io, local_file_header_location)
+      io << [0x0001].pack(C_v)                        # 2 bytes    Tag for this "extra" block type
+      io << [28].pack(C_v)                            # 2 bytes    Size of this "extra" block. For us it will always be 28
+      io << [uncompressed_size].pack(C_Qe)            # 8 bytes    Original uncompressed file size
+      io << [compressed_size].pack(C_Qe)              # 8 bytes    Size of compressed data
+      io << [local_file_header_location].pack(C_Qe)   # 8 bytes    Offset of local header record
+      io << [0].pack(C_V)                             # 4 bytes    Number of the disk on which this file starts
+    end
+
+    def write_central_directory_file_header(io, local_file_header_location)
+      # At this point if the header begins somewhere beyound 0xFFFFFFFF we _have_ to record the offset
+      # of the local file header as a zip64 extra field, so we give up, give in, you loose, love will always win...
+      @requires_zip64 = true if local_file_header_location > FOUR_BYTE_MAX_UINT
+      
+      io << [0x02014b50].pack(C_V)                        # central file header signature   4 bytes  (0x02014b50)
+      io << MADE_BY_SIGNATURE                             # version made by                 2 bytes
+      if @requires_zip64
+        io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v) # version needed to extract       2 bytes
+      else
+        io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)       # version needed to extract       2 bytes
+      end
+
+      io << [gp_flags_based_on_filename].pack(C_v)        # general purpose bit flag        2 bytes
+      io << [storage_mode].pack(C_v)                      # compression method              2 bytes
+      io << [to_binary_dos_time(mtime)].pack(C_v)         # last mod file time              2 bytes
+      io << [to_binary_dos_date(mtime)].pack(C_v)         # last mod file date              2 bytes
+      io << [crc32].pack(C_V)                             # crc-32                          4 bytes
+
+      if @requires_zip64
+        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # compressed size              4 bytes
+        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # uncompressed size            4 bytes
+      else
+        io << [compressed_size].pack(C_V)                 # compressed size              4 bytes
+        io << [uncompressed_size].pack(C_V)               # uncompressed size            4 bytes
+      end
+
+      # Filename should not be longer than 0xFFFF otherwise this wont fit here
+      io << [filename.bytesize].pack(C_v)                 # file name length                2 bytes
+
+      extra_size = 0
+      if @requires_zip64
+        extra_size += bytesize_of {|buf|
+          write_zip_64_extra_for_central_directory_file_header(buf, local_file_header_location)
+        }
+      end
+      io << [extra_size].pack(C_v)                        # extra field length              2 bytes
+
+      io << [0].pack(C_v)                                 # file comment length             2 bytes
+      io << [0].pack(C_v)                                 # disk number start               2 bytes
+      io << [0].pack(C_v)                                 # internal file attributes        2 bytes
+      
+      io << [DEFAULT_EXTERNAL_ATTRS].pack(C_V)           # external file attributes        4 bytes
+
+      if @requires_zip64
+        io << [FOUR_BYTE_MAX_UINT].pack(C_V)             # relative offset of local header 4 bytes
+      else
+        io << [local_file_header_location].pack(C_V)     # relative offset of local header 4 bytes
+      end
+      io << filename                                     # file name (variable size)
+
+      if @requires_zip64                                  # extra field (variable size)
+        write_zip_64_extra_for_central_directory_file_header(io, local_file_header_location)
+      end
+                                                          # file comment (variable size)
+    end
+
+    private
+
+    def to_binary_dos_time(t)
+      (t.sec/2) + (t.min << 5) + (t.hour << 11)
+    end
+
+    def to_binary_dos_date(t)
+      (t.day) + (t.month << 5) + ((t.year - 1980) << 9)
+    end
+  end
+
+  # Creates a new streaming writer.
+  # The writer is stateful and knows it's list of ZIP file entries as they are being added.
+  def initialize
+    @files = []
+    @local_header_offsets = []
+  end
+
+  # Adds a file to the entry list and immediately writes out it's local file header into the
+  # output stream.
+  #
+  # @param io[#<<, #tell] the buffer to write the local file header to
+  # @param filename[String] The name of the file
+  # @param crc32[Fixnum]    The CRC32 checksum of the file
+  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @param uncompressed_size[Fixnum]  The size of the file once extracted
+  # @param storage_mode[Fixnum]  Either 0 for "stored" or 8 for "deflated"
+  # @param mtime[Time] What modification time to record for the file
+  # @return [void]
+  def add_local_file_header(io:, filename:, crc32:, compressed_size:, uncompressed_size:, storage_mode:, mtime: Time.now.utc)
+    if @files.any?{|e| e.filename == filename }
+      raise DuplicateFilenames, "Filename #{filename.inspect} already used in the archive"
+    end
+    raise UnknownMode, "Unknown compression mode #{storage_mode}" unless [STORED, DEFLATED].include?(storage_mode)
+    e = Entry.new(filename, crc32, compressed_size, uncompressed_size, storage_mode, mtime)
+    @files << e
+    @local_header_offsets << io.tell
+    e.write_local_file_header(io)
+  end
+
+  # Writes the central directory (including the Zip6 salient bits if necessary)
+  #
+  # @param io[#<<, #tell] the buffer to write the central directory to.
+  #                     The method will use `tell` on the buffer since it has to know where the central directory is located
+  # @return [void]
+  def write_central_directory(io)
+    start_of_central_directory = io.tell
+
+    # Central directory file headers, per file in order
+    @files.each_with_index do |file, i|
+      local_file_header_offset_from_start_of_file = @local_header_offsets.fetch(i)
+      file.write_central_directory_file_header(io, local_file_header_offset_from_start_of_file)
+    end
+    central_dir_size = io.tell - start_of_central_directory
+
+    zip64_required = central_dir_size > FOUR_BYTE_MAX_UINT ||
+      start_of_central_directory > FOUR_BYTE_MAX_UINT ||
+      @files.length > TWO_BYTE_MAX_UINT ||
+      @files.any?(&:requires_zip64?)
+
+    # Then, if zip64 is used
+    if zip64_required
+      # [zip64 end of central directory record]
+      zip64_eocdr_offset = io.tell
+                                                # zip64 end of central dir
+      io << [0x06064b50].pack(C_V)             # signature                       4 bytes  (0x06064b50)
+      io << [44].pack(C_Qe)                    # size of zip64 end of central
+                                                # directory record                8 bytes
+                                                # (this is ex. the 12 bytes of the signature and the size value itself).
+                                                # Without the extensible data sector it is always 44.
+      io << MADE_BY_SIGNATURE                                # version made by                 2 bytes
+      io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v)      # version needed to extract       2 bytes
+      io << [0].pack(C_V)                                    # number of this disk             4 bytes
+      io << [0].pack(C_V)                                    # number of the disk with the
+                                                             # start of the central directory  4 bytes
+      io << [@files.length].pack(C_Qe)                       # total number of entries in the
+                                                             # central directory on this disk  8 bytes
+      io << [@files.length].pack(C_Qe)                       # total number of entries in the
+                                                             # central directory               8 bytes
+      io << [central_dir_size].pack(C_Qe)                    # size of the central directory   8 bytes
+                                                             # offset of start of central
+                                                             # directory with respect to
+      io << [start_of_central_directory].pack(C_Qe)          # the starting disk number        8 bytes
+                                                              # zip64 extensible data sector    (variable size)
+
+      # [zip64 end of central directory locator]
+      io << [0x07064b50].pack("V")                           # zip64 end of central dir locator
+                                                             # signature                       4 bytes  (0x07064b50)
+      io << [0].pack(C_V)                                    # number of the disk with the
+                                                             # start of the zip64 end of
+                                                             # central directory               4 bytes
+      io << [zip64_eocdr_offset].pack(C_Qe)                  # relative offset of the zip64
+                                                             # end of central directory record 8 bytes
+                                                             # (note: "relative" is actually "from the start of the file")
+      io << [1].pack(C_V)                                    # total number of disks           4 bytes
+    end
+
+    # Then the end of central directory record:
+    io << [0x06054b50].pack(C_V)                            # end of central dir signature     4 bytes  (0x06054b50)
+    io << [0].pack(C_v)                                     # number of this disk              2 bytes
+    io << [0].pack(C_v)                                     # number of the disk with the
+                                                            # start of the central directory 2 bytes
+    
+    if zip64_required # the number of entries will be read from the zip64 part of the central directory
+      io << [TWO_BYTE_MAX_UINT].pack(C_v)                   # total number of entries in the
+                                                            # central directory on this disk   2 bytes
+      io << [TWO_BYTE_MAX_UINT].pack(C_v)                   # total number of entries in
+                                                            # the central directory            2 bytes
+    else
+      io << [@files.length].pack(C_v)                       # total number of entries in the
+                                                            # central directory on this disk   2 bytes
+      io << [@files.length].pack(C_v)                       # total number of entries in
+                                                            # the central directory            2 bytes
+    end
+    
+    if zip64_required
+      io << [FOUR_BYTE_MAX_UINT].pack(C_V)                  # size of the central directory    4 bytes
+      io << [FOUR_BYTE_MAX_UINT].pack(C_V)                  # offset of start of central
+                                                            # directory with respect to
+                                                            # the starting disk number        4 bytes
+    else
+      io << [central_dir_size].pack(C_V)                    # size of the central directory    4 bytes
+      io << [start_of_central_directory].pack(C_V)          # offset of start of central
+                                                            # directory with respect to
+                                                            # the starting disk number        4 bytes
+    end
+    io << [0].pack(C_v)                                     # .ZIP file comment length        2 bytes
+                                                            # .ZIP file comment       (variable size)
+  end
+  
+  private_constant :FOUR_BYTE_MAX_UINT, :TWO_BYTE_MAX_UINT,
+    :VERSION_MADE_BY, :VERSION_NEEDED_TO_EXTRACT, :VERSION_NEEDED_TO_EXTRACT_ZIP64,
+    :DEFAULT_EXTERNAL_ATTRS, :MADE_BY_SIGNATURE, 
+    :Entry, :C_V, :C_v, :C_Qe
+end

data/lib/zip_tricks/streamer.rb

@@ -38,8 +38,10 @@ class ZipTricks::Streamer
   def initialize(stream)
     raise InvalidOutput, "The stream should respond to #<<" unless stream.respond_to?(:<<)
     stream = ZipTricks::WriteAndTell.new(stream) unless stream.respond_to?(:tell) && stream.respond_to?(:advance_position_by)
+    
     @output_stream = stream
-
+    @zip = ZipTricks::Microzip.new
+    
     @state_monitor = VeryTinyStateMachine.new(:before_entry, callbacks_to=self)
     @state_monitor.permit_state :in_entry_header, :in_entry_body, :in_central_directory, :closed
     @state_monitor.permit_transition :before_entry => :in_entry_header
@@ -47,8 +49,6 @@ class ZipTricks::Streamer
     @state_monitor.permit_transition :in_entry_body => :in_entry_header
     @state_monitor.permit_transition :in_entry_body => :in_central_directory
     @state_monitor.permit_transition :in_central_directory => :closed
-
-    @entry_set = ::Zip::EntrySet.new
   end
 
   # Writes a part of a zip entry body (actual binary data of the entry) into the output stream.
@@ -99,16 +99,8 @@ class ZipTricks::Streamer
   # @return [Fixnum] the offset the output IO is at after writing the entry header
   def add_compressed_entry(entry_name, uncompressed_size, crc32, compressed_size)
     @state_monitor.transition! :in_entry_header
-
-    entry = ::Zip::Entry.new(@file_name, entry_name)
-    entry.compression_method = Zip::Entry::DEFLATED
-    entry.crc = crc32
-    entry.size = uncompressed_size
-    entry.compressed_size = compressed_size
-    set_gp_flags_for_filename(entry, entry_name)
-
-    @entry_set << entry
-    entry.write_local_entry(@output_stream)
+    @zip.add_local_file_header(io: @output_stream, filename: entry_name, crc32: crc32,
+      compressed_size: compressed_size, uncompressed_size: uncompressed_size, storage_mode: ZipTricks::Microzip::DEFLATED)
     @expected_bytes_for_entry = compressed_size
     @bytes_written_for_entry = 0
     @output_stream.tell
@@ -123,21 +115,13 @@ class ZipTricks::Streamer
   # @return [Fixnum] the offset the output IO is at after writing the entry header
   def add_stored_entry(entry_name, uncompressed_size, crc32)
     @state_monitor.transition! :in_entry_header
-
-    entry = ::Zip::Entry.new(@file_name, entry_name)
-    entry.compression_method = Zip::Entry::STORED
-    entry.crc = crc32
-    entry.size = uncompressed_size
-    entry.compressed_size = uncompressed_size
-    set_gp_flags_for_filename(entry, entry_name)
-    @entry_set << entry
-    entry.write_local_entry(@output_stream)
+    @zip.add_local_file_header(io: @output_stream, filename: entry_name, crc32: crc32,
+      compressed_size: uncompressed_size, uncompressed_size: uncompressed_size, storage_mode: ZipTricks::Microzip::STORED)
     @bytes_written_for_entry = 0
     @expected_bytes_for_entry = uncompressed_size
     @output_stream.tell
   end
 
-
   # Writes out the global footer and the directory entry header and the global directory of the ZIP
   # archive using the information about the entries added using `add_stored_entry` and `add_compressed_entry`.
   #
@@ -146,8 +130,7 @@ class ZipTricks::Streamer
   # @return [Fixnum] the offset the output IO is at after writing the central directory
   def write_central_directory!
     @state_monitor.transition! :in_central_directory
-    cdir = Zip::CentralDirectory.new(@entry_set, comment = nil)
-    cdir.write_to_stream(@output_stream)
+    @zip.write_central_directory(@output_stream)
     @output_stream.tell
   end
 
@@ -165,17 +148,6 @@ class ZipTricks::Streamer
 
   private
 
-  # Set the general purpose flags for the entry. The only flag we care about is the EFS
-  # bit (bit 11) which should be set if the filename is UTF8. If it is, we need to set the
-  # bit so that the unarchiving application knows that the filename in the archive is UTF-8
-  # encoded, and not some DOS default. For ASCII entries it does not matter.
-  def set_gp_flags_for_filename(entry, filename)
-    filename.encode(Encoding::ASCII)
-    entry.gp_flags = DEFAULT_GP_FLAGS
-  rescue Encoding::UndefinedConversionError #=> UTF8 filename
-    entry.gp_flags = DEFAULT_GP_FLAGS | EFS
-  end
-
   # Checks whether the number of bytes written conforms to the declared entry size
   def leaving_in_entry_body_state
     if @bytes_written_for_entry != @expected_bytes_for_entry

data/lib/zip_tricks.rb

@@ -2,7 +2,7 @@ require 'zip'
 require 'very_tiny_state_machine'
 
 module ZipTricks
-  VERSION = '2.7.0'
+  VERSION = '2.8.0'
   
   # Require all the sub-components except myself
   Dir.glob(__dir__ + '/**/*.rb').sort.each {|p| require p unless p == __FILE__ }

data/spec/spec_helper.rb

@@ -4,11 +4,114 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
 require 'zip_tricks'
 require 'digest'
+require 'fileutils'
+require 'shellwords'
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+module Keepalive
+  # Travis-CI kills the build if it does not receive output on standard out or standard error
+  # for longer than a few minutes. We have a few tests that take a _very_ long time, and during
+  # those tests this method has to be called every now and then to revive the output and let the
+  # build proceed.
+  def still_alive!
+    $keepalive_last_out_ping_at ||= Time.now
+    if (Time.now - $keepalive_last_out_ping_at) > 3
+      $keepalive_last_out_ping_at = Time.now
+      $stdout << '_'
+    end
+  end
+  extend self
+end
 
-RSpec.configure do |config|
 
+class ManagedTempfile < Tempfile
+  @@managed_tempfiles = []
+  
+  def initialize(*)
+    super
+    @@managed_tempfiles << self
+  end
+  
+  def self.prune!
+    @@managed_tempfiles.each do |tf|
+      (tf.close; tf.unlink) rescue nil
+    end
+    @@managed_tempfiles.clear
+  end
+end
+
+# A Tempfile filled with N bytes of random data, that also knows the CRC32 of that data
+class RandomFile < ManagedTempfile
+  attr_reader :crc32
+  RANDOM_MEG = Random.new.bytes(1024 * 1024) # Allocate it once to prevent heap churn
+  def initialize(size)
+    super('random-bin')
+    binmode
+    crc = ZipTricks::StreamCRC32.new
+    bytes = size % (1024 * 1024)
+    megs = size / (1024 * 1024)
+    megs.times do
+      Keepalive.still_alive!
+      self << RANDOM_MEG
+      crc << RANDOM_MEG
+    end
+    random_blob = Random.new.bytes(bytes)
+    self << random_blob
+    crc << random_blob
+    @crc32 = crc.to_i
+    rewind
+  end
+
+  def copy_to(io)
+    rewind
+    while data = read(10*1024*1024)
+      io << data
+      Keepalive.still_alive!
+    end
+    rewind
+  end
+end
+
+module ZipInspection
+  def inspect_zip_with_external_tool(path_to_zip)
+    zipinfo_path = 'zipinfo'
+    $zip_inspection_buf ||= StringIO.new
+    $zip_inspection_buf.puts "\n"
+    $zip_inspection_buf.puts "Inspecting ZIP output of #{inspect}." # The only way to get at the RSpec example without using the block argument
+    $zip_inspection_buf.puts "Be aware that the zipinfo version on OSX is too old to deal with Zip6."
+    escaped_cmd = Shellwords.join([zipinfo_path, '-tlhvz', path_to_zip])
+    $zip_inspection_buf.puts `#{escaped_cmd}`
+  end
+  
+  def open_with_external_app(app_path, path_to_zip, skip_if_missing)
+    bin_exists = File.exist?(app_path)
+    skip "This system does not have #{File.basename(app_path)}" if skip_if_missing && !bin_exists
+    return unless bin_exists
+    `#{Shellwords.join([app_path, path_to_zip])}`
+  end
+  
+  def open_zip_with_archive_utility(path_to_zip, skip_if_missing: false)
+    # ArchiveUtility sometimes puts the stuff it unarchives in ~/Downloads etc. so do
+    # not perform any checks on the files since we do not really know where they are on disk.
+    # Visual inspection should show whether the unarchiving is handled correctly.
+    au_path = '/System/Library/CoreServices/Applications/Archive Utility.app/Contents/MacOS/Archive Utility'
+    open_with_external_app(au_path, path_to_zip, skip_if_missing)
+  end
+  
+  def open_zip_with_unarchiver(path_to_zip, skip_if_missing: false)
+    ua_path = '/Applications/The Unarchiver.app/Contents/MacOS/The Unarchiver'
+    open_with_external_app(ua_path, path_to_zip, skip_if_missing)
+  end
+end
+
+RSpec.configure do |config|
+  config.include Keepalive
+  config.include ZipInspection
+  
+  config.after :each do
+    ManagedTempfile.prune!
+  end
+  
+  config.after :suite do
+    $stderr << $zip_inspection_buf.string if $zip_inspection_buf
+  end
 end

data/spec/zip_tricks/microzip_interop_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../spec_helper'
+
+describe 'Microzip in interop context' do
+  let(:described_class) { ZipTricks::Microzip}
+  
+  it 'creates an archive that can be opened by Rubyzip, with a small number of very tiny text files' do
+    tf = ManagedTempfile.new('zip')
+    z = described_class.new
+
+    test_str = Random.new.bytes(64)
+    crc = Zlib.crc32(test_str)
+    t = Time.now.utc
+
+    3.times do |i|
+      fn = "test-#{i}"
+      z.add_local_file_header(io: tf, filename: fn, crc32: crc, compressed_size: test_str.bytesize,
+        uncompressed_size: test_str.bytesize, storage_mode: 0, mtime: t)
+      tf << test_str
+    end
+    z.write_central_directory(tf)
+    tf.flush
+
+    Zip::File.open(tf.path) do |zip_file|
+      entries = zip_file.to_a
+      expect(entries.length).to eq(3)
+      entries.each do |entry|
+        # Make sure it is tagged as UNIX
+        expect(entry.fstype).to eq(3)
+
+        # Check the file contents
+        readback = entry.get_input_stream.read
+        readback.force_encoding(Encoding::BINARY)
+        expect(readback).to eq(test_str)
+
+        # The CRC
+        expect(entry.crc).to eq(crc)
+
+        # Check the name
+        expect(entry.name).to match(/test/)
+
+        # Check the right external attributes (non-executable on UNIX)
+        expect(entry.external_file_attributes).to eq(2175008768)
+      end
+    end
+
+    inspect_zip_with_external_tool(tf.path)
+  end
+end

data/spec/zip_tricks/microzip_spec.rb

@@ -0,0 +1,236 @@
+require_relative '../spec_helper'
+
+describe ZipTricks::Microzip do
+  class ByteReader < Struct.new(:io)
+    def read_2b
+      io.read(2).unpack('v').first
+    end
+    
+    def read_2c
+      io.read(2).unpack('CC').first
+    end
+    
+    def read_4b
+      io.read(4).unpack('V').first
+    end
+    
+    def read_8b
+      io.read(8).unpack('Q<').first
+    end
+    
+    def read_n(n)
+      io.read(n)
+    end
+  end
+  
+  it 'raises an exception if the filename is non-unique in the already existing set' do
+    z = described_class.new
+    z.add_local_file_header(io: StringIO.new, filename: 'foo.txt', crc32: 0, compressed_size: 0, uncompressed_size: 0, storage_mode: 0)
+    expect {
+      z.add_local_file_header(io: StringIO.new, filename: 'foo.txt', crc32: 0, compressed_size: 0, uncompressed_size: 0, storage_mode: 0)
+    }.to raise_error(/already/)
+  end
+
+  it 'raises an exception if the filename does not fit in 0xFFFF bytes' do
+    longest_filename_in_the_universe = "x" * (0xFFFF + 1)
+    z = described_class.new
+    expect {
+      z.add_local_file_header(io: StringIO.new, filename: longest_filename_in_the_universe, 
+        crc32: 0, compressed_size: 0, uncompressed_size: 0, storage_mode: 0)
+    }.to raise_error(/filename/)
+  end
+  
+  describe '#add_local_file_header' do
+    it 'writes out the local file header for an entry that fits into a standard ZIP' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      zip.add_local_file_header(io: buf, filename: 'first-file.bin', crc32: 123, compressed_size: 8981,
+        uncompressed_size: 90981, storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      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(0)          # 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(123)        # CRC32
+      expect(br.read_4b).to eq(8981)       # compressed size
+      expect(br.read_4b).to eq(90981)      # uncompressed size
+      expect(br.read_2b).to eq('first-file.bin'.bytesize)      # byte length of the filename
+      expect(br.read_2b).to be_zero        # size of extra fields
+      expect(br.read_n('first-file.bin'.bytesize)).to eq('first-file.bin') # the filename
+      expect(buf).to be_eof
+    end
+    
+    it 'writes out the local file header for an entry with a UTF-8 filename, setting the proper GP flag bit' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      zip.add_local_file_header(io: buf, filename: 'файл.bin', crc32: 123, compressed_size: 8981,
+        uncompressed_size: 90981, storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      br.read_4b # Signature
+      br.read_2b # Version needed to extract
+      expect(br.read_2b).to eq(2048)       # gp flags
+    end
+    
+    it 'writes out the local file header for an entry with a filename with diacritics, setting the proper GP flag bit' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      zip.add_local_file_header(io: buf, filename: 'Kungälv', crc32: 123, compressed_size: 8981,
+        uncompressed_size: 90981, storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      br.read_4b # Signature
+      br.read_2b # Version needed to extract
+      expect(br.read_2b).to eq(2048)       # gp flags
+      br.read_2b
+      br.read_2b
+      br.read_2b
+      br.read_4b
+      br.read_4b
+      br.read_4b
+      br.read_2b
+      br.read_2b
+      filename_readback = br.read_n('Kungälv'.bytesize)
+      expect(filename_readback.force_encoding(Encoding::UTF_8)).to eq('Kungälv')
+    end
+    
+    it 'writes out the local file header for an entry that requires Zip64 based on its compressed size _only_' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      zip.add_local_file_header(io: buf, filename: 'first-file.bin', crc32: 123, compressed_size: (0xFFFFFFFF + 1),
+        uncompressed_size: 90981, storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50) # Signature
+      expect(br.read_2b).to eq(45)         # Version needed to extract (require Zip64 support)
+      expect(br.read_2b).to eq(0)          # 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(123)        # CRC32
+      expect(br.read_4b).to eq(0xFFFFFFFF) # compressed size (blanked out)
+      expect(br.read_4b).to eq(0xFFFFFFFF) # uncompressed size (blanked out)
+      expect(br.read_2b).to eq('first-file.bin'.bytesize)      # byte length of the filename
+      expect(br.read_2b).to eq(20)         # size of extra fields
+      expect(br.read_n('first-file.bin'.bytesize)).to eq('first-file.bin') # the filename
+      expect(br.read_2b).to eq(1)              # Zip64 extra field signature
+      expect(br.read_2b).to eq(16)             # Size of the Zip64 extra field
+      expect(br.read_8b).to eq(90981)          # True compressed size
+      expect(br.read_8b).to eq(0xFFFFFFFF + 1) # True uncompressed size
+      expect(buf).to be_eof
+    end
+    
+    it 'writes out the local file header for an entry that requires Zip64 based on its uncompressed size _only_' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      zip.add_local_file_header(io: buf, filename: 'first-file.bin', crc32: 123, compressed_size: 90981,
+        uncompressed_size: (0xFFFFFFFF + 1), storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50) # Signature
+      expect(br.read_2b).to eq(45)         # Version needed to extract (require Zip64 support)
+      expect(br.read_2b).to eq(0)          # 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(123)        # CRC32
+      expect(br.read_4b).to eq(0xFFFFFFFF) # compressed size (blanked out)
+      expect(br.read_4b).to eq(0xFFFFFFFF) # uncompressed size (blanked out)
+      expect(br.read_2b).to eq('first-file.bin'.bytesize)      # byte length of the filename
+      expect(br.read_2b).to eq(20)         # size of extra fields
+      expect(br.read_n('first-file.bin'.bytesize)).to eq('first-file.bin') # the filename
+      expect(br.read_2b).to eq(1)              # Zip64 extra field signature
+      expect(br.read_2b).to eq(16)             # Size of the Zip64 extra field
+      expect(br.read_8b).to eq(0xFFFFFFFF + 1) # True uncompressed size
+      expect(br.read_8b).to eq(90981)          # True compressed size
+      expect(buf).to be_eof
+    end
+    
+    it 'does not write out the Zip64 extra if the position in the destination IO is beyond the Zip64 size limit' do
+      buf = StringIO.new
+      zip = described_class.new
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      expect(buf).to receive(:tell).and_return(0xFFFFFFFF + 1)
+      zip.add_local_file_header(io: buf, filename: 'first-file.bin', crc32: 123, compressed_size: 123,
+        uncompressed_size: 456, storage_mode: 8, mtime: mtime)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x04034b50) # Signature
+      expect(br.read_2b).to eq(20)         # Version needed to extract (require Zip64 support)
+      br.read_2b
+      br.read_2b
+      br.read_2b
+      br.read_2b
+      br.read_4b
+      br.read_4b
+      br.read_4b
+      br.read_2b
+      expect(br.read_2b).to be_zero
+    end
+  end
+  
+  describe '#write_central_directory' do
+    it 'can write the central directory and makes it a valid one even if there were no files' do
+      buf = StringIO.new
+      
+      zip = described_class.new
+      zip.write_central_directory(buf)
+      
+      buf.rewind
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x06054b50) # EOCD signature
+      expect(br.read_2b).to eq(0)          # disk number
+      expect(br.read_2b).to eq(0)          # disk number of the disk containing EOCD
+      expect(br.read_2b).to eq(0)          # num files in the central directory of this disk
+      expect(br.read_2b).to eq(0)          # num files in the central directories of all disks
+      expect(br.read_4b).to eq(0)          # central directorys size
+      expect(br.read_4b).to eq(0)          # offset of start of central directory from the beginning of the disk
+      expect(br.read_2b).to eq(0)          # ZIP file comment length
+      expect(buf).to be_eof
+    end
+    
+    it 'writes the central directory for 2 files' do
+      zip = described_class.new
+      
+      mtime = Time.utc(2016, 7, 17, 13, 48)
+      
+      buf = StringIO.new
+      zip.add_local_file_header(io: buf, filename: 'first-file.bin', crc32: 123, compressed_size: 5,
+        uncompressed_size: 8, storage_mode: 8, mtime: mtime)
+      buf << Random.new.bytes(5)
+      zip.add_local_file_header(io: buf, filename: 'first-file.txt', crc32: 123, compressed_size: 9,
+        uncompressed_size: 9, storage_mode: 0, mtime: mtime)
+      buf << Random.new.bytes(5)
+      
+      central_dir_offset = buf.tell
+      
+      zip.write_central_directory(buf)
+      
+      # Seek to where the central directory begins
+      buf.rewind
+      buf.seek(central_dir_offset)
+      
+      br = ByteReader.new(buf)
+      expect(br.read_4b).to eq(0x02014b50) # Central directory entry sig
+      
+      skip "Not finished"
+    end
+    
+    it 'writes the central directory 1 file that is larger than 4GB'
+    it 'writes the central directory for 2 files which, together, make the central directory start beyound the 4GB threshold'
+  end
+end

data/spec/zip_tricks/remote_io_spec.rb

@@ -80,7 +80,9 @@ describe ZipTricks::RemoteIO do
     end
 
     after :each do
-      @buf.close; @buf.unlink
+      if @buf
+        @buf.close; @buf.unlink
+      end
     end
 
     context 'without arguments' do

data/spec/zip_tricks/stored_size_estimator_spec.rb

@@ -13,10 +13,10 @@ describe ZipTricks::StoredSizeEstimator do
 
       estimator.add_stored_entry("second-file.bin", raw_file_2.size)
 
-      r = estimator.add_compressed_entry("second-file.bin", raw_file_2.size, raw_file_3.size)
+      r = estimator.add_compressed_entry("second-flie.bin", raw_file_2.size, raw_file_3.size)
       expect(r).to eq(estimator), "add_compressed_entry should return self"
     end
 
-    expect(predicted_size).to eq(1410524)
+    expect(predicted_size).to eq(1410585)
   end
 end

data/spec/zip_tricks/streamer_spec.rb

@@ -38,14 +38,14 @@ describe ZipTricks::Streamer do
     expect(retval).to eq(zip)
     expect(io.tell).to eq(8950)
 
-    pos = zip.add_stored_entry('file.jpg', 8921, 182919)
+    pos = zip.add_stored_entry('filf.jpg', 8921, 182919)
     expect(pos).to eq(8988)
     zip << SecureRandom.random_bytes(8921)
     expect(io.tell).to eq(17909)
 
     pos = zip.write_central_directory!
     expect(pos).to eq(io.tell)
-    expect(pos).to eq(17985)
+    expect(pos).to eq(18039)
 
     pos_after_close = zip.close
     expect(pos_after_close).to eq(pos)
@@ -90,17 +90,10 @@ describe ZipTricks::Streamer do
     expect(per_filename['compressed-file.bin'].bytesize).to eq(f.size)
     expect(Digest::SHA1.hexdigest(per_filename['compressed-file.bin'])).to eq(Digest::SHA1.hexdigest(f.read))
 
-    output = `unzip -v #{zip_file.path}`
-    puts output.inspect
+    inspect_zip_with_external_tool(zip_file.path)
   end
 
-
   it 'creates an archive that OSX ArchiveUtility can handle' do
-    au_path = '/System/Library/CoreServices/Applications/Archive Utility.app/Contents/MacOS/Archive Utility'
-    unless File.exist?(au_path)
-      skip "This system does not have ArchiveUtility"
-    end
-
     outbuf = Tempfile.new('zip')
     outbuf.binmode
 
@@ -131,13 +124,10 @@ describe ZipTricks::Streamer do
       outbuf.flush
       File.unlink('test.zip') rescue nil
       File.rename(outbuf.path, 'osx-archive-test.zip')
-
-      # ArchiveUtility sometimes puts the stuff it unarchives in ~/Downloads etc. so do
-      # not perform any checks on the files since we do not really know where they are on disk.
-      # Visual inspection should show whether the unarchiving is handled correctly.
-      `#{Shellwords.join([au_path, 'osx-archive-test.zip'])}`
+      
+      # Mark this test as skipped if the system does not have the binary
+      open_zip_with_archive_utility('osx-archive-test.zip', skip_if_missing: true)
     end
-
     FileUtils.rm_rf('osx-archive-test')
     FileUtils.rm_rf('osx-archive-test.zip')
   end
@@ -188,8 +178,7 @@ describe ZipTricks::Streamer do
     wd = Dir.pwd
     Dir.mktmpdir do | td |
       Dir.chdir(td)
-      output = `unzip -v #{zip_buf.path}`
-      puts output.inspect
+      inspect_zip_with_external_tool(zip_buf.path)
     end
     Dir.chdir(wd)
   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.7.0 ruby lib
+# stub: zip_tricks 2.8.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "zip_tricks"
-  s.version = "2.7.0"
+  s.version = "2.8.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-15"
+  s.date = "2016-07-18"
   s.description = "Makes rubyzip stream, for real"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
@@ -35,6 +35,7 @@ Gem::Specification.new do |s|
     "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/null_writer.rb",
     "lib/zip_tricks/rack_body.rb",
     "lib/zip_tricks/remote_io.rb",
@@ -47,6 +48,8 @@ Gem::Specification.new do |s|
     "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/rack_body_spec.rb",
     "spec/zip_tricks/remote_io_spec.rb",
     "spec/zip_tricks/remote_uncap_spec.rb",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zip_tricks
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-15 00:00:00.000000000 Z
+date: 2016-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -172,6 +172,7 @@ files:
 - 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/null_writer.rb
 - lib/zip_tricks/rack_body.rb
 - lib/zip_tricks/remote_io.rb
@@ -184,6 +185,8 @@ files:
 - 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/rack_body_spec.rb
 - spec/zip_tricks/remote_io_spec.rb
 - spec/zip_tricks/remote_uncap_spec.rb