zip_kit 6.4.1 → 6.4.2

data/rbi/zip_kit.rbi

@@ -1034,11 +1034,6 @@ end, T.untyped)
   os_type = 3 # UNIX
   [VERSION_MADE_BY, os_type].pack("CC").freeze
 end, T.untyped)
-    C_UINT4 = T.let("V", T.untyped)
-    C_UINT2 = T.let("v", T.untyped)
-    C_UINT8 = T.let("Q<", T.untyped)
-    C_CHAR = T.let("C", T.untyped)
-    C_INT4 = T.let("l<", T.untyped)
 
     # sord duck - #<< looks like a duck type, replacing with untyped
     # Writes the local file header, that precedes the actual file _data_.
@@ -1201,27 +1196,53 @@ end, T.untyped)
     sig { params(t: T.untyped).returns(T.untyped) }
     def to_binary_dos_date(t); end
 
-    # sord omit - no YARD type given for "values_to_packspecs", using untyped
-    # sord omit - no YARD return type given, using untyped
-    # Unzips a given array of tuples of "numeric value, pack specifier" and then packs all the odd
-    # values using specifiers from all the even values. It is harder to explain than to show:
-    # 
-    #   pack_array([1, 'V', 2, 'v', 148, 'v]) #=> "\x01\x00\x00\x00\x02\x00\x94\x00"
-    # 
-    # will do the following two transforms:
-    # 
-    #  [1, 'V', 2, 'v', 148, 'v] -> [1,2,148], ['V','v','v'] -> [1,2,148].pack('Vvv') -> "\x01\x00\x00\x00\x02\x00\x94\x00".
-    # This might seem like a "clever optimisation" but the issue is that `pack` needs an array allocated per call, and
-    # we output very verbosely - value-by-value. This might be quite a few array allocs. Using something like this
-    # helps us save the array allocs
-    sig { params(values_to_packspecs: T.untyped).returns(T.untyped) }
-    def pack_array(values_to_packspecs); end
-
     # sord omit - no YARD type given for "unix_permissions_int", using untyped
     # sord omit - no YARD type given for "file_type_int", using untyped
     # sord omit - no YARD return type given, using untyped
     sig { params(unix_permissions_int: T.untyped, file_type_int: T.untyped).returns(T.untyped) }
     def generate_external_attrs(unix_permissions_int, file_type_int); end
+
+    # Collects the values of a ZIP record and packs them all with a single `Array#pack`.
+    # Packing value-by-value allocates an Array and a String per value, and the ZIP headers have lots of values.
+    # All integers are little-endian, as the ZIP format wants them.
+    class PackBuffer
+      sig { void }
+      def initialize; end
+
+      # _@param_ `value` — a 1-byte unsigned int
+      sig { params(value: Integer).returns(T.self_type) }
+      def uint1(value); end
+
+      # _@param_ `value` — a 2-byte unsigned int
+      sig { params(value: Integer).returns(T.self_type) }
+      def uint2(value); end
+
+      # _@param_ `value` — a 4-byte unsigned int
+      sig { params(value: Integer).returns(T.self_type) }
+      def uint4(value); end
+
+      # _@param_ `value` — an 8-byte unsigned int
+      sig { params(value: Integer).returns(T.self_type) }
+      def uint8(value); end
+
+      # _@param_ `value` — a 4-byte signed int
+      sig { params(value: Integer).returns(T.self_type) }
+      def int4(value); end
+
+      # _@param_ `value` — a String whose bytes get appended as-is, regardless of its encoding
+      sig { params(value: String).returns(T.self_type) }
+      def bytes(value); end
+
+      # _@return_ — the packed values in binary encoding
+      sig { returns(String) }
+      def b; end
+
+      # sord omit - no YARD type given for "value", using untyped
+      # sord omit - no YARD type given for "packspec", using untyped
+      # sord omit - no YARD return type given, using untyped
+      sig { params(value: T.untyped, packspec: T.untyped).returns(T.untyped) }
+      def append(value, packspec); end
+    end
   end
 
   # Acts as a converter between callers which send data to the `#<<` method (such as all the ZipKit
@@ -1355,6 +1376,10 @@ end, T.untyped)
     C_UINT4 = T.let("V", T.untyped)
     C_UINT2 = T.let("v", T.untyped)
     C_UINT8 = T.let("Q<", T.untyped)
+    LOCAL_HEADER_FIXED_FIELDS_UNPACKSPEC = T.let("VvvvvvVVVvv", T.untyped)
+    SIZE_OF_LOCAL_HEADER_FIXED_FIELDS = T.let(30, T.untyped)
+    CDIR_ENTRY_FIXED_FIELDS_UNPACKSPEC = T.let("VvvvvvvVVVvvvvvVV", T.untyped)
+    SIZE_OF_CDIR_ENTRY_FIXED_FIELDS = T.let(46, T.untyped)
     MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE = T.let(4 + # Offset of the start of central directory
 4 + # Size of the central directory
 2 + # Number of files in the cdir
@@ -1364,19 +1389,7 @@ end, T.untyped)
 2 + # Number of files in the cdir of this disk
 2 + # The comment size
 0xFFFF, T.untyped)
-    MAX_LOCAL_HEADER_SIZE = T.let(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, T.untyped)
+    LOCAL_HEADER_READ_SIZE = T.let(4 * 1024, T.untyped)
     SIZE_OF_USABLE_EOCD_RECORD = T.let(4 + # Signature
 2 + # Number of this disk
 2 + # Number of the disk with the EOCD record
@@ -1424,9 +1437,8 @@ end, T.untyped)
     # sord duck - #read looks like a duck type, replacing with untyped
     # Parse the local header entry and get the offset in the IO at which the
     # actual compressed data of the file starts within the ZIP.
-    # The method will eager-read the entire local header for the file
-    # (the maximum size the local header may use), starting at the given offset,
-    # and will then compute its size. That size plus the local header offset
+    # The method will read the local header for the file, starting at the
+    # given offset, and will then compute its size. That size plus the local header offset
     # given will be the compressed data offset of the entry (read starting at
     # this offset to get the data).
     # 
@@ -1442,9 +1454,8 @@ end, T.untyped)
     # sord duck - #read looks like a duck type, replacing with untyped
     # sord omit - no YARD return type given, using untyped
     # Get the offset in the IO at which the actual compressed data of the file
-    # starts within the ZIP. The method will eager-read the entire local header
-    # for the file (the maximum size the local header may use), starting at the
-    # given offset, and will then compute its size. That size plus the local
+    # starts within the ZIP. The method will read the local header for the file,
+    # starting at the given offset, and will then compute its size. That size plus the local
     # header offset given will be the compressed data offset of the entry
     # (read starting at this offset to get the data).
     # 
@@ -1512,6 +1523,12 @@ end, T.untyped)
     sig { params(io: T.untyped, signature_magic_number: T.untyped).returns(T.untyped) }
     def assert_signature(io, signature_magic_number); end
 
+    # sord omit - no YARD type given for "readback", using untyped
+    # sord omit - no YARD type given for "signature_magic_number", using untyped
+    # sord omit - no YARD return type given, using untyped
+    sig { params(readback: T.untyped, signature_magic_number: T.untyped).returns(T.untyped) }
+    def assert_signature_value(readback, signature_magic_number); end
+
     # sord omit - no YARD type given for "io", using untyped
     # sord omit - no YARD type given for "n", using untyped
     # sord omit - no YARD return type given, using untyped
@@ -2301,9 +2318,12 @@ end, T.untyped)
     # 
     # * `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.
+    # * `cache-control` will be set to `no-transform`. This is so that `Rack::Deflater` and proxies which compress responses (like gzip)
+    #      are not going to try to compress your response again (and, with `Rack::Deflater` set to `sync: false`, buffer all of it to do so).
+    #      It says nothing about caching, so add your own directives to it if you need them, and keep `no-transform` in there
+    # * `content-encoding` will be set to `identity`. This 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. Note that it does _not_ stop `Rack::Deflater`, which compresses
+    #      responses with `content-encoding: identity` just the same
     # * `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.

data/rbi/zip_kit.rbs

@@ -910,11 +910,6 @@ module ZipKit
     FILE_TYPE_FILE: untyped
     FILE_TYPE_DIRECTORY: untyped
     MADE_BY_SIGNATURE: untyped
-    C_UINT4: untyped
-    C_UINT2: untyped
-    C_UINT8: untyped
-    C_CHAR: untyped
-    C_INT4: untyped
 
     # sord duck - #<< looks like a duck type, replacing with untyped
     # Writes the local file header, that precedes the actual file _data_.
@@ -1060,25 +1055,43 @@ module ZipKit
     # sord omit - no YARD return type given, using untyped
     def to_binary_dos_date: (untyped t) -> untyped
 
-    # sord omit - no YARD type given for "values_to_packspecs", using untyped
-    # sord omit - no YARD return type given, using untyped
-    # Unzips a given array of tuples of "numeric value, pack specifier" and then packs all the odd
-    # values using specifiers from all the even values. It is harder to explain than to show:
-    # 
-    #   pack_array([1, 'V', 2, 'v', 148, 'v]) #=> "\x01\x00\x00\x00\x02\x00\x94\x00"
-    # 
-    # will do the following two transforms:
-    # 
-    #  [1, 'V', 2, 'v', 148, 'v] -> [1,2,148], ['V','v','v'] -> [1,2,148].pack('Vvv') -> "\x01\x00\x00\x00\x02\x00\x94\x00".
-    # This might seem like a "clever optimisation" but the issue is that `pack` needs an array allocated per call, and
-    # we output very verbosely - value-by-value. This might be quite a few array allocs. Using something like this
-    # helps us save the array allocs
-    def pack_array: (untyped values_to_packspecs) -> untyped
-
     # sord omit - no YARD type given for "unix_permissions_int", using untyped
     # sord omit - no YARD type given for "file_type_int", using untyped
     # sord omit - no YARD return type given, using untyped
     def generate_external_attrs: (untyped unix_permissions_int, untyped file_type_int) -> untyped
+
+    # Collects the values of a ZIP record and packs them all with a single `Array#pack`.
+    # Packing value-by-value allocates an Array and a String per value, and the ZIP headers have lots of values.
+    # All integers are little-endian, as the ZIP format wants them.
+    class PackBuffer
+      def initialize: () -> void
+
+      # _@param_ `value` — a 1-byte unsigned int
+      def uint1: (Integer value) -> self
+
+      # _@param_ `value` — a 2-byte unsigned int
+      def uint2: (Integer value) -> self
+
+      # _@param_ `value` — a 4-byte unsigned int
+      def uint4: (Integer value) -> self
+
+      # _@param_ `value` — an 8-byte unsigned int
+      def uint8: (Integer value) -> self
+
+      # _@param_ `value` — a 4-byte signed int
+      def int4: (Integer value) -> self
+
+      # _@param_ `value` — a String whose bytes get appended as-is, regardless of its encoding
+      def bytes: (String value) -> self
+
+      # _@return_ — the packed values in binary encoding
+      def b: () -> String
+
+      # sord omit - no YARD type given for "value", using untyped
+      # sord omit - no YARD type given for "packspec", using untyped
+      # sord omit - no YARD return type given, using untyped
+      def append: (untyped value, untyped packspec) -> untyped
+    end
   end
 
   # Acts as a converter between callers which send data to the `#<<` method (such as all the ZipKit
@@ -1198,8 +1211,12 @@ module ZipKit
     C_UINT4: untyped
     C_UINT2: untyped
     C_UINT8: untyped
+    LOCAL_HEADER_FIXED_FIELDS_UNPACKSPEC: untyped
+    SIZE_OF_LOCAL_HEADER_FIXED_FIELDS: untyped
+    CDIR_ENTRY_FIXED_FIELDS_UNPACKSPEC: untyped
+    SIZE_OF_CDIR_ENTRY_FIXED_FIELDS: untyped
     MAX_END_OF_CENTRAL_DIRECTORY_RECORD_SIZE: untyped
-    MAX_LOCAL_HEADER_SIZE: untyped
+    LOCAL_HEADER_READ_SIZE: untyped
     SIZE_OF_USABLE_EOCD_RECORD: untyped
 
     # sord duck - #tell looks like a duck type, replacing with untyped
@@ -1239,9 +1256,8 @@ module ZipKit
     # sord duck - #read looks like a duck type with an equivalent RBS interface, replacing with _Reader
     # Parse the local header entry and get the offset in the IO at which the
     # actual compressed data of the file starts within the ZIP.
-    # The method will eager-read the entire local header for the file
-    # (the maximum size the local header may use), starting at the given offset,
-    # and will then compute its size. That size plus the local header offset
+    # The method will read the local header for the file, starting at the
+    # given offset, and will then compute its size. That size plus the local header offset
     # given will be the compressed data offset of the entry (read starting at
     # this offset to get the data).
     # 
@@ -1256,9 +1272,8 @@ module ZipKit
     # sord duck - #read looks like a duck type with an equivalent RBS interface, replacing with _Reader
     # sord omit - no YARD return type given, using untyped
     # Get the offset in the IO at which the actual compressed data of the file
-    # starts within the ZIP. The method will eager-read the entire local header
-    # for the file (the maximum size the local header may use), starting at the
-    # given offset, and will then compute its size. That size plus the local
+    # starts within the ZIP. The method will read the local header for the file,
+    # starting at the given offset, and will then compute its size. That size plus the local
     # header offset given will be the compressed data offset of the entry
     # (read starting at this offset to get the data).
     # 
@@ -1317,6 +1332,11 @@ module ZipKit
     # sord omit - no YARD return type given, using untyped
     def assert_signature: (untyped io, untyped signature_magic_number) -> untyped
 
+    # sord omit - no YARD type given for "readback", using untyped
+    # sord omit - no YARD type given for "signature_magic_number", using untyped
+    # sord omit - no YARD return type given, using untyped
+    def assert_signature_value: (untyped readback, untyped signature_magic_number) -> untyped
+
     # sord omit - no YARD type given for "io", using untyped
     # sord omit - no YARD type given for "n", using untyped
     # sord omit - no YARD return type given, using untyped
@@ -2020,9 +2040,12 @@ module ZipKit
     # 
     # * `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.
+    # * `cache-control` will be set to `no-transform`. This is so that `Rack::Deflater` and proxies which compress responses (like gzip)
+    #      are not going to try to compress your response again (and, with `Rack::Deflater` set to `sync: false`, buffer all of it to do so).
+    #      It says nothing about caching, so add your own directives to it if you need them, and keep `no-transform` in there
+    # * `content-encoding` will be set to `identity`. This 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. Note that it does _not_ stop `Rack::Deflater`, which compresses
+    #      responses with `content-encoding: identity` just the same
     # * `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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zip_kit
 version: !ruby/object:Gem::Version
-  version: 6.4.1
+  version: 6.4.2
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -11,7 +11,7 @@ authors:
 - Felix Bünemann
 bindir: exe
 cert_chain: []
-date: 2026-10-08 00:00:00.000000000 Z
+date: 2026-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler