zip_kit 6.4.1 → 6.4.2

data/lib/zip_kit/zip_writer.rb

@@ -43,11 +43,64 @@ class ZipKit::ZipWriter
     [VERSION_MADE_BY, os_type].pack("CC").freeze
   end
 
-  C_UINT4 = "V" # Encode a 4-byte unsigned little-endian uint
-  C_UINT2 = "v" # Encode a 2-byte unsigned little-endian uint
-  C_UINT8 = "Q<" # Encode an 8-byte unsigned little-endian uint
-  C_CHAR = "C" # For bit-encoded strings
-  C_INT4 = "l<" # Encode a 4-byte signed little-endian int
+  # Collects the values of a ZIP record and packs them all with a single `Array#pack`.
+  # Packing value-by-value allocates an Array and a String per value, and the ZIP headers have lots of values.
+  # All integers are little-endian, as the ZIP format wants them.
+  class PackBuffer
+    def initialize
+      @values = []
+      @packspec = +""
+    end
+
+    # @param value[Integer] a 1-byte unsigned int
+    # @return [self]
+    def uint1(value)
+      append(value, "C")
+    end
+
+    # @param value[Integer] a 2-byte unsigned int
+    # @return [self]
+    def uint2(value)
+      append(value, "v")
+    end
+
+    # @param value[Integer] a 4-byte unsigned int
+    # @return [self]
+    def uint4(value)
+      append(value, "V")
+    end
+
+    # @param value[Integer] an 8-byte unsigned int
+    # @return [self]
+    def uint8(value)
+      append(value, "Q<")
+    end
+
+    # @param value[Integer] a 4-byte signed int
+    # @return [self]
+    def int4(value)
+      append(value, "l<")
+    end
+
+    # @param value[String] a String whose bytes get appended as-is, regardless of its encoding
+    # @return [self]
+    def bytes(value)
+      append(value, "a*")
+    end
+
+    # @return [String] the packed values in binary encoding
+    def b
+      @values.pack(@packspec)
+    end
+
+    private
+
+    def append(value, packspec)
+      @values << value
+      @packspec << packspec
+      self
+    end
+  end
 
   private_constant :FOUR_BYTE_MAX_UINT,
     :TWO_BYTE_MAX_UINT,
@@ -57,9 +110,7 @@ class ZipKit::ZipWriter
     :FILE_TYPE_FILE,
     :FILE_TYPE_DIRECTORY,
     :MADE_BY_SIGNATURE,
-    :C_UINT4,
-    :C_UINT2,
-    :C_UINT8,
+    :PackBuffer,
     :ZIP_KIT_COMMENT
 
   # Writes the local file header, that precedes the actual file _data_.
@@ -81,61 +132,43 @@ class ZipKit::ZipWriter
   def write_local_file_header(io:, filename:, compressed_size:, uncompressed_size:, crc32:, gp_flags:, mtime:, storage_mode:, extended_timestamp: true)
     requires_zip64 = compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT
 
+    # 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.
+    extra_fields = "".b
+    extra_fields << zip_64_extra_for_local_file_header(compressed_size: compressed_size, uncompressed_size: uncompressed_size) if requires_zip64
+    extra_fields << timestamp_extra_for_local_file_header(mtime) if extended_timestamp
+
+    buf = PackBuffer.new
     # local file header signature     4 bytes  (0x04034b50)
-    io << [0x04034b50].pack(C_UINT4)
+    buf.uint4(0x04034b50)
     # version needed to extract       2 bytes
-    io << if requires_zip64
-      [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2)
-    else
-      [VERSION_NEEDED_TO_EXTRACT].pack(C_UINT2)
-    end
-
+    buf.uint2(requires_zip64 ? VERSION_NEEDED_TO_EXTRACT_ZIP64 : VERSION_NEEDED_TO_EXTRACT)
     # general purpose bit flag        2 bytes
-    io << [gp_flags].pack(C_UINT2)
+    buf.uint2(gp_flags)
     # compression method              2 bytes
-    io << [storage_mode].pack(C_UINT2)
+    buf.uint2(storage_mode)
     # last mod file time              2 bytes
-    io << [to_binary_dos_time(mtime)].pack(C_UINT2)
+    buf.uint2(to_binary_dos_time(mtime))
     # last mod file date              2 bytes
-    io << [to_binary_dos_date(mtime)].pack(C_UINT2)
+    buf.uint2(to_binary_dos_date(mtime))
     # crc-32                          4 bytes
-    io << [crc32].pack(C_UINT4)
-
-    if requires_zip64
-      # compressed size              4 bytes
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-      # uncompressed size            4 bytes
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-    else
-      # compressed size              4 bytes
-      io << [compressed_size].pack(C_UINT4)
-      # uncompressed size            4 bytes
-      io << [uncompressed_size].pack(C_UINT4)
-    end
-
+    buf.uint4(crc32)
+    # compressed size                 4 bytes
+    buf.uint4(requires_zip64 ? FOUR_BYTE_MAX_UINT : compressed_size)
+    # uncompressed size               4 bytes
+    buf.uint4(requires_zip64 ? FOUR_BYTE_MAX_UINT : uncompressed_size)
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
-    # file name length             2 bytes
-    io << [filename.bytesize].pack(C_UINT2)
-
-    extra_fields = StringIO.new
-
-    # 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 requires_zip64
-      extra_fields << zip_64_extra_for_local_file_header(compressed_size: compressed_size, uncompressed_size: uncompressed_size)
-    end
-    extra_fields << timestamp_extra_for_local_file_header(mtime) if extended_timestamp
-
+    # file name length                2 bytes
+    buf.uint2(filename.bytesize)
     # extra field length              2 bytes
-    io << [extra_fields.size].pack(C_UINT2)
-
+    buf.uint2(extra_fields.bytesize)
     # file name (variable size)
-    io << filename
-
+    buf.bytes(filename)
     # Contents of the extra fields (variable size)
-    io << extra_fields.string
+    buf.bytes(extra_fields)
+    io << buf.b
   end
 
   # Writes the file header for the central directory, for a particular file in the archive. When writing out this data,
@@ -168,94 +201,70 @@ class ZipKit::ZipWriter
     add_zip64 = (local_file_header_location > FOUR_BYTE_MAX_UINT) ||
       (compressed_size > FOUR_BYTE_MAX_UINT) || (uncompressed_size > FOUR_BYTE_MAX_UINT)
 
-    # central file header signature   4 bytes  (0x02014b50)
-    io << [0x02014b50].pack(C_UINT4)
-    # version made by                 2 bytes
-    io << MADE_BY_SIGNATURE
+    extra_fields = "".b
+    if add_zip64
+      extra_fields << zip_64_extra_for_central_directory_file_header(local_file_header_location: local_file_header_location,
+        compressed_size: compressed_size,
+        uncompressed_size: uncompressed_size)
+    end
+    extra_fields << timestamp_extra_for_central_directory_entry(mtime) if extended_timestamp
 
-    # version needed to extract       2 bytes
-    io << if add_zip64
-      [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2)
+    # Because the add_empty_directory method will create a directory with a trailing "/",
+    # this check can be used to assign proper permissions to the created directory.
+    external_attrs = if filename.end_with?("/")
+      unix_permissions ||= DEFAULT_DIRECTORY_UNIX_PERMISSIONS
+      generate_external_attrs(unix_permissions, FILE_TYPE_DIRECTORY)
     else
-      [VERSION_NEEDED_TO_EXTRACT].pack(C_UINT2)
+      unix_permissions ||= DEFAULT_FILE_UNIX_PERMISSIONS
+      generate_external_attrs(unix_permissions, FILE_TYPE_FILE)
     end
 
+    buf = PackBuffer.new
+    # central file header signature   4 bytes  (0x02014b50)
+    buf.uint4(0x02014b50)
+    # version made by                 2 bytes
+    buf.bytes(MADE_BY_SIGNATURE)
+    # version needed to extract       2 bytes
+    buf.uint2(add_zip64 ? VERSION_NEEDED_TO_EXTRACT_ZIP64 : VERSION_NEEDED_TO_EXTRACT)
     # general purpose bit flag        2 bytes
-    io << [gp_flags].pack(C_UINT2)
+    buf.uint2(gp_flags)
     # compression method              2 bytes
-    io << [storage_mode].pack(C_UINT2)
+    buf.uint2(storage_mode)
     # last mod file time              2 bytes
-    io << [to_binary_dos_time(mtime)].pack(C_UINT2)
+    buf.uint2(to_binary_dos_time(mtime))
     # last mod file date              2 bytes
-    io << [to_binary_dos_date(mtime)].pack(C_UINT2)
+    buf.uint2(to_binary_dos_date(mtime))
     # crc-32                          4 bytes
-    io << [crc32].pack(C_UINT4)
-
-    # compressed size              4 bytes
-    # uncompressed size            4 bytes
-    if add_zip64
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-    else
-      io << [compressed_size].pack(C_UINT4)
-      io << [uncompressed_size].pack(C_UINT4)
-    end
-
+    buf.uint4(crc32)
+    # compressed size                 4 bytes
+    buf.uint4(add_zip64 ? FOUR_BYTE_MAX_UINT : compressed_size)
+    # uncompressed size               4 bytes
+    buf.uint4(add_zip64 ? FOUR_BYTE_MAX_UINT : uncompressed_size)
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
     # file name length                2 bytes
-    io << [filename.bytesize].pack(C_UINT2)
-
-    extra_fields = StringIO.new
-    if add_zip64
-      extra_fields << zip_64_extra_for_central_directory_file_header(local_file_header_location: local_file_header_location,
-        compressed_size: compressed_size,
-        uncompressed_size: uncompressed_size)
-    end
-    extra_fields << timestamp_extra_for_central_directory_entry(mtime) if extended_timestamp
-
+    buf.uint2(filename.bytesize)
     # extra field length              2 bytes
-    io << [extra_fields.size].pack(C_UINT2)
+    buf.uint2(extra_fields.bytesize)
     # file comment length             2 bytes
-    io << [0].pack(C_UINT2)
-
+    buf.uint2(0)
     # 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
     # disk number start               2 bytes
-    io << if add_zip64
-      [TWO_BYTE_MAX_UINT].pack(C_UINT2)
-    else
-      [0].pack(C_UINT2)
-    end
+    buf.uint2(add_zip64 ? TWO_BYTE_MAX_UINT : 0)
     # internal file attributes        2 bytes
-    io << [0].pack(C_UINT2)
-
-    # Because the add_empty_directory method will create a directory with a trailing "/",
-    # this check can be used to assign proper permissions to the created directory.
-    external_attrs = if filename.end_with?("/")
-      unix_permissions ||= DEFAULT_DIRECTORY_UNIX_PERMISSIONS
-      generate_external_attrs(unix_permissions, FILE_TYPE_DIRECTORY)
-    else
-      unix_permissions ||= DEFAULT_FILE_UNIX_PERMISSIONS
-      generate_external_attrs(unix_permissions, FILE_TYPE_FILE)
-    end
-
+    buf.uint2(0)
     # external file attributes        4 bytes
-    io << [external_attrs].pack(C_UINT4)
-
+    buf.uint4(external_attrs)
     # relative offset of local header 4 bytes
-    io << if add_zip64
-      [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-    else
-      [local_file_header_location].pack(C_UINT4)
-    end
-
+    buf.uint4(add_zip64 ? FOUR_BYTE_MAX_UINT : local_file_header_location)
     # file name (variable size)
-    io << filename
+    buf.bytes(filename)
     # extra field (variable size)
-    io << extra_fields.string
+    buf.bytes(extra_fields)
     # file comment (variable size)
     # (empty)
+    io << buf.b
   end
 
   # Writes the data descriptor following the file data for a file whose local file header
@@ -268,25 +277,30 @@ class ZipKit::ZipWriter
   # @param uncompressed_size[Integer]  The size of the file once extracted
   # @return [void]
   def write_data_descriptor(io:, compressed_size:, uncompressed_size:, crc32:)
-    # Although not originally assigned a signature, the value
-    # 0x08074b50 has commonly been adopted as a signature value
-    # for the data descriptor record.
-    io << [0x08074b50].pack(C_UINT4)
-
-    # crc-32                          4 bytes
-    io << [crc32].pack(C_UINT4)
-
     # 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.
     # We switch if either of the sizes requires ZIP64, so that both values are encoded similarly.
     requires_zip64 = compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT
-    pack_spec = requires_zip64 ? C_UINT8 : C_UINT4
-
-    # compressed size                 4 bytes, or 8 bytes for ZIP64
-    io << [compressed_size].pack(pack_spec)
-    # uncompressed size               4 bytes, or 8 bytes for ZIP64
-    io << [uncompressed_size].pack(pack_spec)
+    buf = PackBuffer.new
+    # Although not originally assigned a signature, the value
+    # 0x08074b50 has commonly been adopted as a signature value
+    # for the data descriptor record.
+    buf.uint4(0x08074b50)
+    # crc-32                          4 bytes
+    buf.uint4(crc32)
+    if requires_zip64
+      # compressed size                 8 bytes
+      buf.uint8(compressed_size)
+      # uncompressed size               8 bytes
+      buf.uint8(uncompressed_size)
+    else
+      # compressed size                 4 bytes
+      buf.uint4(compressed_size)
+      # uncompressed size               4 bytes
+      buf.uint4(uncompressed_size)
+    end
+    io << buf.b
   end
 
   # Writes the "end of central directory record" (including the Zip6 salient bits if necessary)
@@ -305,91 +319,81 @@ class ZipKit::ZipWriter
       zip64_eocdr_offset > FOUR_BYTE_MAX_UINT ||
       num_files_in_archive > TWO_BYTE_MAX_UINT
 
+    buf = PackBuffer.new
+
     # Then, if zip64 is used
     if zip64_required
       # [zip64 end of central directory record]
       # zip64 end of central dir signature                       4 bytes  (0x06064b50)
-      io << [0x06064b50].pack(C_UINT4)
-
+      buf.uint4(0x06064b50)
       # 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 << [44].pack(C_UINT8)
-
+      buf.uint8(44)
       # version made by                 2 bytes
-      io << MADE_BY_SIGNATURE
+      buf.bytes(MADE_BY_SIGNATURE)
       # version needed to extract       2 bytes
-      io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2)
+      buf.uint2(VERSION_NEEDED_TO_EXTRACT_ZIP64)
       # number of this disk             4 bytes
-      io << [0].pack(C_UINT4)
+      buf.uint4(0)
       # number of the disk with the start of the central directory  4 bytes
-      io << [0].pack(C_UINT4)
+      buf.uint4(0)
       # total number of entries in the
       # central directory on this disk  8 bytes
-      io << [num_files_in_archive].pack(C_UINT8)
+      buf.uint8(num_files_in_archive)
       # total number of entries in the
       # central directory               8 bytes
-      io << [num_files_in_archive].pack(C_UINT8)
+      buf.uint8(num_files_in_archive)
       # size of the central directory   8 bytes
-      io << [central_directory_size].pack(C_UINT8)
+      buf.uint8(central_directory_size)
       # offset of start of central directory with respect to
       # the starting disk number        8 bytes
-      io << [start_of_central_directory_location].pack(C_UINT8)
+      buf.uint8(start_of_central_directory_location)
       # zip64 extensible data sector (variable size)
       # (blank for us)
 
       # zip64 end of central dir locator
       # signature                       4 bytes  (0x07064b50)
-      io << [0x07064b50].pack(C_UINT4)
+      buf.uint4(0x07064b50)
       # number of the disk with the start of the zip64 end of
       # central directory               4 bytes
-      io << [0].pack(C_UINT4)
+      buf.uint4(0)
       # relative offset of the zip64
       # end of central directory record 8 bytes
       # (note: "relative" is actually "from the start of the file")
-      io << [zip64_eocdr_offset].pack(C_UINT8)
+      buf.uint8(zip64_eocdr_offset)
       # total number of disks           4 bytes
-      io << [1].pack(C_UINT4)
+      buf.uint4(1)
     end
 
     # Then the end of central directory record:
     # end of central dir signature     4 bytes  (0x06054b50)
-    io << [0x06054b50].pack(C_UINT4)
+    buf.uint4(0x06054b50)
     # number of this disk              2 bytes
-    io << [0].pack(C_UINT2)
+    buf.uint2(0)
     # number of the disk with the
     # start of the central directory 2 bytes
-    io << [0].pack(C_UINT2)
-
+    buf.uint2(0)
     # total number of entries in the
     # central directory on this disk   2 bytes
+    # (the number of entries will be read from the zip64 part of the central directory if zip64 is used)
+    buf.uint2(zip64_required ? TWO_BYTE_MAX_UINT : num_files_in_archive)
     # total number of entries in
     # 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_UINT2)
-      io << [TWO_BYTE_MAX_UINT].pack(C_UINT2)
-    else
-      io << [num_files_in_archive].pack(C_UINT2)
-      io << [num_files_in_archive].pack(C_UINT2)
-    end
-
+    buf.uint2(zip64_required ? TWO_BYTE_MAX_UINT : num_files_in_archive)
     # size of the central directory    4 bytes
+    buf.uint4(zip64_required ? FOUR_BYTE_MAX_UINT : central_directory_size)
     # offset of start of central
     # directory with respect to
     # the starting disk number        4 bytes
-    if zip64_required
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
-    else
-      io << [central_directory_size].pack(C_UINT4)
-      io << [start_of_central_directory_location].pack(C_UINT4)
-    end
+    buf.uint4(zip64_required ? FOUR_BYTE_MAX_UINT : start_of_central_directory_location)
     # .ZIP file comment length        2 bytes
-    io << [comment.bytesize].pack(C_UINT2)
+    buf.uint2(comment.bytesize)
     # .ZIP file comment       (variable size)
-    io << comment
+    buf.bytes(comment)
+    io << buf.b
   end
 
   private
@@ -400,17 +404,16 @@ class ZipKit::ZipWriter
   # @param uncompressed_size[Integer]  The size of the file once extracted
   # @return [String]
   def zip_64_extra_for_local_file_header(compressed_size:, uncompressed_size:)
-    data_and_packspecs = [
-      # 2 bytes    Tag for this "extra" block type
-      0x0001, C_UINT2,
-      # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
-      16, C_UINT2,
-      # 8 bytes    Original uncompressed file size
-      uncompressed_size, C_UINT8,
-      # 8 bytes    Size of compressed data
-      compressed_size, C_UINT8
-    ]
-    pack_array(data_and_packspecs)
+    buf = PackBuffer.new
+    # 2 bytes    Tag for this "extra" block type
+    buf.uint2(0x0001)
+    # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
+    buf.uint2(16)
+    # 8 bytes    Original uncompressed file size
+    buf.uint8(uncompressed_size)
+    # 8 bytes    Size of compressed data
+    buf.uint8(compressed_size)
+    buf.b
   end
 
   # Writes the extended timestamp information field for local headers.
@@ -449,18 +452,19 @@ class ZipKit::ZipWriter
     #       bit 2           if set, creation time is present
     #       bits 3-7        reserved for additional timestamps; not set
     flags = 0b00000001 # Set the lowest bit only, to indicate that only mtime is present
-    data_and_packspecs = [
-      # tag for this extra block type ("UT")
-      0x5455, C_UINT2,
-      # the size of this block (1 byte used for the Flag + 3 longs used for the timestamp)
-      (1 + 4), C_UINT2,
-      # encode a single byte
-      flags, C_CHAR,
-      # Use a signed int, not the unsigned one used by the rest of the ZIP spec.
-      mtime.utc.to_i, C_INT4
-    ]
     # The atime and ctime can be omitted if not present
-    pack_array(data_and_packspecs)
+    buf = PackBuffer.new
+    # tag for this extra block type ("UT")
+    buf.uint2(0x5455)
+    # the size of this block (1 byte used for the Flag + 3 longs used for the timestamp)
+    buf.uint2((1 + 4))
+    # encode a single byte
+    buf.uint1(flags)
+    # Use a signed int, not the unsigned one used by the rest of the ZIP spec.
+    # Time#utc would convert the given Time to UTC in-place, and the DOS time fields
+    # computed from it afterwards would then be in UTC instead of local time
+    buf.int4(mtime.to_i)
+    buf.b
   end
 
   # Since we do not supply atime or ctime, the contents of the two extra fields (central dir and local header)
@@ -475,21 +479,20 @@ class ZipKit::ZipWriter
   # @param local_file_header_location[Integer] Byte offset of the start of the local file header from the beginning of the ZIP archive
   # @return [String]
   def zip_64_extra_for_central_directory_file_header(compressed_size:, uncompressed_size:, local_file_header_location:)
-    data_and_packspecs = [
-      # 2 bytes    Tag for this "extra" block type
-      0x0001, C_UINT2,
-      # 2 bytes    Size of this "extra" block. For us it will always be 28
-      28, C_UINT2,
-      # 8 bytes    Original uncompressed file size
-      uncompressed_size, C_UINT8,
-      # 8 bytes    Size of compressed data
-      compressed_size, C_UINT8,
-      # 8 bytes    Offset of local header record
-      local_file_header_location, C_UINT8,
-      # 4 bytes    Number of the disk on which this file starts
-      0, C_UINT4
-    ]
-    pack_array(data_and_packspecs)
+    buf = PackBuffer.new
+    # 2 bytes    Tag for this "extra" block type
+    buf.uint2(0x0001)
+    # 2 bytes    Size of this "extra" block. For us it will always be 28
+    buf.uint2(28)
+    # 8 bytes    Original uncompressed file size
+    buf.uint8(uncompressed_size)
+    # 8 bytes    Size of compressed data
+    buf.uint8(compressed_size)
+    # 8 bytes    Offset of local header record
+    buf.uint8(local_file_header_location)
+    # 4 bytes    Number of the disk on which this file starts
+    buf.uint4(0)
+    buf.b
   end
 
   def to_binary_dos_time(t)
@@ -500,22 +503,6 @@ class ZipKit::ZipWriter
     t.day + (t.month << 5) + ((t.year - 1980) << 9)
   end
 
-  # Unzips a given array of tuples of "numeric value, pack specifier" and then packs all the odd
-  # values using specifiers from all the even values. It is harder to explain than to show:
-  #
-  #   pack_array([1, 'V', 2, 'v', 148, 'v]) #=> "\x01\x00\x00\x00\x02\x00\x94\x00"
-  #
-  # will do the following two transforms:
-  #
-  #  [1, 'V', 2, 'v', 148, 'v] -> [1,2,148], ['V','v','v'] -> [1,2,148].pack('Vvv') -> "\x01\x00\x00\x00\x02\x00\x94\x00".
-  # This might seem like a "clever optimisation" but the issue is that `pack` needs an array allocated per call, and
-  # we output very verbosely - value-by-value. This might be quite a few array allocs. Using something like this
-  # helps us save the array allocs
-  def pack_array(values_to_packspecs)
-    values, packspecs = values_to_packspecs.partition.each_with_index { |_, i| i.even? }
-    values.pack(packspecs.join)
-  end
-
   def generate_external_attrs(unix_permissions_int, file_type_int)
     (file_type_int << 12 | (unix_permissions_int & 0o7777)) << 16
   end