zip_kit 6.2.1 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1d33b58f4501d3ddbae7abcab3957fde0549abf734eae72ca1a7ce45601f479
-  data.tar.gz: e9126924e6fe75329237ba551a1a65218676c7d2b3757f4ad91e73eb0bce154e
+  metadata.gz: dcd59b7f9d367a40895c9bac2f909f3e22ebd0a96ee737073ef5153c4d486c70
+  data.tar.gz: 05665ca021d401cad02f80c38d8965c2e5fef1a477317f7ee92246d1c54a21ae
 SHA512:
-  metadata.gz: 011e57f856ebe7f625b0bfa5eeb4a240c6c38f2b07ff0434b7e89805516b2d47b6d4230ac404203d00562586909c72d7ea225a7238d47af70fb99ed97b3d50bc
-  data.tar.gz: b68fbaae2e57314c47e7971aeef2150341ba80308c7dee1536718250f5cac01b4b387fe3f73cde5f84fb1ffcd93500343ec451d0fccf9f19b2c0c4a58e74aa2f
+  metadata.gz: b13d15a467565ef66ce6a21ac3891e8a26b30246d538c232aca193c3fe24a24a8f3a2d844d48eaeaeeb5ccc2f92cfcaab20e4afa1a2717b89ba27f55bb4635e4
+  data.tar.gz: 29aacf905b670323861812a4aece1446917ac2f94ece22b948f5d2f77a6eb7574c39598177e7c4f33cc230fd863b4f1c02eb961c5b48e4823d40854a25368101

data/.yardopts

@@ -1 +1 @@
---markup markdown
+--markup markdown --no-private --protected lib/**/*.rb - LICENSE.txt IMPLEMENTATION_DETAILS.md RUBYZIP_DIFFERENCES.md CONTRIBUTING.md CODE_OF_CONDUCT.md CHANGELOG.md

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 6.3.0
+
+* Include `RailsStreaming` automatically via a Railtie. It is not really necessary to force people to manage it manually.
+
+## 6.2.2
+
+* Make sure "zlib" gets required at the top, as it is used everywhere
+* Improve documentation
+* Make sure `zip_kit_stream` honors the custom `Content-Type` parameter
+* Add a streaming example with Sinatra (and add a Sinatra app to the test harness)
+
 ## 6.2.1
 
 * Make `RailsStreaming` compatible with `ActionController::Live` (previously the response would hang)

data/CONTRIBUTING.md

@@ -16,7 +16,7 @@ If you are interested in contributing code and would like to learn more about th
 
  - [ruby](https://ruby-doc.org)
  - [rubyzip](https://github.com/rubyzip/rubyzip) as we like to test "our implementation against theirs"
- - [rspec](http://rspec.info/) and [appraisal]() https://github.com/thoughtbot/appraisal) for testing
+ - [rspec](http://rspec.info/) for testing
  - [zip files](https://en.wikipedia.org/wiki/Zip_(file_format))
 
 # How do I make a contribution?

data/IMPLEMENTATION_DETAILS.md

@@ -78,8 +78,8 @@ you can try this:
 
    [Encoding::CP437, Encoding::ISO_8859_1, Encoding::UTF_8]
 
-We don't want no such thing, and sorry Windows users, you are going to need a decent unarchiver
-that honors the standard. Alas, alas.
+While this could work, we found it to be broken in practice as the decoding of the filename
+also depends on the system locale.
 
 Additionally, the tests with the unarchivers we _do_ support have shown that including the InfoZIP
 extra field does not actually help any of them recognize the file name correctly. And the use of

data/README.md

@@ -14,8 +14,13 @@ point. Usable for creating very large ZIP archives for immediate sending out to
 large ZIP archives without memory inflation.
 
 The original gem (zip_tricks) handled all the zipping needs (millions of ZIP files generated per day),
-for a large file transfer service, so we are pretty confident it is widely compatible with a large number
-of unarchiving end-user applications and is well tested.
+for WeTransfer, it is widely compatible with a large number of unarchiving end-user applications.
+
+## How does it work? How is it different from Rubyzip?
+
+Check out [the implementation details](IMPLEMENTATION_DETAILS.md) on the design of the library, and
+we have a separate [reference](RUBYZIP_DIFFERENCES.md) on why you might want to use ZipKit over
+Rubyzip and vice versa.
 
 ## Requirements
 
@@ -23,13 +28,11 @@ Ruby 2.6+ syntax support is required, as well as a a working zlib (all available
 
 ## Diving in: send some large CSV reports from Rails
 
-The easiest is to include the `ZipKit::RailsStreaming` module into your
-controller. You will then have a `zip_kit_stream` method available which accepts a block:
+The included `Railtie` will automatically include `ZipKit::RailsStreaming` into the
+`ActionController::Base` class. You will then have a `zip_kit_stream` method available which accepts a block:
 
 ```ruby
 class ZipsController < ActionController::Base
-  include ZipKit::RailsStreaming
-
   def download
     zip_kit_stream do |zip|
       zip.write_file('report1.csv') do |sink|
@@ -48,6 +51,8 @@ class ZipsController < ActionController::Base
 end
 ```
 
+The block receives the `ZipKit::Streamer` object you can write your files through.
+
 The `write_file` method will use some heuristics to determine whether your output file would benefit
 from compression, and pick the appropriate storage mode for the file accordingly.
 
@@ -55,9 +60,9 @@ If you want some more conveniences you can also use [zipline](https://github.com
 will automatically process and stream attachments (Carrierwave, Shrine, ActiveStorage) and remote objects
 via HTTP.
 
-`RailsStreaming` will *not* use [ActionController::Live](https://api.rubyonrails.org/classes/ActionController/Live.html)
-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.
+`RailsStreaming` does *not* require [ActionController::Live](https://api.rubyonrails.org/classes/ActionController/Live.html)
+and will stream without it. See {ZipKit::RailsStreaming#zip_kit_stream} for more details on this. You can use it
+together with `Live` just fine if you need to.
 
 ## Writing into streaming destinations
 
@@ -108,11 +113,17 @@ zip.write_file('line_items.csv') do |sink|
 end
 ```
 
-## Create a ZIP file without size estimation, compress on-the-fly during writes
+## Automatic storage mode (stored vs. deflated)
+
+The ZIP file format allows storage in both compressed and raw storage modes. The raw ("stored")
+mode does not require decompression and unarchives faster.
+
+ZipKit will buffer a small amount of output and attempt to compress it using deflate compression.
+If this turns out to be significantly smaller than raw data, it is then going to proceed with
+all further output using deflate compression. Memory use is going to be very modest, but it allows
+you to not have to think about the appropriate storage mode.
 
-Basic use case is compressing on the fly. Some data will be buffered by the Zlib deflater, but
-memory inflation is going to be very constrained. Data will be written to destination at fairly regular
-intervals. Deflate compression will work best for things like text files. For example, here is how to
+Deflate compression will work great for JSONs, CSVs and other text- or text-like formats. For example, here is how to
 output direct to STDOUT (so that you can run `$ ruby archive.rb > file.zip` in your terminal):
 
 ```ruby
@@ -126,8 +137,8 @@ ZipKit::Streamer.open($stdout) do |zip|
 end
 ```
 
-Unfortunately with this approach it is impossible to compute the size of the ZIP file being output,
-since you do not know how large the compressed data segments are going to be.
+If you want to use specific storage modes, use `write_deflated_file` and `write_stored_file` instead of
+`write_file`.
 
 ## Send a ZIP from a Rack response
 
@@ -152,7 +163,11 @@ end
 
 ## Send a ZIP file of known size, with correct headers
 
-Use the `SizeEstimator` to compute the correct size of the resulting archive.
+Sending a file with data descriptors is not always desirable - you don't really know how large your ZIP is going to be.
+If you want to present your users with proper download progress, you would need to set a `Content-Length` header - and
+know ahead of time how large your download is going to be. This can be done with ZipKit, provided you know how large
+the compressed versions of your file are going to be. Use the {ZipKit::SizeEstimator} to do the pre-calculation - it
+is not going to produce any large amounts of output, and will give you a to-the-byte value for your future archive:
 
 ```ruby
 bytesize = ZipKit::SizeEstimator.estimate do |z|

data/RUBYZIP_DIFFERENCES.md

@@ -0,0 +1,56 @@
+# Key differences between Rubyzip and ZipKit
+
+Please bear in mind that this is written down not to disparage [Rubyzip.](https://github.com/rubyzip/rubyzip)
+
+Rubyzip is, by all means, a very mature, fully featured library, and while ZipKit does have overlap with it in some functionality there are
+differences in supported features which may be important for you when choosing.
+
+## What ZipKit supports and Rubyzip does not
+
+* ZipKit outputs archives in a streaming fashion, using data descriptors.
+  This allows output of archives of very large size, without buffering.
+  Rubyzip will seek in the already written archive to overwrite the local entry after the write of every file into the output ZIP.
+  At the moment, it is difficult to build a streaming Rubyzip solution due to the output of extra field placeholders.
+* ZipKit supports block-deflate which allows for distributed compression of files
+* ZipKit reads files from the central directory, which allows for very rapid reading. Reading works well with data descriptors
+  and Zip64, and is economical enough to enable "remote uncapping" where pieces of a ZIP file get read over HTTP to reconstruct
+  the archive structure. Actual reading can then be done on a per-entry basis. Rubyzip reads entry data from local entries, which
+  is error prone and much less economical than using the central directory
+* ZipKit deliberately _does not_ allow you to crawl directories to add to an archive, as this has been used for security exploits
+  in Rubyzip.
+* ZipKit deliberately _does not_ allow you to extract a ZIP archive directly to the filesystem, as this has been used for security
+  exploits in Rubyzip.
+* When writing, ZipKit applies careful buffering to speed up CRC32 calculations. Rubyzip combines CRC32 values at every write, which
+  can be slow if there are many small writes.
+* ZipKit comes with a Rails helper and a Rack-compatible response body for facilitating streaming. Rubyzip has no Rails integration
+  and no Rack integration.
+* ZipKit allows you to estimate the exact size of an archive ahead of time
+* ZipKit has a heuristic module which picks the storage mode (stored or deflated) depending on how well your input compresses
+* ZipKit requires components using autoloading, which means that your application will likely boot faster as you will almost never
+  need all of the features in one codebase. Rubyzip requires its components eagerly.
+* ZipKit comes with exhaustive YARD documentation and `.rbi` typedefs for [Sorbet/Tapioca](https://sorbet.org/blog/2022/07/27/srb-tapioca)
+
+## What Rubyzip supports and ZipKit does not
+
+* Rubyzip allows limited manipulation of existing ZIP files by overwriting the archive entries
+* Rubyzip supports "classic" ZIP encryption - both for reading and writing. ZipKit has no encryption support.
+* Rubyzip allows extraction into a directory, ZipKit avoids implementing this for security reasons
+* Rubyzip allows archiving a directory, ZipKit avoids implementing this for security reasons
+* Rubyzip supports separate atime and ctime in the `UniversalTime` extra fields. ZipKit outputs just one timestamp
+* Rubyzip attempts to faithfully replicate UNIX permissions on the files being output. ZipKit does not attempt that
+  because it turned out that these permissions can break unarchiving of folders on macOS.
+
+## Where there is currently feature parity
+
+These used to be different, but Rubyzip has made great progress in addressing.
+
+* ZipKit automatically applies the EFS flag for Unicode filenames in the archive. This used to be optional in RubyZip
+* ZipKit automatically enables Zip64 and does so only when necessary. applies the EFS flag for Unicode filenames in the archive. This used to be optional in RubyZip.
+* ZipKit outputs the `UT` precise time extra field
+* ZipKit used to be distributed under the MIT-Hippocratic license which is much more restrictive than the Rubyzip BSD-2-Clause. ZipKit is now MIT-licensed. 
+
+## Code style differences
+
+Rubyzip is written in a somewhat Java-like style, with a lot of encapsulation and data hiding. ZipKit aims to be more approachable and have "less" of everything.
+Less modules, less classes, less OOP - just enough to be useful. But that is a matter of taste, and as such should not matter to you all that much
+when picking one over the other. Or it might, you never know ;-)

data/Rakefile

@@ -11,11 +11,7 @@ task :format do
   `bundle exec magic_frozen_string_literal ./lib`
 end
 
-YARD::Rake::YardocTask.new(:doc) do |t|
-  # The dash has to be between the two to "divide" the source files and
-  # miscellaneous documentation files that contain no code
-  t.files = ["lib/**/*.rb", "-", "LICENSE.txt", "IMPLEMENTATION_DETAILS.md"]
-end
+YARD::Rake::YardocTask.new(:doc)
 RSpec::Core::RakeTask.new(:spec)
 
 task :generate_typedefs do

data/examples/sinatra_application.rb

@@ -0,0 +1,16 @@
+require "sinatra/base"
+
+class SinatraApp < Sinatra::Base
+  get "/" do
+    content_type :zip
+    stream do |out|
+      ZipKit::Streamer.open(out) do |z|
+        z.write_file(File.basename(__FILE__)) do |io|
+          File.open(__FILE__, "r") do |f|
+            IO.copy_stream(f, io)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zip_kit/block_deflate.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "zlib"
-
 # Permits Deflate compression in independent blocks. The workflow is as follows:
 #
 # * Run every block to compress through deflate_chunk, remove the header,

data/lib/zip_kit/output_enumerator.rb

@@ -34,6 +34,15 @@ require "time" # for .httpdate
 #
 # to bypass things like `Rack::ETag` and the nginx buffering.
 class ZipKit::OutputEnumerator
+  # With HTTP output it is better to apply a small amount of buffering. While Streamer
+  # output does not buffer at all, the `OutputEnumerator` does as it is going to
+  # be used as a Rack response body. Applying some buffering helps reduce the number
+  # of syscalls for otherwise tiny writes, which relieves the app webserver from
+  # doing too much work managing those writes. While we recommend buffering, the
+  # buffer size is configurable via the constructor - so you can disable buffering
+  # if you really need to. While ZipKit ams not to buffer, in this instance this
+  # buffering is justified. See https://github.com/WeTransfer/zip_tricks/issues/78
+  # for the background on buffering.
   DEFAULT_WRITE_BUFFER_SIZE = 64 * 1024
 
   # Creates a new OutputEnumerator enumerator. The enumerator can be read from using `each`,

data/lib/zip_kit/rails_streaming.rb

@@ -3,16 +3,30 @@
 # Should be included into a Rails controller for easy ZIP output from any action.
 module ZipKit::RailsStreaming
   # Opens a {ZipKit::Streamer} and yields it to the caller. The output of the streamer
-  # gets automatically forwarded to the Rails response stream. When the output completes,
-  # the Rails response stream is going to be closed automatically.
+  # will be sent through to the HTTP response body as it gets produced.
+  #
+  # Note that there is an important difference in how this method works, depending whether
+  # you use it in a controller which includes `ActionController::Live` vs. one that does not.
+  # With a standard `ActionController` this method will assign a response body, but streaming
+  # will begin when your action method returns. With `ActionController::Live` the streaming
+  # will begin immediately, before the method returns. In all other aspects the method should
+  # stream correctly in both types of controllers.
+  #
+  # If you encounter buffering (streaming does not start for a very long time) you probably
+  # have a piece of Rack middleware in your stack which buffers. Known offenders are `Rack::ContentLength`,
+  # `Rack::MiniProfiler` and `Rack::ETag`. ZipKit will try to work around these but it is not
+  # always possible. If you encounter buffering, examine your middleware stack and try to suss
+  # out whether any middleware might be buffering. You can also try setting `use_chunked_transfer_encoding`
+  # to `true` - this is not recommended but sometimes necessary, for example to bypass `Rack::ContentLength`.
+  #
   # @param filename[String] name of the file for the Content-Disposition header
   # @param type[String] the content type (MIME type) of the archive being output
   # @param use_chunked_transfer_encoding[Boolean] whether to forcibly encode output as chunked. Normally you should not need this.
-  # @param zip_streamer_options[Hash] options that will be passed to the Streamer.
-  #     See {ZipKit::Streamer#initialize} for the full list of options.
-  # @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)
+  # @param output_enumerator_options[Hash] options that will be passed to the OutputEnumerator - these include
+  #     options for the Streamer. See {ZipKit::OutputEnumerator#initialize} for the full list of options.
+  # @yieldparam [ZipKit::Streamer] zip the {ZipKit::Streamer} that can be written to
+  # @return [Boolean] always returns true
+  def zip_kit_stream(filename: "download.zip", type: "application/zip", use_chunked_transfer_encoding: false, **output_enumerator_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)
@@ -26,38 +40,45 @@ module ZipKit::RailsStreaming
     end
 
     headers = ZipKit::OutputEnumerator.streaming_http_headers
-    response.headers.merge!(headers)
+
+    # Allow Rails headers to override ours. This is important if, for example, a content type gets
+    # set to something else than "application/zip"
+    response.headers.reverse_merge!(headers)
 
     # 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)
+    # with some buffering. See OutputEnumerator docs for more.
+    rack_zip_body = ZipKit::OutputEnumerator.new(**output_enumerator_options, &zip_streaming_blk)
+
+    # 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.
+    if use_chunked_transfer_encoding
+      response.headers["Transfer-Encoding"] = "chunked"
+      rack_zip_body = ZipKit::RackChunkedBody.new(rack_zip_body)
+    end
 
     # 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
+      # response body assignment - the action will just hang. We need to read out the response
+      # body ourselves and write it into the Rails stream.
       begin
-        output_enum.each { |bytes| response.stream.write(bytes) }
+        rack_zip_body.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
+      # Stream using a Rack body assigned to the ActionController response body
+      self.response_body = rack_zip_body
     end
+
+    true
   end
 end

data/lib/zip_kit/railtie.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ZipKit::Railtie < ::Rails::Railtie
+  initializer "zip_kit.install_extensions" do |app|
+    ActionController::Base.include(ZipKit::RailsStreaming)
+  end
+end

data/lib/zip_kit/version.rb

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

data/lib/zip_kit.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "zip_kit/version"
+require "zlib"
 
 module ZipKit
   autoload :OutputEnumerator, File.dirname(__FILE__) + "/zip_kit/rack_body.rb"
@@ -23,4 +24,6 @@ module ZipKit
   autoload :WriteShovel, File.dirname(__FILE__) + "/zip_kit/write_shovel.rb"
   autoload :RackChunkedBody, File.dirname(__FILE__) + "/zip_kit/rack_chunked_body.rb"
   autoload :RackTempfileBody, File.dirname(__FILE__) + "/zip_kit/rack_tempfile_body.rb"
+
+  require_relative "zip_kit/railtie" if defined?(::Rails)
 end

data/rbi/zip_kit.rbi

@@ -1,6 +1,9 @@
 # typed: strong
 module ZipKit
-  VERSION = T.let("6.2.1", T.untyped)
+  VERSION = T.let("6.3.0", T.untyped)
+
+  class Railtie < Rails::Railtie
+  end
 
   # 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
@@ -1976,8 +1979,21 @@ end, T.untyped)
   # Should be included into a Rails controller for easy ZIP output from any action.
   module RailsStreaming
     # Opens a {ZipKit::Streamer} and yields it to the caller. The output of the streamer
-    # gets automatically forwarded to the Rails response stream. When the output completes,
-    # the Rails response stream is going to be closed automatically.
+    # will be sent through to the HTTP response body as it gets produced.
+    # 
+    # Note that there is an important difference in how this method works, depending whether
+    # you use it in a controller which includes `ActionController::Live` vs. one that does not.
+    # With a standard `ActionController` this method will assign a response body, but streaming
+    # will begin when your action method returns. With `ActionController::Live` the streaming
+    # will begin immediately, before the method returns. In all other aspects the method should
+    # stream correctly in both types of controllers.
+    # 
+    # If you encounter buffering (streaming does not start for a very long time) you probably
+    # have a piece of Rack middleware in your stack which buffers. Known offenders are `Rack::ContentLength`,
+    # `Rack::MiniProfiler` and `Rack::ETag`. ZipKit will try to work around these but it is not
+    # always possible. If you encounter buffering, examine your middleware stack and try to suss
+    # out whether any middleware might be buffering. You can also try setting `use_chunked_transfer_encoding`
+    # to `true` - this is not recommended but sometimes necessary, for example to bypass `Rack::ContentLength`.
     # 
     # _@param_ `filename` — name of the file for the Content-Disposition header
     # 
@@ -1985,19 +2001,19 @@ end, T.untyped)
     # 
     # _@param_ `use_chunked_transfer_encoding` — whether to forcibly encode output as chunked. Normally you should not need this.
     # 
-    # _@param_ `zip_streamer_options` — options that will be passed to the Streamer. See {ZipKit::Streamer#initialize} for the full list of options.
+    # _@param_ `output_enumerator_options` — options that will be passed to the OutputEnumerator - these include options for the Streamer. See {ZipKit::OutputEnumerator#initialize} for the full list of options.
     # 
-    # _@return_ — The output enumerator assigned to the response body
+    # _@return_ — always returns true
     sig do
       params(
         filename: String,
         type: String,
         use_chunked_transfer_encoding: T::Boolean,
-        zip_streamer_options: T::Hash[T.untyped, T.untyped],
-        zip_streaming_blk: T.proc.params(the: ZipKit::Streamer).void
-      ).returns(ZipKit::OutputEnumerator)
+        output_enumerator_options: T::Hash[T.untyped, T.untyped],
+        zip_streaming_blk: T.proc.params(zip: ZipKit::Streamer).void
+      ).returns(T::Boolean)
     end
-    def zip_kit_stream(filename: "download.zip", type: "application/zip", use_chunked_transfer_encoding: false, **zip_streamer_options, &zip_streaming_blk); end
+    def zip_kit_stream(filename: "download.zip", type: "application/zip", use_chunked_transfer_encoding: false, **output_enumerator_options, &zip_streaming_blk); end
   end
 
   # The output enumerator makes it possible to "pull" from a ZipKit streamer

data/zip_kit.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   # 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 "rubyzip", "~> 2" # 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"
@@ -40,7 +40,9 @@ 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 "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
+  spec.add_development_dependency "sinatra"
   spec.add_development_dependency "sord"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zip_kit
 version: !ruby/object:Gem::Version
-  version: 6.2.1
+  version: 6.3.0
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -34,14 +34,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -216,6 +216,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -250,6 +264,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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: sord
   requirement: !ruby/object:Gem::Requirement
@@ -284,6 +312,7 @@ files:
 - IMPLEMENTATION_DETAILS.md
 - LICENSE.txt
 - README.md
+- RUBYZIP_DIFFERENCES.md
 - Rakefile
 - bench/buffered_crc32_bench.rb
 - examples/archive_size_estimate.rb
@@ -292,6 +321,7 @@ files:
 - examples/parallel_compression_with_block_deflate.rb
 - examples/rack_application.rb
 - examples/s3_upload.rb
+- examples/sinatra_application.rb
 - lib/zip_kit.rb
 - lib/zip_kit/block_deflate.rb
 - lib/zip_kit/block_write.rb
@@ -304,6 +334,7 @@ files:
 - lib/zip_kit/rack_chunked_body.rb
 - lib/zip_kit/rack_tempfile_body.rb
 - lib/zip_kit/rails_streaming.rb
+- lib/zip_kit/railtie.rb
 - lib/zip_kit/remote_io.rb
 - lib/zip_kit/remote_uncap.rb
 - lib/zip_kit/size_estimator.rb
@@ -343,7 +374,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Stream out ZIP files from Ruby. Successor to zip_tricks.