zip_kit 6.2.0 → 6.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14382b872a41cb63ba80b664d0b42135b8105aabbf42f2813716d3b98c1f4ff5
-  data.tar.gz: c78ff42650fba09aa01854a91cf491f51ab307413c01b8cd7c0f0ccb0d8954cb
+  metadata.gz: f1d33b58f4501d3ddbae7abcab3957fde0549abf734eae72ca1a7ce45601f479
+  data.tar.gz: e9126924e6fe75329237ba551a1a65218676c7d2b3757f4ad91e73eb0bce154e
 SHA512:
-  metadata.gz: 41a91eda762ca8668fe2696746367ade01b9029f03056f8d9da93b6dfb1f811d4eaec7b1159015287128db1ef94382a2776bdac86872cbe642a087c46154b450
-  data.tar.gz: 676b8fd3e58f255087731cc209249bbba6e9ab8f87269cb182fc3ed62664d0c1a4ae14a51415fb4c9fc5f8674182a795d8f5103a57fb2b5a5ba28441948fa66e
+  metadata.gz: 011e57f856ebe7f625b0bfa5eeb4a240c6c38f2b07ff0434b7e89805516b2d47b6d4230ac404203d00562586909c72d7ea225a7238d47af70fb99ed97b3d50bc
+  data.tar.gz: b68fbaae2e57314c47e7971aeef2150341ba80308c7dee1536718250f5cac01b4b387fe3f73cde5f84fb1ffcd93500343ec451d0fccf9f19b2c0c4a58e74aa2f

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 6.2.1
+
+* Make `RailsStreaming` compatible with `ActionController::Live` (previously the response would hang)
+* Make `BlockWrite` respond to `write` in addition to `<<`
+
 ## 6.2.0
 
 * Remove forced `Transfer-Encoding: chunked` and the chunking body wrapper. It is actually a good idea to trust the app webserver to apply the transfer encoding as is appropriate. For the case when "you really have to", add a bypass in `RailsStreaming#zip_kit_stream` for forcing the chunking manually.
@@ -149,7 +154,7 @@
 ## 4.4.2
 
 * Add 2.4 to Travis rubies
-* Fix a severe performance degradation in Streamer with large file counts (https://github.com/WeTransfer/zip_kit/pull/14)
+* Fix a severe performance degradation in Streamer with large file counts (https://github.com/WeTransfer/zip_tricks/pull/14)
 
 ## 4.4.1
 

data/CONTRIBUTING.md

@@ -106,11 +106,11 @@ project:
 
    ```bash
    # Clone your fork of the repo into the current directory
-   git clone git@github.com:WeTransfer/zip_kit.git
+   git clone git@github.com:julik/zip_kit.git
    # Navigate to the newly cloned directory
    cd zip_kit
    # Assign the original repo to a remote called "upstream"
-   git remote add upstream git@github.com:WeTransfer/zip_kit.git
+   git remote add upstream git@github.com:julik/zip_kit.git
    ```
 
 2. If you cloned a while ago, get the latest changes from upstream:

data/README.md

@@ -59,7 +59,7 @@ via HTTP.
 and the ZIP output will run in the same thread as your main request. Your testing flows (be it minitest or
 RSpec) should work normally with controller actions returning ZIPs.
 
-## Writing into other streaming destinations and through streaming wrappers
+## Writing into streaming destinations
 
 Any object that accepts bytes via either `<<` or `write` methods can be a write destination. For example, here
 is how to upload a sizeable ZIP to S3 - the SDK will happily chop your upload into multipart upload parts:
@@ -69,23 +69,23 @@ bucket = Aws::S3::Bucket.new("mybucket")
 obj = bucket.object("big.zip")
 obj.upload_stream do |write_stream|
   ZipKit::Streamer.open(write_stream) do |zip|
-    zip.write_file("large.csv") do |sink|
-      CSV(sink) do |csv|
-        csv << ["Line", "Item"]
-        20_000.times do |n|
-          csv << [n, "Item number #{n}"]
-        end
+    zip.write_file("file.csv") do |sink|
+      File.open("large.csv", "rb") do |file_input|
+        IO.copy_stream(file_input, sink)
       end
     end
   end
 end
 ```
 
+## Writing through streaming wrappers
+
 Any object that writes using either `<<` or `write` can write into a `sink`. For example, you can do streaming
-output with [builder](https://github.com/jimweirich/builder#project-builder)
+output with [builder](https://github.com/jimweirich/builder#project-builder) which calls `<<` on its `target`
+every time a complete write call is done:
 
 ```ruby
-zip.write_file('report1.csv') do |sink|
+zip.write_file('employees.xml') do |sink|
   builder = Builder::XmlMarkup.new(target: sink, indent: 2)
   builder.people do
     Person.all.find_each do |person|
@@ -95,8 +95,18 @@ zip.write_file('report1.csv') do |sink|
 end
 ```
 
-and this output will be compressed and output into the ZIP file on the fly. zip_kit composes with any
-Ruby code that streams its output into a destination.
+The output will be compressed and output into the ZIP file on the fly. Same for CSV:
+
+```ruby
+zip.write_file('line_items.csv') do |sink|
+  CSV(sink) do |csv|
+    csv << ["Line", "Item"]
+    20_000.times do |n|
+      csv << [n, "Item number #{n}"]
+    end
+  end
+end
+```
 
 ## Create a ZIP file without size estimation, compress on-the-fly during writes
 
@@ -122,12 +132,10 @@ since you do not know how large the compressed data segments are going to be.
 ## Send a ZIP from a Rack response
 
 zip_kit provides an `OutputEnumerator` object which will yield the binary chunks piece
-by piece, and apply some amount of buffering as well. Note that you might want to wrap
-it with a chunked transfer encoder - the `to_rack_response_headers_and_body` method will do
-that for you. Return the headers and the body to your webserver and you will have your ZIP streamed!
-The block that you give to the `OutputEnumerator` receive the {ZipKit::Streamer} object and will only
-start executing once your response body starts getting iterated over - when actually sending
-the response to the client (unless you are using a buffering Rack webserver, such as Webrick).
+by piece, and apply some amount of buffering as well. Return the headers and the body to your webserver
+and you will have your ZIP streamed! The block that you give to the `OutputEnumerator` will receive
+the {ZipKit::Streamer} object and will only start executing once your response body starts getting iterated
+over - when actually sending the response to the client (unless you are using a buffering Rack webserver, such as Webrick).
 
 ```ruby
 body = ZipKit::OutputEnumerator.new do | zip |
@@ -139,8 +147,7 @@ body = ZipKit::OutputEnumerator.new do | zip |
   end
 end
 
-headers, streaming_body = body.to_rack_response_headers_and_body(env)
-[200, headers, streaming_body]
+[200, body.streaming_http_headers, body]
 ```
 
 ## Send a ZIP file of known size, with correct headers
@@ -160,8 +167,10 @@ zip_body = ZipKit::OutputEnumerator.new do | zip |
   zip << read_file('myfile2.bin')
 end
 
-headers, streaming_body = body.to_rack_response_headers_and_body(env, content_length: bytesize)
-[200, headers, streaming_body]
+hh = zip_body.streaming_http_headers
+hh["Content-Length"] = bytesize.to_s
+
+[200, hh, zip_body]
 ```
 
 ## Writing ZIP files using the Streamer bypass

data/lib/zip_kit/block_write.rb

@@ -17,9 +17,12 @@
 #     end
 #     [200, {}, MyRackResponse.new]
 class ZipKit::BlockWrite
+  include ZipKit::WriteShovel
+
   # Creates a new BlockWrite.
   #
   # @param block The block that will be called when this object receives the `<<` message
+  # @yieldparam bytes[String] A string in binary encoding which has just been written into the object
   def initialize(&block)
     @block = block
   end
@@ -36,7 +39,7 @@ class ZipKit::BlockWrite
   # @param buf[String] the string to write. Note that a zero-length String
   #    will not be forwarded to the block, as it has special meaning when used
   #    with chunked encoding (it indicates the end of the stream).
-  # @return self
+  # @return [ZipKit::BlockWrite]
   def <<(buf)
     # Zero-size output has a special meaning  when using chunked encoding
     return if buf.nil? || buf.bytesize.zero?

data/lib/zip_kit/output_enumerator.rb

@@ -60,14 +60,11 @@ class ZipKit::OutputEnumerator
   #       ...
   #     end
   #
-  # @param kwargs_for_new [Hash] keyword arguments for {Streamer.new}
-  # @return [ZipKit::OutputEnumerator] the enumerator you can read bytestrings of the ZIP from by calling `each`
-  #
   # @param streamer_options[Hash] options for Streamer, see {ZipKit::Streamer.new}
   # @param write_buffer_size[Integer] By default all ZipKit writes are unbuffered. For output to sockets
   #     it is beneficial to bulkify those writes so that they are roughly sized to a socket buffer chunk. This
   #     object will bulkify writes for you in this way (so `each` will yield not on every call to `<<` from the Streamer
-  #     but at block size boundaries or greater). Set it to 0 for unbuffered writes.
+  #     but at block size boundaries or greater). Set the parameter to 0 for unbuffered writes.
   # @param blk a block that will receive the Streamer object when executing. The block will not be executed
   #     immediately but only once `each` is called on the OutputEnumerator
   def initialize(write_buffer_size: DEFAULT_WRITE_BUFFER_SIZE, **streamer_options, &blk)
@@ -100,9 +97,14 @@ class ZipKit::OutputEnumerator
   end
 
   # Returns a Hash of HTTP response headers you are likely to need to have your response stream correctly.
+  # This is on the {ZipKit::OutputEnumerator} class since those headers are common, independent of the
+  # particular response body getting served. You might want to override the headers with your particular
+  # 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.
   #
   # @return [Hash]
-  def streaming_http_headers
+  def self.streaming_http_headers
     _headers = {
       # We need to ensure Rack::ETag does not suddenly start buffering us, see
       # https://github.com/rack/rack/issues/1619#issuecomment-606315714
@@ -121,6 +123,15 @@ class ZipKit::OutputEnumerator
     }
   end
 
+  # Returns a Hash of HTTP response headers for this particular response. This used to contain "Content-Length" for
+  # presized responses, but is now effectively a no-op.
+  #
+  # @see [ZipKit::OutputEnumerator.streaming_http_headers]
+  # @return [Hash]
+  def streaming_http_headers
+    self.class.streaming_http_headers
+  end
+
   # Returns a tuple of `headers, body` - headers are a `Hash` and the body is
   # an object that can be used as a Rack response body. This method used to accept arguments
   # but will now just ignore them.

data/lib/zip_kit/rails_streaming.rb

@@ -13,10 +13,6 @@ module ZipKit::RailsStreaming
   # @yieldparam [ZipKit::Streamer] the streamer that can be written to
   # @return [ZipKit::OutputEnumerator] The output enumerator assigned to the response body
   def zip_kit_stream(filename: "download.zip", type: "application/zip", use_chunked_transfer_encoding: false, **zip_streamer_options, &zip_streaming_blk)
-    # The output enumerator yields chunks of bytes generated from ZipKit. Instantiating it
-    # first will also validate the Streamer options.
-    output_enum = ZipKit::OutputEnumerator.new(**zip_streamer_options, &zip_streaming_blk)
-
     # We want some common headers for file sending. Rails will also set
     # self.sending_file = true for us when we call send_file_headers!
     send_file_headers!(type: type, filename: filename)
@@ -29,16 +25,39 @@ module ZipKit::RailsStreaming
       logger&.warn { "The downstream HTTP proxy/LB insists on HTTP/1.0 protocol, ZIP response will be buffered." }
     end
 
-    headers = output_enum.streaming_http_headers
+    headers = ZipKit::OutputEnumerator.streaming_http_headers
+    response.headers.merge!(headers)
 
-    # In rare circumstances (such as the app using Rack::ContentLength - which should normally
-    # not be used allow the user to force the use of the chunked encoding
-    if use_chunked_transfer_encoding
-      output_enum = ZipKit::RackChunkedBody.new(output_enum)
-      headers["Transfer-Encoding"] = "chunked"
-    end
+    # The output enumerator yields chunks of bytes generated from the Streamer,
+    # with some buffering
+    output_enum = ZipKit::OutputEnumerator.new(**zip_streamer_options, &zip_streaming_blk)
 
-    response.headers.merge!(headers)
-    self.response_body = output_enum
+    # Time for some branching, which mostly has to do with the 999 flavours of
+    # "how to make both Rails and Rack stream"
+    if self.class.ancestors.include?(ActionController::Live)
+      # If this controller includes Live it will not work correctly with a Rack
+      # response body assignment - we need to write into the Live output stream instead
+      begin
+        output_enum.each { |bytes| response.stream.write(bytes) }
+      ensure
+        response.stream.close
+      end
+    elsif use_chunked_transfer_encoding
+      # Chunked encoding may be forced if, for example, you _need_ to bypass Rack::ContentLength.
+      # Rack::ContentLength is normally not in a Rails middleware stack, but it might get
+      # introduced unintentionally - for example, "rackup" adds the ContentLength middleware for you.
+      # There is a recommendation to leave the chunked encoding to the app server, so that servers
+      # that support HTTP/2 can use native framing and not have to deal with the chunked encoding,
+      # see https://github.com/julik/zip_kit/issues/7
+      # But it is not to be excluded that a user may need to force the chunked encoding to bypass
+      # some especially pesky Rack middleware that just would not cooperate. Those include
+      # Rack::MiniProfiler and the above-mentioned Rack::ContentLength.
+      response.headers["Transfer-Encoding"] = "chunked"
+      self.response_body = ZipKit::RackChunkedBody.new(output_enum)
+    else
+      # Stream using a Rack body assigned to the ActionController response body, without
+      # doing explicit chunked encoding. See above for the reasoning.
+      self.response_body = output_enum
+    end
   end
 end

data/lib/zip_kit/streamer.rb

@@ -2,19 +2,19 @@
 
 require "set"
 
-# Is used to write streamed ZIP archives into the provided IO-ish object.
-# The output IO is never going to be rewound or seeked, so the output
-# of this object can be coupled directly to, say, a Rack output. The
-# output can also be a String, Array or anything that responds to `<<`.
+# Is used to write ZIP archives without having to read them back or to overwrite
+# data. It outputs into any object that supports `<<` or `write`, namely:
 #
-# Allows for splicing raw files (for "stored" entries without compression)
-# and splicing of deflated files (for "deflated" storage mode).
+# An `Array`, `File`, `IO`, `Socket` and even `String` all can be output destinations
+# for the `Streamer`.
 #
-# For stored entries, you need to know the CRC32 (as a uint) and the filesize upfront,
-# before the writing of the entry body starts.
+# You can also combine output through the `Streamer` with direct output to the destination,
+# all while preserving the correct offsets in the ZIP file structures. This allows usage
+# of `sendfile()` or socket `splice()` calls for "through" proxying.
 #
-# Any object that responds to `<<` can be used as the Streamer target - you can use
-# a String, an Array, a Socket or a File, at your leisure.
+# If you want to avoid data descriptors - or write data bypassing the Streamer -
+# you need to know the CRC32 (as a uint) and the filesize upfront,
+# before the writing of the entry body starts.
 #
 # ## Using the Streamer with runtime compression
 #
@@ -34,7 +34,7 @@ require "set"
 #       end
 #     end
 #
-# The central directory will be written automatically at the end of the block.
+# The central directory will be written automatically at the end of the `open` block.
 #
 # ## Using the Streamer with entries of known size and having a known CRC32 checksum
 #

data/lib/zip_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZipKit
-  VERSION = "6.2.0"
+  VERSION = "6.2.1"
 end

data/lib/zip_kit/write_shovel.rb

@@ -13,8 +13,8 @@ module ZipKit::WriteShovel
   # Writes the given data to the output stream. Allows the object to be used as
   # a target for `IO.copy_stream(from, to)`
   #
-  # @param d[String] the binary string to write (part of the uncompressed file)
-  # @return [Fixnum] the number of bytes written
+  # @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`)
   def write(bytes)
     self << bytes
     bytes.bytesize

data/rbi/zip_kit.rbi

@@ -1,6 +1,6 @@
 # typed: strong
 module ZipKit
-  VERSION = T.let("6.2.0", T.untyped)
+  VERSION = T.let("6.2.1", T.untyped)
 
   # A ZIP archive contains a flat list of entries. These entries can implicitly
   # create directories when the archive is expanded. For example, an entry with
@@ -100,19 +100,19 @@ module ZipKit
     end
   end
 
-  # Is used to write streamed ZIP archives into the provided IO-ish object.
-  # The output IO is never going to be rewound or seeked, so the output
-  # of this object can be coupled directly to, say, a Rack output. The
-  # output can also be a String, Array or anything that responds to `<<`.
+  # Is used to write ZIP archives without having to read them back or to overwrite
+  # data. It outputs into any object that supports `<<` or `write`, namely:
   # 
-  # Allows for splicing raw files (for "stored" entries without compression)
-  # and splicing of deflated files (for "deflated" storage mode).
+  # An `Array`, `File`, `IO`, `Socket` and even `String` all can be output destinations
+  # for the `Streamer`.
   # 
-  # For stored entries, you need to know the CRC32 (as a uint) and the filesize upfront,
-  # before the writing of the entry body starts.
+  # You can also combine output through the `Streamer` with direct output to the destination,
+  # all while preserving the correct offsets in the ZIP file structures. This allows usage
+  # of `sendfile()` or socket `splice()` calls for "through" proxying.
   # 
-  # Any object that responds to `<<` can be used as the Streamer target - you can use
-  # a String, an Array, a Socket or a File, at your leisure.
+  # If you want to avoid data descriptors - or write data bypassing the Streamer -
+  # you need to know the CRC32 (as a uint) and the filesize upfront,
+  # before the writing of the entry body starts.
   # 
   # ## Using the Streamer with runtime compression
   # 
@@ -132,7 +132,7 @@ module ZipKit
   #       end
   #     end
   # 
-  # The central directory will be written automatically at the end of the block.
+  # The central directory will be written automatically at the end of the `open` block.
   # 
   # ## Using the Streamer with entries of known size and having a known CRC32 checksum
   # 
@@ -563,13 +563,12 @@ module ZipKit
     sig { params(filename: T.untyped).returns(T.untyped) }
     def remove_backslash(filename); end
 
-    # sord infer - argument name in single @param inferred as "bytes"
     # Writes the given data to the output stream. Allows the object to be used as
     # a target for `IO.copy_stream(from, to)`
     # 
-    # _@param_ `d` — the binary string to write (part of the uncompressed file)
+    # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
-    # _@return_ — the number of bytes written
+    # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
     sig { params(bytes: String).returns(Fixnum) }
     def write(bytes); end
 
@@ -678,13 +677,12 @@ module ZipKit
       sig { returns(T.untyped) }
       def close; end
 
-      # sord infer - argument name in single @param inferred as "bytes"
       # Writes the given data to the output stream. Allows the object to be used as
       # a target for `IO.copy_stream(from, to)`
       # 
-      # _@param_ `d` — the binary string to write (part of the uncompressed file)
+      # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
-      # _@return_ — the number of bytes written
+      # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
       sig { params(bytes: String).returns(Fixnum) }
       def write(bytes); end
     end
@@ -748,13 +746,12 @@ module ZipKit
       sig { returns(T::Hash[T.untyped, T.untyped]) }
       def finish; end
 
-      # sord infer - argument name in single @param inferred as "bytes"
       # Writes the given data to the output stream. Allows the object to be used as
       # a target for `IO.copy_stream(from, to)`
       # 
-      # _@param_ `d` — the binary string to write (part of the uncompressed file)
+      # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
-      # _@return_ — the number of bytes written
+      # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
       sig { params(bytes: String).returns(Fixnum) }
       def write(bytes); end
     end
@@ -787,13 +784,12 @@ module ZipKit
       sig { returns(T::Hash[T.untyped, T.untyped]) }
       def finish; end
 
-      # sord infer - argument name in single @param inferred as "bytes"
       # Writes the given data to the output stream. Allows the object to be used as
       # a target for `IO.copy_stream(from, to)`
       # 
-      # _@param_ `d` — the binary string to write (part of the uncompressed file)
+      # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
       # 
-      # _@return_ — the number of bytes written
+      # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
       sig { params(bytes: String).returns(Fixnum) }
       def write(bytes); end
     end
@@ -1107,19 +1103,28 @@ end, T.untyped)
   #     end
   #     [200, {}, MyRackResponse.new]
   class BlockWrite
+    include ZipKit::WriteShovel
+
     # Creates a new BlockWrite.
     # 
     # _@param_ `block` — The block that will be called when this object receives the `<<` message
-    sig { params(block: T.untyped).void }
+    sig { params(block: T.proc.params(bytes: String).void).void }
     def initialize(&block); end
 
     # Sends a string through to the block stored in the BlockWrite.
     # 
     # _@param_ `buf` — the string to write. Note that a zero-length String will not be forwarded to the block, as it has special meaning when used with chunked encoding (it indicates the end of the stream).
-    # 
-    # _@return_ — self
-    sig { params(buf: String).returns(T.untyped) }
+    sig { params(buf: String).returns(ZipKit::BlockWrite) }
     def <<(buf); end
+
+    # Writes the given data to the output stream. Allows the object to be used as
+    # a target for `IO.copy_stream(from, to)`
+    # 
+    # _@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) }
+    def write(bytes); end
   end
 
   # A very barebones ZIP file reader. Is made for maximum interoperability, but at the same
@@ -1657,13 +1662,12 @@ end, T.untyped)
     sig { params(crc32: Fixnum, blob_size: Fixnum).returns(Fixnum) }
     def append(crc32, blob_size); end
 
-    # sord infer - argument name in single @param inferred as "bytes"
     # Writes the given data to the output stream. Allows the object to be used as
     # a target for `IO.copy_stream(from, to)`
     # 
-    # _@param_ `d` — the binary string to write (part of the uncompressed file)
+    # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
-    # _@return_ — the number of bytes written
+    # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
     sig { params(bytes: String).returns(Fixnum) }
     def write(bytes); end
   end
@@ -1728,13 +1732,12 @@ end, T.untyped)
   # "IO-ish" things to also respond to `write`? This is what this module does.
   # Jim would be proud. We miss you, Jim.
   module WriteShovel
-    # sord infer - argument name in single @param inferred as "bytes"
     # Writes the given data to the output stream. Allows the object to be used as
     # a target for `IO.copy_stream(from, to)`
     # 
-    # _@param_ `d` — the binary string to write (part of the uncompressed file)
+    # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
-    # _@return_ — the number of bytes written
+    # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
     sig { params(bytes: String).returns(Fixnum) }
     def write(bytes); end
   end
@@ -1960,13 +1963,12 @@ end, T.untyped)
     sig { returns(T.untyped) }
     def tell; end
 
-    # sord infer - argument name in single @param inferred as "bytes"
     # Writes the given data to the output stream. Allows the object to be used as
     # a target for `IO.copy_stream(from, to)`
     # 
-    # _@param_ `d` — the binary string to write (part of the uncompressed file)
+    # _@param_ `bytes` — the binary string to write (part of the uncompressed file)
     # 
-    # _@return_ — the number of bytes written
+    # _@return_ — the number of bytes written (will always be the bytesize of `bytes`)
     sig { params(bytes: String).returns(Fixnum) }
     def write(bytes); end
   end
@@ -2056,15 +2058,11 @@ end, T.untyped)
     #       ...
     #     end
     # 
-    # _@param_ `kwargs_for_new` — keyword arguments for {Streamer.new}
-    # 
     # _@param_ `streamer_options` — options for Streamer, see {ZipKit::Streamer.new}
     # 
-    # _@param_ `write_buffer_size` — By default all ZipKit writes are unbuffered. For output to sockets it is beneficial to bulkify those writes so that they are roughly sized to a socket buffer chunk. This object will bulkify writes for you in this way (so `each` will yield not on every call to `<<` from the Streamer but at block size boundaries or greater). Set it to 0 for unbuffered writes.
+    # _@param_ `write_buffer_size` — By default all ZipKit writes are unbuffered. For output to sockets it is beneficial to bulkify those writes so that they are roughly sized to a socket buffer chunk. This object will bulkify writes for you in this way (so `each` will yield not on every call to `<<` from the Streamer but at block size boundaries or greater). Set the parameter to 0 for unbuffered writes.
     # 
     # _@param_ `blk` — a block that will receive the Streamer object when executing. The block will not be executed immediately but only once `each` is called on the OutputEnumerator
-    # 
-    # _@return_ — the enumerator you can read bytestrings of the ZIP from by calling `each`
     sig { params(write_buffer_size: Integer, streamer_options: T::Hash[T.untyped, T.untyped], blk: T.untyped).void }
     def initialize(write_buffer_size: DEFAULT_WRITE_BUFFER_SIZE, **streamer_options, &blk); end
 
@@ -2083,6 +2081,18 @@ end, T.untyped)
     def each; end
 
     # Returns a Hash of HTTP response headers you are likely to need to have your response stream correctly.
+    # This is on the {ZipKit::OutputEnumerator} class since those headers are common, independent of the
+    # particular response body getting served. You might want to override the headers with your particular
+    # 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.
+    sig { returns(T::Hash[T.untyped, T.untyped]) }
+    def self.streaming_http_headers; end
+
+    # Returns a Hash of HTTP response headers for this particular response. This used to contain "Content-Length" for
+    # presized responses, but is now effectively a no-op.
+    # 
+    # _@see_ `[ZipKit::OutputEnumerator.streaming_http_headers]`
     sig { returns(T::Hash[T.untyped, T.untyped]) }
     def streaming_http_headers; end
 

data/zip_kit.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.version = ZipKit::VERSION
   spec.authors = ["Julik Tarkhanov", "Noah Berman", "Dmitry Tymchuk", "David Bosveld", "Felix Bünemann"]
   spec.email = ["me@julik.nl"]
-
+  spec.license = "MIT"
   spec.summary = "Stream out ZIP files from Ruby. Successor to zip_tricks."
   spec.description = "Stream out ZIP files from Ruby. Successor to zip_tricks."
   spec.homepage = "https://github.com/julik/zip_kit"
@@ -23,9 +23,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rubyzip", "~> 1"
 
-  spec.add_development_dependency "rack" # For tests where we spin up a server
+  # zip_kit does not use any runtime dependencies (besides zlib). However, for testing
+  # things quite a few things are used - and for a good reason.
+
+  spec.add_development_dependency "rubyzip", "~> 1" # We test our output with _another_ ZIP library, which is the way to go here
+  spec.add_development_dependency "rack" # For tests where we spin up a server. Both for streaming out and for testing reads over HTTP
   spec.add_development_dependency "rake", "~> 12.2"
   spec.add_development_dependency "rspec", "~> 3"
   spec.add_development_dependency "rspec-mocks", "~> 3.10", ">= 3.10.2" # ruby 3 compatibility

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zip_kit
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.2.1
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-11 00:00:00.000000000 Z
+date: 2024-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -324,7 +324,8 @@ files:
 - rbi/zip_kit.rbi
 - zip_kit.gemspec
 homepage: https://github.com/julik/zip_kit
-licenses: []
+licenses:
+- MIT
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: