zip_tricks 2.8.1 → 3.0.0

data/lib/zip_tricks/zip_writer.rb

@@ -0,0 +1,346 @@
+# A low-level ZIP file data writer. You can use it to write out various headers and central directory elements
+# separately. The class handles the actual encoding of the data according to the ZIP format APPNOTE document.
+#
+# The primary reason the writer is a separate object is because it is kept stateless. That is, all the data that
+# is needed for writing a piece of the ZIP (say, the EOCD record, or a data descriptor) can be written
+# without depending on data available elsewhere. This makes the writer very easy to test, since each of
+# it's methods outputs something that only depends on the method's arguments. For example, we use this
+# to test writing Zip64 files which, when tested in a streaming fashion, would need tricky IO stubs
+# to wind IO objects back and forth by large offsets. Instead, we can just write out the EOCD record
+# with given offsets as arguments.
+#
+# Since some methods need a lot of data about the entity being written, everything is passed via
+# keyword arguments - this way it is much less likely that you can make a mistake writing something.
+#
+# Another reason for having a separate Writer is that most ZIP libraries attach the methods for
+# writing out the file headers to some sort of Entry object, which represents a file within the ZIP.
+# However, when you are diagnosing issues with the ZIP files you produce, you actually want to have
+# absolute _most_ of the code responsible for writing the actual encoded bytes available to you on
+# one screen. Altering or checking that code then becomes much, much easier. The methods doing the
+# writing are also intentionally left very verbose - so that you can follow what is happening at
+# all times.
+#
+# All methods of the writer accept anything that responds to `<<` as `io` argument - you can use
+# that to output to String objects, or to output to Arrays that you can later join together.
+class ZipTricks::ZipWriter
+  FOUR_BYTE_MAX_UINT = 0xFFFFFFFF
+  TWO_BYTE_MAX_UINT = 0xFFFF
+  ZIP_TRICKS_COMMENT = 'Written using ZipTricks %s' % ZipTricks::VERSION
+  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    # Encode a 4-byte little-endian uint
+  C_v = 'v'.freeze    # Encode a 2-byte little-endian uint
+  C_Qe = 'Q<'.freeze  # Encode an 8-byte little-endian uint
+
+  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,
+    :C_V, :C_v, :C_Qe, :ZIP_TRICKS_COMMENT
+
+  # Writes the local file header, that precedes the actual file _data_. 
+  # 
+  # @param io[#<<] the buffer to write the local file header to
+  # @param filename[String]  the name of the file in the archive
+  # @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 crc32[Fixnum] The CRC32 checksum of the file
+  # @param mtime[Time]  the modification time to be recorded in the ZIP
+  # @param gp_flags[Fixnum] bit-packed general purpose flags
+  # @param storage_mode[Fixnum] 8 for deflated, 0 for stored...
+  # @return [void]
+  def write_local_file_header(io:, filename:, compressed_size:, uncompressed_size:, crc32:, gp_flags:, mtime:, storage_mode:)
+    requires_zip64 = (compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT)
+
+    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].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_local_file_header(io: buf, compressed_size: 0, uncompressed_size: 0) }
+    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...
+    if requires_zip64
+      write_zip_64_extra_for_local_file_header(io: io, compressed_size: compressed_size, uncompressed_size: uncompressed_size)
+    end
+  end
+
+  # Writes the file header for the central directory, for a particular file in the archive. When writing out this data,
+  # ensure that the CRC32 and both sizes (compressed/uncompressed) are correct for the entry in question.
+  #
+  # @param io[#<<] the buffer to write the local file header to
+  # @param filename[String]  the name of the file in the archive
+  # @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 crc32[Fixnum] The CRC32 checksum of the file
+  # @param mtime[Time]  the modification time to be recorded in the ZIP
+  # @param external_attrs[Fixnum] bit-packed external attributes (defaults to UNIX file with 0644 permissions set)
+  # @param gp_flags[Fixnum] bit-packed general purpose flags
+  # @return [void]
+  def write_central_directory_file_header(io:, local_file_header_location:, gp_flags:, storage_mode:, compressed_size:, uncompressed_size:, mtime:, crc32:, 
+    filename:, external_attrs: DEFAULT_EXTERNAL_ATTRS)
+    # 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...
+    add_zip64 = (local_file_header_location > FOUR_BYTE_MAX_UINT) ||
+        (compressed_size > FOUR_BYTE_MAX_UINT) || (uncompressed_size > 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 add_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].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 add_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 add_zip64
+      extra_size += bytesize_of {|buf|
+        # Supply zeroes for most values as we obnly care about the size of the data written
+        write_zip_64_extra_for_central_directory_file_header(io: buf, compressed_size: 0, uncompressed_size: 0, local_file_header_location: 0)
+      }
+    end
+    io << [extra_size].pack(C_v)                        # extra field length              2 bytes
+
+    io << [0].pack(C_v)                                 # file comment length             2 bytes
+
+    # For The Unarchiver < 3.11.1 this field has to be set to the overflow value if zip64 is used
+    # because otherwise it does not properly advance the pointer when reading the Zip64 extra field
+    # https://bitbucket.org/WAHa_06x36/theunarchiver/pull-requests/2/bug-fix-for-zip64-extra-field-parser/diff
+    if add_zip64                                        # disk number start               2 bytes
+      io << [TWO_BYTE_MAX_UINT].pack(C_v)
+    else
+      io << [0].pack(C_v)
+    end
+    io << [0].pack(C_v)                                # internal file attributes        2 bytes
+    io << [DEFAULT_EXTERNAL_ATTRS].pack(C_V)           # external file attributes        4 bytes
+
+    if add_zip64                                       # relative offset of local header 4 bytes
+      io << [FOUR_BYTE_MAX_UINT].pack(C_V)
+    else
+      io << [local_file_header_location].pack(C_V)
+    end
+    io << filename                                     # file name (variable size)
+
+    if add_zip64                                       # extra field (variable size)
+      write_zip_64_extra_for_central_directory_file_header(io: io, local_file_header_location: local_file_header_location,
+        compressed_size: compressed_size, uncompressed_size: uncompressed_size)
+    end
+    #(empty)                                           # file comment (variable size)
+  end
+
+  # Writes the data descriptor following the file data for a file whose local file header
+  # was written with general-purpose flag bit 3 set. If the one of the sizes exceeds the Zip64 threshold,
+  # the data descriptor will have the sizes written out as 8-byte values instead of 4-byte values.
+  #
+  # @param io[#<<] the buffer to write the local file header to
+  # @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
+  # @return [void]
+  def write_data_descriptor(io:, compressed_size:, uncompressed_size:, crc32:)
+    io << [0x08074b50].pack(C_V)  # Although not originally assigned a signature, the value
+                                  # 0x08074b50 has commonly been adopted as a signature value
+                                  # for the data descriptor record.
+    io << [crc32].pack(C_V)                             # crc-32                          4 bytes
+
+
+    # If one of the sizes is above 0xFFFFFFF use ZIP64 lengths (8 bytes) instead. A good unarchiver
+    # will decide to unpack it as such if it finds the Zip64 extra for the file in the central directory.
+    # So also use the opportune moment to switch the entry to Zip64 if needed
+    requires_zip64 = (compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT)
+    pack_spec = requires_zip64 ? C_Qe : C_V
+
+    io << [compressed_size].pack(pack_spec)       # compressed size                 4 bytes, or 8 bytes for ZIP64
+    io << [uncompressed_size].pack(pack_spec)     # uncompressed size               4 bytes, or 8 bytes for ZIP64
+  end
+
+  # Writes the "end of central directory record" (including the Zip6 salient bits if necessary)
+  #
+  # @param io[#<<] the buffer to write the central directory to.
+  # @param start_of_central_directory_location[Fixnum] byte offset of the start of central directory form the beginning of ZIP file
+  # @param central_directory_size[Fixnum] the size of the central directory (only file headers) in bytes
+  # @param num_files_in_archive[Fixnum] How many files the archive contains
+  # @return [void]
+  def write_end_of_central_directory(io:, start_of_central_directory_location:, central_directory_size:, num_files_in_archive:)
+    zip64_eocdr_offset = start_of_central_directory_location + central_directory_size
+    
+    zip64_required = central_directory_size > FOUR_BYTE_MAX_UINT ||
+      start_of_central_directory_location > FOUR_BYTE_MAX_UINT ||
+      zip64_eocdr_offset > FOUR_BYTE_MAX_UINT ||
+      num_files_in_archive > TWO_BYTE_MAX_UINT
+
+    # Then, if zip64 is used
+    if zip64_required
+      # [zip64 end of central directory record]
+                                                             # 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 (which we are not using)
+                                                             # it is always 44 bytes.
+      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 << [num_files_in_archive].pack(C_Qe)                # total number of entries in the
+                                                             # central directory on this disk  8 bytes
+      io << [num_files_in_archive].pack(C_Qe)                # total number of entries in the
+                                                             # central directory               8 bytes
+      io << [central_directory_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_location].pack(C_Qe) # the starting disk number        8 bytes
+                                                             # zip64 extensible data sector    (variable size), blank for us
+
+      # [zip64 end of central directory locator]
+      io << [0x07064b50].pack(C_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 << [num_files_in_archive].pack(C_v)                # total number of entries in the
+                                                            # central directory on this disk   2 bytes
+      io << [num_files_in_archive].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_directory_size].pack(C_V)              # size of the central directory    4 bytes
+      io << [start_of_central_directory_location].pack(C_V) # offset of start of central
+                                                            # directory with respect to
+                                                            # the starting disk number        4 bytes
+    end
+    io << [ZIP_TRICKS_COMMENT.bytesize].pack(C_v)           # .ZIP file comment length        2 bytes
+    io << ZIP_TRICKS_COMMENT                                # .ZIP file comment       (variable size)
+  end
+  
+  private
+
+  # Writes the Zip64 extra field for the local file header. Will be used by `write_local_file_header` when any sizes given to it warrant that.
+  #
+  # @param io[#<<] the buffer to write the local file header to
+  # @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
+  # @return [void]
+  def write_zip_64_extra_for_local_file_header(io:, compressed_size:, uncompressed_size:)
+    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
+  
+  # Writes the Zip64 extra field for the central directory header.It differs from the extra used in the local file header because it
+  # also contains the location of the local file header in the ZIP as an 8-byte int.
+  #
+  # @param io[#<<] the buffer to write the local file header to
+  # @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 local_file_header_location[Fixnum] Byte offset of the start of the local file header from the beginning of the ZIP archive
+  # @return [void]
+  def write_zip_64_extra_for_central_directory_file_header(io:, compressed_size:, uncompressed_size:, 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 bytesize_of
+    ''.force_encoding(Encoding::BINARY).tap {|b| yield(b) }.bytesize
+  end
+
+  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

data/lib/zip_tricks.rb

@@ -1,8 +1,5 @@
-require 'zip'
-require 'very_tiny_state_machine'
-
 module ZipTricks
-  VERSION = '2.8.1'
+  VERSION = '3.0.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

@@ -6,6 +6,7 @@ require 'zip_tricks'
 require 'digest'
 require 'fileutils'
 require 'shellwords'
+require 'zip'
 
 module Keepalive
   # Travis-CI kills the build if it does not receive output on standard out or standard error
@@ -22,7 +23,6 @@ module Keepalive
   extend self
 end
 
-
 class ManagedTempfile < Tempfile
   @@managed_tempfiles = []
   
@@ -39,38 +39,6 @@ class ManagedTempfile < Tempfile
   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'
@@ -96,11 +64,6 @@ module ZipInspection
     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|

data/spec/zip_tricks/file_reader_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe ZipTricks::FileReader do
+  it 'reads and uncompresses the file written deflated with data descriptors' do
+    zipfile = StringIO.new
+    tolstoy = File.read(__dir__ + '/war-and-peace.txt')
+    tolstoy.force_encoding(Encoding::BINARY)
+
+    ZipTricks::Streamer.open(zipfile) do |zip|
+      zip.write_deflated_file('war-and-peace.txt') do |sink|
+        sink << tolstoy
+      end
+    end
+
+    entries = described_class.read_zip_structure(zipfile)
+    expect(entries.length).to eq(1)
+
+    entry = entries.first
+
+    readback = ''
+    reader = entry.extractor_from(zipfile)
+    readback << reader.extract(10) until reader.eof?
+
+    expect(readback.bytesize).to eq(tolstoy.bytesize)
+    expect(readback[0..10]).to eq(tolstoy[0..10])
+    expect(readback[-10..-1]).to eq(tolstoy[-10..-1])
+  end
+
+  it 'reads the file written stored with data descriptors' do
+    zipfile = StringIO.new
+    tolstoy = File.read(__dir__ + '/war-and-peace.txt')
+    ZipTricks::Streamer.open(zipfile) do |zip|
+      zip.write_stored_file('war-and-peace.txt') do |sink|
+        sink << tolstoy
+      end
+    end
+
+    entries = described_class.read_zip_structure(zipfile)
+    expect(entries.length).to eq(1)
+
+    entry = entries.first
+
+    readback = entry.extractor_from(zipfile).extract
+    expect(readback.bytesize).to eq(tolstoy.bytesize)
+    expect(readback[0..10]).to eq(tolstoy[0..10])
+  end
+end

data/spec/zip_tricks/rack_body_spec.rb

@@ -7,7 +7,7 @@ describe ZipTricks::RackBody do
     file_body = SecureRandom.random_bytes(1024 * 1024 + 8981)
 
     body = described_class.new do | zip |
-      zip.add_stored_entry("A file", file_body.bytesize, Zlib.crc32(file_body))
+      zip.add_stored_entry(filename: "A file", size: file_body.bytesize, crc32: Zlib.crc32(file_body))
       zip << file_body
     end
 
@@ -17,7 +17,7 @@ describe ZipTricks::RackBody do
     body.close
 
     output_buf.rewind
-    expect(output_buf.size).to eq(1057667)
+    expect(output_buf.size).to eq(1057696)
 
     per_filename = {}
     Zip::File.open(output_buf.path) do |zip_file|

data/spec/zip_tricks/remote_io_spec.rb

@@ -38,7 +38,7 @@ describe ZipTricks::RemoteIO do
         uncap = described_class.new
         expect {
           uncap.seek(123, :UNSUPPORTED)
-        }.to raise_error(Errno::ENOTSUP)
+        }.to raise_error(/unsupported/i)
       end
     end
 
@@ -50,18 +50,6 @@ describe ZipTricks::RemoteIO do
         expect(uncap.seek(10, mode)).to eq(0)
       end
     end
-
-    context 'with SEEK_END mode' do
-      it 'seens to 10 bytes to the end of the IO' do
-        uncap = described_class.new
-        expect(uncap).to receive(:request_object_size).and_return(100)
-
-        mode = IO::SEEK_END
-        offset = -10
-        expect(uncap.seek(-10, IO::SEEK_END)).to eq(0)
-        expect(uncap.pos).to eq(90)
-      end
-    end
   end
 
   describe '#read' do
@@ -87,10 +75,10 @@ describe ZipTricks::RemoteIO do
 
     context 'without arguments' do
       it 'reads the entire buffer and alters the position pointer' do
-        expect(@subject.pos).to eq(0)
+        expect(@subject.tell).to eq(0)
         read = @subject.read
         expect(read.bytesize).to eq(@buf.size)
-        expect(@subject.pos).to eq(@buf.size)
+        expect(@subject.tell).to eq(@buf.size)
       end
     end
 
@@ -105,7 +93,7 @@ describe ZipTricks::RemoteIO do
       
       it 'returns exact amount of bytes at the start of the buffer' do
         bytes_read = @subject.read(10)
-        expect(@subject.pos).to eq(10)
+        expect(@subject.tell).to eq(10)
         @buf.seek(0)
         expect(bytes_read).to eq(@buf.read(10))
       end
@@ -114,7 +102,7 @@ describe ZipTricks::RemoteIO do
         @subject.seek(456, IO::SEEK_SET)
 
         bytes_read = @subject.read(10)
-        expect(@subject.pos).to eq(456+10)
+        expect(@subject.tell).to eq(456+10)
 
         @buf.seek(456)
         expect(bytes_read).to eq(@buf.read(10))
@@ -124,13 +112,13 @@ describe ZipTricks::RemoteIO do
         at_end = @buf.size - 4
         @subject.seek(at_end, IO::SEEK_SET)
 
-        expect(@subject.pos).to eq(15728636)
+        expect(@subject.tell).to eq(15728636)
         bytes_read = @subject.read(10)
-        expect(@subject.pos).to eq(@buf.size) # Should have moved the pos pointer to the end
+        expect(@subject.tell).to eq(@buf.size) # Should have moved the pos pointer to the end
 
         expect(bytes_read.bytesize).to eq(4)
 
-        expect(@subject.pos).to eq(@buf.size)
+        expect(@subject.tell).to eq(@buf.size)
       end
     end
   end

data/spec/zip_tricks/remote_uncap_spec.rb

@@ -21,11 +21,11 @@ describe ZipTricks::RemoteUncap, webmock: true do
 
     File.open('temp.zip', 'wb') do |f|
       ZipTricks::Streamer.open(f) do | zip |
-        zip.add_stored_entry('first-file.bin', payload1.size, payload1_crc)
+        zip.add_stored_entry(filename: 'first-file.bin', size: payload1.size, crc32: payload1_crc)
         while blob = payload1.read(1024 * 5)
           zip << blob
         end
-        zip.add_stored_entry('second-file.bin', payload2.size, payload2_crc)
+        zip.add_stored_entry(filename: 'second-file.bin', size: payload2.size, crc32: payload2_crc)
         while blob = payload2.read(1024 * 5)
           zip << blob
         end
@@ -81,9 +81,9 @@ describe ZipTricks::RemoteUncap, webmock: true do
 
     File.open('temp.zip', 'wb') do |f|
       ZipTricks::Streamer.open(f) do | zip |
-        zip.add_stored_entry('first-file.bin', payload1.size, payload1_crc)
+        zip.add_stored_entry(filename: 'first-file.bin', size: payload1.size, crc32: payload1_crc)
         zip << '' # It is empty, so a read() would return nil
-        zip.add_stored_entry('second-file.bin', payload2.size, payload2_crc)
+        zip.add_stored_entry(filename: 'second-file.bin', size: payload2.size, crc32: payload2_crc)
         while blob = payload2.read(1024 * 5)
           zip << blob
         end

data/spec/zip_tricks/size_estimator_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+describe ZipTricks::SizeEstimator do
+  it 'accurately predicts the output zip size' do
+    # Generate a couple of random files
+    raw_file_1 = SecureRandom.random_bytes(1024 * 20)
+    raw_file_2 = SecureRandom.random_bytes(1024 * 128)
+    raw_file_3 = SecureRandom.random_bytes(1258695)
+
+    predicted_size = described_class.estimate do | estimator |
+      r = estimator.add_stored_entry(filename: "first-file.bin", size: raw_file_1.size)
+      expect(r).to eq(estimator), "add_stored_entry should return self"
+
+      estimator.add_stored_entry(filename: "second-file.bin", size: raw_file_2.size)
+
+      r = estimator.add_compressed_entry(filename: "second-flie.bin", compressed_size: raw_file_3.size,
+        uncompressed_size: raw_file_2.size, )
+      expect(r).to eq(estimator), "add_compressed_entry should return self"
+      
+      r = estimator.add_stored_entry(filename: "first-file-with-descriptor.bin", size: raw_file_1.size,
+        use_data_descriptor: true)
+      expect(r).to eq(estimator), "add_stored_entry should return self"
+
+      r = estimator.add_compressed_entry(filename: "second-file-with-descriptor.bin", compressed_size: raw_file_3.size,
+        uncompressed_size: raw_file_2.size, use_data_descriptor: true)
+      expect(r).to eq(estimator), "add_compressed_entry should return self"
+    end
+
+    expect(predicted_size).to eq(2690095)
+  end
+end