zip_kit 6.2.2 → 6.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1136ebba851638486c9e47150a8d706c49a2bbc0074f457c794582d8ce19089
-  data.tar.gz: 80de3edcb5bc748aaf855a7bf0b1f19439522c8efa4b97754f813fe9413bac2c
+  metadata.gz: 442833a965d373fd56e8d085164f536e17560ed4a74e11aab5befc61946de1bc
+  data.tar.gz: 6c470314702d643b8f5b55fb3a328ab62cecfe1982587df9b8179fd84bf9013e
 SHA512:
-  metadata.gz: 20c5922a4178f2068a4f06388b201bd263f01c387d308c2c6297feba1c05385d601072cae0451d59a4a0b4e1ba1e354a6fa7f622ff1b58daf70947e6991b1e82
-  data.tar.gz: c373972ec6980000b40d1808247759b44f317a7aa3795b406e02005412cf0687e0f2311e5809f011eb1fbc19e6b2b7eb2a6a8f036cafe27a2645f6476cf0c441
+  metadata.gz: 8532b5faf979cc98ba0f1e05dff6adf3e6748466553446397c3f7f706fe663182f8fab47a973e3e911b2457eb0622579a62d7b35c1fe18644b7ea05541d7e316
+  data.tar.gz: 377ef88938f5ec86ea6cd2e15c6857eac9ff2ffc25bb629cf2a0d0ba774a823013e4b4061d1a5392dc4b88e8cbd3d022a1f90e41d1cb68ad72c5e9d42f3c51cd

data/.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
       matrix:
         ruby:
           - '2.6'
-          - '3.2'
+          - '3.3'
     steps:
       - name: Checkout
         uses: actions/checkout@v4

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,11 @@
+## 6.3.1
+
+* Include `RailsStreaming` in a Rails loader callback, so that ActionController does not need to be in the namespace.
+
+## 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

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

@@ -5,6 +5,7 @@ The ZipKit streaming implementation is designed around the following requirement
 * Only ahead-writes (no IO seek or rewind)
 * Automatic switching to Zip64 as the files get written (no IO seeks), but not requiring Zip64 support if the archive can do without
 * Make use of the fact that CRC32 checksums and the sizes of the files (compressed _and_ uncompressed) are known upfront
+* Make it possible to output "sparse" ZIP archives (manifests that can be resolved into a ZIP via edge includes)
 
 It strives to be compatible with the following unzip programs _at the minimum:_
 
@@ -14,9 +15,6 @@ It strives to be compatible with the following unzip programs _at the minimum:_
 * Windows 7 - 7Zip 9.20
 
 Below is the list of _specific_ decisions taken when writing the implementation, with an explanation for each.
-We specifically _omit_ a number of things that we could do, but that are not necessary to satisfy our objectives.
-The omissions are _intentional_ since we do not want to have things of which we _assume_ they work, or have things
-that work only for one obscure unarchiver in one obscure case (like WinRAR with chinese filenames).
 
 ## Data descriptors (postfix CRC32/file sizes)
 
@@ -53,38 +51,14 @@ field, any other extra fields should come after.
 
 If a diacritic-containing character (such as å) does fit into the DOS-437
 codepage, it should be encodable as such. This would, in theory, let older Windows tools
-decode the filename correctly. However, this kills the filename decoding for the OSX builtin
-archive utility (it assumes the filename to be UTF-8, regardless). So if we allow filenames
-to be encoded in DOS-437, we _potentially_ have support in Windows but we upset everyone on Mac.
-If we just use UTF-8 and set the right EFS bit in general purpose flags, we upset Windows users
-because most of the Windows unarchive tools (at least the builtin ones) do not give a flying eff
-about the EFS support bit being set.
-
-Additionally, if we use Unarchiver on OSX (which is our recommended unpacker for large files),
-it will (very rightfully) ask us how we should decode each filename that does not have the EFS bit,
-but does contain something non-ASCII-decodable. This is horrible UX for users.
-
-So, basically, we have 2 choices, for filenames containing diacritics (for bona-fide UTF-8 you do not
-even get those choices, you _have_ to use UTF-8):
-
-* Make life easier for Windows users by setting stuff to DOS, not care about the standard _and_ make
-  most of Mac users upset
-* Make life easy for Mac users and conform to the standard, and tell Windows users to get a _decent_
-  ZIP unarchiving tool.
-
-We are going with option 2, and this is well-thought-out. Trust me. If you want the crazytown
-filename encoding scheme that is described here http://stackoverflow.com/questions/13261347
-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.
-
-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
-those fields for the UTF-8 filename, per spec, tells us we should not set the EFS bit - which ruins
-the unarchiving for all other solutions. As any other, this decision may be changed in the future.
+decode the filename correctly. However, this only works under the following circumstances:
+
+* All the filenames in the archive are within the same "super-ASCII" encoding
+* The Windows locale on the computer opening the archive is set to the same locale as the filename in the archive
+
+A better approach is to use the EFS flag, which we enable when a filename does not encode cleanly
+into base ASCII. The extended filename extra field did not work well for us - and it does not
+combine correctly with the EFS flag.
 
 There are some interesting notes about the Info-ZIP/EFS combination here
 https://commons.apache.org/proper/commons-compress/zip.html

data/README.md

@@ -5,17 +5,32 @@
 
 Allows streaming, non-rewinding ZIP file output from Ruby.
 
-`zip_kit` is a successor to and continuation of [zip_tricks](https://github.com/WeTransfer/zip_tricks), which
-was inspired by [zipline](https://github.com/fringd/zipline). I am grateful to WeTransfer for allowing me
-to develop zip_tricks and for sharing it with the community.
+> [!IMPORTANT]
+> `zip_kit` is a successor to and continuation of [zip_tricks.](https://github.com/WeTransfer/zip_tricks)
+> I am grateful to WeTransfer for allowing me to develop zip_tricks and for sharing it with the community.
 
 Allows you to write a ZIP archive out to a `File`, `Socket`, `String` or `Array` without having to rewind it at any
 point. Usable for creating very large ZIP archives for immediate sending out to clients, or for writing
 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.
+The gem handled all the zipping needs for WeTransfer for half a decade, with hundreds of millions
+of correct ZIP files generated. It is compatible with most end-user applications for opening archives.
+
+The files output with zip_kit will be valid [OCF containers](https://www.w3.org/TR/epub-33/#sec-container-zip),
+the library can be used to generate JAR files, EPUBs, OpenOffice/Office documents etc.
+
+## 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.
+
+## Migrating from zip_tricks
+
+If you want to migrate your code from zip_tricks to zip_kit, all you need to do is a blanket replacement in your code.
+Swap out the `ZipTricks` constant for `ZipKit` and you should be in business. All of the API available in ZipTricks 5.x
+still works as of ZipKit 6.x and will stay working. If something in your project still depends on zip_tricks you can use
+both gems inside of the same "apex" project - there will be no conflicts.
 
 ## Requirements
 
@@ -23,13 +38,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 +61,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 +70,8 @@ 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` 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.
+`zip_kit_stream` does *not* require [ActionController::Live](https://api.rubyonrails.org/classes/ActionController/Live.html)
+and will stream without it. It will work inside `Live` controllers just fine though.
 
 ## Writing into streaming destinations
 
@@ -123,10 +137,10 @@ output direct to STDOUT (so that you can run `$ ruby archive.rb > file.zip` in y
 
 ```ruby
 ZipKit::Streamer.open($stdout) do |zip|
-  zip.write_file('mov.mp4.txt') do |sink|
+  zip.write_file('mov.mp4') do |sink| # Will use "stored" mode
     File.open('mov.mp4', 'rb'){|source| IO.copy_stream(source, sink) }
   end
-  zip.write_file('long-novel.txt') do |sink|
+  zip.write_file('long-novel.txt') do |sink| # Will use "deflated" mode
     File.open('novel.txt', 'rb'){|source| IO.copy_stream(source, sink) }
   end
 end
@@ -161,7 +175,7 @@ end
 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
+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

data/RUBYZIP_DIFFERENCES.md

@@ -0,0 +1,53 @@
+# 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
+* 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)
+* ZipKit allows you to compose "sparse" ZIP files where the contents of the files inside the archive comes from an external source, and does not have to be passed through the library (or be turned into Ruby strings), which enables interesting use cases such as download proxies with random access and resume.
+
+## 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/lib/zip_kit/block_deflate.rb

@@ -55,7 +55,7 @@ class ZipKit::BlockDeflate
   # `output_io` can also be a {ZipKit::Streamer} to expedite ops.
   #
   # @param output_io [IO] the stream to write to (should respond to `:<<`)
-  # @return [Fixnum] number of bytes written to `output_io`
+  # @return [Integer] number of bytes written to `output_io`
   def self.write_terminator(output_io)
     output_io << END_MARKER
     END_MARKER.bytesize
@@ -65,7 +65,7 @@ class ZipKit::BlockDeflate
   # The returned string can be spliced into another deflate stream.
   #
   # @param bytes [String] Bytes to compress
-  # @param level [Fixnum] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
+  # @param level [Integer] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
   # @return [String] compressed bytes
   def self.deflate_chunk(bytes, level: Zlib::DEFAULT_COMPRESSION)
     raise "Invalid Zlib compression level #{level}" unless VALID_COMPRESSIONS.include?(level)
@@ -90,9 +90,9 @@ class ZipKit::BlockDeflate
   #
   # @param input_io [IO] the stream to read from (should respond to `:read`)
   # @param output_io [IO] the stream to write to (should respond to `:<<`)
-  # @param level [Fixnum] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
-  # @param block_size [Fixnum] The block size to use (defaults to `DEFAULT_BLOCKSIZE`)
-  # @return [Fixnum] number of bytes written to `output_io`
+  # @param level [Integer] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
+  # @param block_size [Integer] The block size to use (defaults to `DEFAULT_BLOCKSIZE`)
+  # @return [Integer] number of bytes written to `output_io`
   def self.deflate_in_blocks_and_terminate(input_io,
     output_io,
     level: Zlib::DEFAULT_COMPRESSION,
@@ -110,9 +110,9 @@ class ZipKit::BlockDeflate
   #
   # @param input_io [IO] the stream to read from (should respond to `:read`)
   # @param output_io [IO] the stream to write to (should respond to `:<<`)
-  # @param level [Fixnum] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
-  # @param block_size [Fixnum] The block size to use (defaults to `DEFAULT_BLOCKSIZE`)
-  # @return [Fixnum] number of bytes written to `output_io`
+  # @param level [Integer] Zlib compression level (defaults to `Zlib::DEFAULT_COMPRESSION`)
+  # @param block_size [Integer] The block size to use (defaults to `DEFAULT_BLOCKSIZE`)
+  # @return [Integer] number of bytes written to `output_io`
   def self.deflate_in_blocks(input_io,
     output_io,
     level: Zlib::DEFAULT_COMPRESSION,

data/lib/zip_kit/file_reader.rb

@@ -86,46 +86,46 @@ class ZipKit::FileReader
   # the Entry object used in Streamer for ZIP writing, since during writing more
   # data can be kept in memory for immediate use.
   class ZipEntry
-    # @return [Fixnum] bit-packed version signature of the program that made the archive
+    # @return [Integer] bit-packed version signature of the program that made the archive
     attr_accessor :made_by
 
-    # @return [Fixnum] ZIP version support needed to extract this file
+    # @return [Integer] ZIP version support needed to extract this file
     attr_accessor :version_needed_to_extract
 
-    # @return [Fixnum] bit-packed general purpose flags
+    # @return [Integer] bit-packed general purpose flags
     attr_accessor :gp_flags
 
-    # @return [Fixnum] Storage mode (0 for stored, 8 for deflate)
+    # @return [Integer] Storage mode (0 for stored, 8 for deflate)
     attr_accessor :storage_mode
 
-    # @return [Fixnum] the bit-packed DOS time
+    # @return [Integer] the bit-packed DOS time
     attr_accessor :dos_time
 
-    # @return [Fixnum] the bit-packed DOS date
+    # @return [Integer] the bit-packed DOS date
     attr_accessor :dos_date
 
-    # @return [Fixnum] the CRC32 checksum of this file
+    # @return [Integer] the CRC32 checksum of this file
     attr_accessor :crc32
 
-    # @return [Fixnum] size of compressed file data in the ZIP
+    # @return [Integer] size of compressed file data in the ZIP
     attr_accessor :compressed_size
 
-    # @return [Fixnum] size of the file once uncompressed
+    # @return [Integer] size of the file once uncompressed
     attr_accessor :uncompressed_size
 
     # @return [String] the filename
     attr_accessor :filename
 
-    # @return [Fixnum] disk number where this file starts
+    # @return [Integer] disk number where this file starts
     attr_accessor :disk_number_start
 
-    # @return [Fixnum] internal attributes of the file
+    # @return [Integer] internal attributes of the file
     attr_accessor :internal_attrs
 
-    # @return [Fixnum] external attributes of the file
+    # @return [Integer] external attributes of the file
     attr_accessor :external_attrs
 
-    # @return [Fixnum] at what offset the local file header starts
+    # @return [Integer] at what offset the local file header starts
     #        in your original IO object
     attr_accessor :local_file_header_offset
 
@@ -151,7 +151,7 @@ class ZipKit::FileReader
       end
     end
 
-    # @return [Fixnum] at what offset you should start reading
+    # @return [Integer] at what offset you should start reading
     #       for the compressed data in your original IO object
     def compressed_data_offset
       @compressed_data_offset || raise(LocalHeaderPending)
@@ -298,7 +298,7 @@ class ZipKit::FileReader
   # this offset to get the data).
   #
   # @param io[#read] an IO-ish object the ZIP file can be read from
-  # @return [Array<ZipEntry, Fixnum>] the parsed local header entry and
+  # @return [Array<ZipEntry, Integer>] the parsed local header entry and
   # the compressed data offset
   def read_local_file_header(io:)
     local_file_header_offset = io.tell
@@ -365,8 +365,8 @@ class ZipKit::FileReader
   # (read starting at this offset to get the data).
   #
   # @param io[#seek, #read] an IO-ish object the ZIP file can be read from
-  # @param local_file_header_offset[Fixnum] absolute offset (0-based) where the
-  # local file header is supposed to begin @return [Fixnum] absolute offset
+  # @param local_file_header_offset[Integer] absolute offset (0-based) where the
+  # 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
   def get_compressed_data_offset(io:, local_file_header_offset:)
     seek(io, local_file_header_offset)

data/lib/zip_kit/rails_streaming.rb

@@ -3,8 +3,7 @@
 # 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.
@@ -25,7 +24,7 @@ module ZipKit::RailsStreaming
   # @param use_chunked_transfer_encoding[Boolean] whether to forcibly encode output as chunked. Normally you should not need this.
   # @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] the streamer that can be written to
+  # @yieldparam zip[ZipKit::Streamer] 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

data/lib/zip_kit/railtie.rb

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

data/lib/zip_kit/remote_io.rb

@@ -40,7 +40,7 @@ class ZipKit::RemoteIO
   # so if you are at offset 0 in the IO of size 10, doing a `read(20)`
   # will only return you 10 bytes of result, and not raise any exceptions.
   #
-  # @param n_bytes[Fixnum, nil] how many bytes to read, or `nil` to read all the way to the end
+  # @param n_bytes[Integer, nil] how many bytes to read, or `nil` to read all the way to the end
   # @return [String] the read bytes
   def read(n_bytes = nil)
     # If the resource is empty there is nothing to read
@@ -62,7 +62,7 @@ class ZipKit::RemoteIO
 
   # Returns the current pointer position within the IO
   #
-  # @return [Fixnum]
+  # @return [Integer]
   def tell
     @pos
   end

data/lib/zip_kit/size_estimator.rb

@@ -24,7 +24,7 @@ class ZipKit::SizeEstimator
   #
   # @param kwargs_for_streamer_new Any options to pass to Streamer, see {Streamer#initialize}
   # @return [Integer] the size of the resulting archive, in bytes
-  # @yieldparam [SizeEstimator] the estimator
+  # @yieldparam estimator[SizeEstimator] the estimator
   def self.estimate(**kwargs_for_streamer_new)
     streamer = ZipKit::Streamer.new(ZipKit::NullWriter, **kwargs_for_streamer_new)
     estimator = new(streamer)
@@ -35,7 +35,7 @@ class ZipKit::SizeEstimator
   # Add a fake entry to the archive, to see how big it is going to be in the end.
   #
   # @param filename [String] the name of the file (filenames are variable-width in the ZIP)
-  # @param size [Fixnum] size of the uncompressed entry
+  # @param size [Integer] size of the uncompressed entry
   # @param use_data_descriptor[Boolean] whether the entry uses a postfix
   # data descriptor to specify size
   # @return self
@@ -54,8 +54,8 @@ class ZipKit::SizeEstimator
   # Add a fake entry to the archive, to see how big it is going to be in the end.
   #
   # @param filename [String] the name of the file (filenames are variable-width in the ZIP)
-  # @param uncompressed_size [Fixnum] size of the uncompressed entry
-  # @param compressed_size [Fixnum] size of the compressed entry
+  # @param uncompressed_size [Integer] size of the uncompressed entry
+  # @param compressed_size [Integer] size of the compressed entry
   # @param use_data_descriptor[Boolean] whether the entry uses a postfix data
   #                                     descriptor to specify size
   # @return self

data/lib/zip_kit/stream_crc32.rb

@@ -16,7 +16,7 @@ class ZipKit::StreamCRC32
   # Compute a CRC32 value from an IO object. The object should respond to `read` and `eof?`
   #
   # @param io[IO] the IO to read the data from
-  # @return [Fixnum] the computed CRC32 value
+  # @return [Integer] the computed CRC32 value
   def self.from_io(io)
     # If we can specify the string capacity upfront we will not have to resize
     # the string during operation. This saves time but is only available on
@@ -43,7 +43,7 @@ class ZipKit::StreamCRC32
 
   # Returns the CRC32 value computed so far
   #
-  # @return [Fixnum] the updated CRC32 value for all the blobs so far
+  # @return [Integer] the updated CRC32 value for all the blobs so far
   def to_i
     @crc
   end
@@ -51,9 +51,9 @@ class ZipKit::StreamCRC32
   # Appends a known CRC32 value to the current one, and combines the
   # contained CRC32 value in-place.
   #
-  # @param crc32[Fixnum] the CRC32 value to append
-  # @param blob_size[Fixnum] the size of the daata the `crc32` is computed from
-  # @return [Fixnum] the updated CRC32 value for all the blobs so far
+  # @param crc32[Integer] the CRC32 value to append
+  # @param blob_size[Integer] the size of the daata the `crc32` is computed from
+  # @return [Integer] the updated CRC32 value for all the blobs so far
   def append(crc32, blob_size)
     @crc = Zlib.crc32_combine(@crc, crc32, blob_size)
   end

data/lib/zip_kit/version.rb

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

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/lib/zip_kit.rb

@@ -24,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.2", T.untyped)
+  VERSION = T.let("6.3.1", 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
@@ -569,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.
@@ -683,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
 
@@ -752,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
 
@@ -790,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
@@ -832,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.
@@ -930,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
@@ -965,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
@@ -992,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
@@ -1014,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
@@ -1027,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
@@ -1050,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
@@ -1123,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
 
@@ -1283,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
@@ -1296,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
@@ -1499,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
@@ -1511,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
@@ -1519,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
@@ -1563,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
@@ -1632,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
@@ -1648,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
@@ -1659,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
@@ -1668,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
 
@@ -1738,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
 
@@ -1798,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.
@@ -1809,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
@@ -1835,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
 
@@ -1861,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
@@ -1889,7 +1892,7 @@ 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.
@@ -1903,7 +1906,7 @@ end, T.untyped)
     # _@param_ `use_data_descriptor` — whether the entry uses a postfix
     # 
     # _@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.
@@ -1920,8 +1923,8 @@ end, T.untyped)
     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
@@ -1969,15 +1972,14 @@ 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
 
   # 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.
@@ -2008,7 +2010,7 @@ end, T.untyped)
         type: String,
         use_chunked_transfer_encoding: T::Boolean,
         output_enumerator_options: T::Hash[T.untyped, T.untyped],
-        zip_streaming_blk: T.proc.params(the: ZipKit::Streamer).void
+        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, **output_enumerator_options, &zip_streaming_blk); end

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,6 +40,7 @@ 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zip_kit
 version: !ruby/object:Gem::Version
-  version: 6.2.2
+  version: 6.3.1
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-27 00:00:00.000000000 Z
+date: 2024-08-11 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
@@ -285,10 +299,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
 - ".github/workflows/ci.yml"
 - ".gitignore"
-- ".rspec"
 - ".standard.yml"
 - ".yardopts"
 - CHANGELOG.md
@@ -298,8 +310,8 @@ files:
 - IMPLEMENTATION_DETAILS.md
 - LICENSE.txt
 - README.md
+- RUBYZIP_DIFFERENCES.md
 - Rakefile
-- bench/buffered_crc32_bench.rb
 - examples/archive_size_estimate.rb
 - examples/config.ru
 - examples/deferred_write.rb
@@ -319,6 +331,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
@@ -358,7 +371,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Stream out ZIP files from Ruby. Successor to zip_tricks.

data/.document

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

data/.rspec

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

data/bench/buffered_crc32_bench.rb

@@ -1,109 +0,0 @@
-require "bundler"
-Bundler.setup
-
-require "benchmark"
-require "benchmark/ips"
-require_relative "../lib/zip_kit"
-
-n_bytes = 5 * 1024 * 1024
-r = Random.new
-bytes = (0...n_bytes).map { r.bytes(1) }
-buffer_sizes = [
-  1,
-  256,
-  512,
-  1024,
-  8 * 1024,
-  16 * 1024,
-  32 * 1024,
-  64 * 1024,
-  128 * 1024,
-  256 * 1024,
-  512 * 1024,
-  1024 * 1024,
-  2 * 1024 * 1024
-]
-
-Benchmark.ips do |x|
-  x.config(time: 5, warmup: 2)
-  buffer_sizes.each do |buf_size|
-    x.report "Single-byte <<-writes of #{n_bytes} using a #{buf_size} byte buffer" do
-      crc = ZipKit::WriteBuffer.new(ZipKit::StreamCRC32.new, buf_size)
-      bytes.each { |b| crc << b }
-      crc.to_i
-    end
-  end
-  x.compare!
-end
-
-__END__
-
-Warming up --------------------------------------
-Single-byte <<-writes of 5242880 using a 1 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 256 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 512 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 1024 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 8192 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 16384 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 32768 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 65536 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 131072 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 262144 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 524288 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 1048576 byte buffer
-                         1.000  i/100ms
-Single-byte <<-writes of 5242880 using a 2097152 byte buffer
-                         1.000  i/100ms
-Calculating -------------------------------------
-Single-byte <<-writes of 5242880 using a 1 byte buffer
-                          0.054  (± 0.0%) i/s -      1.000  in  18.383019s
-Single-byte <<-writes of 5242880 using a 256 byte buffer
-                          0.121  (± 0.0%) i/s -      1.000  in   8.286061s
-Single-byte <<-writes of 5242880 using a 512 byte buffer
-                          0.124  (± 0.0%) i/s -      1.000  in   8.038112s
-Single-byte <<-writes of 5242880 using a 1024 byte buffer
-                          0.128  (± 0.0%) i/s -      1.000  in   7.828562s
-Single-byte <<-writes of 5242880 using a 8192 byte buffer
-                          0.123  (± 0.0%) i/s -      1.000  in   8.121586s
-Single-byte <<-writes of 5242880 using a 16384 byte buffer
-                          0.127  (± 0.0%) i/s -      1.000  in   7.872240s
-Single-byte <<-writes of 5242880 using a 32768 byte buffer
-                          0.126  (± 0.0%) i/s -      1.000  in   7.911816s
-Single-byte <<-writes of 5242880 using a 65536 byte buffer
-                          0.126  (± 0.0%) i/s -      1.000  in   7.917318s
-Single-byte <<-writes of 5242880 using a 131072 byte buffer
-                          0.127  (± 0.0%) i/s -      1.000  in   7.897223s
-Single-byte <<-writes of 5242880 using a 262144 byte buffer
-                          0.130  (± 0.0%) i/s -      1.000  in   7.675608s
-Single-byte <<-writes of 5242880 using a 524288 byte buffer
-                          0.130  (± 0.0%) i/s -      1.000  in   7.679886s
-Single-byte <<-writes of 5242880 using a 1048576 byte buffer
-                          0.128  (± 0.0%) i/s -      1.000  in   7.788439s
-Single-byte <<-writes of 5242880 using a 2097152 byte buffer
-                          0.128  (± 0.0%) i/s -      1.000  in   7.797839s
-
-Comparison:
-Single-byte <<-writes of 5242880 using a 262144 byte buffer:        0.1 i/s
-Single-byte <<-writes of 5242880 using a 524288 byte buffer:        0.1 i/s - 1.00x  slower
-Single-byte <<-writes of 5242880 using a 1048576 byte buffer:        0.1 i/s - 1.01x  slower
-Single-byte <<-writes of 5242880 using a 2097152 byte buffer:        0.1 i/s - 1.02x  slower
-Single-byte <<-writes of 5242880 using a 1024 byte buffer:        0.1 i/s - 1.02x  slower
-Single-byte <<-writes of 5242880 using a 16384 byte buffer:        0.1 i/s - 1.03x  slower
-Single-byte <<-writes of 5242880 using a 131072 byte buffer:        0.1 i/s - 1.03x  slower
-Single-byte <<-writes of 5242880 using a 32768 byte buffer:        0.1 i/s - 1.03x  slower
-Single-byte <<-writes of 5242880 using a 65536 byte buffer:        0.1 i/s - 1.03x  slower
-Single-byte <<-writes of 5242880 using a 512 byte buffer:        0.1 i/s - 1.05x  slower
-Single-byte <<-writes of 5242880 using a 8192 byte buffer:        0.1 i/s - 1.06x  slower
-Single-byte <<-writes of 5242880 using a 256 byte buffer:        0.1 i/s - 1.08x  slower
-Single-byte <<-writes of 5242880 using a 1 byte buffer:        0.1 i/s - 2.39x  slower