zip_tricks 2.6.0 → 2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33d767b5968d6743916c79ae85953e802a3f3e4a
-  data.tar.gz: 30bcfd521a5db58cfea176d6b36c82c09609c485
+  metadata.gz: bbb6bf8e96402a401c0bd282c77f48adb8b6e797
+  data.tar.gz: 7fea8830d270a647f66edd6d89c2c04a4674c2f7
 SHA512:
-  metadata.gz: 41b5f45f0ae560ca28386e939da7cbb4648fe34fe0c84acbff1a761786b797d1a17a30a33cf72201596783a0dfa307d8d7910089872d76aecaf8b10986a9ccd9
-  data.tar.gz: 0539bde9484ba1cb6bf580cfbc252271a1498bdbca9703701d22333a67f6d495360558590e6eaf2e945742a46e63bbe0d519f32664bdc329908a1b80f6ad8b76
+  metadata.gz: f79662655eeccdaeede66019b345fa9274c264beedf48dbcb7098dcaceba10f86d881e5d27ce720c6c875adb5eb7c0d8352d79d9beb1dd4d320932896c164b34
+  data.tar.gz: 0070e683f68a0f72c07dee4992d2213e604d73ee01df0ca7dcbbcd55dc9ab6ff66a26f0a8ecf0098495575b2e9fbda8b52044fb51ee436d58f7e53d20159428a

data/lib/zip_tricks/block_deflate.rb

@@ -27,7 +27,7 @@ module ZipTricks::BlockDeflate
     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.
   #
@@ -40,11 +40,11 @@ module ZipTricks::BlockDeflate
     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
@@ -64,7 +64,7 @@ module ZipTricks::BlockDeflate
     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

data/lib/zip_tricks/block_write.rb

@@ -17,7 +17,7 @@ class ZipTricks::BlockWrite
   # 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
@@ -25,14 +25,14 @@ class ZipTricks::BlockWrite
     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

data/lib/zip_tricks/manifest.rb

@@ -1,10 +1,10 @@
 # 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 |
@@ -26,14 +26,14 @@ class ZipTricks::Manifest < Struct.new(:zip_streamer, :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)
@@ -45,14 +45,14 @@ class ZipTricks::Manifest < Struct.new(:zip_streamer, :io, :part_list)
     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)
@@ -65,19 +65,19 @@ class ZipTricks::Manifest < Struct.new(:zip_streamer, :io, :part_list)
     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)

data/lib/zip_tricks/rack_body.rb

@@ -12,19 +12,19 @@ class ZipTricks::RackBody
   #     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.
@@ -32,7 +32,7 @@ class ZipTricks::RackBody
     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}

data/lib/zip_tricks/remote_io.rb

@@ -2,14 +2,14 @@
 # - or, more precisely, to be useful as a source for the RubyZip
 # central directory parser
 class ZipTricks::RemoteIO
-  
+
   # @param fetcher[#request_object_size, #request_range] an object that can fetch
   def initialize(fetcher = :NOT_SET)
     @pos = 0
     @fetcher = fetcher
     @remote_size = false
   end
-  
+
   # Emulates IO#seek
   def seek(offset, mode = IO::SEEK_SET)
     case mode
@@ -28,16 +28,17 @@ class ZipTricks::RemoteIO
   # Emulates IO#read
   def read(n_bytes = nil)
     @remote_size ||= request_object_size
-    
+
     # If the resource is empty there is nothing to read
     return nil if @remote_size.zero?
-    
+
     maximum_avaialable = @remote_size - @pos
     n_bytes ||= maximum_avaialable # nil == read to the end of file
+    return '' if n_bytes.zero?
     raise ArgumentError, "No negative reads(#{n_bytes})" if n_bytes < 0
-    
+
     n_bytes = clamp(0, n_bytes, maximum_avaialable)
-    
+
     read_n_bytes_from_remote(@pos, n_bytes).tap do |data|
       if data.bytesize != n_bytes
         raise "Remote read returned #{data.bytesize} bytes instead of #{n_bytes} as requested"
@@ -53,30 +54,30 @@ class ZipTricks::RemoteIO
   def pos
     @pos
   end
-  
+
   protected
 
   def request_range(range)
     @fetcher.request_range(range)
   end
-  
+
   def request_object_size
     @fetcher.request_object_size
   end
-  
+
   # Reads N bytes at offset from remote
   def read_n_bytes_from_remote(start_at, n_bytes)
     range = (start_at..(start_at + n_bytes - 1))
     request_range(range)
   end
-  
+
   # Reads the Content-Length and caches it
   def remote_size
     @remote_size ||= request_object_size
   end
-  
+
   private
-  
+
   def clamp(a,b,c)
     return a if b < a
     return c if b > c

data/lib/zip_tricks/remote_uncap.rb

@@ -3,59 +3,59 @@
 # offsets at which the actual file contents is located. You can then
 # use the `Range:` HTTP headers to download those entries separately.
 class ZipTricks::RemoteUncap
-    
+
   # Represents a file embedded within a remote ZIP archive
   class RemoteZipEntry
-    
+
     # @return [String] filename of the file in the remote ZIP
     attr_accessor :name
-    
+
     # @return [Fixnum] size in bytes of the file when uncompressed
     attr_accessor :size_uncompressed
 
     # @return [Fixnum] size in bytes of the file when compressed (the segment in the ZIP)
     attr_accessor :size_compressed
-    
+
     # @return [Fixnum] compression method (0 for stored, 8 for deflate)
     attr_accessor :compression_method
-    
+
     # @return [Fixnum] where the file data starts within the ZIP
     attr_accessor :starts_at_offset
-    
+
     # @return [Fixnum] where the file data ends within the zip.
     #     Will be equal to starts_at_offset if the file is empty
     attr_accessor :ends_at_offset
-    
+
     # Yields the object during initialization
     def initialize
       yield self
     end
   end
-  
+
   # @param uri[String] the HTTP(S) URL to read the ZIP footer from 
   # @return [Array<RemoteZipEntry>] metadata about the files within the remote archive
   def self.files_within_zip_at(uri)
     fetcher = new(uri)
     fake_io = ZipTricks::RemoteIO.new(fetcher)
     dir = Zip::CentralDirectory.read_from_stream(fake_io)
-    
+
     dir.entries.map do | rubyzip_entry |
       RemoteZipEntry.new do | entry |
         entry.name = rubyzip_entry.name
         entry.size_uncompressed = rubyzip_entry.size
         entry.size_compressed = rubyzip_entry.compressed_size
         entry.compression_method = rubyzip_entry.compression_method
-        
+
         entry.starts_at_offset = rubyzip_entry.local_header_offset + rubyzip_entry.calculate_local_header_size
         entry.ends_at_offset = entry.starts_at_offset + rubyzip_entry.compressed_size
       end
     end
   end
-  
+
   def initialize(uri)
     @uri = URI(uri)
   end
-  
+
   # @param range[Range] the HTTP range of data to fetch from remote
   # @return [String] the response body of the ranged request
   def request_range(range)

data/lib/zip_tricks/stored_size_estimator.rb

@@ -1,6 +1,6 @@
 # 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:
   #
@@ -20,7 +20,7 @@ class ZipTricks::StoredSizeEstimator < Struct.new(:manifest)
     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)
@@ -30,7 +30,7 @@ class ZipTricks::StoredSizeEstimator < Struct.new(:manifest)
     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)

data/lib/zip_tricks/stream_crc32.rb

@@ -9,12 +9,12 @@ class ZipTricks::StreamCRC32
     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
@@ -23,14 +23,14 @@ class ZipTricks::StreamCRC32
     @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.
   #

data/lib/zip_tricks/streamer.rb

@@ -13,13 +13,13 @@
 class ZipTricks::Streamer
   EntryBodySizeMismatch = Class.new(StandardError)
   InvalidOutput = Class.new(ArgumentError)
-  
+
   # Language encoding flag (EFS) bit (general purpose bit 11)
   EFS = 0b100000000000
-  
+
   # Default general purpose flags for each entry.
   DEFAULT_GP_FLAGS = 0b00000000000
-  
+
   # Creates a new Streamer on top of the given IO-ish object and yields it. Once the given block
   # returns, the Streamer will have it's `close` method called, which will write out the central
   # directory of the archive to the output.
@@ -31,7 +31,7 @@ class ZipTricks::Streamer
     yield(archive)
     archive.close
   end
-  
+
   # Creates a new Streamer on top of the given IO-ish object.
   #
   # @param stream [IO] the destination IO for the ZIP (should respond to `tell` and `<<`)
@@ -39,7 +39,7 @@ class ZipTricks::Streamer
     raise InvalidOutput, "The stream should respond to #<<" unless stream.respond_to?(:<<)
     stream = ZipTricks::WriteAndTell.new(stream) unless stream.respond_to?(:tell) && stream.respond_to?(:advance_position_by)
     @output_stream = stream
-    
+
     @state_monitor = VeryTinyStateMachine.new(:before_entry, callbacks_to=self)
     @state_monitor.permit_state :in_entry_header, :in_entry_body, :in_central_directory, :closed
     @state_monitor.permit_transition :before_entry => :in_entry_header
@@ -47,7 +47,7 @@ class ZipTricks::Streamer
     @state_monitor.permit_transition :in_entry_body => :in_entry_header
     @state_monitor.permit_transition :in_entry_body => :in_central_directory
     @state_monitor.permit_transition :in_central_directory => :closed
-    
+
     @entry_set = ::Zip::EntrySet.new
   end
 
@@ -61,7 +61,7 @@ class ZipTricks::Streamer
     @bytes_written_for_entry += binary_data.bytesize
     self
   end
-  
+
   # Advances the internal IO pointer to keep the offsets of the ZIP file in check. Use this if you are going
   # to use accelerated writes to the socket (like the `sendfile()` call) after writing the headers, or if you
   # just need to figure out the size of the archive.
@@ -74,7 +74,7 @@ class ZipTricks::Streamer
     @bytes_written_for_entry += num_bytes
     @output_stream.tell
   end
-  
+
   # Writes out the local header for an entry (file in the ZIP) that is using the deflated storage model (is compressed).
   # Once this method is called, the `<<` method has to be called to write the actual contents of the body.
   #
@@ -88,21 +88,21 @@ class ZipTricks::Streamer
   # @return [Fixnum] the offset the output IO is at after writing the entry header
   def add_compressed_entry(entry_name, uncompressed_size, crc32, compressed_size)
     @state_monitor.transition! :in_entry_header
-    
+
     entry = ::Zip::Entry.new(@file_name, entry_name)
     entry.compression_method = Zip::Entry::DEFLATED
     entry.crc = crc32
     entry.size = uncompressed_size
     entry.compressed_size = compressed_size
     set_gp_flags_for_filename(entry, entry_name)
-    
+
     @entry_set << entry
     entry.write_local_entry(@output_stream)
     @expected_bytes_for_entry = compressed_size
     @bytes_written_for_entry = 0
     @output_stream.tell
   end
-  
+
   # Writes out the local header for an entry (file in the ZIP) that is using the stored storage model (is stored as-is).
   # Once this method is called, the `<<` method has to be called one or more times to write the actual contents of the body.
   #
@@ -112,7 +112,7 @@ class ZipTricks::Streamer
   # @return [Fixnum] the offset the output IO is at after writing the entry header
   def add_stored_entry(entry_name, uncompressed_size, crc32)
     @state_monitor.transition! :in_entry_header
-    
+
     entry = ::Zip::Entry.new(@file_name, entry_name)
     entry.compression_method = Zip::Entry::STORED
     entry.crc = crc32
@@ -125,8 +125,8 @@ class ZipTricks::Streamer
     @expected_bytes_for_entry = uncompressed_size
     @output_stream.tell
   end
-  
-  
+
+
   # Writes out the global footer and the directory entry header and the global directory of the ZIP
   # archive using the information about the entries added using `add_stored_entry` and `add_compressed_entry`.
   #
@@ -139,7 +139,7 @@ class ZipTricks::Streamer
     cdir.write_to_stream(@output_stream)
     @output_stream.tell
   end
-  
+
   # Closes the archive. Writes the central directory if it has not yet been written.
   # Switches the Streamer into a state where it can no longer be written to.
   #
@@ -151,9 +151,9 @@ class ZipTricks::Streamer
     @state_monitor.transition! :closed
     @output_stream.tell
   end
-    
+
   private
-  
+
   # Set the general purpose flags for the entry. The only flag we care about is the EFS
   # bit (bit 11) which should be set if the filename is UTF8. If it is, we need to set the
   # bit so that the unarchiving application knows that the filename in the archive is UTF-8
@@ -164,7 +164,7 @@ class ZipTricks::Streamer
   rescue Encoding::UndefinedConversionError #=> UTF8 filename
     entry.gp_flags = DEFAULT_GP_FLAGS | EFS
   end
-  
+
   # Checks whether the number of bytes written conforms to the declared entry size
   def leaving_in_entry_body_state
     if @bytes_written_for_entry != @expected_bytes_for_entry

data/lib/zip_tricks/write_and_tell.rb

@@ -5,7 +5,7 @@ class ZipTricks::WriteAndTell
     @io = io
     @pos = 0
   end
-  
+
   def <<(bytes)
     return self if bytes.nil?
     binary_bytes = binary(bytes)
@@ -13,17 +13,17 @@ class ZipTricks::WriteAndTell
     @pos += binary_bytes.bytesize
     self
   end
-  
+
   def advance_position_by(num_bytes)
     @pos += num_bytes
   end
-  
+
   def tell
     @pos
   end
-  
+
   private
-  
+
   def binary(str)
     return str if str.encoding == Encoding::BINARY
     str.force_encoding(Encoding::BINARY)

data/lib/zip_tricks.rb

@@ -2,7 +2,7 @@ require 'zip'
 require 'very_tiny_state_machine'
 
 module ZipTricks
-  VERSION = '2.6.0'
+  VERSION = '2.6.1'
   
   # Require all the sub-components except myself
   Dir.glob(__dir__ + '/**/*.rb').sort.each {|p| require p unless p == __FILE__ }

data/spec/zip_tricks/block_deflate_spec.rb

@@ -4,7 +4,7 @@ describe ZipTricks::BlockDeflate do
   def tag_deflated(deflated_string, raw_string)
     [120, 156].pack("C*") + deflated_string + [3,0].pack("C*") + [Zlib.adler32(raw_string)].pack("N")
   end
-  
+
   describe '.deflate_chunk' do
     it 'compresses a blob that can be inflated later, when the header, footer and adler32 are added' do
       blob = 'compressible' * 1024 * 4
@@ -13,26 +13,26 @@ describe ZipTricks::BlockDeflate do
       complete_deflated_segment = tag_deflated(compressed, blob)
       expect(Zlib.inflate(complete_deflated_segment)).to eq(blob)
     end
-    
+
     it 'removes the header' do
       blob = 'compressible' * 1024 * 4
       compressed = described_class.deflate_chunk(blob)
       expect(compressed[0..1]).not_to eq([120, 156].pack("C*"))
     end
-    
+
     it 'removes the adler32' do
       blob = 'compressible' * 1024 * 4
       compressed = described_class.deflate_chunk(blob)
       adler = [Zlib.adler32(blob)].pack("N")
       expect(compressed).not_to end_with(adler)
     end
-    
+
     it 'removes the end marker' do
       blob = 'compressible' * 1024 * 4
       compressed = described_class.deflate_chunk(blob)
       expect(compressed[-7..-5]).not_to eq([3,0].pack("C*"))
     end
-    
+
     it 'honors the compression level' do
       deflater = Zlib::Deflate.new
       expect(Zlib::Deflate).to receive(:new).with(2) { deflater }
@@ -40,7 +40,7 @@ describe ZipTricks::BlockDeflate do
       compressed = described_class.deflate_chunk(blob, level: 2)
     end
   end
-  
+
   describe 'deflate_in_blocks_and_terminate' do
     it 'uses deflate_in_blocks' do
       data = 'compressible' * 1024 * 1024 * 10
@@ -50,7 +50,7 @@ describe ZipTricks::BlockDeflate do
       expect(described_class).to receive(:deflate_in_blocks).with(input, output, level: -1, block_size: block_size).and_call_original
       described_class.deflate_in_blocks_and_terminate(input, output, block_size: block_size)
     end
-    
+
     it 'passes a custom compression level' do
       data = 'compressible' * 1024 * 1024 * 10
       input = StringIO.new(data)
@@ -58,7 +58,7 @@ describe ZipTricks::BlockDeflate do
       expect(described_class).to receive(:deflate_in_blocks).with(input, output, level: 9, block_size: 5242880).and_call_original
       described_class.deflate_in_blocks_and_terminate(input, output, level: Zlib::BEST_COMPRESSION)
     end
-    
+
     it 'writes the end marker' do
       data = 'compressible' * 1024 * 1024 * 10
       input = StringIO.new(data)
@@ -67,7 +67,7 @@ describe ZipTricks::BlockDeflate do
       expect(output.string[-2..-1]).to eq([3,0].pack("C*"))
     end
   end
-  
+
   describe '.write_terminator' do
     it 'writes the terminator and returns 2 for number of bytes written' do
       buf = double('IO')
@@ -75,35 +75,35 @@ describe ZipTricks::BlockDeflate do
       expect(described_class.write_terminator(buf)).to eq(2)
     end
   end
-  
+
   describe '.deflate_in_blocks' do
     it 'honors the block size' do
       data = 'compressible' * 1024 * 1024 * 10
       input = StringIO.new(data)
       output = StringIO.new
       block_size = 1024 * 64
-    
+
       num_chunks = (data.bytesize / block_size.to_f).ceil
       expect(described_class).to receive(:deflate_chunk).exactly(num_chunks).times.and_call_original
       expect(input).to receive(:read).with(block_size).exactly(num_chunks + 1).times.and_call_original
       expect(output).to receive(:<<).exactly(num_chunks).times.and_call_original
-      
+
       described_class.deflate_in_blocks(input, output, block_size: block_size)
     end
-    
+
     it 'does not write the end marker' do
       input_string = 'compressible' * 1024 * 1024 * 10
       output_string = ''
-      
+
       described_class.deflate_in_blocks(StringIO.new(input_string), StringIO.new(output_string))
       expect(output_string).not_to be_empty
       expect(output_string).not_to end_with([3,0].pack("C*"))
     end
-    
+
     it 'returns the number of bytes written' do
       input_string = 'compressible' * 1024 * 1024 * 10
       output_string = ''
-      
+
       num_bytes = described_class.deflate_in_blocks(StringIO.new(input_string), StringIO.new(output_string))
       expect(num_bytes).to eq(245016)
     end