zip_tricks 4.5.2 → 4.6.0

data/lib/zip_tricks/streamer.rb

@@ -162,14 +162,17 @@ class ZipTricks::Streamer
   # Streamer, because otherwise it is impossible to know it's size upfront.
   #
   # @param filename [String] the name of the file in the entry
+  # @param modification_time [Time] the modification time of the file in the archive
   # @param compressed_size [Integer] the size of the compressed entry that
   #                                   is going to be written into the archive
   # @param uncompressed_size [Integer] the size of the entry when uncompressed, in bytes
   # @param crc32 [Integer] the CRC32 checksum of the entry when uncompressed
   # @param use_data_descriptor [Boolean] whether the entry body will be followed by a data descriptor
   # @return [Integer] the offset the output IO is at after writing the entry header
-  def add_deflated_entry(filename:, compressed_size: 0, uncompressed_size: 0, crc32: 0, use_data_descriptor: false)
-    add_file_and_write_local_header(filename: filename, crc32: crc32,
+  def add_deflated_entry(filename:, modification_time: Time.now.utc, compressed_size: 0, uncompressed_size: 0, crc32: 0, use_data_descriptor: false)
+    add_file_and_write_local_header(filename: filename,
+                                    modification_time: modification_time,
+                                    crc32: crc32,
                                     storage_mode: DEFLATED,
                                     compressed_size: compressed_size,
                                     uncompressed_size: uncompressed_size,
@@ -186,12 +189,14 @@ class ZipTricks::Streamer
   # times to write the actual contents of the body.
   #
   # @param filename [String] the name of the file in the entry
+  # @param modification_time [Time] the modification time of the file in the archive
   # @param size [Integer] the size of the file when uncompressed, in bytes
   # @param crc32 [Integer] the CRC32 checksum of the entry when uncompressed
   # @param use_data_descriptor [Boolean] whether the entry body will be followed by a data descriptor. When in use
   # @return [Integer] the offset the output IO is at after writing the entry header
-  def add_stored_entry(filename:, size: 0, crc32: 0, use_data_descriptor: false)
+  def add_stored_entry(filename:, modification_time: Time.now.utc,  size: 0, crc32: 0, use_data_descriptor: false)
     add_file_and_write_local_header(filename: filename,
+                                    modification_time: modification_time,
                                     crc32: crc32,
                                     storage_mode: STORED,
                                     compressed_size: size,
@@ -203,9 +208,11 @@ class ZipTricks::Streamer
   # Adds an empty directory to the archive with a size of 0 and permissions of 755.
   #
   # @param dirname [String] the name of the directory in the archive
+  # @param modification_time [Time] the modification time of the directory in the archive
   # @return [Integer] the offset the output IO is at after writing the entry header
-  def add_empty_directory(dirname:)
+  def add_empty_directory(dirname:, modification_time: Time.now.utc)
     add_file_and_write_local_header(filename: dirname.to_s + '/',
+                                    modification_time: modification_time,
                                     crc32: 0,
                                     storage_mode: STORED,
                                     compressed_size: 0,
@@ -246,10 +253,12 @@ class ZipTricks::Streamer
   # and attention is recommended.
   #
   # @param filename[String] the name of the file in the archive
+  # @param modification_time [Time] the modification time of the file in the archive
   # @yield [#<<, #write] an object that the file contents must be written to that will be automatically closed
   # @return [#<<, #write, #close] an object that the file contents must be written to, has to be closed manually
-  def write_stored_file(filename)
+  def write_stored_file(filename, modification_time: Time.now.utc)
     add_stored_entry(filename: filename,
+                     modification_time: modification_time,
                      use_data_descriptor: true,
                      crc32: 0,
                      size: 0)
@@ -296,9 +305,11 @@ class ZipTricks::Streamer
   # and attention is recommended.
   #
   # @param filename[String] the name of the file in the archive
+  # @param modification_time [Time] the modification time of the file in the archive
   # @yield [#<<, #write] an object that the file contents must be written to
-  def write_deflated_file(filename)
+  def write_deflated_file(filename, modification_time: Time.now.utc)
     add_deflated_entry(filename: filename,
+                       modification_time: modification_time,
                        use_data_descriptor: true,
                        crc32: 0,
                        compressed_size: 0,
@@ -388,20 +399,20 @@ class ZipTricks::Streamer
 
   private
 
-  def add_file_and_write_local_header(filename:,
-                                      crc32:,
-                                      storage_mode:,
-                                      compressed_size:,
-                                      uncompressed_size:,
-                                      use_data_descriptor:)
+  def add_file_and_write_local_header(
+filename:,
+modification_time:,
+crc32:,
+storage_mode:,
+compressed_size:,
+uncompressed_size:,
+use_data_descriptor:)
 
     # Clean backslashes and uniqify filenames if there are duplicates
     filename = remove_backslash(filename)
     filename = uniquify_name(filename) if @filenames_set.include?(filename)
 
-    unless [STORED, DEFLATED].include?(storage_mode)
-      raise UnknownMode, "Unknown compression mode #{storage_mode}"
-    end
+    raise UnknownMode, "Unknown compression mode #{storage_mode}" unless [STORED, DEFLATED].include?(storage_mode)
 
     raise Overflow, 'Filename is too long' if filename.bytesize > 0xFFFF
 
@@ -416,11 +427,13 @@ class ZipTricks::Streamer
                   compressed_size,
                   uncompressed_size,
                   storage_mode,
-                  mtime = Time.now.utc,
+                  modification_time,
                   use_data_descriptor)
+
     @files << e
     @filenames_set << e.filename
     @local_header_offsets << @out.tell
+
     @writer.write_local_file_header(io: @out,
                                     gp_flags: e.gp_flags,
                                     crc32: e.crc32,

data/lib/zip_tricks/streamer/deflated_writer.rb

@@ -1,39 +1,62 @@
 # frozen_string_literal: true
 
+# Sends writes to the given `io` compressed using a {Zlib::Deflate}. Also
+# registers data passing through it in a CRC32 checksum calculator. Is made to be completely
+# interchangeable with the StoredWriter in terms of interface.
 class ZipTricks::Streamer::DeflatedWriter
   # After how many bytes of incoming data the deflater for the
   # contents must be flushed. This is done to prevent unreasonable
-  # memory use when archiving large files.
+  # memory use when archiving large files, and to ensure we write to
+  # the socket often enough while still maintaining acceptable
+  # compression
   FLUSH_EVERY_N_BYTES = 1024 * 1024 * 5
 
+  # The amount of bytes we will buffer before computing the intermediate
+  # CRC32 checksums. Benchmarks show that the optimum is 64KB (see
+  # `bench/buffered_crc32_bench.rb), if that is exceeded Zlib is going
+  # to perform internal CRC combine calls which will make the speed go down again.
+  CRC32_BUFFER_SIZE = 64 * 1024
+
   def initialize(io)
-    @io = io
+    @compressed_io = ZipTricks::WriteAndTell.new(io)
     @uncompressed_size = 0
-    @started_at = @io.tell
-    @crc = ZipTricks::StreamCRC32.new
     @deflater = ::Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -::Zlib::MAX_WBITS)
+    @crc = ZipTricks::WriteBuffer.new(ZipTricks::StreamCRC32.new, CRC32_BUFFER_SIZE)
     @bytes_since_last_flush = 0
   end
 
-  def finish
-    @io << @deflater.finish until @deflater.finished?
-    {crc32: @crc.to_i, compressed_size: @io.tell - @started_at, uncompressed_size: @uncompressed_size}
-  end
-
+  # Writes the given data into the deflater, and flushes the deflater
+  # after having written more than FLUSH_EVERY_N_BYTES bytes of data
+  #
+  # @param data[String] data to be written
+  # @return self
   def <<(data)
     @uncompressed_size += data.bytesize
     @bytes_since_last_flush += data.bytesize
-    @io << @deflater.deflate(data)
+    @compressed_io << @deflater.deflate(data)
     @crc << data
+
     interim_flush
+
     self
   end
 
+  # Returns the amount of data received for writing, the amount of
+  # compressed data written and the CRC32 checksum. The return value
+  # can be directly used as the argument to {Streamer#update_last_entry_and_write_data_descriptor}
+  #
+  # @param data[String] data to be written
+  # @return [Hash] a hash of `{crc32, compressed_size, uncompressed_size}`
+  def finish
+    @compressed_io << @deflater.finish until @deflater.finished?
+    {crc32: @crc.to_i, compressed_size: @compressed_io.tell, uncompressed_size: @uncompressed_size}
+  end
+
   private
 
   def interim_flush
     return if @bytes_since_last_flush < FLUSH_EVERY_N_BYTES
-    @io << @deflater.flush
+    @compressed_io << @deflater.flush
     @bytes_since_last_flush = 0
   end
 end

data/lib/zip_tricks/streamer/entry.rb

@@ -8,7 +8,6 @@ class ZipTricks::Streamer::Entry < Struct.new(:filename, :crc32, :compressed_siz
   def initialize(*)
     super
     filename.force_encoding(Encoding::UTF_8)
-    # Rubocop: convention: Avoid using rescue in its modifier form.
     @requires_efs_flag = !(begin
                              filename.encode(Encoding::ASCII)
                            rescue

data/lib/zip_tricks/streamer/stored_writer.rb

@@ -1,23 +1,36 @@
 # frozen_string_literal: true
 
-# Rubocop: convention: Missing top-level class documentation comment.
+# Sends writes to the given `io`, and also registers all the data passing
+# through it in a CRC32 checksum calculator. Is made to be completely
+# interchangeable with the DeflatedWriter in terms of interface.
 class ZipTricks::Streamer::StoredWriter
+  # The amount of bytes we will buffer before computing the intermediate
+  # CRC32 checksums. Benchmarks show that the optimum is 64KB (see
+  # `bench/buffered_crc32_bench.rb), if that is exceeded Zlib is going
+  # to perform internal CRC combine calls which will make the speed go down again.
+  CRC32_BUFFER_SIZE = 64 * 1024
+
   def initialize(io)
-    @io = io
-    @uncompressed_size = 0
-    @compressed_size = 0
-    @started_at = @io.tell
-    @crc = ZipTricks::StreamCRC32.new
+    @io = ZipTricks::WriteAndTell.new(io)
+    @crc = ZipTricks::WriteBuffer.new(ZipTricks::StreamCRC32.new, CRC32_BUFFER_SIZE)
   end
 
+  # Writes the given data to the contained IO object.
+  #
+  # @param data[String] data to be written
+  # @return self
   def <<(data)
     @io << data
     @crc << data
     self
   end
 
+  # Returns the amount of data written and the CRC32 checksum. The return value
+  # can be directly used as the argument to {Streamer#update_last_entry_and_write_data_descriptor}
+  #
+  # @param data[String] data to be written
+  # @return [Hash] a hash of `{crc32, compressed_size, uncompressed_size}`
   def finish
-    size = @io.tell - @started_at
-    {crc32: @crc.to_i, compressed_size: size, uncompressed_size: size}
+    {crc32: @crc.to_i, compressed_size: @io.tell, uncompressed_size: @io.tell}
   end
 end

data/lib/zip_tricks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZipTricks
-  VERSION = '4.5.2'
+  VERSION = '4.6.0'
 end

data/lib/zip_tricks/write_buffer.rb

@@ -0,0 +1,49 @@
+# Some operations (such as CRC32) benefit when they are performed
+# on larger chunks of data. In certain use cases, it is possible that
+# the consumer of ZipTricks is going to be writing small chunks
+# in rapid succession, so CRC32 is going to have to perform a lot of
+# CRC32 combine operations - and this adds up. Since the CRC32 value
+# is usually not needed until the complete output has completed
+# we can buffer at least some amount of data before computing CRC32 over it.
+class ZipTricks::WriteBuffer
+  # Creates a new WriteBuffer bypassing into a given writable object
+  #
+  # @param writable[#<<] An object that responds to `#<<` with string as argument
+  # @param buffer_size[Integer] How many bytes to buffer
+  def initialize(writable, buffer_size)
+    @buf = StringIO.new
+    @buffer_size = buffer_size
+    @writable = writable
+  end
+
+  # Appends the given data to the write buffer, and flushes the buffer into the
+  # writable if the buffer size exceeds the `buffer_size` given at initialization
+  #
+  # @param data[String] data to be written
+  # @return self
+  def <<(data)
+    @buf << data
+    flush! if @buf.size > @buffer_size
+    self
+  end
+
+  # Explicitly flushes the buffer if it contains anything
+  #
+  # @return self
+  def flush!
+    @writable << @buf.string if @buf.size > 0
+    @buf.truncate(0)
+    @buf.rewind
+    self
+  end
+
+  # Flushes the buffer and returns the result of `#to_i` of the contained `writable`.
+  # Primarily facilitates working with StreamCRC32 objects where you finish the
+  # computation by retrieving the CRC as an integer
+  #
+  # @return [Integer] the return value of `writable#to_i`
+  def to_i
+    flush!
+    @writable.to_i
+  end
+end

data/lib/zip_tricks/zip_writer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Layout/CommentIndentation, Metrics/LineLength, Metrics/AbcSize, Style/RedundantParentheses, Metrics/PerceivedComplexity, Layout/MultilineOperationIndentation, Layout/AlignParameters, Style/ConditionalAssignment, Layout/ExtraSpacing, Metrics/CyclomaticComplexity, Lint/UselessAssignment, Metrics/ParameterLists, Layout/LeadingCommentSpace, Naming/ConstantName
-#
 # 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.
 #
@@ -29,7 +27,7 @@
 class ZipTricks::ZipWriter
   FOUR_BYTE_MAX_UINT = 0xFFFFFFFF
   TWO_BYTE_MAX_UINT = 0xFFFF
-  ZIP_TRICKS_COMMENT = 'Written using ZipTricks %s' % ZipTricks::VERSION
+  ZIP_TRICKS_COMMENT = 'Written using ZipTricks %<version>s' % {version: ZipTricks::VERSION}
   VERSION_MADE_BY                        = 52
   VERSION_NEEDED_TO_EXTRACT              = 20
   VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
@@ -41,13 +39,13 @@ class ZipTricks::ZipWriter
     # We snatch the incantations from Rubyzip for this.
     unix_perms = 0o644
     file_type_file = 0o10
-    external_attrs = (file_type_file << 12 | (unix_perms & 0o7777)) << 16
+    (file_type_file << 12 | (unix_perms & 0o7777)) << 16
   end
   EMPTY_DIRECTORY_EXTERNAL_ATTRS = begin
     # Applies permissions to an empty directory.
     unix_perms = 0o755
     file_type_dir = 0o04
-    external_attrs = (file_type_dir << 12 | (unix_perms & 0o7777)) << 16
+    (file_type_dir << 12 | (unix_perms & 0o7777)) << 16
   end
   MADE_BY_SIGNATURE = begin
     # A combination of the VERSION_MADE_BY low byte and the OS type high byte
@@ -55,16 +53,23 @@ class ZipTricks::ZipWriter
     [VERSION_MADE_BY, os_type].pack('CC')
   end
 
-  C_V = 'V'    # Encode a 4-byte unsigned little-endian uint
-  C_v = 'v'    # Encode a 2-byte unsigned little-endian uint
-  C_Qe = 'Q<'  # Encode an 8-byte unsigned little-endian uint
-  C_C = 'C' # For bit-encoded strings
-  C_N = 'N' # Encode a 4-byte signed little-endian int
-
-  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
+  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 = 'N' # Encode a 4-byte signed little-endian int
+
+  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_UINT4,
+                   :C_UINT2,
+                   :C_UINT8,
+                   :ZIP_TRICKS_COMMENT
 
   # Writes the local file header, that precedes the actual file _data_.
   #
@@ -80,29 +85,29 @@ class ZipTricks::ZipWriter
   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)
+    io << [0x04034b50].pack(C_UINT4)                        # local file header signature     4 bytes  (0x04034b50)
+    io << if requires_zip64                                 # version needed to extract       2 bytes
+      [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2)
     else
-      io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)
+      [VERSION_NEEDED_TO_EXTRACT].pack(C_UINT2)
     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
+    io << [gp_flags].pack(C_UINT2)                          # general purpose bit flag        2 bytes
+    io << [storage_mode].pack(C_UINT2)                      # compression method              2 bytes
+    io << [to_binary_dos_time(mtime)].pack(C_UINT2)         # last mod file time              2 bytes
+    io << [to_binary_dos_date(mtime)].pack(C_UINT2)         # last mod file date              2 bytes
+    io << [crc32].pack(C_UINT4)                             # 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
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)              # compressed size              4 bytes
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)              # 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
+      io << [compressed_size].pack(C_UINT4)                 # compressed size              4 bytes
+      io << [uncompressed_size].pack(C_UINT4)               # 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
+    io << [filename.bytesize].pack(C_UINT2)                 # file name length             2 bytes
 
     extra_fields = StringIO.new
 
@@ -115,7 +120,7 @@ class ZipTricks::ZipWriter
     end
     extra_fields << timestamp_extra(mtime)
 
-    io << [extra_fields.size].pack(C_v)                # extra field length              2 bytes
+    io << [extra_fields.size].pack(C_UINT2)                # extra field length              2 bytes
 
     io << filename                                     # file name (variable size)
     io << extra_fields.string
@@ -144,32 +149,32 @@ class ZipTricks::ZipWriter
     # 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)
+                (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 << [0x02014b50].pack(C_UINT4)                        # 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
+    io << if add_zip64
+      [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2) # version needed to extract       2 bytes
     else
-      io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)       # version needed to extract       2 bytes
+      [VERSION_NEEDED_TO_EXTRACT].pack(C_UINT2)       # 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
+    io << [gp_flags].pack(C_UINT2)                          # general purpose bit flag        2 bytes
+    io << [storage_mode].pack(C_UINT2)                      # compression method              2 bytes
+    io << [to_binary_dos_time(mtime)].pack(C_UINT2)         # last mod file time              2 bytes
+    io << [to_binary_dos_date(mtime)].pack(C_UINT2)         # last mod file date              2 bytes
+    io << [crc32].pack(C_UINT4)                             # 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
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)              # compressed size              4 bytes
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)              # 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
+      io << [compressed_size].pack(C_UINT4)                 # compressed size              4 bytes
+      io << [uncompressed_size].pack(C_UINT4)               # 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
+    io << [filename.bytesize].pack(C_UINT2)                 # file name length                2 bytes
 
     extra_fields = StringIO.new
     if add_zip64
@@ -179,36 +184,37 @@ class ZipTricks::ZipWriter
     end
     extra_fields << timestamp_extra(mtime)
 
-    io << [extra_fields.size].pack(C_v)                 # extra field length              2 bytes
+    io << [extra_fields.size].pack(C_UINT2)                 # extra field length              2 bytes
 
-    io << [0].pack(C_v)                                 # file comment length             2 bytes
+    io << [0].pack(C_UINT2)                                 # 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)
+    io << if add_zip64                                        # disk number start               2 bytes
+      [TWO_BYTE_MAX_UINT].pack(C_UINT2)
     else
-      io << [0].pack(C_v)
-    end
-    io << [0].pack(C_v)                                # internal file attributes        2 bytes
+      [0].pack(C_UINT2)
+          end
+    io << [0].pack(C_UINT2)                                # internal file attributes        2 bytes
 
     # 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.
-    if filename.end_with?('/')
-      io << [EMPTY_DIRECTORY_EXTERNAL_ATTRS].pack(C_V)
+    io << if filename.end_with?('/')
+      [EMPTY_DIRECTORY_EXTERNAL_ATTRS].pack(C_UINT4)
     else
-      io << [DEFAULT_EXTERNAL_ATTRS].pack(C_V)           # external file attributes        4 bytes
+      [DEFAULT_EXTERNAL_ATTRS].pack(C_UINT4)           # external file attributes        4 bytes
     end
 
-    if add_zip64                                       # relative offset of local header 4 bytes
-      io << [FOUR_BYTE_MAX_UINT].pack(C_V)
+    io << if add_zip64                                 # relative offset of local header 4 bytes
+      [FOUR_BYTE_MAX_UINT].pack(C_UINT4)
     else
-      io << [local_file_header_location].pack(C_V)
+      [local_file_header_location].pack(C_UINT4)
     end
+
     io << filename                                     # file name (variable size)
     io << extra_fields.string                          # extra field (variable size)
-    #(empty)                                           # file comment (variable size)
+    # (empty)                                          # file comment (variable size)
   end
 
   # Writes the data descriptor following the file data for a file whose local file header
@@ -221,16 +227,16 @@ class ZipTricks::ZipWriter
   # @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
+    io << [0x08074b50].pack(C_UINT4)  # 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_UINT4)                             # 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
+    pack_spec = requires_zip64 ? C_UINT8 : C_UINT4
 
     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
@@ -248,77 +254,77 @@ class ZipTricks::ZipWriter
     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
+                     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.
+      # zip64 end of central dir
+      io << [0x06064b50].pack(C_UINT4)                           # signature                       4 bytes  (0x06064b50)
+      io << [44].pack(C_UINT8)                                  # 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
+      io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_UINT2)      # version needed to extract       2 bytes
+      io << [0].pack(C_UINT4)                                    # number of this disk             4 bytes
+      io << [0].pack(C_UINT4)                                    # number of the disk with the
+      # start of the central directory  4 bytes
+      io << [num_files_in_archive].pack(C_UINT8)                # total number of entries in the
+      # central directory on this disk  8 bytes
+      io << [num_files_in_archive].pack(C_UINT8)                # total number of entries in the
+      # central directory               8 bytes
+      io << [central_directory_size].pack(C_UINT8)              # size of the central directory   8 bytes
+      # offset of start of central
+      # directory with respect to
+      io << [start_of_central_directory_location].pack(C_UINT8) # 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
+      io << [0x07064b50].pack(C_UINT4)                           # zip64 end of central dir locator
+      # signature                       4 bytes  (0x07064b50)
+      io << [0].pack(C_UINT4)                                    # number of the disk with the
+      # start of the zip64 end of
+      # central directory               4 bytes
+      io << [zip64_eocdr_offset].pack(C_UINT8)                  # 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_UINT4)                                    # 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
+    io << [0x06054b50].pack(C_UINT4)                            # end of central dir signature     4 bytes  (0x06054b50)
+    io << [0].pack(C_UINT2)                                     # number of this disk              2 bytes
+    io << [0].pack(C_UINT2)                                     # 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
+      io << [TWO_BYTE_MAX_UINT].pack(C_UINT2)                   # total number of entries in the
+      # central directory on this disk   2 bytes
+      io << [TWO_BYTE_MAX_UINT].pack(C_UINT2)                   # 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
+      io << [num_files_in_archive].pack(C_UINT2)                # total number of entries in the
+      # central directory on this disk   2 bytes
+      io << [num_files_in_archive].pack(C_UINT2)                # 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
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)                  # size of the central directory    4 bytes
+      io << [FOUR_BYTE_MAX_UINT].pack(C_UINT4)                  # 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
+      io << [central_directory_size].pack(C_UINT4)              # size of the central directory    4 bytes
+      io << [start_of_central_directory_location].pack(C_UINT4) # offset of start of central
+      # directory with respect to
+      # the starting disk number        4 bytes
     end
-    io << [comment.bytesize].pack(C_v)                      # .ZIP file comment length        2 bytes
+    io << [comment.bytesize].pack(C_UINT2)                      # .ZIP file comment length        2 bytes
     io << comment                                           # .ZIP file comment       (variable size)
   end
 
@@ -331,10 +337,10 @@ class ZipTricks::ZipWriter
   # @return [String]
   def zip_64_extra_for_local_file_header(compressed_size:, uncompressed_size:)
     data_and_packspecs = [
-      0x0001, C_v,                       # 2 bytes    Tag for this "extra" block type
-      16, C_v,                           # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
-      uncompressed_size, C_Qe,           # 8 bytes    Original uncompressed file size
-      compressed_size, C_Qe,             # 8 bytes    Size of compressed data
+      0x0001, C_UINT2,                       # 2 bytes    Tag for this "extra" block type
+      16, C_UINT2,                           # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
+      uncompressed_size, C_UINT8,           # 8 bytes    Original uncompressed file size
+      compressed_size, C_UINT8,             # 8 bytes    Size of compressed data
     ]
     pack_array(data_and_packspecs)
   end
@@ -374,10 +380,10 @@ class ZipTricks::ZipWriter
     #       bits 3-7        reserved for additional timestamps; not set
     flags = 0b10000000 # Set bit 1 only to indicate only mtime is present
     data_and_packspecs = [
-      0x5455, C_v,  # tag for this extra block type ("UT")
-      (1 + 4), C_v, # the size of this block (1 byte used for the Flag + 1 long used for the timestamp)
-      flags, C_C,   # encode a single byte
-      mtime.utc.to_i, C_N, # Use a signed long, not the unsigned one used by the rest of the ZIP spec.
+      0x5455, C_UINT2,  # tag for this extra block type ("UT")
+      (1 + 4), C_UINT2, # the size of this block (1 byte used for the Flag + 1 long used for the timestamp)
+      flags, C_CHAR,   # encode a single byte
+      mtime.utc.to_i, C_INT4, # Use a signed long, not the unsigned one used by the rest of the ZIP spec.
     ]
     pack_array(data_and_packspecs)
   end
@@ -391,12 +397,12 @@ class ZipTricks::ZipWriter
   # @return [String]
   def zip_64_extra_for_central_directory_file_header(compressed_size:, uncompressed_size:, local_file_header_location:)
     data_and_packspecs = [
-      0x0001, C_v,                        # 2 bytes    Tag for this "extra" block type
-      28,     C_v,                        # 2 bytes    Size of this "extra" block. For us it will always be 28
-      uncompressed_size, C_Qe,            # 8 bytes    Original uncompressed file size
-      compressed_size,   C_Qe,            # 8 bytes    Size of compressed data
-      local_file_header_location, C_Qe,   # 8 bytes    Offset of local header record
-      0, C_V,                             # 4 bytes    Number of the disk on which this file starts
+      0x0001, C_UINT2,                        # 2 bytes    Tag for this "extra" block type
+      28,     C_UINT2,                        # 2 bytes    Size of this "extra" block. For us it will always be 28
+      uncompressed_size, C_UINT8,            # 8 bytes    Original uncompressed file size
+      compressed_size,   C_UINT8,            # 8 bytes    Size of compressed data
+      local_file_header_location, C_UINT8,   # 8 bytes    Offset of local header record
+      0, C_UINT4,                             # 4 bytes    Number of the disk on which this file starts
     ]
     pack_array(data_and_packspecs)
   end
@@ -406,7 +412,7 @@ class ZipTricks::ZipWriter
   end
 
   def to_binary_dos_date(t)
-    (t.day) + (t.month << 5) + ((t.year - 1980) << 9)
+    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