zip_kit 6.3.0 → 6.3.2

data/lib/zip_kit/write_shovel.rb

@@ -14,7 +14,7 @@ module ZipKit::WriteShovel
   # a target for `IO.copy_stream(from, to)`
   #
   # @param bytes[String] the binary string to write (part of the uncompressed file)
-  # @return [Fixnum] the number of bytes written (will always be the bytesize of `bytes`)
+  # @return [Integer] the number of bytes written (will always be the bytesize of `bytes`)
   def write(bytes)
     self << bytes
     bytes.bytesize

data/lib/zip_kit/zip_writer.rb

@@ -64,12 +64,12 @@ class ZipKit::ZipWriter
   #
   # @param io[#<<] the buffer to write the local file header to
   # @param filename[String]  the name of the file in the archive
-  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
-  # @param uncompressed_size[Fixnum]  The size of the file once extracted
-  # @param crc32[Fixnum] The CRC32 checksum of the file
+  # @param compressed_size[Integer]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @param uncompressed_size[Integer]  The size of the file once extracted
+  # @param crc32[Integer] The CRC32 checksum of the file
   # @param mtime[Time]  the modification time to be recorded in the ZIP
-  # @param gp_flags[Fixnum] bit-packed general purpose flags
-  # @param storage_mode[Fixnum] 8 for deflated, 0 for stored...
+  # @param gp_flags[Integer] bit-packed general purpose flags
+  # @param storage_mode[Integer] 8 for deflated, 0 for stored...
   # @return [void]
   def write_local_file_header(io:, filename:, compressed_size:, uncompressed_size:, crc32:, gp_flags:, mtime:, storage_mode:)
     requires_zip64 = compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT
@@ -136,11 +136,11 @@ class ZipKit::ZipWriter
   #
   # @param io[#<<] the buffer to write the local file header to
   # @param filename[String]  the name of the file in the archive
-  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
-  # @param uncompressed_size[Fixnum]  The size of the file once extracted
-  # @param crc32[Fixnum] The CRC32 checksum of the file
+  # @param compressed_size[Integer]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @param uncompressed_size[Integer]  The size of the file once extracted
+  # @param crc32[Integer] The CRC32 checksum of the file
   # @param mtime[Time]  the modification time to be recorded in the ZIP
-  # @param gp_flags[Fixnum] bit-packed general purpose flags
+  # @param gp_flags[Integer] bit-packed general purpose flags
   # @param unix_permissions[Integer] the permissions for the file, or nil for the default to be used
   # @return [void]
   def write_central_directory_file_header(io:,
@@ -253,9 +253,9 @@ class ZipKit::ZipWriter
   # the data descriptor will have the sizes written out as 8-byte values instead of 4-byte values.
   #
   # @param io[#<<] the buffer to write the local file header to
-  # @param crc32[Fixnum]    The CRC32 checksum of the file
-  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
-  # @param uncompressed_size[Fixnum]  The size of the file once extracted
+  # @param crc32[Integer]    The CRC32 checksum of the file
+  # @param compressed_size[Integer]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @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
@@ -282,9 +282,9 @@ class ZipKit::ZipWriter
   # Writes the "end of central directory record" (including the Zip6 salient bits if necessary)
   #
   # @param io[#<<] the buffer to write the central directory to.
-  # @param start_of_central_directory_location[Fixnum] byte offset of the start of central directory form the beginning of ZIP file
-  # @param central_directory_size[Fixnum] the size of the central directory (only file headers) in bytes
-  # @param num_files_in_archive[Fixnum] How many files the archive contains
+  # @param start_of_central_directory_location[Integer] byte offset of the start of central directory form the beginning of ZIP file
+  # @param central_directory_size[Integer] the size of the central directory (only file headers) in bytes
+  # @param num_files_in_archive[Integer] How many files the archive contains
   # @param comment[String] the comment for the archive (defaults to ZIP_KIT_COMMENT)
   # @return [void]
   def write_end_of_central_directory(io:, start_of_central_directory_location:, central_directory_size:, num_files_in_archive:, comment: ZIP_KIT_COMMENT)
@@ -386,8 +386,8 @@ class ZipKit::ZipWriter
 
   # Writes the Zip64 extra field for the local file header. Will be used by `write_local_file_header` when any sizes given to it warrant that.
   #
-  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
-  # @param uncompressed_size[Fixnum]  The size of the file once extracted
+  # @param compressed_size[Integer]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @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 = [
@@ -460,9 +460,9 @@ class ZipKit::ZipWriter
   # Writes the Zip64 extra field for the central directory header.It differs from the extra used in the local file header because it
   # also contains the location of the local file header in the ZIP as an 8-byte int.
   #
-  # @param compressed_size[Fixnum]    The size of the compressed (or stored) data - how much space it uses in the ZIP
-  # @param uncompressed_size[Fixnum]  The size of the file once extracted
-  # @param local_file_header_location[Fixnum] Byte offset of the start of the local file header from the beginning of the ZIP archive
+  # @param compressed_size[Integer]    The size of the compressed (or stored) data - how much space it uses in the ZIP
+  # @param uncompressed_size[Integer]  The size of the file once extracted
+  # @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 = [

data/rbi/zip_kit.rbi

@@ -1,6 +1,6 @@
 # typed: strong
 module ZipKit
-  VERSION = T.let("6.3.0", T.untyped)
+  VERSION = T.let("6.3.1", T.untyped)
 
   class Railtie < Rails::Railtie
   end
@@ -572,7 +572,7 @@ module ZipKit
     # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
     # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-    sig { params(bytes: String).returns(Fixnum) }
+    sig { params(bytes: String).returns(Integer) }
     def write(bytes); end
 
     # Is used internally by Streamer to keep track of entries in the archive during writing.
@@ -686,7 +686,7 @@ module ZipKit
       # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
       # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-      sig { params(bytes: String).returns(Fixnum) }
+      sig { params(bytes: String).returns(Integer) }
       def write(bytes); end
     end
 
@@ -755,7 +755,7 @@ module ZipKit
       # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
       # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-      sig { params(bytes: String).returns(Fixnum) }
+      sig { params(bytes: String).returns(Integer) }
       def write(bytes); end
     end
 
@@ -793,7 +793,7 @@ module ZipKit
       # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
       # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-      sig { params(bytes: String).returns(Fixnum) }
+      sig { params(bytes: String).returns(Integer) }
       def write(bytes); end
     end
   end
@@ -835,11 +835,11 @@ module ZipKit
     # _@param_ `n_bytes` — how many bytes to read, or `nil` to read all the way to the end
     # 
     # _@return_ — the read bytes
-    sig { params(n_bytes: T.nilable(Fixnum)).returns(String) }
+    sig { params(n_bytes: T.nilable(Integer)).returns(String) }
     def read(n_bytes = nil); end
 
     # Returns the current pointer position within the IO
-    sig { returns(Fixnum) }
+    sig { returns(Integer) }
     def tell; end
 
     # Only used internally when reading the remote ZIP.
@@ -933,12 +933,12 @@ end, T.untyped)
       params(
         io: T.untyped,
         filename: String,
-        compressed_size: Fixnum,
-        uncompressed_size: Fixnum,
-        crc32: Fixnum,
-        gp_flags: Fixnum,
+        compressed_size: Integer,
+        uncompressed_size: Integer,
+        crc32: Integer,
+        gp_flags: Integer,
         mtime: Time,
-        storage_mode: Fixnum
+        storage_mode: Integer
       ).void
     end
     def write_local_file_header(io:, filename:, compressed_size:, uncompressed_size:, crc32:, gp_flags:, mtime:, storage_mode:); end
@@ -968,12 +968,12 @@ end, T.untyped)
       params(
         io: T.untyped,
         local_file_header_location: T.untyped,
-        gp_flags: Fixnum,
+        gp_flags: Integer,
         storage_mode: T.untyped,
-        compressed_size: Fixnum,
-        uncompressed_size: Fixnum,
+        compressed_size: Integer,
+        uncompressed_size: Integer,
         mtime: Time,
-        crc32: Fixnum,
+        crc32: Integer,
         filename: String,
         unix_permissions: T.nilable(Integer)
       ).void
@@ -995,9 +995,9 @@ end, T.untyped)
     sig do
       params(
         io: T.untyped,
-        compressed_size: Fixnum,
-        uncompressed_size: Fixnum,
-        crc32: Fixnum
+        compressed_size: Integer,
+        uncompressed_size: Integer,
+        crc32: Integer
       ).void
     end
     def write_data_descriptor(io:, compressed_size:, uncompressed_size:, crc32:); end
@@ -1017,9 +1017,9 @@ end, T.untyped)
     sig do
       params(
         io: T.untyped,
-        start_of_central_directory_location: Fixnum,
-        central_directory_size: Fixnum,
-        num_files_in_archive: Fixnum,
+        start_of_central_directory_location: Integer,
+        central_directory_size: Integer,
+        num_files_in_archive: Integer,
         comment: String
       ).void
     end
@@ -1030,7 +1030,7 @@ end, T.untyped)
     # _@param_ `compressed_size` — The size of the compressed (or stored) data - how much space it uses in the ZIP
     # 
     # _@param_ `uncompressed_size` — The size of the file once extracted
-    sig { params(compressed_size: Fixnum, uncompressed_size: Fixnum).returns(String) }
+    sig { params(compressed_size: Integer, uncompressed_size: Integer).returns(String) }
     def zip_64_extra_for_local_file_header(compressed_size:, uncompressed_size:); end
 
     # sord omit - no YARD type given for "mtime", using untyped
@@ -1053,7 +1053,7 @@ end, T.untyped)
     # _@param_ `uncompressed_size` — The size of the file once extracted
     # 
     # _@param_ `local_file_header_location` — Byte offset of the start of the local file header from the beginning of the ZIP archive
-    sig { params(compressed_size: Fixnum, uncompressed_size: Fixnum, local_file_header_location: Fixnum).returns(String) }
+    sig { params(compressed_size: Integer, uncompressed_size: Integer, local_file_header_location: Integer).returns(String) }
     def zip_64_extra_for_central_directory_file_header(compressed_size:, uncompressed_size:, local_file_header_location:); end
 
     # sord omit - no YARD type given for "t", using untyped
@@ -1126,7 +1126,7 @@ end, T.untyped)
     # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
     # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-    sig { params(bytes: String).returns(Fixnum) }
+    sig { params(bytes: String).returns(Integer) }
     def write(bytes); end
   end
 
@@ -1286,7 +1286,7 @@ end, T.untyped)
     # _@param_ `io` — an IO-ish object the ZIP file can be read from
     # 
     # _@return_ — the parsed local header entry and
-    sig { params(io: T.untyped).returns(T::Array[T.any(ZipEntry, Fixnum)]) }
+    sig { params(io: T.untyped).returns(T::Array[T.any(ZipEntry, Integer)]) }
     def read_local_file_header(io:); end
 
     # sord duck - #seek looks like a duck type, replacing with untyped
@@ -1299,13 +1299,13 @@ end, T.untyped)
     # header offset given will be the compressed data offset of the entry
     # (read starting at this offset to get the data).
     # 
-    # local file header is supposed to begin @return [Fixnum] absolute offset
+    # local file header is supposed to begin @return [Integer] absolute offset
     # (0-based) of where the compressed data begins for this file within the ZIP
     # 
     # _@param_ `io` — an IO-ish object the ZIP file can be read from
     # 
     # _@param_ `local_file_header_offset` — absolute offset (0-based) where the
-    sig { params(io: T.untyped, local_file_header_offset: Fixnum).returns(T.untyped) }
+    sig { params(io: T.untyped, local_file_header_offset: Integer).returns(T.untyped) }
     def get_compressed_data_offset(io:, local_file_header_offset:); end
 
     # Parse an IO handle to a ZIP archive into an array of Entry objects, reading from the end
@@ -1502,7 +1502,7 @@ end, T.untyped)
 
       # _@return_ — at what offset you should start reading
       # for the compressed data in your original IO object
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       def compressed_data_offset; end
 
       # Tells whether the compressed data offset is already known for this entry
@@ -1514,7 +1514,7 @@ end, T.untyped)
       sig { returns(T::Boolean) }
       def uses_data_descriptor?; end
 
-      # sord infer - inferred type of parameter "offset" as Fixnum using getter's return type
+      # sord infer - inferred type of parameter "offset" as Integer using getter's return type
       # sord omit - no YARD return type given, using untyped
       # Sets the offset at which the compressed data for this file starts in the ZIP.
       # By default, the value will be set by the Reader for you. If you use delayed
@@ -1522,43 +1522,43 @@ end, T.untyped)
       # 
       #     entry.compressed_data_offset = reader.get_compressed_data_offset(io: file,
       #            local_file_header_offset: entry.local_header_offset)
-      sig { params(offset: Fixnum).returns(T.untyped) }
+      sig { params(offset: Integer).returns(T.untyped) }
       def compressed_data_offset=(offset); end
 
       # _@return_ — bit-packed version signature of the program that made the archive
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :made_by
 
       # _@return_ — ZIP version support needed to extract this file
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :version_needed_to_extract
 
       # _@return_ — bit-packed general purpose flags
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :gp_flags
 
       # _@return_ — Storage mode (0 for stored, 8 for deflate)
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :storage_mode
 
       # _@return_ — the bit-packed DOS time
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :dos_time
 
       # _@return_ — the bit-packed DOS date
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :dos_date
 
       # _@return_ — the CRC32 checksum of this file
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :crc32
 
       # _@return_ — size of compressed file data in the ZIP
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :compressed_size
 
       # _@return_ — size of the file once uncompressed
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :uncompressed_size
 
       # _@return_ — the filename
@@ -1566,20 +1566,20 @@ end, T.untyped)
       attr_accessor :filename
 
       # _@return_ — disk number where this file starts
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :disk_number_start
 
       # _@return_ — internal attributes of the file
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :internal_attrs
 
       # _@return_ — external attributes of the file
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :external_attrs
 
       # _@return_ — at what offset the local file header starts
       # in your original IO object
-      sig { returns(Fixnum) }
+      sig { returns(Integer) }
       attr_accessor :local_file_header_offset
 
       # _@return_ — the file comment
@@ -1635,7 +1635,7 @@ end, T.untyped)
     # _@param_ `io` — the IO to read the data from
     # 
     # _@return_ — the computed CRC32 value
-    sig { params(io: IO).returns(Fixnum) }
+    sig { params(io: IO).returns(Integer) }
     def self.from_io(io); end
 
     # Creates a new streaming CRC32 calculator
@@ -1651,7 +1651,7 @@ end, T.untyped)
     # Returns the CRC32 value computed so far
     # 
     # _@return_ — the updated CRC32 value for all the blobs so far
-    sig { returns(Fixnum) }
+    sig { returns(Integer) }
     def to_i; end
 
     # Appends a known CRC32 value to the current one, and combines the
@@ -1662,7 +1662,7 @@ end, T.untyped)
     # _@param_ `blob_size` — the size of the daata the `crc32` is computed from
     # 
     # _@return_ — the updated CRC32 value for all the blobs so far
-    sig { params(crc32: Fixnum, blob_size: Fixnum).returns(Fixnum) }
+    sig { params(crc32: Integer, blob_size: Integer).returns(Integer) }
     def append(crc32, blob_size); end
 
     # Writes the given data to the output stream. Allows the object to be used as
@@ -1671,7 +1671,7 @@ end, T.untyped)
     # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
     # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-    sig { params(bytes: String).returns(Fixnum) }
+    sig { params(bytes: String).returns(Integer) }
     def write(bytes); end
   end
 
@@ -1741,7 +1741,7 @@ end, T.untyped)
     # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
     # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-    sig { params(bytes: String).returns(Fixnum) }
+    sig { params(bytes: String).returns(Integer) }
     def write(bytes); end
   end
 
@@ -1801,7 +1801,7 @@ end, T.untyped)
     # _@param_ `output_io` — the stream to write to (should respond to `:<<`)
     # 
     # _@return_ — number of bytes written to `output_io`
-    sig { params(output_io: IO).returns(Fixnum) }
+    sig { params(output_io: IO).returns(Integer) }
     def self.write_terminator(output_io); end
 
     # Compress a given binary string and flush the deflate stream at byte boundary.
@@ -1812,7 +1812,7 @@ end, T.untyped)
     # _@param_ `level` — Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
     # 
     # _@return_ — compressed bytes
-    sig { params(bytes: String, level: Fixnum).returns(String) }
+    sig { params(bytes: String, level: Integer).returns(String) }
     def self.deflate_chunk(bytes, level: Zlib::DEFAULT_COMPRESSION); end
 
     # Compress the contents of input_io into output_io, in blocks
@@ -1838,9 +1838,9 @@ end, T.untyped)
       params(
         input_io: IO,
         output_io: IO,
-        level: Fixnum,
-        block_size: Fixnum
-      ).returns(Fixnum)
+        level: Integer,
+        block_size: Integer
+      ).returns(Integer)
     end
     def self.deflate_in_blocks_and_terminate(input_io, output_io, level: Zlib::DEFAULT_COMPRESSION, block_size: DEFAULT_BLOCKSIZE); end
 
@@ -1864,9 +1864,9 @@ end, T.untyped)
       params(
         input_io: IO,
         output_io: IO,
-        level: Fixnum,
-        block_size: Fixnum
-      ).returns(Fixnum)
+        level: Integer,
+        block_size: Integer
+      ).returns(Integer)
     end
     def self.deflate_in_blocks(input_io, output_io, level: Zlib::DEFAULT_COMPRESSION, block_size: DEFAULT_BLOCKSIZE); end
   end
@@ -1892,21 +1892,19 @@ end, T.untyped)
     # _@param_ `kwargs_for_streamer_new` — Any options to pass to Streamer, see {Streamer#initialize}
     # 
     # _@return_ — the size of the resulting archive, in bytes
-    sig { params(kwargs_for_streamer_new: T.untyped, blk: T.proc.params(the: SizeEstimator).void).returns(Integer) }
+    sig { params(kwargs_for_streamer_new: T.untyped, blk: T.proc.params(estimator: SizeEstimator).void).returns(Integer) }
     def self.estimate(**kwargs_for_streamer_new, &blk); end
 
     # Add a fake entry to the archive, to see how big it is going to be in the end.
     # 
-    # data descriptor to specify size
-    # 
     # _@param_ `filename` — the name of the file (filenames are variable-width in the ZIP)
     # 
     # _@param_ `size` — size of the uncompressed entry
     # 
-    # _@param_ `use_data_descriptor` — whether the entry uses a postfix
+    # _@param_ `use_data_descriptor` — whether there is going to be a data descriptor written after the entry body, to specify size. You must enable this if you are going to be using {Streamer#write_stored_file} as otherwise your estimated size is not going to be accurate
     # 
     # _@return_ — self
-    sig { params(filename: String, size: Fixnum, use_data_descriptor: T::Boolean).returns(T.untyped) }
+    sig { params(filename: String, size: Integer, use_data_descriptor: T::Boolean).returns(T.untyped) }
     def add_stored_entry(filename:, size:, use_data_descriptor: false); end
 
     # Add a fake entry to the archive, to see how big it is going to be in the end.
@@ -1917,14 +1915,14 @@ end, T.untyped)
     # 
     # _@param_ `compressed_size` — size of the compressed entry
     # 
-    # _@param_ `use_data_descriptor` — whether the entry uses a postfix data descriptor to specify size
+    # _@param_ `use_data_descriptor` — whether there is going to be a data descriptor written after the entry body, to specify size. You must enable this if you are going to be using {Streamer#write_deflated_file} as otherwise your estimated size is not going to be accurate
     # 
     # _@return_ — self
     sig do
       params(
         filename: String,
-        uncompressed_size: Fixnum,
-        compressed_size: Fixnum,
+        uncompressed_size: Integer,
+        compressed_size: Integer,
         use_data_descriptor: T::Boolean
       ).returns(T.untyped)
     end
@@ -1972,7 +1970,7 @@ end, T.untyped)
     # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
     # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
-    sig { params(bytes: String).returns(Fixnum) }
+    sig { params(bytes: String).returns(Integer) }
     def write(bytes); end
   end
 
@@ -2102,6 +2100,17 @@ end, T.untyped)
     # ones - for example, specific content types are needed for files which are, technically, ZIP files
     # but are of a file format built "on top" of ZIPs - such as ODTs, [pkpass files](https://developer.apple.com/documentation/walletpasses/building_a_pass)
     # and ePubs.
+    # 
+    # More value, however, is in the "technical" headers this method will provide. It will take the following steps to make sure streaming works correctly.
+    # 
+    # * `Last-Modified` will be set to "now" so that the response is considered "fresh" by `Rack::ETag`. This is done so that `Rack::ETag` won't try to
+    #      calculate a lax ETag value and thus won't start buffering your response out of nowhere
+    # * `Content-Encoding` will be set to `identity`. This is so that proxies or the Rack middleware that applies compression to the response (like gzip)
+    #      is not going to try to compress your response. It also tells the receiving browsers (or downstream proxies) that they should not attempt to
+    #      open or uncompress the response before saving it or passing it onwards.
+    # * `X-Accel-Buffering` will be set to 'no` - this tells both nginx and the Google Cloud load balancer that the response should not be buffered
+    # 
+    # These header values are known to get as close as possible to guaranteeing streaming on most environments where Ruby web applications may be hosted.
     sig { returns(T::Hash[T.untyped, T.untyped]) }
     def self.streaming_http_headers; end
 

data/zip_kit.gemspec

@@ -40,6 +40,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "standard", "1.28.5" # Very specific version of standard for 2.6 with _known_ settings
   spec.add_development_dependency "magic_frozen_string_literal"
   spec.add_development_dependency "puma"
+  spec.add_development_dependency "mutex_m" # Some deps use it but it is no longer in stdlib since 3.4
+  spec.add_development_dependency "bigdecimal" # Some deps use it but it is no longer in stdlib since 3.4
   spec.add_development_dependency "rails", "~> 5" # For testing RailsStreaming against an actual Rails controller
   spec.add_development_dependency "actionpack", "~> 5" # For testing RailsStreaming against an actual Rails controller
   spec.add_development_dependency "nokogiri", "~> 1", ">= 1.13" # Rails 5 does by mistake use an older Nokogiri otherwise

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zip_kit
 version: !ruby/object:Gem::Version
-  version: 6.3.0
+  version: 6.3.2
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -9,10 +9,9 @@ authors:
 - Dmitry Tymchuk
 - David Bosveld
 - Felix Bünemann
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-01 00:00:00.000000000 Z
+date: 2025-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -216,6 +215,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -299,10 +326,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
 - ".github/workflows/ci.yml"
 - ".gitignore"
-- ".rspec"
 - ".standard.yml"
 - ".yardopts"
 - CHANGELOG.md
@@ -314,7 +339,6 @@ files:
 - README.md
 - RUBYZIP_DIFFERENCES.md
 - Rakefile
-- bench/buffered_crc32_bench.rb
 - examples/archive_size_estimate.rb
 - examples/config.ru
 - examples/deferred_write.rb
@@ -359,7 +383,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -374,8 +397,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Stream out ZIP files from Ruby. Successor to zip_tricks.
 test_files: []

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/.rspec

@@ -1 +0,0 @@
---color