zip_tricks 4.4.2 → 4.5.0

data/lib/zip_tricks/streamer/deflated_writer.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 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.
   FLUSH_EVERY_N_BYTES = 1024 * 1024 * 5
-  
+
   def initialize(io)
     @io = io
     @uncompressed_size = 0
@@ -15,9 +17,9 @@ class ZipTricks::Streamer::DeflatedWriter
 
   def finish
     @io << @deflater.finish until @deflater.finished?
-    [@crc.to_i, @io.tell - @started_at, @uncompressed_size]
+    {crc32: @crc.to_i, compressed_size: @io.tell - @started_at, uncompressed_size: @uncompressed_size}
   end
-  
+
   def <<(data)
     @uncompressed_size += data.bytesize
     @bytes_since_last_flush += data.bytesize
@@ -27,11 +29,6 @@ class ZipTricks::Streamer::DeflatedWriter
     self
   end
 
-  def write(data)
-    self << data
-    data.bytesize
-  end
-  
   private
 
   def interim_flush
@@ -39,4 +36,4 @@ class ZipTricks::Streamer::DeflatedWriter
     @io << @deflater.flush
     @bytes_since_last_flush = 0
   end
-end
+end

data/lib/zip_tricks/streamer/entry.rb

@@ -1,10 +1,19 @@
+# frozen_string_literal: true
+
 # Is used internally by Streamer to keep track of entries in the archive during writing.
 # Normally you will not have to use this class directly
-class ZipTricks::Streamer::Entry < Struct.new(:filename, :crc32, :compressed_size, :uncompressed_size, :storage_mode, :mtime, :use_data_descriptor)
+class ZipTricks::Streamer::Entry < Struct.new(:filename, :crc32, :compressed_size,
+                                              :uncompressed_size, :storage_mode, :mtime,
+                                              :use_data_descriptor)
   def initialize(*)
     super
     filename.force_encoding(Encoding::UTF_8)
-    @requires_efs_flag = !(filename.encode(Encoding::ASCII) rescue false)
+    # Rubocop: convention: Avoid using rescue in its modifier form.
+    @requires_efs_flag = !(begin
+                             filename.encode(Encoding::ASCII)
+                           rescue
+                             false
+                           end)
   end
 
   # Set the general purpose flags for the entry. We care about is the EFS
@@ -18,5 +27,4 @@ class ZipTricks::Streamer::Entry < Struct.new(:filename, :crc32, :compressed_siz
     flag |= 0x0008 if use_data_descriptor        # bit 3
     flag
   end
-
 end

data/lib/zip_tricks/streamer/stored_writer.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Rubocop: convention: Missing top-level class documentation comment.
 class ZipTricks::Streamer::StoredWriter
   def initialize(io)
     @io = io
@@ -13,13 +16,8 @@ class ZipTricks::Streamer::StoredWriter
     self
   end
 
-  def write(data)
-    self << data
-    data.bytesize
-  end
-
   def finish
     size = @io.tell - @started_at
-    [@crc.to_i, size, size]
+    {crc32: @crc.to_i, compressed_size: size, uncompressed_size: size}
   end
-end
+end

data/lib/zip_tricks/streamer/writable.rb

@@ -1,20 +1,43 @@
-# Gets yielded from the writing methods of the CompressingStreamer
-# and accepts the data being written into the ZIP
+# frozen_string_literal: true
+
+# Gets yielded from the writing methods of the Streamer
+# and accepts the data being written into the ZIP for deflate
+# or stored modes. Can be used as a destination for `IO.copy_stream`
+#
+#    IO.copy_stream(File.open('source.bin', 'rb), writable)
 class ZipTricks::Streamer::Writable
   # Initializes a new Writable with the object it delegates the writes to.
-  # Normally you would not need to use this method directly 
-  def initialize(writer)
+  # Normally you would not need to use this method directly
+  def initialize(streamer, writer)
+    @streamer = streamer
     @writer = writer
+    @closed = false
   end
+
   # Writes the given data to the output stream
   #
   # @param d[String] the binary string to write (part of the uncompressed file)
   # @return [self]
-  def <<(d); @writer << d; self; end
-  
+  def <<(d)
+    raise 'Trying to write to a closed Writable' if @closed
+    @writer << d
+    self
+  end
+
   # Writes the given data to the output stream
   #
   # @param d[String] the binary string to write (part of the uncompressed file)
   # @return [Fixnum] the number of bytes written
-  def write(d); @writer << d; d.bytesize; end
+  def write(d)
+    self << d
+    d.bytesize
+  end
+
+  # Flushes the writer and recovers the CRC32/size values. It then calls
+  # `update_last_entry_and_write_data_descriptor` on the given Streamer.
+  def close
+    return if @closed
+    @streamer.update_last_entry_and_write_data_descriptor(**@writer.finish)
+    @closed = true
+  end
 end

data/lib/zip_tricks/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ZipTricks
-  VERSION = '4.4.2'
+  VERSION = '4.5.0'
 end

data/lib/zip_tricks/write_and_tell.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A tiny wrapper over any object that supports :<<.
 # Adds :tell and :advance_position_by.
 class ZipTricks::WriteAndTell

data/lib/zip_tricks/zip_writer.rb

@@ -1,3 +1,7 @@
+# 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.
 #
@@ -35,15 +39,15 @@ class ZipTricks::ZipWriter
     # 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
+    unix_perms = 0o644
+    file_type_file = 0o10
+    external_attrs = (file_type_file << 12 | (unix_perms & 0o7777)) << 16
   end
   EMPTY_DIRECTORY_EXTERNAL_ATTRS = begin
     # Applies permissions to an empty directory.
-    unix_perms = 0755
-    file_type_dir = 004
-    external_attrs = (file_type_file << 12 | (unix_perms & 07777)) << 16
+    unix_perms = 0o755
+    file_type_dir = 0o04
+    external_attrs = (file_type_file << 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
@@ -51,19 +55,19 @@ class ZipTricks::ZipWriter
     [VERSION_MADE_BY, os_type].pack('CC')
   end
 
-  C_V = 'V'.freeze    # Encode a 4-byte unsigned little-endian uint
-  C_v = 'v'.freeze    # Encode a 2-byte unsigned little-endian uint
-  C_Qe = 'Q<'.freeze  # Encode an 8-byte unsigned little-endian uint
-  C_C = 'C'.freeze # For bit-encoded strings
-  C_N = 'N'.freeze # Encode a 4-byte signed little-endian int
-  
+  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
 
-  # Writes the local file header, that precedes the actual file _data_. 
-  # 
+  # 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
@@ -100,21 +104,21 @@ class ZipTricks::ZipWriter
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
     io << [filename.bytesize].pack(C_v)                 # file name length             2 bytes
 
+    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.
-    extra_fields = if requires_zip64
-      zip_64_extra_for_local_file_header(compressed_size: compressed_size, uncompressed_size: uncompressed_size)
-    else
-      ''
+    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(mtime)
 
-    io << [extra_fields.bytesize].pack(C_v)            # extra field length              2 bytes
+    io << [extra_fields.size].pack(C_v)                # extra field length              2 bytes
 
     io << filename                                     # file name (variable size)
-    io << extra_fields
+    io << extra_fields.string
   end
 
   # Writes the file header for the central directory, for a particular file in the archive. When writing out this data,
@@ -128,8 +132,15 @@ class ZipTricks::ZipWriter
   # @param mtime[Time]  the modification time to be recorded in the ZIP
   # @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:)
+  def write_central_directory_file_header(io:,
+                                          local_file_header_location:,
+                                          gp_flags:,
+                                          storage_mode:,
+                                          compressed_size:,
+                                          uncompressed_size:,
+                                          mtime:,
+                                          crc32:,
+                                          filename:)
     # 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) ||
@@ -142,7 +153,7 @@ class ZipTricks::ZipWriter
     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
@@ -160,15 +171,15 @@ class ZipTricks::ZipWriter
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
     io << [filename.bytesize].pack(C_v)                 # file name length                2 bytes
 
-    extra_fields = if add_zip64
-      zip_64_extra_for_central_directory_file_header(local_file_header_location: local_file_header_location,
-          compressed_size: compressed_size, uncompressed_size: uncompressed_size)
-    else
-      ''
+    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(mtime)
-    
-    io << [extra_fields.bytesize].pack(C_v)             # extra field length              2 bytes
+
+    io << [extra_fields.size].pack(C_v)                 # extra field length              2 bytes
 
     io << [0].pack(C_v)                                 # file comment length             2 bytes
 
@@ -181,10 +192,10 @@ class ZipTricks::ZipWriter
       io << [0].pack(C_v)
     end
     io << [0].pack(C_v)                                # 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?("/")
+    if filename.end_with?('/')
       io << [EMPTY_DIRECTORY_EXTERNAL_ATTRS].pack(C_V)
     else
       io << [DEFAULT_EXTERNAL_ATTRS].pack(C_V)           # external file attributes        4 bytes
@@ -196,7 +207,7 @@ class ZipTricks::ZipWriter
       io << [local_file_header_location].pack(C_V)
     end
     io << filename                                     # file name (variable size)
-    io << extra_fields                                 # extra field (variable size)
+    io << extra_fields.string                          # extra field (variable size)
     #(empty)                                           # file comment (variable size)
   end
 
@@ -215,7 +226,6 @@ class ZipTricks::ZipWriter
                                   # 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
@@ -236,7 +246,7 @@ class ZipTricks::ZipWriter
   # @return [void]
   def write_end_of_central_directory(io:, start_of_central_directory_location:, central_directory_size:, num_files_in_archive:, comment: ZIP_TRICKS_COMMENT)
     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 ||
@@ -311,7 +321,7 @@ class ZipTricks::ZipWriter
     io << [comment.bytesize].pack(C_v)                      # .ZIP file comment length        2 bytes
     io << 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.
@@ -336,7 +346,7 @@ class ZipTricks::ZipWriter
   # remaining times
   def timestamp_extra(mtime)
     #         Local-header version:
-    # 
+    #
     #         Value         Size        Description
     #         -----         ----        -----------
     # (time)  0x5455        Short       tag for this extra block type ("UT")
@@ -345,9 +355,9 @@ class ZipTricks::ZipWriter
     #         (ModTime)     Long        time of last modification (UTC/GMT)
     #         (AcTime)      Long        time of last access (UTC/GMT)
     #         (CrTime)      Long        time of original creation (UTC/GMT)
-    # 
+    #
     #         Central-header version:
-    # 
+    #
     #         Value         Size        Description
     #         -----         ----        -----------
     # (time)  0x5455        Short       tag for this extra block type ("UT")
@@ -357,7 +367,7 @@ class ZipTricks::ZipWriter
     #
     # The lower three bits of Flags in both headers indicate which time-
     #       stamps are present in the LOCAL extra field:
-    # 
+    #
     #       bit 0           if set, modification time is present
     #       bit 1           if set, access time is present
     #       bit 2           if set, creation time is present
@@ -371,7 +381,7 @@ class ZipTricks::ZipWriter
     ]
     pack_array(data_and_packspecs)
   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.
   #
@@ -390,15 +400,15 @@ class ZipTricks::ZipWriter
     ]
     pack_array(data_and_packspecs)
   end
-  
+
   def to_binary_dos_time(t)
-    (t.sec/2) + (t.min << 5) + (t.hour << 11)
+    (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
-  
+
   # 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:
   #

data/testing/generate_test_files.rb

@@ -1,96 +1,126 @@
+# frozen_string_literal: true
+
 require_relative 'support'
 
-build_test "Two small stored files" do |zip|
-  zip.add_stored_entry(filename: 'text.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+build_test 'Two small stored files' do |zip|
+  zip.add_stored_entry(filename: 'text.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 
-  zip.add_stored_entry(filename: 'image.jpg', size: $image_file.bytesize, crc32: $image_file_crc)
+  zip.add_stored_entry(filename: 'image.jpg',
+                       size: $image_file.bytesize,
+                       crc32: $image_file_crc)
   zip << $image_file
 end
 
-build_test "Two small stored files and an empty directory" do |zip|
-  zip.add_stored_entry(filename: 'text.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+build_test 'Two small stored files and an empty directory' do |zip|
+  zip.add_stored_entry(filename: 'text.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 
-  zip.add_stored_entry(filename: 'image.jpg', size: $image_file.bytesize, crc32: $image_file_crc)
+  zip.add_stored_entry(filename: 'image.jpg',
+                       size: $image_file.bytesize,
+                       crc32: $image_file_crc)
   zip << $image_file
-  
-  zip.add_empty_directory(dirname: "Chekov")
+
+  zip.add_empty_directory(dirname: 'Chekov')
 end
 
-build_test "Filename with diacritics" do |zip|
-  zip.add_stored_entry(filename: 'Kungälv.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+build_test 'Filename with diacritics' do |zip|
+  zip.add_stored_entry(filename: 'Kungälv.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 end
 
-build_test "Purely UTF-8 filename" do |zip|
-  zip.add_stored_entry(filename: 'Война и мир.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+build_test 'Purely UTF-8 filename' do |zip|
+  zip.add_stored_entry(filename: 'Война и мир.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 end
 
 # The trick of this test is that each file of the 2, on it's own, does _not_ exceed the
 # size threshold for Zip64. Together, however, they do.
-build_test "Two entries larger than the overall Zip64 offset" do |zip|
-  big = generate_big_entry((0xFFFFFFFF / 2) + 1024)
-  zip.add_stored_entry(filename: 'repeated-A.txt', size: big.size, crc32: big.crc32)
+build_test 'Two entries larger than the overall Zip64 offset' do |zip|
+  big = generate_big_entry((0xFFFFFFFF / 2) + 1_024)
+  zip.add_stored_entry(filename: 'repeated-A.txt',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 
-  zip.add_stored_entry(filename: 'repeated-B.txt', size: big.size, crc32: big.crc32)
+  zip.add_stored_entry(filename: 'repeated-B.txt',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 end
 
-build_test "One entry that requires Zip64 and a tiny entry following it" do |zip|
-  big = generate_big_entry(0xFFFFFFFF + 2048)
-  zip.add_stored_entry(filename: 'large-requires-zip64.bin', size: big.size, crc32: big.crc32)
+build_test 'One entry that requires Zip64 and a tiny entry following it' do |zip|
+  big = generate_big_entry(0xFFFFFFFF + 2_048)
+  zip.add_stored_entry(filename: 'large-requires-zip64.bin',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 
-  zip.add_stored_entry(filename: 'tiny-after.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+  zip.add_stored_entry(filename: 'tiny-after.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 end
 
-build_test "One tiny entry followed by second that requires Zip64" do |zip|
-  zip.add_stored_entry(filename: 'tiny-at-start.txt', size: $war_and_peace.bytesize, crc32: $war_and_peace_crc)
+build_test 'One tiny entry followed by second that requires Zip64' do |zip|
+  zip.add_stored_entry(filename: 'tiny-at-start.txt',
+                       size: $war_and_peace.bytesize,
+                       crc32: $war_and_peace_crc)
   zip << $war_and_peace
 
-  big = generate_big_entry(0xFFFFFFFF + 2048)
-  zip.add_stored_entry(filename: 'large-requires-zip64.bin', size: big.size, crc32: big.crc32)
+  big = generate_big_entry(0xFFFFFFFF + 2_048)
+  zip.add_stored_entry(filename: 'large-requires-zip64.bin',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 end
 
-build_test "Two entries both requiring Zip64" do |zip|
-  big = generate_big_entry(0xFFFFFFFF + 2048)
-  zip.add_stored_entry(filename: 'huge-file-1.bin', size: big.size, crc32: big.crc32)
+build_test 'Two entries both requiring Zip64' do |zip|
+  big = generate_big_entry(0xFFFFFFFF + 2_048)
+  zip.add_stored_entry(filename: 'huge-file-1.bin',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 
-  zip.add_stored_entry(filename: 'huge-file-2.bin', size: big.size, crc32: big.crc32)
+  zip.add_stored_entry(filename: 'huge-file-2.bin',
+                       size: big.size,
+                       crc32: big.crc32)
   big.write_to(zip)
 end
 
-build_test "Two stored entries using data descriptors" do |zip|
+build_test 'Two stored entries using data descriptors' do |zip|
   zip.write_stored_file('stored.1.bin') do |sink|
-    sink << Random.new.bytes(1024 * 1024 * 4)
+    sink << Random.new.bytes(1_024 * 1_024 * 4)
   end
   zip.write_stored_file('stored.2.bin') do |sink|
-    sink << Random.new.bytes(1024 * 1024 * 3)
+    sink << Random.new.bytes(1_024 * 1_024 * 3)
   end
 end
 
-build_test "One entry deflated using data descriptors" do |zip|
+build_test 'One entry deflated using data descriptors' do |zip|
   big = generate_big_entry(0xFFFFFFFF / 64)
   zip.write_deflated_file('war-and-peace-repeated-compressed.txt') do |sink|
     big.write_to(sink)
   end
 end
 
-build_test "Two entries larger than the overall Zip64 offset using data descriptors" do |zip|
-  big = generate_big_entry((0xFFFFFFFF / 2) + 1024)
-  
+build_test 'Two entries larger than the overall Zip64 offset using data descriptors' do |zip|
+  big = generate_big_entry((0xFFFFFFFF / 2) + 1_024)
+
   zip.write_stored_file('repeated-A.txt') { |sink| big.write_to(sink) }
   zip.write_stored_file('repeated-B.txt') { |sink| big.write_to(sink) }
 end
 
-build_test "One stored entry larger than Zip64 threshold using data descriptors" do |zip|
-  big = generate_big_entry(0xFFFFFFFF + 64000)
-  
+build_test 'One stored entry larger than Zip64 threshold using data descriptors' do |zip|
+  big = generate_big_entry(0xFFFFFFFF + 64_000)
+
   zip.write_stored_file('repeated-A.txt') { |sink| big.write_to(sink) }
 end