zip_tricks 2.8.1 → 3.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zip_tricks
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-22 00:00:00.000000000 Z
+date: 2016-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -20,7 +20,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -31,19 +31,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: very_tiny_state_machine
+  name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: range_utils
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -172,30 +186,33 @@ files:
 - lib/zip_tricks.rb
 - lib/zip_tricks/block_deflate.rb
 - lib/zip_tricks/block_write.rb
-- lib/zip_tricks/manifest.rb
-- lib/zip_tricks/microzip.rb
+- lib/zip_tricks/file_reader.rb
 - lib/zip_tricks/null_writer.rb
 - lib/zip_tricks/rack_body.rb
 - lib/zip_tricks/remote_io.rb
 - lib/zip_tricks/remote_uncap.rb
-- lib/zip_tricks/stored_size_estimator.rb
+- lib/zip_tricks/size_estimator.rb
 - lib/zip_tricks/stream_crc32.rb
 - lib/zip_tricks/streamer.rb
+- lib/zip_tricks/streamer/deflated_writer.rb
+- lib/zip_tricks/streamer/entry.rb
+- lib/zip_tricks/streamer/stored_writer.rb
+- lib/zip_tricks/streamer/writable.rb
 - lib/zip_tricks/write_and_tell.rb
+- lib/zip_tricks/zip_writer.rb
 - spec/spec_helper.rb
 - spec/zip_tricks/block_deflate_spec.rb
 - spec/zip_tricks/block_write_spec.rb
-- spec/zip_tricks/manifest_spec.rb
-- spec/zip_tricks/microzip_interop_spec.rb
-- spec/zip_tricks/microzip_spec.rb
+- spec/zip_tricks/file_reader_spec.rb
 - spec/zip_tricks/rack_body_spec.rb
 - spec/zip_tricks/remote_io_spec.rb
 - spec/zip_tricks/remote_uncap_spec.rb
-- spec/zip_tricks/stored_size_estimator_spec.rb
+- spec/zip_tricks/size_estimator_spec.rb
 - spec/zip_tricks/stream_crc32_spec.rb
 - spec/zip_tricks/streamer_spec.rb
 - spec/zip_tricks/war-and-peace.txt
 - spec/zip_tricks/write_and_tell_spec.rb
+- spec/zip_tricks/zip_writer_spec.rb
 - zip_tricks.gemspec
 homepage: http://github.com/wetransfer/zip_tricks
 licenses:

data/lib/zip_tricks/manifest.rb

@@ -1,85 +0,0 @@
-# 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<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/microzip.rb

@@ -1,339 +0,0 @@
-# A replacement for RubyZip for streaming, with a couple of small differences.
-# The first difference is that it is verbosely-written-to-the-spec and you can actually
-# follow what is happening. It does not support quite a few fancy features of Rubyzip,
-# but instead it can be digested in one reading, and has solid Zip64 support. It also does
-# not attempt any tricks with Zip64 placeholder extra fields because the ZipTricks streaming
-# engine assumes you _know_ how large your file is (both compressed and uncompressed) _and_
-# you have the file's CRC32 checksum upfront.
-#
-# Just like Rubyzip it will switch to Zip64 automatically if required, but there is no global
-# setting to enable that behavior - it is always on.
-class ZipTricks::Microzip
-  STORED   = 0
-  DEFLATED = 8
-
-  TooMuch = Class.new(StandardError)
-  PathError = Class.new(StandardError)
-  DuplicateFilenames = Class.new(StandardError)
-  UnknownMode = Class.new(StandardError)
-  
-  FOUR_BYTE_MAX_UINT = 0xFFFFFFFF
-  TWO_BYTE_MAX_UINT = 0xFFFF
-  
-  VERSION_MADE_BY                        = 52
-  VERSION_NEEDED_TO_EXTRACT              = 20
-  VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
-  DEFAULT_EXTERNAL_ATTRS = begin
-    # These need to be set so that the unarchived files do not become executable on UNIX, for
-    # security purposes. Strictly speaking we would want to make this user-customizable,
-    # but for now just putting in sane defaults will do. For example, Trac with zipinfo does this:
-    # zipinfo.external_attr = 0644 << 16L # permissions -r-wr--r--.
-    # We snatch the incantations from Rubyzip for this.
-    unix_perms = 0644
-    file_type_file = 010
-    external_attrs = (file_type_file << 12 | (unix_perms & 07777)) << 16
-  end
-  MADE_BY_SIGNATURE = begin
-    # A combination of the VERSION_MADE_BY low byte and the OS type high byte
-    os_type = 3 # UNIX
-    [VERSION_MADE_BY, os_type].pack('CC')
-  end
-
-  C_V = 'V'.freeze
-  C_v = 'v'.freeze
-  C_Qe = 'Q<'.freeze
-
-  class Entry < Struct.new(:filename, :crc32, :compressed_size, :uncompressed_size, :storage_mode, :mtime)
-    def initialize(*)
-      super
-      filename.force_encoding(Encoding::UTF_8)
-      @requires_efs_flag = !(filename.encode(Encoding::ASCII) rescue false)
-      @requires_zip64 = (compressed_size > FOUR_BYTE_MAX_UINT || uncompressed_size > FOUR_BYTE_MAX_UINT)
-      raise TooMuch, "Filename is too long" if filename.bytesize > TWO_BYTE_MAX_UINT
-      raise PathError, "Paths in ZIP may only contain forward slashes (UNIX separators)" if filename.include?('\\')
-    end
-
-    def requires_zip64?
-      @requires_zip64
-    end
-    
-    # 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
-    # encoded, and not some DOS default. For ASCII entries it does not matter.
-    def gp_flags_based_on_filename
-      @requires_efs_flag ? (0b00000000000 | 0b100000000000) : 0b00000000000
-    end
-
-    def write_local_file_header(io)
-      # TBD: caveat. If this entry _does_ fit into a standard zip segment (both compressed and
-      # uncompressed size at or below 0xFFFF etc), but it is _located_ at an offset that requires
-      # Zip64 to be used (beyound 4GB), we are going to be omitting the Zip64 extras in the local
-      # file header, but we will be enabling them when writing the central directory. Then the
-      # CD record for the file _will_ have Zip64 extra, but the local file header won't. In theory,
-      # this should not pose a problem, but then again... life in this world can be harsh.
-      #
-      # If it turns out that it _does_ pose a problem, we can always do:
-      #
-      #   @requires_zip64 = true if io.tell > FOUR_BYTE_MAX_UINT
-      #
-      # right here, and have the data written regardless even if the file fits.
-      io << [0x04034b50].pack(C_V)                        # local file header signature     4 bytes  (0x04034b50)
-
-      if @requires_zip64                                  # version needed to extract       2 bytes
-        io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v)
-      else
-        io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)
-      end
-
-      io << [gp_flags_based_on_filename].pack("v")        # general purpose bit flag        2 bytes
-      io << [storage_mode].pack("v")                      # compression method              2 bytes
-      io << [to_binary_dos_time(mtime)].pack(C_v)         # last mod file time              2 bytes
-      io << [to_binary_dos_date(mtime)].pack(C_v)         # last mod file date              2 bytes
-      io << [crc32].pack(C_V)                             # crc-32                          4 bytes
-
-      if @requires_zip64
-        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # compressed size              4 bytes
-        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # uncompressed size            4 bytes
-      else
-        io << [compressed_size].pack(C_V)                 # compressed size              4 bytes
-        io << [uncompressed_size].pack(C_V)               # uncompressed size            4 bytes
-      end
-
-      # 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(buf) }
-      end
-      io << [extra_size].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...
-      write_zip_64_extra_for_local_file_header(io) if @requires_zip64
-    end
-
-    def write_zip_64_extra_for_local_file_header(io)
-      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
-    end
-
-    def write_zip_64_extra_for_central_directory_file_header(io, 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
-    end
-
-    def write_central_directory_file_header(io, local_file_header_location)
-      # At this point if the header begins somewhere beyound 0xFFFFFFFF we _have_ to record the offset
-      # of the local file header as a zip64 extra field, so we give up, give in, you loose, love will always win...
-      @requires_zip64 = true if local_file_header_location > FOUR_BYTE_MAX_UINT
-      
-      io << [0x02014b50].pack(C_V)                        # central file header signature   4 bytes  (0x02014b50)
-      io << MADE_BY_SIGNATURE                             # version made by                 2 bytes
-      if @requires_zip64
-        io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v) # version needed to extract       2 bytes
-      else
-        io << [VERSION_NEEDED_TO_EXTRACT].pack(C_v)       # version needed to extract       2 bytes
-      end
-
-      io << [gp_flags_based_on_filename].pack(C_v)        # general purpose bit flag        2 bytes
-      io << [storage_mode].pack(C_v)                      # compression method              2 bytes
-      io << [to_binary_dos_time(mtime)].pack(C_v)         # last mod file time              2 bytes
-      io << [to_binary_dos_date(mtime)].pack(C_v)         # last mod file date              2 bytes
-      io << [crc32].pack(C_V)                             # crc-32                          4 bytes
-
-      if @requires_zip64
-        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # compressed size              4 bytes
-        io << [FOUR_BYTE_MAX_UINT].pack(C_V)              # uncompressed size            4 bytes
-      else
-        io << [compressed_size].pack(C_V)                 # compressed size              4 bytes
-        io << [uncompressed_size].pack(C_V)               # uncompressed size            4 bytes
-      end
-
-      # 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_central_directory_file_header(buf, local_file_header_location)
-        }
-      end
-      io << [extra_size].pack(C_v)                        # extra field length              2 bytes
-
-      io << [0].pack(C_v)                                 # file comment length             2 bytes
-      
-      # For The Unarchiver < 3.11.1 this field has to be set to the overflow value if zip64 is used
-      # because otherwise it does not properly advance the pointer when reading the Zip64 extra field
-      # https://bitbucket.org/WAHa_06x36/theunarchiver/pull-requests/2/bug-fix-for-zip64-extra-field-parser/diff
-      if @requires_zip64
-        io << [TWO_BYTE_MAX_UINT].pack(C_v)               # disk number start               2 bytes
-      else
-        io << [0].pack(C_v)                               # disk number start               2 bytes
-      end
-      io << [0].pack(C_v)                                # internal file attributes        2 bytes
-      io << [DEFAULT_EXTERNAL_ATTRS].pack(C_V)           # external file attributes        4 bytes
-
-      if @requires_zip64
-        io << [FOUR_BYTE_MAX_UINT].pack(C_V)             # relative offset of local header 4 bytes
-      else
-        io << [local_file_header_location].pack(C_V)     # relative offset of local header 4 bytes
-      end
-      io << filename                                     # file name (variable size)
-
-      if @requires_zip64                                  # extra field (variable size)
-        write_zip_64_extra_for_central_directory_file_header(io, local_file_header_location)
-      end
-                                                          # file comment (variable size)
-    end
-
-    private
-
-    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
-
-    def to_binary_dos_date(t)
-      (t.day) + (t.month << 5) + ((t.year - 1980) << 9)
-    end
-  end
-
-  # Creates a new streaming writer.
-  # The writer is stateful and knows it's list of ZIP file entries as they are being added.
-  def initialize
-    @files = []
-    @local_header_offsets = []
-  end
-
-  # Adds a file to the entry list and immediately writes out it's local file header into the
-  # output stream.
-  #
-  # @param io[#<<, #tell] the buffer to write the local file header to
-  # @param filename[String] The name of the file
-  # @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 storage_mode[Fixnum]  Either 0 for "stored" or 8 for "deflated"
-  # @param mtime[Time] What modification time to record for the file
-  # @return [void]
-  def add_local_file_header(io:, filename:, crc32:, compressed_size:, uncompressed_size:, storage_mode:, mtime: Time.now.utc)
-    if @files.any?{|e| e.filename == filename }
-      raise DuplicateFilenames, "Filename #{filename.inspect} already used in the archive"
-    end
-    raise UnknownMode, "Unknown compression mode #{storage_mode}" unless [STORED, DEFLATED].include?(storage_mode)
-    e = Entry.new(filename, crc32, compressed_size, uncompressed_size, storage_mode, mtime)
-    @files << e
-    @local_header_offsets << io.tell
-    e.write_local_file_header(io)
-  end
-
-  # Writes the central directory (including the Zip6 salient bits if necessary)
-  #
-  # @param io[#<<, #tell] the buffer to write the central directory to.
-  #                     The method will use `tell` on the buffer since it has to know where the central directory is located
-  # @return [void]
-  def write_central_directory(io)
-    start_of_central_directory = io.tell
-
-    # Central directory file headers, per file in order
-    @files.each_with_index do |file, i|
-      local_file_header_offset_from_start_of_file = @local_header_offsets.fetch(i)
-      file.write_central_directory_file_header(io, local_file_header_offset_from_start_of_file)
-    end
-    central_dir_size = io.tell - start_of_central_directory
-
-    zip64_required = central_dir_size > FOUR_BYTE_MAX_UINT ||
-      start_of_central_directory > FOUR_BYTE_MAX_UINT ||
-      @files.length > TWO_BYTE_MAX_UINT ||
-      @files.any?(&:requires_zip64?)
-
-    # Then, if zip64 is used
-    if zip64_required
-      # [zip64 end of central directory record]
-      zip64_eocdr_offset = io.tell
-                                                # zip64 end of central dir
-      io << [0x06064b50].pack(C_V)             # signature                       4 bytes  (0x06064b50)
-      io << [44].pack(C_Qe)                    # size of zip64 end of central
-                                                # directory record                8 bytes
-                                                # (this is ex. the 12 bytes of the signature and the size value itself).
-                                                # Without the extensible data sector it is always 44.
-      io << MADE_BY_SIGNATURE                                # version made by                 2 bytes
-      io << [VERSION_NEEDED_TO_EXTRACT_ZIP64].pack(C_v)      # version needed to extract       2 bytes
-      io << [0].pack(C_V)                                    # number of this disk             4 bytes
-      io << [0].pack(C_V)                                    # number of the disk with the
-                                                             # start of the central directory  4 bytes
-      io << [@files.length].pack(C_Qe)                       # total number of entries in the
-                                                             # central directory on this disk  8 bytes
-      io << [@files.length].pack(C_Qe)                       # total number of entries in the
-                                                             # central directory               8 bytes
-      io << [central_dir_size].pack(C_Qe)                    # size of the central directory   8 bytes
-                                                             # offset of start of central
-                                                             # directory with respect to
-      io << [start_of_central_directory].pack(C_Qe)          # the starting disk number        8 bytes
-                                                             # zip64 extensible data sector    (variable size), blank for us
-
-      # [zip64 end of central directory locator]
-      io << [0x07064b50].pack(C_V)                           # zip64 end of central dir locator
-                                                             # signature                       4 bytes  (0x07064b50)
-      io << [0].pack(C_V)                                    # number of the disk with the
-                                                             # start of the zip64 end of
-                                                             # central directory               4 bytes
-      io << [zip64_eocdr_offset].pack(C_Qe)                  # relative offset of the zip64
-                                                             # end of central directory record 8 bytes
-                                                             # (note: "relative" is actually "from the start of the file")
-      io << [1].pack(C_V)                                    # total number of disks           4 bytes
-    end
-
-    # Then the end of central directory record:
-    io << [0x06054b50].pack(C_V)                            # end of central dir signature     4 bytes  (0x06054b50)
-    io << [0].pack(C_v)                                     # number of this disk              2 bytes
-    io << [0].pack(C_v)                                     # number of the disk with the
-                                                            # start of the central directory 2 bytes
-    
-    if zip64_required # the number of entries will be read from the zip64 part of the central directory
-      io << [TWO_BYTE_MAX_UINT].pack(C_v)                   # total number of entries in the
-                                                            # central directory on this disk   2 bytes
-      io << [TWO_BYTE_MAX_UINT].pack(C_v)                   # total number of entries in
-                                                            # the central directory            2 bytes
-    else
-      io << [@files.length].pack(C_v)                       # total number of entries in the
-                                                            # central directory on this disk   2 bytes
-      io << [@files.length].pack(C_v)                       # total number of entries in
-                                                            # the central directory            2 bytes
-    end
-    
-    if zip64_required
-      io << [FOUR_BYTE_MAX_UINT].pack(C_V)                  # size of the central directory    4 bytes
-      io << [FOUR_BYTE_MAX_UINT].pack(C_V)                  # offset of start of central
-                                                            # directory with respect to
-                                                            # the starting disk number        4 bytes
-    else
-      io << [central_dir_size].pack(C_V)                    # size of the central directory    4 bytes
-      io << [start_of_central_directory].pack(C_V)          # offset of start of central
-                                                            # directory with respect to
-                                                            # the starting disk number        4 bytes
-    end
-    io << [0].pack(C_v)                                     # .ZIP file comment length        2 bytes
-                                                            # .ZIP file comment       (variable size)
-  end
-  
-  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, 
-    :Entry, :C_V, :C_v, :C_Qe
-end

data/lib/zip_tricks/stored_size_estimator.rb

@@ -1,44 +0,0 @@
-# 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/spec/zip_tricks/manifest_spec.rb

@@ -1,60 +0,0 @@
-require_relative '../spec_helper'
-
-describe ZipTricks::Manifest do
-  it 'builds a map of the contained ranges, and has its cumulative size match the predicted archive size exactly' do
-    # Generate a couple of random files
-    raw_file_1 = SecureRandom.random_bytes(1024 * 20)
-    raw_file_2 = SecureRandom.random_bytes(1024 * 128)
-    raw_file_3 = SecureRandom.random_bytes(1258695)
-
-    manifest, bytesize = described_class.build do | builder |
-      r = builder.add_stored_entry(name: "first-file.bin", size_uncompressed: raw_file_1.size)
-      expect(r).to eq(builder), "add_stored_entry should return self"
-
-      builder.add_stored_entry(name: "second-file.bin", size_uncompressed: raw_file_2.size)
-
-      r = builder.add_compressed_entry(name: "second-file-comp.bin", size_uncompressed: raw_file_2.size, 
-        size_compressed: raw_file_3.size, segment_info: 'http://example.com/second-file-deflated-segment.bin')
-      expect(r).to eq(builder), "add_compressed_entry should return self"
-    end
-
-    require 'range_utils'
-
-    expect(manifest).to be_kind_of(Array)
-    total_size_of_all_parts = manifest.inject(0) do | total_bytes, span |
-      total_bytes + RangeUtils.size_from_range(span.byte_range_in_zip)
-    end
-    expect(total_size_of_all_parts).to eq(1410595)
-    expect(bytesize).to eq(1410595)
-
-    expect(manifest.length).to eq(7)
-
-    first_header = manifest[0]
-    expect(first_header.part_type).to eq(:entry_header)
-    expect(first_header.byte_range_in_zip).to eq(0..43)
-    expect(first_header.filename).to eq("first-file.bin")
-    expect(first_header.additional_metadata).to be_nil
-
-    first_body = manifest[1]
-    expect(first_body.part_type).to eq(:entry_body)
-    expect(first_body.byte_range_in_zip).to eq(44..20523)
-    expect(first_body.filename).to eq("first-file.bin")
-    expect(first_body.additional_metadata).to be_nil
-
-    third_header = manifest[4]
-    expect(third_header.part_type).to eq(:entry_header)
-    expect(third_header.byte_range_in_zip).to eq(151641..151690)
-    expect(third_header.filename).to eq("second-file-comp.bin")
-    expect(third_header.additional_metadata).to eq("http://example.com/second-file-deflated-segment.bin")
-
-    third_body = manifest[5]
-    expect(third_body.part_type).to eq(:entry_body)
-    expect(third_body.byte_range_in_zip).to eq(151691..1410385)
-    expect(third_body.filename).to eq("second-file-comp.bin")
-    expect(third_body.additional_metadata).to eq("http://example.com/second-file-deflated-segment.bin")
-
-    cd = manifest[-1]
-    expect(cd.part_type).to eq(:central_directory)
-    expect(cd.byte_range_in_zip).to eq(1410386..1410594)
-  end
-end