zip_tricks 4.5.2 → 4.6.0

data/examples/rack_application.rb

@@ -53,7 +53,7 @@ class ZipDownload
 
     # Add a Content-Disposition so that the download has a .zip extension
     # (this will not work well with UTF-8 filenames on Windows, but hey!)
-    content_disposition = format('attachment; filename=%s.zip', filename)
+    content_disposition = 'attachment; filename=%<filename>s.zip' % {filename: filename}
 
     # and return the response, adding the Content-Length we have computed earlier
     [

data/lib/zip_tricks/file_reader.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Naming/ConstantName
-
 require 'stringio'
 
 # A very barebones ZIP file reader. Is made for maximum interoperability, but at the same
@@ -146,8 +144,8 @@ class ZipTricks::FileReader
       when 0
         StoredReader.new(from_io, compressed_size)
       else
-        raise UnsupportedFeature, format('Unsupported storage mode for reading - %d',
-                                         storage_mode)
+        raise UnsupportedFeature, 'Unsupported storage mode for reading - %<storage_mode>d' %
+                                  {storage_mode: storage_mode}
       end
     end
 
@@ -208,7 +206,10 @@ class ZipTricks::FileReader
         num_files_and_central_directory_offset(io, eocd_offset)
       end
 
-    log { format('Located the central directory start at %d', cdir_location) }
+    log do
+      'Located the central directory start at %<location>d' %
+        {location: cdir_location}
+    end
     seek(io, cdir_location)
 
     # Read the entire central directory AND anything behind it, in one fell swoop.
@@ -227,15 +228,15 @@ class ZipTricks::FileReader
     central_directory_str = io.read # and not read_n(io, cdir_size), see above
     central_directory_io = StringIO.new(central_directory_str)
     log do
-      format('Read %d bytes with central directory + EOCD record and locator',
-             central_directory_str.bytesize)
+      'Read %<byte_size>d bytes with central directory + EOCD record and locator' %
+        {byte_size: central_directory_str.bytesize}
     end
 
     entries = (0...num_files).map do |entry_n|
       offset_location = cdir_location + central_directory_io.tell
       log do
-        format('Reading the central directory entry %d starting at offset %d',
-               entry_n, offset_location)
+        'Reading the central directory entry %<entry_n>d starting at offset %<offset>d' %
+          {entry_n: entry_n, offset: offset_location}
       end
       read_cdir_entry(central_directory_io)
     end
@@ -272,16 +273,16 @@ class ZipTricks::FileReader
       entries << entry
       next_local_header_offset = entry.compressed_data_offset + entry.compressed_size
       log do
-        format('Recovered a local file file header at offset %d, seeking to the next at %d',
-               cur_offset, next_local_header_offset)
+        'Recovered a local file file header at offset %<cur_offset>d, seeking to the next at %<header_offset>d' %
+          {cur_offset: cur_offset, header_offset: next_local_header_offset}
       end
       seek(io, next_local_header_offset) # Seek to the next entry, and raise if seek is impossible
     end
     entries
   rescue ReadError
     log do
-      format('Got a read/seek error after reaching %d, no more entries can be recovered',
-             cur_offset)
+      'Got a read/seek error after reaching %<cur_offset>d, no more entries can be recovered' %
+        {cur_offset: cur_offset}
     end
     entries
   end
@@ -332,8 +333,8 @@ class ZipTricks::FileReader
       # the values fetched from the conventional header
       zip64_extra = StringIO.new(zip64_extra_contents)
       log do
-        format('Will read Zip64 extra data from local header field for %s, %d bytes',
-               e.filename, zip64_extra.size)
+        'Will read Zip64 extra data from local header field for %<filename>s, %<size>d bytes' %
+          {filename: e.filename, size: zip64_extra.size}
       end
       # Now here be dragons. The APPNOTE specifies that
       #
@@ -396,8 +397,8 @@ class ZipTricks::FileReader
   def read_local_headers(entries, io)
     entries.each_with_index do |entry, i|
       log do
-        format('Reading the local header for entry %d at offset %d',
-               i, entry.local_file_header_offset)
+        'Reading the local header for entry %<index>d at offset %<offset>d' %
+          {index: i, offset: entry.local_file_header_offset}
       end
       off = get_compressed_data_offset(io: io,
                                        local_file_header_offset: entry.local_file_header_offset)
@@ -429,7 +430,6 @@ class ZipTricks::FileReader
 
   def assert_signature(io, signature_magic_number)
     readback = read_4b(io)
-    # Rubocop: Use a guard clause instead of wrapping the code inside a conditional expression
     if readback != signature_magic_number
       expected = '0x0' + signature_magic_number.to_s(16)
       actual = '0x0' + readback.to_s(16)
@@ -460,24 +460,21 @@ class ZipTricks::FileReader
   end
 
   def read_2b(io)
-    read_n(io, 2).unpack(C_v).shift
+    read_n(io, 2).unpack(C_UINT2).shift
   end
 
   def read_4b(io)
-    read_n(io, 4).unpack(C_V).shift
+    read_n(io, 4).unpack(C_UINT4).shift
   end
 
   def read_8b(io)
-    read_n(io, 8).unpack(C_Qe).shift
+    read_n(io, 8).unpack(C_UINT8).shift
   end
 
   def read_cdir_entry(io)
-    # Rubocop:  convention: Assignment Branch Condition size for
     # read_cdir_entry is too high. [45.66/15]
-    # Rubocop: convention: Method has too many lines. [30/10]
     assert_signature(io, 0x02014b50)
     ZipEntry.new.tap do |e|
-      # Rubocop: convention: Block has too many lines. [27/25]
       e.made_by = read_2b(io)
       e.version_needed_to_extract = read_2b(io)
       e.gp_flags = read_2b(io)
@@ -510,8 +507,8 @@ class ZipTricks::FileReader
         # the values fetched from the conventional header
         zip64_extra = StringIO.new(zip64_extra_contents)
         log do
-          format('Will read Zip64 extra data for %s, %d bytes',
-                 e.filename, zip64_extra.size)
+          'Will read Zip64 extra data for %<filename>s, %<size>d bytes' %
+            {filename: e.filename, size: zip64_extra.size}
         end
         # Now here be dragons. The APPNOTE specifies that
         #
@@ -522,16 +519,9 @@ class ZipTricks::FileReader
         #
         # It means that before we read this stuff we need to check if the previously-read
         # values are at overflow, and only _then_ proceed to read them. Bah.
-        # Rubocop: convention: Line is too long.
-        if e.uncompressed_size == 0xFFFFFFFF
-          e.uncompressed_size = read_8b(zip64_extra)
-        end
-        if e.compressed_size == 0xFFFFFFFF
-          e.compressed_size = read_8b(zip64_extra)
-        end
-        if e.local_file_header_offset == 0xFFFFFFFF
-          e.local_file_header_offset = read_8b(zip64_extra)
-        end
+        e.uncompressed_size = read_8b(zip64_extra) if e.uncompressed_size == 0xFFFFFFFF
+        e.compressed_size = read_8b(zip64_extra) if e.compressed_size == 0xFFFFFFFF
+        e.local_file_header_offset = read_8b(zip64_extra) if e.local_file_header_offset == 0xFFFFFFFF
         # Disk number comes last and we can skip it anyway, since we do
         # not support multi-disk archives
       end
@@ -553,54 +543,56 @@ class ZipTricks::FileReader
     raise MissingEOCD unless eocd_idx_in_buf
 
     eocd_offset = implied_position_of_eocd_record + eocd_idx_in_buf
-    log { format('Found EOCD signature at offset %d', eocd_offset) }
+    log do
+      'Found EOCD signature at offset %<offset>d' % {offset: eocd_offset}
+    end
 
     eocd_offset
   end
 
-  # This is tricky. Essentially, we have to scan the maximum possible number
-  # of bytes (that the EOCD can theoretically occupy including the comment),
+  def all_indices_of_substr_in_str(of_substring, in_string)
+    last_i = 0
+    found_at_indices = []
+    while last_i = in_string.index(of_substring, last_i)
+      found_at_indices << last_i
+      last_i += of_substring.bytesize
+    end
+    found_at_indices
+  end
+
+  # We have to scan the maximum possible number
+  # of bytes that the EOCD can theoretically occupy including the comment after it,
   # and we have to find a combination of:
-  #   [EOCD signature, <some ZIP medatata>, comment byte size, the comment of
-  # that size, eof].
-  # The only way I could find to do this was with a sliding window, but
-  # there probably is a better way.
-  # Rubocop:  convention: Assignment Branch Condition size for
-  # locate_eocd_signature is too high. [17.49/15]
-  # Rubocop:  convention: Method has too many lines. [14/10]
+  #   [EOCD signature, <some ZIP medatata>, comment byte size, comment of size]
+  # at the end. To do so, we first find all indices of the signature in the trailer
+  # string, and then check whether the bytestring starting at the signature and
+  # ending at the end of string satisfies that given pattern.
   def locate_eocd_signature(in_str)
-    # We have to scan from the _very_ tail. We read the very minimum size
-    # the EOCD record can have (up to and including the comment size), using
-    # a sliding window. Once our end offset matches the comment size we found our
-    # EOCD marker.
+    eocd_signature = 0x06054b50
+    eocd_signature_str = [eocd_signature].pack('V')
     unpack_pattern = 'VvvvvVVv'
     minimum_record_size = 22
-    end_location = minimum_record_size * -1
-    loop do
-      # If the window is nil, we have rolled off the start of the string, nothing to do here.
-      # We use negative values because if we used positive slice indices
-      # we would have to detect the rollover ourselves
-      break unless window = in_str[end_location, minimum_record_size]
-
-      window_location = in_str.bytesize + end_location
-      unpacked = window.unpack(unpack_pattern)
-      # If we found the signarue, pick up the comment size, and check if the size of the window
-      # plus that comment size is where we are in the string. If we are - bingo.
-      if unpacked[0] == 0x06054b50 && comment_size = unpacked[-1]
-        assumed_eocd_location = in_str.bytesize - comment_size - minimum_record_size
-        # if the comment size is where we should be at - we found our EOCD
-        return assumed_eocd_location if assumed_eocd_location == window_location
+    str_size = in_str.bytesize
+    indices = all_indices_of_substr_in_str(eocd_signature_str, in_str)
+    indices.each do |check_at|
+      maybe_record = in_str[check_at..str_size]
+      # If the record is smaller than the minimum - we will never recover anything
+      break if maybe_record.bytesize < minimum_record_size
+      # Now we check if the record ends with the combination
+      # of the comment size and an arbitrary byte string of that size.
+      # If it does - we found our match
+      *_unused, comment_size = maybe_record.unpack(unpack_pattern)
+      if (maybe_record.bytesize - minimum_record_size) == comment_size
+        return check_at # Found the EOCD marker location
       end
-
-      end_location -= 1 # Shift the window back, by one byte, and try again.
     end
+    # If we haven't caught anything, return nil deliberately instead of returning the last statement
+    nil
   end
 
   # Find the Zip64 EOCD locator segment offset. Do this by seeking backwards from the
   # EOCD record in the archive by fixed offsets
-  # Rubocop: convention: Assignment Branch Condition size for
   #          get_zip64_eocd_location is too high. [15.17/15]
-  # Rubocop: convention: Method has too many lines. [15/10]
   def get_zip64_eocd_location(file_io, eocd_offset)
     zip64_eocd_loc_offset = eocd_offset
     zip64_eocd_loc_offset -= 4 # The signature
@@ -609,8 +601,8 @@ class ZipTricks::FileReader
     zip64_eocd_loc_offset -= 4 # Total number of disks
 
     log do
-      format('Will look for the Zip64 EOCD locator signature at offset %d',
-             zip64_eocd_loc_offset)
+      'Will look for the Zip64 EOCD locator signature at offset %<offset>d' %
+        {offset: zip64_eocd_loc_offset}
     end
 
     # If the offset is negative there is certainly no Zip64 EOCD locator here
@@ -619,7 +611,9 @@ class ZipTricks::FileReader
     file_io.seek(zip64_eocd_loc_offset, IO::SEEK_SET)
     assert_signature(file_io, 0x07064b50)
 
-    log { format('Found Zip64 EOCD locator at offset %d', zip64_eocd_loc_offset) }
+    log do
+      'Found Zip64 EOCD locator at offset %<offset>d' % {offset: zip64_eocd_loc_offset}
+    end
 
     disk_num = read_4b(file_io) # number of the disk
     raise UnsupportedFeature, 'The archive spans multiple disks' if disk_num != 0
@@ -628,9 +622,7 @@ class ZipTricks::FileReader
     nil
   end
 
-  # Rubocop: convention: Assignment Branch Condition size for
   #          num_files_and_central_directory_offset_zip64 is too high. [21.12/15]
-  # Rubocop: convention: Method has too many lines. [17/10]
   def num_files_and_central_directory_offset_zip64(io, zip64_end_of_cdir_location)
     seek(io, zip64_end_of_cdir_location)
 
@@ -644,20 +636,16 @@ class ZipTricks::FileReader
 
     disk_n = read_4b(zip64_eocdr) # number of this disk
     disk_n_with_eocdr = read_4b(zip64_eocdr) # number of the disk with the EOCDR
-    if disk_n != disk_n_with_eocdr
-      raise UnsupportedFeature, 'The archive spans multiple disks'
-    end
+    raise UnsupportedFeature, 'The archive spans multiple disks' if disk_n != disk_n_with_eocdr
 
     num_files_this_disk = read_8b(zip64_eocdr) # number of files on this disk
     num_files_total     = read_8b(zip64_eocdr) # files total in the central directory
 
-    if num_files_this_disk != num_files_total
-      raise UnsupportedFeature, 'The archive spans multiple disks'
-    end
+    raise UnsupportedFeature, 'The archive spans multiple disks' if num_files_this_disk != num_files_total
 
     log do
-      format('Zip64 EOCD record states there are %d files in the archive',
-             num_files_total)
+      'Zip64 EOCD record states there are %<amount>d files in the archive' %
+        {amount: num_files_total}
     end
 
     central_dir_size    = read_8b(zip64_eocdr) # Size of the central directory
@@ -666,58 +654,48 @@ class ZipTricks::FileReader
     [num_files_total, central_dir_offset, central_dir_size]
   end
 
-  C_V = 'V'
-  C_v = 'v'
-  C_Qe = 'Q<'
+  C_UINT4 = 'V'
+  C_UINT2 = 'v'
+  C_UINT8 = 'Q<'
 
   # To prevent too many tiny reads, read the maximum possible size of end of
   # central directory record upfront (all the fixed fields + at most 0xFFFF
   # bytes of the archive comment)
-  MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE =
-    begin
-      4 + # Offset of the start of central directory
-      4 + # Size of the central directory
-      2 + # Number of files in the cdir
-      4 + # End-of-central-directory signature
-      2 + # Number of this disk
-      2 + # Number of disk with the start of cdir
-      2 + # Number of files in the cdir of this disk
-      2 + # The comment size
-      0xFFFF # Maximum comment size
-    end
+  MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = 4 + # Offset of the start of central directory
+                                             4 + # Size of the central directory
+                                             2 + # Number of files in the cdir
+                                             4 + # End-of-central-directory signature
+                                             2 + # Number of this disk
+                                             2 + # Number of disk with the start of cdir
+                                             2 + # Number of files in the cdir of this disk
+                                             2 + # The comment size
+                                             0xFFFF # Maximum comment size
 
   # To prevent too many tiny reads, read the maximum possible size of the local file header upfront.
   # The maximum size is all the usual items, plus the maximum size
   # of the filename (0xFFFF bytes) and the maximum size of the extras (0xFFFF bytes)
-  MAX_LOCAL_HEADER_SIZE =
-    begin
-      4 + # signature
-      2 + # Version needed to extract
-      2 + # gp flags
-      2 + # storage mode
-      2 + # dos time
-      2 + # dos date
-      4 + # CRC32
-      4 + # Comp size
-      4 + # Uncomp size
-      2 + # Filename size
-      2 + # Extra fields size
-      0xFFFF + # Maximum filename size
-      0xFFFF   # Maximum extra fields size
-    end
-
-  SIZE_OF_USABLE_EOCD_RECORD =
-    begin
-      4 + # Signature
-      2 + # Number of this disk
-      2 + # Number of the disk with the EOCD record
-      2 + # Number of entries in the central directory of this disk
-      2 + # Number of entries in the central directory total
-      4 + # Size of the central directory
-      4   # Start of the central directory offset
-    end
+  MAX_LOCAL_HEADER_SIZE = 4 + # signature
+                          2 + # Version needed to extract
+                          2 + # gp flags
+                          2 + # storage mode
+                          2 + # dos time
+                          2 + # dos date
+                          4 + # CRC32
+                          4 + # Comp size
+                          4 + # Uncomp size
+                          2 + # Filename size
+                          2 + # Extra fields size
+                          0xFFFF + # Maximum filename size
+                          0xFFFF   # Maximum extra fields size
+
+  SIZE_OF_USABLE_EOCD_RECORD = 4 + # Signature
+                               2 + # Number of this disk
+                               2 + # Number of the disk with the EOCD record
+                               2 + # Number of entries in the central directory of this disk
+                               2 + # Number of entries in the central directory total
+                               4 + # Size of the central directory
+                               4   # Start of the central directory offset
 
-  # Rubocop: convention: Method has too many lines. [11/10]
   def num_files_and_central_directory_offset(file_io, eocd_offset)
     seek(file_io, eocd_offset)
 
@@ -735,7 +713,7 @@ class ZipTricks::FileReader
     [num_files, cdir_offset, cdir_size]
   end
 
-  private_constant :C_V, :C_v, :C_Qe, :MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE,
+  private_constant :C_UINT4, :C_UINT2, :C_UINT8, :MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE,
                    :MAX_LOCAL_HEADER_SIZE, :SIZE_OF_USABLE_EOCD_RECORD
 
   # Is provided as a stub to be overridden in a subclass if you need it. Will report

data/lib/zip_tricks/remote_io.rb

@@ -38,13 +38,11 @@ class ZipTricks::RemoteIO
   #
   # @param n_bytes[Fixnum, nil] how many bytes to read, or `nil` to read all the way to the end
   # @return [String] the read bytes
-  # Rubocop: convention: Assignment Branch Condition size for read is too high. [17.92/15]
-  # Rubocop: convention: Method has too many lines. [13/10]
   def read(n_bytes = nil)
     @remote_size ||= request_object_size
 
     # If the resource is empty there is nothing to read
-    return nil if @remote_size.zero?
+    return if @remote_size.zero?
 
     maximum_avaialable = @remote_size - @pos
     n_bytes ||= maximum_avaialable # nil == read to the end of file
@@ -54,9 +52,7 @@ class ZipTricks::RemoteIO
     n_bytes = clamp(0, n_bytes, maximum_avaialable)
 
     read_n_bytes_from_remote(@pos, n_bytes).tap do |data|
-      if data.bytesize != n_bytes
-        raise "Remote read returned #{data.bytesize} bytes instead of #{n_bytes} as requested"
-      end
+      raise "Remote read returned #{data.bytesize} bytes instead of #{n_bytes} as requested" if data.bytesize != n_bytes
       @pos = clamp(0, @pos + data.bytesize, @remote_size)
     end
   end

data/lib/zip_tricks/stream_crc32.rb

@@ -2,21 +2,18 @@
 
 # A simple stateful class for keeping track of a CRC32 value through multiple writes
 class ZipTricks::StreamCRC32
-  BUFFER_SIZE = 1024 * 1024 * 5
-
   # Compute a CRC32 value from an IO object. The object should respond to `read` and `eof?`
   #
   # @param io[IO] the IO to read the data from
   # @return [Fixnum] the computed CRC32 value
   def self.from_io(io)
     crc = new
-    crc << io.read(BUFFER_SIZE) until io.eof?
+    crc << io.read(1024 * 512) until io.eof?
     crc.to_i
   end
 
   # Creates a new streaming CRC32 calculator
   def initialize
-    @buf = StringIO.new
     @crc = Zlib.crc32('')
   end
 
@@ -25,8 +22,7 @@ class ZipTricks::StreamCRC32
   # @param blob[String] the string to compute the CRC32 from
   # @return [self]
   def <<(blob)
-    @buf << blob
-    buf_flush if @buf.size > BUFFER_SIZE
+    @crc = Zlib.crc32_combine(@crc, Zlib.crc32(blob), blob.bytesize)
     self
   end
 
@@ -34,7 +30,6 @@ class ZipTricks::StreamCRC32
   #
   # @return [Fixnum] the updated CRC32 value for all the blobs so far
   def to_i
-    buf_flush if @buf.size > 0
     @crc
   end
 
@@ -45,15 +40,6 @@ class ZipTricks::StreamCRC32
   # @param blob_size[Fixnum] the size of the daata the `crc32` is computed from
   # @return [Fixnum] the updated CRC32 value for all the blobs so far
   def append(crc32, blob_size)
-    buf_flush if @buf.size > 0
     @crc = Zlib.crc32_combine(@crc, crc32, blob_size)
   end
-
-  private
-
-  def buf_flush
-    @crc = Zlib.crc32_combine(@crc, Zlib.crc32(@buf.string), @buf.size)
-    @buf.truncate(0)
-    @buf.rewind
-  end
 end