zip_tricks 2.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0cda66fb0e3453ab3c239126c67686d124fcce5
+  data.tar.gz: 28327929e311c13ad556b85cef2ddf73ee1fc653
+SHA512:
+  metadata.gz: 5f5e227ce148f6d7468371f8d8653b8fa15331f0495e674f0e8972fa32d532865757acfb1c0051b147fe44fcbc81e0798821bd3c7cf1dd75e4e3e85852715e90
+  data.tar.gz: 5f455aed3939b423b1459e510a00cfc749701102e1dc714677fc74a2e2de6b9b18f7aebf23a09ffc68b5bd1c51bb627e22c305f1d1ffc0b9c933a4954f111828

data/.document

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+- 2.1
+- 2.2
+sudo: false
+cache: bundler

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem 'rubyzip', '~> 1.1.7'
+gem 'very_tiny_state_machine', '~> 2'
+
+group :development do
+  gem 'rake', '~> 10.4'
+  gem "rspec", "~> 3.2.0", '< 3.3'
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem 'range_utils'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 WeTransfer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# zip_tricks
+
+[![Build Status](https://travis-ci.org/WeTransfer/zip_tricks.svg?branch=master)](https://travis-ci.org/WeTransfer/zip_tricks)
+
+Makes Rubyzip sing, dance and play saxophone for streaming applications.
+Spiritual successor to [zipline](https://github.com/fringd/zipline)
+
+Requires Ruby 2.1+, rubyzip and a couple of other gems (all available to jRuby as well).
+The library is composed of a loose set of modules which are described below.
+
+## BlockDeflate
+
+Deflate a byte stream in blocks of N bytes, optionally writing a terminator marker. This can be used to
+compress a file in parts.
+
+    source_file = File.open('12_gigs.bin', 'rb')
+    compressed = Tempfile.new
+    # Will not compress everything in memory, but do it per chunk to spare memory. `compressed`
+    # will be written to at the end of each chunk.
+    ZipTricks::BlockDeflate.deflate_in_blocks_and_terminate(source_file, compressed)
+
+You can also do the same to parts that you will later concatenate together elsewhere, in that case
+you need to skip the end marker:
+
+    compressed = Tempfile.new
+    ZipTricks::BlockDeflate.deflate_in_blocks(File.open('part1.bin', 'rb), compressed)
+    ZipTricks::BlockDeflate.deflate_in_blocks(File.open('part2.bin', 'rb), compressed)
+    ZipTricks::BlockDeflate.deflate_in_blocks(File.open('partN.bin', 'rb), compressed)
+    ZipTricks::BlockDeflate.write_terminator(compressed)
+
+You can also elect to just compress strings in memory (to splice them later):
+
+    compressed_string = ZipTricks::BlockDeflate.deflate_chunk(big_string)
+
+## Streamer
+
+Is used to write a streaming ZIP file when you know the CRC32 for the raw files
+and the sizes of these files upfront. This writes the local headers immediately, without having to
+rewind the output IO. It also avoids using the local footers instead of headers, therefore permitting
+Zip64-sized entries to be stored easily.
+
+    # io has to be an object that supports #<< and #tell
+    io = ... # can be a Tempfile, but can also be a BlockWrite adapter for, say, Rack
+    
+    ZipTricks::Streamer.open(io) do | zip |
+      
+      # raw_file is written "as is" (STORED mode)
+      zip.add_stored_entry("first-file.bin", raw_file.size, raw_file_crc32)
+      while blob = raw_file.read(2048)
+        zip << blob
+      end
+      
+      # another_file is assumed to be block-deflated (DEFLATE mode)
+      zip.add_compressed_entry("another-file.bin", another_file_size, another_file_crc32, compressed_file.size)
+      while blob = compressed_file.read(2048)
+        zip << blob
+      end
+      
+      # If you are storing block-deflated parts of a single file, you have to terminate the output
+      # with an end marker manually
+      zip.add_compressed_entry("compressed-in-parts.bin", another_file_size, another_file_crc32, deflated_size)
+      while blob = part1.read(2048)
+        zip << blob
+      end
+      while blob = part2.read(2048)
+        zip << blob
+      end
+      ZipTricks::BlockDeflate.write_terminator(zip)
+      
+      ... # more file writes etc.
+    end
+
+## RackBody
+
+Can be used to output a streamed ZIP archive directly through a Rack response body.
+The block given to the constructor will be called when the response body will be read by the webserver,
+and will receive a {ZipTricks::Streamer} as it's block argument. You can then add entries to the Streamer as usual.
+The archive will be automatically closed at the end of the block.
+
+    # Precompute the Content-Length ahead of time
+    content_length = ZipTricks::StoredSizeEstimator.perform_fake_archiving do | estimator |
+      estimator.add_stored_entry('large.tif', size=1289894)
+    end
+    
+    # Prepare the response body. The block will only be called when the response starts to be written.
+    body = ZipTricks::RackBody.new do | streamer |
+      streamer.add_stored_entry('large.tif', size=1289894, crc32=198210)
+      streamer << large_file.read(1024*1024) until large_file.eof?
+      ...
+    end
+    
+    return [200, {'Content-Type' => 'binary/octet-stream', 'Content-Length' => content_length.to_s}, body]
+  
+## BlockWrite
+
+Can be used as the destination IO, but will call the given block instead on every call to `:<<`.
+This can be used to attach the output of the zip compressor to the Rack response body, or another
+destination. For Rack/Rails just use RackBody since it sets this up for you.
+
+    io = ZipTricks::BlockWrite.new{|data| socket << data }
+    ZipTricks::Streamer.open(io) do | zip |
+      zip.add_stored_entry("first-file.bin", raw_file.size, raw_file_crc32)
+      ....
+    end
+
+## StoredSizeEstimator
+
+Is used to predict the size of the ZIP archive after output. This can be used to generate, say, a `Content-Length` header,
+or to predict the size of the resulting archive on the storage device. The size is estimated using a very fast "fake archiving"
+procedure, so it computes the sizes of all the headers and the central directory very accurately.
+
+    expected_zip_archive_size = StoredSizeEstimator.perform_fake_archiving do | estimator |
+      estimator.add_stored_entry("file.doc", size=898291)
+      estimator.add_compressed_entry("family.JPG", size=89281911, compressed_size=89218)
+    end
+
+
+## StreamCRC32
+
+Computes the CRC32 value in a streaming fashion. Is slightly more convenient for the purpose than using the raw Zlib
+library functions.
+
+    crc = ZipTricks::StreamCRC32.new
+    crc << large_file.read(1024 * 12) until large_file.eof?
+    ...
+    
+    crc.to_i # Returns the actual CRC32 value computed so far
+    ...
+    # Append a known CRC32 value that has been computed previosuly
+    crc.append(precomputed_crc32, size_of_the_blob_computed_from)
+
+## Contributing to zip_tricks
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2015 WeTransfer. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require_relative 'lib/zip_tricks'
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "zip_tricks"
+  gem.homepage = "http://github.com/wetransfer/zip_tricks"
+  gem.license = "MIT"
+  gem.version = ZipTricks::VERSION
+  gem.summary = %Q{Makes rubyzip stream, for real}
+  gem.description = %Q{Makes rubyzip stream, for real}
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik Tarkhanov"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zip_tricks #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/zip_tricks/block_deflate.rb

@@ -0,0 +1,89 @@
+# Permits Deflate compression in independent blocks. The workflow is as follows:
+#
+# * Run every block to compress through deflate_chunk, remove the header, footer and adler32 from the result
+# * Write out the compressed block bodies (the ones deflate_chunk returns)to your output, in sequence
+# * Write out the footer (\03\00)
+#
+# The resulting stream is guaranteed to be handled properly by all zip unarchiving tools, including the
+# BOMArchiveHelper/ArchiveUtility on OSX.
+#
+# You could also build a compressor for Rubyzip using this module quite easily,
+# even though this is outside the scope of the library.
+#
+# When you deflate the chunks separately, you need to write the end marker yourself (using `write_terminator`).
+# If you just want to deflate a large IO's contents, use `deflate_in_blocks_and_terminate` to have the end marker
+# written out for you.
+module ZipTricks::BlockDeflate
+  DEFAULT_BLOCKSIZE = 1024*1024*5
+  END_MARKER = [3, 0].pack("C*")
+  VALID_COMPRESSIONS = (Zlib::DEFAULT_COMPRESSION..Zlib::BEST_COMPRESSION).to_a.freeze # Zlib::NO_COMPRESSION..
+  # Write the end marker (\x3\x0) to the given IO.
+  #
+  # `output_io` can also be a {ZipTricks::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`
+  def self.write_terminator(output_io)
+    output_io << END_MARKER
+    END_MARKER.bytesize
+  end
+  
+  # Compress a given binary string and flush the deflate stream at byte boundary.
+  # 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`)
+  # @return [String] compressed bytes
+  def self.deflate_chunk(bytes, level: Zlib::DEFAULT_COMPRESSION)
+    raise "Invalid Zlib compression level #{level}" unless VALID_COMPRESSIONS.include?(level)
+    z = Zlib::Deflate.new(level)
+    compressed_blob = z.deflate(bytes, Zlib::SYNC_FLUSH)
+    compressed_blob << z.finish
+    z.close
+    
+    # Remove the header (2 bytes), the [3,0] end marker and the adler (4 bytes)
+    compressed_blob[2...-6]
+  end
+  
+  # Compress the contents of input_io into output_io, in blocks
+  # of block_size. Aligns the parts so that they can be concatenated later.
+  # Writes deflate end marker (\x3\x0) into `output_io` as the final step, so
+  # the contents of `output_io` can be spliced verbatim into a ZIP archive.
+  #
+  # Once the write completes, no more parts for concatenation should be written to
+  # the same stream.
+  #
+  # `output_io` can also be a {ZipTricks::Streamer} to expedite ops.
+  #
+  # @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`
+  def self.deflate_in_blocks_and_terminate(input_io, output_io, level: Zlib::DEFAULT_COMPRESSION, block_size: DEFAULT_BLOCKSIZE)
+    bytes_written = deflate_in_blocks(input_io, output_io, level: level, block_size: block_size)
+    bytes_written + write_terminator(output_io)
+  end
+  
+  # Compress the contents of input_io into output_io, in blocks
+  # of block_size. Align the parts so that they can be concatenated later.
+  # Will not write the deflate end marker (\x3\x0) so more parts can be written
+  # later and succesfully read back in provided the end marker wll be written.
+  #
+  # `output_io` can also be a {ZipTricks::Streamer} to expedite ops.
+  #
+  # @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`
+  def self.deflate_in_blocks(input_io, output_io, level: Zlib::DEFAULT_COMPRESSION, block_size: DEFAULT_BLOCKSIZE)
+    bytes_written = 0
+    while block = input_io.read(block_size)
+      deflated = deflate_chunk(block, level: level)
+      output_io << deflated
+      bytes_written += deflated.bytesize
+    end
+    bytes_written
+  end
+end

data/lib/zip_tricks/block_write.rb

@@ -0,0 +1,40 @@
+# Stashes a block given by the Rack webserver when calling each() on a body, and calls
+# that block every time it is written to using :<< (shovel). Poses as an IO for rubyzip.
+class ZipTricks::BlockWrite
+  # The block is the block given to each() of the Rack body, or other block you want
+  # to receive the string chunks written by the zip compressor.
+  def initialize(&block)
+    @block = block
+  end
+
+  # Make sure those methods raise outright
+  [:seek, :pos=, :to_s].each do |m|
+    define_method(m) do |*args|
+      raise "#{m} not supported - this IO adapter is non-rewindable"
+    end
+  end
+
+  # Every time this object gets written to, call the Rack body each() block with the bytes given instead.
+  def <<(buf)
+    return if buf.nil?
+    
+    # Ensure we ALWAYS write in binary encoding.
+    encoded = if buf.encoding != Encoding::BINARY
+      # If we got a frozen string we can't force_encoding on it
+      buf.force_encoding(Encoding::BINARY) rescue buf.dup.force_encoding(Encoding::BINARY)
+    else
+      buf
+    end
+    
+    #  buf.dup.force_encoding(Encoding::BINARY)
+    return if encoded.bytesize.zero? # Zero-size output has a special meaning when using chunked encoding
+    
+    @block.call(encoded)
+    self
+  end
+  
+  # Does nothing
+  def close
+    nil
+  end
+end

data/lib/zip_tricks/manifest.rb

@@ -0,0 +1,85 @@
+# Helps to estimate archive sizes
+class ZipTricks::Manifest < Struct.new(:zip_streamer, :io, :part_list)
+  
+  # Describes a span within the ZIP bytestream
+  class ZipSpan < Struct.new(:part_type, :byte_range_in_zip, :filename, :additional_metadata)
+  end
+  
+  # Builds an array of spans within the ZIP file and computes the size of the resulting archive in bytes.
+  #
+  #     zip_spans, bytesize = Manifest.build do | b |
+  #       b.add_stored_entry(name: "file.doc", size: 898291)
+  #       b.add_compressed_entry(name: "family.tif", size: 89281911, compressed_size: 121908)
+  #     end
+  #     bytesize #=> ... (Fixnum or Bignum)
+  #     zip_spans[0] #=> Manifest::ZipSpan(part_type: :entry_header, byte_range_in_zip: 0..44, ...)
+  #     zip_spans[-1] #=> Manifest::ZipSpan(part_type: :central_directory, byte_range_in_zip: 776721..898921, ...)
+  #
+  # @return [Array<Array<ZipSpan>, Fixnum>] an array of byte spans within the final ZIP, and the total size of the archive
+  # @yield [Manifest] the manifest object you can add entries to
+  def self.build
+    output_io = ZipTricks::WriteAndTell.new(ZipTricks::NullWriter)
+    part_list = []
+    last_range_end = 0
+    ZipTricks::Streamer.open(output_io) do | zip_streamer |
+      manifest = new(zip_streamer, output_io, part_list)
+      yield(manifest)
+      last_range_end = part_list[-1].byte_range_in_zip.end
+    end
+    
+    # Record the position of the central directory
+    directory_location = (last_range_end + 1)..(output_io.tell - 1)
+    part_list << ZipSpan.new(:central_directory, directory_location, :central_directory, nil)
+    
+    [part_list, output_io.tell]
+  end
+  
+  # Add a fake entry to the archive, to see how big it is going to be in the end.
+  #
+  # @param name [String] the name of the file (filenames are variable-width in the ZIP)
+  # @param size_uncompressed [Fixnum] size of the uncompressed entry
+  # @param segment_info[Object] if you need to save anything to retrieve later from the Manifest,
+  #                            pass it here (like the URL of the file)
+  # @return self
+  def add_stored_entry(name:, size_uncompressed:, segment_info: nil)
+    register_part(:entry_header, name, segment_info) do
+      zip_streamer.add_stored_entry(name, size_uncompressed, C_fake_crc)
+    end
+    
+    register_part(:entry_body, name, segment_info) do
+      zip_streamer.simulate_write(size_uncompressed)
+    end
+    
+    self
+  end
+  
+  # Add a fake entry to the archive, to see how big it is going to be in the end.
+  #
+  # @param name [String] the name of the file (filenames are variable-width in the ZIP)
+  # @param size_uncompressed [Fixnum] size of the uncompressed entry
+  # @param size_compressed [Fixnum] size of the compressed entry
+  # @param segment_info[Object] if you need to save anything to retrieve later from the Manifest,
+  #                            pass it here (like the URL of the file)
+  # @return self
+  def add_compressed_entry(name:, size_uncompressed:, size_compressed:, segment_info: nil)
+    register_part(:entry_header, name, segment_info) do
+      zip_streamer.add_compressed_entry(name, size_uncompressed, C_fake_crc, size_compressed)
+    end
+    
+    register_part(:entry_body, name, segment_info) do
+      zip_streamer.simulate_write(size_compressed)
+    end
+    
+    self
+  end
+  
+  private
+  
+  C_fake_crc = Zlib.crc32('Mary had a little lamb')
+  private_constant :C_fake_crc
+  
+  def register_part(span_type, filename, metadata)
+    before, _, after = io.tell, yield, (io.tell - 1)
+    part_list << ZipSpan.new(span_type, (before..after), filename, metadata)
+  end
+end

data/lib/zip_tricks/null_writer.rb

@@ -0,0 +1,7 @@
+# Used when you need to supply a destination IO for some
+# write operations, but want to discard the data (like when
+# estimating the size of a ZIP)
+module ZipTricks::NullWriter
+  def <<(data); self; end
+  extend self
+end

data/lib/zip_tricks/rack_body.rb

@@ -0,0 +1,41 @@
+# Can be used as a Rack response body directly. Will yield
+# a {ZipTricks::Streamer} for adding entries to the archive and writing
+# zip entry bodies.
+class ZipTricks::RackBody
+  # Prepares a new Rack response body with a Zip output stream.
+  # The block given to the constructor will be called when the response
+  # body will be read by the webserver, and will receive a {ZipTricks::Streamer}
+  # as it's block argument. You can then add entries to the Streamer as usual.
+  # The archive will be automatically closed at the end of the block.
+  #
+  #     # Precompute the Content-Length ahead of time
+  #     content_length = ZipTricks::StoredSizeEstimator.perform_fake_archiving do | estimator |
+  #       estimator.add_stored_entry('large.tif', size=1289894)
+  #     end
+  #     
+  #     # Prepare the response body. The block will only be called when the response starts to be written.
+  #     body = ZipTricks::RackBody.new do | streamer |
+  #       streamer.add_stored_entry('large.tif', size=1289894, crc32=198210)
+  #       streamer << large_file.read(1024*1024) until large_file.eof?
+  #       ...
+  #     end
+  #     
+  #     return [200, {'Content-Type' => 'binary/octet-stream', 'Content-Length' => content_length.to_s}, body]
+  def initialize(&blk)
+    @archiving_block = blk
+  end
+  
+  # Connects a {ZipTricks::BlockWrite} to the Rack webserver output,
+  # and calls the proc given to the constructor with a {ZipTricks::Streamer}
+  # for archive writing.
+  def each(&body_chunk_block)
+    fake_io = ZipTricks::BlockWrite.new(&body_chunk_block)
+    ZipTricks::Streamer.open(fake_io, &@archiving_block)
+  end
+  
+  # Does nothing because nothing has to be deallocated or canceled
+  # even if the zip output is incomplete. The archive gets closed
+  # automatically as part of {ZipTricks::Streamer.open}
+  def close
+  end
+end

data/lib/zip_tricks/stored_size_estimator.rb

@@ -0,0 +1,44 @@
+# Helps to estimate archive sizes
+class ZipTricks::StoredSizeEstimator < Struct.new(:manifest)
+  
+  # Performs the estimate using fake archiving. It needs to know the sizes of the
+  # entries upfront. Usage:
+  #
+  #     expected_zip_size = StoredSizeEstimator.perform_fake_archiving do | estimator |
+  #       estimator.add_stored_entry("file.doc", size=898291)
+  #       estimator.add_compressed_entry("family.tif", size=89281911, compressed_size=121908)
+  #     end
+  #
+  # @return [Fixnum] the size of the resulting archive, in bytes
+  # @yield [StoredSizeEstimator] the estimator
+  def self.perform_fake_archiving
+    _, bytes = ZipTricks::Manifest.build do |manifest|
+      # The API for this class uses positional arguments. The Manifest API
+      # uses keyword arguments.
+      call_adapter = new(manifest)
+      yield(call_adapter)
+    end
+    bytes
+  end
+  
+  # Add a fake entry to the archive, to see how big it is going to be in the end.
+  #
+  # @param name [String] the name of the file (filenames are variable-width in the ZIP)
+  # @param size_uncompressed [Fixnum] size of the uncompressed entry
+  # @return self
+  def add_stored_entry(name, size_uncompressed)
+    manifest.add_stored_entry(name: name, size_uncompressed: size_uncompressed)
+    self
+  end
+  
+  # Add a fake entry to the archive, to see how big it is going to be in the end.
+  #
+  # @param name [String] the name of the file (filenames are variable-width in the ZIP)
+  # @param size_uncompressed [Fixnum] size of the uncompressed entry
+  # @param size_compressed [Fixnum] size of the compressed entry
+  # @return self
+  def add_compressed_entry(name, size_uncompressed, size_compressed)
+    manifest.add_compressed_entry(name: name, size_uncompressed: size_uncompressed, size_compressed: size_compressed)
+    self
+  end
+end

data/lib/zip_tricks/stream_crc32.rb

@@ -0,0 +1,43 @@
+# A simple stateful class for keeping track of a CRC32 value through multiple writes
+class ZipTricks::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
+  def self.from_io(io)
+    crc = new
+    crc << io.read(1024 * 512) until io.eof?
+    crc.to_i
+  end
+  
+  # Creates a new streaming CRC32 calculator
+  def initialize
+    @crc = Zlib.crc32('')
+  end
+  
+  # Append data to the CRC32. Updates the contained CRC32 value in place.
+  #
+  # @param blob[String] the string to compute the CRC32 from
+  # @return [self]
+  def <<(blob)
+    @crc = Zlib.crc32_combine(@crc, Zlib.crc32(blob), blob.bytesize)
+    self
+  end
+  
+  # Returns the CRC32 value computed so far
+  #
+  # @return crc[Fixnum] the updated CRC32 value for all the blobs so far
+  def to_i
+    @crc
+  end
+  
+  # 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 crc[Fixnum] the updated CRC32 value for all the blobs so far
+  def append(crc32, blob_size)
+    @crc = Zlib.crc32_combine(@crc, crc32, blob_size)
+  end
+end