zip_tricks 4.2.1 → 4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99c656baa62bbe09d48e090b2971d63ab3bb875a
-  data.tar.gz: d6b84eb8c621b7039ae205f9e3d9ff5d29887032
+  metadata.gz: 62ea03396a8a75e72000952d6c5ff69b9d8f0a80
+  data.tar.gz: 6cf0bca2293065a1b5430e73d26a9a0117064adb
 SHA512:
-  metadata.gz: fa0dfe2f578443c695be43c3e170b81bc24fdc836401e3b8e50f41379a7583bd425fffbb1ed1d618624988c63e45fd0732f234d57abb249ccea3ef4d20c863d9
-  data.tar.gz: 30a98f251dd26cde99a62f1cf93ff889aceb30f3ae3eebbba3516b01da3fd56d920e8816d5f742b4c0b17d731b6d8be1f235b4d5bc595b0dc3ecd3960e6b1618
+  metadata.gz: c5ca0c25882b1770b663b199bc6f00b4763691f51f9bc34cd9594442be37e942738c1fbbcf6eff0d8aac56e99a81310f4e691a32aed3a84647e0a8e3d48aa9f2
+  data.tar.gz: 4d53363180343a0017e4054c2d55b40da0c74213a75a3aaf1e339715a6a3ad5ae9b7150abb79685f9cc9d19822d84e9122a12399a75f5488fccad18e35b31357

data/Gemfile

@@ -10,5 +10,5 @@ group :development do
   gem 'coderay'
   gem "yard", "~> 0.8"
   gem "bundler", "~> 1.0"
-  gem "jeweler", "~> 2.0.1"
+  gem "jeweler", "~> 2", '>= 2.1.2'
 end

data/README.md

@@ -4,23 +4,28 @@
 
 Allows streaming, non-rewinding ZIP file output from Ruby.
 Spiritual successor to [zipline](https://github.com/fringd/zipline)
-
 Requires Ruby 2.1+ syntax support and a working zlib (all available to jRuby as well).
 
+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.
+
 ## Create a ZIP file without size estimation, compress on-the-fly)
 
 When you compress on the fly and use data descriptors it is not really possible to compute the file size upfront.
 But it is very likely to yield good compression - especially if you send things like CSV files.
 
-    out = my_tempfile # can also be a socket
-    ZipTricks::Streamer.open(out) do |zip|
-      zip.write_stored_file('mov.mp4.txt') do |sink|
-        File.open('mov.mp4', 'rb'){|source| IO.copy_stream(source, sink) }
-      end
-      zip.write_deflated_file('long-novel.txt') do |sink|
-        File.open('novel.txt', 'rb'){|source| IO.copy_stream(source, sink) }
-      end
-    end
+```ruby
+out = my_tempfile # can also be a socket
+ZipTricks::Streamer.open(out) do |zip|
+  zip.write_stored_file('mov.mp4.txt') do |sink|
+    File.open('mov.mp4', 'rb'){|source| IO.copy_stream(source, sink) }
+  end
+  zip.write_deflated_file('long-novel.txt') do |sink|
+    File.open('novel.txt', 'rb'){|source| IO.copy_stream(source, sink) }
+  end
+end
+```
 
 ## Send the same ZIP file from a Rack response
 
@@ -28,35 +33,39 @@ Create a `RackBody` object and give it's constructor a block that adds files.
 The block will only be called when actually sending the response to the client
 (unless you are using a buffering Rack webserver, such as Webrick).
 
-    body = ZipTricks::RackBody.new do | zip |
-      zip.write_stored_file('mov.mp4') do |sink| # Those MPEG4 files do not compress that well
-        File.open('mov.mp4', 'rb'){|source| IO.copy_stream(source, sink) }
-      end
-      zip.write_deflated_file('long-novel.txt') do |sink|
-        File.open('novel.txt', 'rb'){|source| IO.copy_stream(source, sink) }
-      end
-    end
-    [200, {'Transfer-Encoding' => 'chunked'}, body]
+```ruby
+body = ZipTricks::RackBody.new do | zip |
+  zip.write_stored_file('mov.mp4') do |sink| # Those MPEG4 files do not compress that well
+    File.open('mov.mp4', 'rb'){|source| IO.copy_stream(source, sink) }
+  end
+  zip.write_deflated_file('long-novel.txt') do |sink|
+    File.open('novel.txt', 'rb'){|source| IO.copy_stream(source, sink) }
+  end
+end
+[200, {'Transfer-Encoding' => 'chunked'}, body]
+```
 
 ## Send a ZIP file of known size, with correct headers
 
 Use the `SizeEstimator` to compute the correct size of the resulting archive.
 
-    # Prepare the response body. The block will only be called when the response starts to be written.
-    zip_body = ZipTricks::RackBody.new do | zip |
-      zip.add_stored_entry(filename: "myfile1.bin", size: 9090821, crc32: 12485)
-      zip << read_file('myfile1.bin')
-      zip.add_stored_entry(filename: "myfile2.bin", size: 458678, crc32: 89568)
-      zip << read_file('myfile2.bin')
-    end
-    
-    # Precompute the Content-Length ahead of time
-    bytesize = ZipTricks::SizeEstimator.estimate do |z|
-     z.add_stored_entry(filename: 'myfile1.bin', size: 9090821)
-     z.add_stored_entry(filename: 'myfile2.bin', size: 458678)
-    end
-    
-    [200, {'Content-Length' => bytesize.to_s}, zip_body]
+```ruby
+# Prepare the response body. The block will only be called when the response starts to be written.
+zip_body = ZipTricks::RackBody.new do | zip |
+  zip.add_stored_entry(filename: "myfile1.bin", size: 9090821, crc32: 12485)
+  zip << read_file('myfile1.bin')
+  zip.add_stored_entry(filename: "myfile2.bin", size: 458678, crc32: 89568)
+  zip << read_file('myfile2.bin')
+end
+
+# Precompute the Content-Length ahead of time
+bytesize = ZipTricks::SizeEstimator.estimate do |z|
+ z.add_stored_entry(filename: 'myfile1.bin', size: 9090821)
+ z.add_stored_entry(filename: 'myfile2.bin', size: 458678)
+end
+
+[200, {'Content-Length' => bytesize.to_s}, zip_body]
+```
 
 ## Other usage examples
 
@@ -70,32 +79,36 @@ If the write destination for your use case is a `Socket` (say, you are writing u
 the metadata of the file upfront (the CRC32 of the uncompressed file and the sizes), you can write directly
 to that socket using some accelerated writing technique, and only use the Streamer to write out the ZIP metadata.
 
-    # io has to be an object that supports #<<
-    ZipTricks::Streamer.open(io) do | zip |
-      # raw_file is written "as is" (STORED mode).
-      # Write the local file header first..
-      zip.add_stored_entry(filename: "first-file.bin", size: raw_file.size, crc32: raw_file_crc32)
-      
-      # then send the actual file contents bypassing the Streamer interface
-      io.sendfile(my_temp_file)
-      
-      # ...and then adjust the ZIP offsets within the Streamer
-      zip.simulate_write(my_temp_file.size)
-    end
+```ruby
+# io has to be an object that supports #<<
+ZipTricks::Streamer.open(io) do | zip |
+  # raw_file is written "as is" (STORED mode).
+  # Write the local file header first..
+  zip.add_stored_entry(filename: "first-file.bin", size: raw_file.size, crc32: raw_file_crc32)
+  
+  # then send the actual file contents bypassing the Streamer interface
+  io.sendfile(my_temp_file)
+  
+  # ...and then adjust the ZIP offsets within the Streamer
+  zip.simulate_write(my_temp_file.size)
+end
+```
 
 ## Computing the CRC32 value of a large file
 
-`BlockCRC32` computes the CRC32 checksum of an IO in a streaming fashion. It 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)
+`BlockCRC32` computes the CRC32 checksum of an IO in a streaming fashion.
+It is slightly more convenient for the purpose than using the raw Zlib library functions.
+
+```ruby
+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
  

data/Rakefile

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

data/lib/zip_tricks.rb

@@ -1,5 +1,5 @@
 module ZipTricks
-  VERSION = '4.2.1'
+  VERSION = '4.2.2'
   
   # Require all the sub-components except myself
   Dir.glob(__dir__ + '/**/*.rb').sort.each {|p| require p unless p == __FILE__ }

data/lib/zip_tricks/file_reader/inflating_reader.rb

@@ -20,6 +20,9 @@ class ZipTricks::FileReader::InflatingReader
     return '' if n_bytes.zero?
 
     compressed_chunk = @io.read(n_bytes)
+
+    return if compressed_chunk.nil?
+
     @already_read += compressed_chunk.bytesize
     @zlib_inflater.inflate(compressed_chunk)
   end

data/lib/zip_tricks/file_reader/stored_reader.rb

@@ -19,6 +19,9 @@ class ZipTricks::FileReader::StoredReader
     return '' if n_bytes.zero?
 
     compressed_chunk = @io.read(n_bytes)
+
+    return if compressed_chunk.nil?
+
     @already_read += compressed_chunk.bytesize
     compressed_chunk
   end

data/lib/zip_tricks/zip_writer.rb

@@ -48,11 +48,12 @@ class ZipTricks::ZipWriter
   C_V = 'V'.freeze    # Encode a 4-byte little-endian uint
   C_v = 'v'.freeze    # Encode a 2-byte little-endian uint
   C_Qe = 'Q<'.freeze  # Encode an 8-byte little-endian uint
-
+  C_es = ''.freeze
+  
   private_constant :FOUR_BYTE_MAX_UINT, :TWO_BYTE_MAX_UINT,
     :VERSION_MADE_BY, :VERSION_NEEDED_TO_EXTRACT, :VERSION_NEEDED_TO_EXTRACT_ZIP64,
     :DEFAULT_EXTERNAL_ATTRS, :MADE_BY_SIGNATURE,
-    :C_V, :C_v, :C_Qe, :ZIP_TRICKS_COMMENT
+    :C_V, :C_v, :C_Qe, :C_es, :ZIP_TRICKS_COMMENT
 
   # Writes the local file header, that precedes the actual file _data_. 
   # 
@@ -92,21 +93,21 @@ class ZipTricks::ZipWriter
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
     io << [filename.bytesize].pack(C_v)                 # file name length             2 bytes
 
-    extra_size = 0
-    if requires_zip64
-      extra_size += bytesize_of {|buf| write_zip_64_extra_for_local_file_header(io: buf, compressed_size: 0, uncompressed_size: 0) }
+    extra_fields = if requires_zip64
+      zip_64_extra_for_local_file_header(compressed_size: compressed_size, uncompressed_size: uncompressed_size)
+    else
+      C_es
     end
-    io << [extra_size].pack(C_v)                      # extra field length              2 bytes
 
-    io << filename                                    # file name (variable size)
+    io << [extra_fields.bytesize].pack(C_v)            # extra field length              2 bytes
+
+    io << filename                                     # file name (variable size)
 
     # Interesting tidbit:
     # https://social.technet.microsoft.com/Forums/windows/en-US/6a60399f-2879-4859-b7ab-6ddd08a70948
     # TL;DR of it is: Windows 7 Explorer _will_ open Zip64 entries. However, it desires to have the
     # Zip64 extra field as _the first_ extra field. If we decide to add the Info-ZIP UTF-8 field...
-    if requires_zip64
-      write_zip_64_extra_for_local_file_header(io: io, compressed_size: compressed_size, uncompressed_size: uncompressed_size)
-    end
+    io << extra_fields if requires_zip64
   end
 
   # Writes the file header for the central directory, for a particular file in the archive. When writing out this data,
@@ -153,14 +154,13 @@ class ZipTricks::ZipWriter
     # Filename should not be longer than 0xFFFF otherwise this wont fit here
     io << [filename.bytesize].pack(C_v)                 # file name length                2 bytes
 
-    extra_size = 0
-    if add_zip64
-      extra_size += bytesize_of {|buf|
-        # Supply zeroes for most values as we obnly care about the size of the data written
-        write_zip_64_extra_for_central_directory_file_header(io: buf, compressed_size: 0, uncompressed_size: 0, local_file_header_location: 0)
-      }
+    extra_fields = if add_zip64
+      zip_64_extra_for_central_directory_file_header(local_file_header_location: local_file_header_location,
+          compressed_size: compressed_size, uncompressed_size: uncompressed_size)
+    else
+      C_es
     end
-    io << [extra_size].pack(C_v)                        # extra field length              2 bytes
+    io << [extra_fields.bytesize].pack(C_v)             # extra field length              2 bytes
 
     io << [0].pack(C_v)                                 # file comment length             2 bytes
 
@@ -181,11 +181,7 @@ class ZipTricks::ZipWriter
       io << [local_file_header_location].pack(C_V)
     end
     io << filename                                     # file name (variable size)
-
-    if add_zip64                                       # extra field (variable size)
-      write_zip_64_extra_for_central_directory_file_header(io: io, local_file_header_location: local_file_header_location,
-        compressed_size: compressed_size, uncompressed_size: uncompressed_size)
-    end
+    io << extra_fields                                 # extra field (variable size)
     #(empty)                                           # file comment (variable size)
   end
 
@@ -305,38 +301,38 @@ class ZipTricks::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 io[#<<] the buffer to write the local file header to
   # @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
-  # @return [void]
-  def write_zip_64_extra_for_local_file_header(io:, compressed_size:, uncompressed_size:)
-    io << [0x0001].pack(C_v)                        # 2 bytes    Tag for this "extra" block type
-    io << [16].pack(C_v)                            # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
-    io << [uncompressed_size].pack(C_Qe)            # 8 bytes    Original uncompressed file size
-    io << [compressed_size].pack(C_Qe)              # 8 bytes    Size of compressed data
+  # @return [String]
+  def zip_64_extra_for_local_file_header(compressed_size:, uncompressed_size:)
+    data_and_packspecs = [
+      0x0001, C_v,                       # 2 bytes    Tag for this "extra" block type
+      16, C_v,                           # 2 bytes    Size of this "extra" block. For us it will always be 16 (2x8)
+      uncompressed_size, C_Qe,           # 8 bytes    Original uncompressed file size
+      compressed_size, C_Qe,             # 8 bytes    Size of compressed data
+    ]
+    pack_array(data_and_packspecs)
   end
   
   # 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 io[#<<] the buffer to write the local file header to
   # @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
-  # @return [void]
-  def write_zip_64_extra_for_central_directory_file_header(io:, compressed_size:, uncompressed_size:, local_file_header_location:)
-    io << [0x0001].pack(C_v)                        # 2 bytes    Tag for this "extra" block type
-    io << [28].pack(C_v)                            # 2 bytes    Size of this "extra" block. For us it will always be 28
-    io << [uncompressed_size].pack(C_Qe)            # 8 bytes    Original uncompressed file size
-    io << [compressed_size].pack(C_Qe)              # 8 bytes    Size of compressed data
-    io << [local_file_header_location].pack(C_Qe)   # 8 bytes    Offset of local header record
-    io << [0].pack(C_V)                             # 4 bytes    Number of the disk on which this file starts
+  # @return [String]
+  def zip_64_extra_for_central_directory_file_header(compressed_size:, uncompressed_size:, local_file_header_location:)
+    data_and_packspecs = [
+      0x0001, C_v,                        # 2 bytes    Tag for this "extra" block type
+      28,     C_v,                        # 2 bytes    Size of this "extra" block. For us it will always be 28
+      uncompressed_size, C_Qe,            # 8 bytes    Original uncompressed file size
+      compressed_size,   C_Qe,            # 8 bytes    Size of compressed data
+      local_file_header_location, C_Qe,   # 8 bytes    Offset of local header record
+      0, C_V,                             # 4 bytes    Number of the disk on which this file starts
+    ]
+    pack_array(data_and_packspecs)
   end
   
-  def bytesize_of
-    ''.force_encoding(Encoding::BINARY).tap {|b| yield(b) }.bytesize
-  end
-
   def to_binary_dos_time(t)
     (t.sec/2) + (t.min << 5) + (t.hour << 11)
   end
@@ -344,4 +340,17 @@ class ZipTricks::ZipWriter
   def to_binary_dos_date(t)
     (t.day) + (t.month << 5) + ((t.year - 1980) << 9)
   end
+  
+  # Unzips a given array of tuples of "numeric value, pack specifier" and then packs all the odd
+  # values using specifiers from all the even values. It is harder to explain than to show:
+  #
+  #   pack_array([1, 'V', 2, 'v', 148, 'v]) #=> "\x01\x00\x00\x00\x02\x00\x94\x00"
+  #
+  # will do the following two transforms:
+  #
+  #  [1, 'V', 2, 'v', 148, 'v] -> [1,2,148], ['V','v','v'] -> [1,2,148].pack('Vvv') -> "\x01\x00\x00\x00\x02\x00\x94\x00"
+  def pack_array(values_to_packspecs)
+    values, packspecs = values_to_packspecs.partition.each_with_index { |_, i| i.even? }
+    values.pack(packspecs.join)
+  end
 end

data/zip_tricks.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: zip_tricks 4.2.1 ruby lib
+# stub: zip_tricks 4.2.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "zip_tricks"
-  s.version = "4.2.1"
+  s.version = "4.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2016-10-10"
+  s.date = "2016-11-13"
   s.description = "Stream out ZIP files from Ruby"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
@@ -86,7 +86,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<coderay>, [">= 0"])
       s.add_development_dependency(%q<yard>, ["~> 0.8"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<jeweler>, [">= 2.1.2", "~> 2"])
     else
       s.add_dependency(%q<rubyzip>, ["~> 1.1"])
       s.add_dependency(%q<terminal-table>, [">= 0"])
@@ -97,7 +97,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<coderay>, [">= 0"])
       s.add_dependency(%q<yard>, ["~> 0.8"])
       s.add_dependency(%q<bundler>, ["~> 1.0"])
-      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<jeweler>, [">= 2.1.2", "~> 2"])
     end
   else
     s.add_dependency(%q<rubyzip>, ["~> 1.1"])
@@ -109,7 +109,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<coderay>, [">= 0"])
     s.add_dependency(%q<yard>, ["~> 0.8"])
     s.add_dependency(%q<bundler>, ["~> 1.0"])
-    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<jeweler>, [">= 2.1.2", "~> 2"])
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zip_tricks
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 4.2.2
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-10 00:00:00.000000000 Z
+date: 2016-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -146,16 +146,22 @@ dependencies:
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: '2'
 description: Stream out ZIP files from Ruby
 email: me@julik.nl
 executables: []