zip_tricks 4.7.3 → 4.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 537945ff9983b6d84190281aaf71d52a265e49f5
-  data.tar.gz: 1aa8b7a739b624dd7de4ea3e960d966f6f3d9ad3
+SHA256:
+  metadata.gz: a8147080f700510b88cb5e807e61ac71caf94e4b35af7a13162f3fcb0557b221
+  data.tar.gz: 507c345c51f13b2874577497359f49179447b494eacf55f81c6a0b182feeb97a
 SHA512:
-  metadata.gz: 4a98133de0c4902de0babccb5ce5c59e97d9636e1191c65d61bdf538e58c3b81847871bee79584609fc1864f32a0b3dfb8068781149f5b957e43ad1ed80a8b35
-  data.tar.gz: 42e5c29411a5b1a3942bf88f359694572fe0c4a3efbd61006457e0f53c5d0b9948bf8d5f7f801a5c819d341b2e6fc52f2479030c5dd9248b53e5f031faf65423
+  metadata.gz: 328483359ec8a1ced39c3cdc4b853d0fadda7a2c66e1d36e0babc3e701648e57b212b85b5adf6cc24fc92d63eff28889216b11438252f8d1e32d9bdfbb1acaab
+  data.tar.gz: 99d3e5e9a31ab39ae1bbf39128a086373eadb29a44dee76fc4674eb73ad96ed9c190ca50d9d7227b16f6421d01b2603026386d0e16260eec33f417fd68f85e58

data/.rubocop.yml

@@ -1,5 +1,7 @@
 inherit_gem:
   wetransfer_style: ruby/default.yml
+AllCops:
+  TargetRubyVersion: 2.1
 Layout/FirstMethodArgumentLineBreak:
   Enabled: false
 Layout/FirstMethodParameterLineBreak:
@@ -7,4 +9,5 @@ Layout/FirstMethodParameterLineBreak:
 Style/GlobalVars:
   Exclude:
       - qa/*.rb
-      - spec/spec_helper.rb
+      - spec/spec_helper.rb
+      - spec/support/zip_inspection.rb

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 4.8.3
+
+* Fix a leak of 1 zlib deflater object per deflated file when writing out compressed files with data descriptors. The deflater
+  needs to be closed explicitly, which we weren't previously doing.
+
+## 4.8.2
+
+* Fix extended timestamp timestamp value encoding. Previously we would use an incorrect encoding for the timestamp value, which would output correct but nonsensical timestamps. The pack specifier is now changed to output the correct value.
+
+## 4.8.1
+
+* Fix extended timestamp extra field output. The first bit of the flag would be set instead of the last bit of
+  the flag, which made it impossible for Rubyzip to read the timestamp of the entry - and it would also make
+  the extra field useless for most reading applications.
+
+## 4.8.0
+
+* Make sure that when directories clobber files and vice versa we raise a clear error. Add `PathSet` which keeps track of entries
+  and all the directories needed to create them, document `PathSet`
+* Move the `uniquify_filenames` function into a module for easier removal later
+* Add the `auto_rename_duplicate_filenames` parameter to `Streamer` constructor. We need to make this optional
+  because making filenames unique can be very tricky when subdirectories are involved, and strictly
+  speaking we should not be applying this transformation at all - there should be no output of
+  duplicate filenames by the caller. So making the filenames should be available, but optional.
+
+## 4.7.4
+
+* Use a single fixed capacity string in StreamCRC32.from_io to avoid unnecessary allocations
+* Fix a few tests that were calling out to external binaries
+
 ## 4.7.3
 
 * Fix RemoteUncap#request_object_size to function correctly

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2016 WeTransfer
+Copyright (c) 2019 WeTransfer
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,7 +1,6 @@
 # zip_tricks
 
-[![Build Status](https://travis-ci.org/WeTransfer/zip_tricks.svg?branch=master)](https://travis-ci.org/WeTransfer/zip_tricks)
-[![Gem Version](https://badge.fury.io/rb/zip_tricks.svg)](https://badge.fury.io/rb/zip_tricks)
+[![Build Status](https://travis-ci.org/WeTransfer/zip_tricks.svg?branch=backports-v4)](https://travis-ci.org/WeTransfer/zip_tricks)
 
 Allows streaming, non-rewinding ZIP file output from Ruby.
 
@@ -30,7 +29,7 @@ The easiest is to use the Rails' built-in streaming feature:
 class ZipsController < ActionController::Base
   include ActionController::Live # required for streaming
   include ZipTricks::RailsStreaming
-  
+
   def download
     zip_tricks_stream do |zip|
       zip.write_deflated_file('report1.csv') do |sink|
@@ -122,10 +121,10 @@ 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
@@ -143,7 +142,7 @@ It is slightly more convenient for the purpose than using the raw Zlib library f
 
 ```ruby
 crc = ZipTricks::StreamCRC32.new
-crc << large_file.read(1024 * 12) until large_file.eof?
+crc << next_chunk_of_data
 ...
 
 crc.to_i # Returns the actual CRC32 value computed so far
@@ -152,6 +151,12 @@ crc.to_i # Returns the actual CRC32 value computed so far
 crc.append(precomputed_crc32, size_of_the_blob_computed_from)
 ```
 
+You can also compute the CRC32 for an entire IO object if it responds to `#eof?`:
+
+```ruby
+crc = ZipTricks::StreamCRC32.from_io(file) # Returns an Integer
+```
+
 ## Reading ZIP files
 
 The library contains a reader module, play with it to see what is possible. It is not a complete ZIP reader
@@ -160,7 +165,7 @@ as such it performs it's function quite well. Please beware of the security impl
 that have not been formally verified (ours hasn't been).
 
 ## 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.
@@ -172,4 +177,4 @@ that have not been formally verified (ours hasn't been).
 
 ## Copyright
 
-Copyright (c) 2016 WeTransfer. See LICENSE.txt for further details.
+Copyright (c) 2019 WeTransfer. See LICENSE.txt for further details.

data/lib/zip_tricks/path_set.rb

@@ -0,0 +1,148 @@
+# rubocop:disable Layout/IndentHeredoc
+
+# A ZIP archive contains a flat list of entries. These entries can implicitly
+# create directories when the archive is expanded. For example, an entry with
+# the filename of "some folder/file.docx" will make the unarchiving application
+# create a directory called "some folder" automatically, and then deposit the
+# file "file.docx" in that directory. These "implicit" directories can be
+# arbitrarily nested, and create a tree structure of directories. That structure
+# however is implicit as the archive contains a flat list.
+#
+# This creates opportunities for conflicts. For example, imagine the following
+# structure:
+#
+# * `something/` - specifies an empty directory with the name "something"
+# * `something` - specifies a file, creates a conflict
+#
+# This can be prevented with filename uniqueness checks. It does get funkier however
+# as the rabbit hole goes down:
+#
+# * `dir/subdir/another_subdir/yet_another_subdir/file.bin` - declares a file and directories
+# * `dir/subdir/another_subdir/yet_another_subdir` - declares a file at one of the levels, creates a conflict
+#
+# The results of this ZIP structure aren't very easy to predict as they depend on the
+# application that opens the archive. For example, BOMArchiveHelper on macOS will expand files
+# as they are declared in the ZIP, but once a conflict occurs it will fail with "error -21". It
+# is not very transparent to the user why unarchiving fails, and it has to - and can reliably - only
+# be prevented when the archive gets created.
+#
+# Unfortunately that conflicts with another "magical" feature of ZipTricks which automatically
+# "fixes" duplicate filenames - filenames (paths) which have already been added to the archive.
+# This fix is performed by appending (1), then (2) and so forth to the filename so that the
+# conflict is avoided. This is not possible to apply to directories, because when one of the
+# path components is reused in multiple filenames it means those entities should end up in
+# the same directory (subdirectory) once the archive is opened.
+class ZipTricks::PathSet
+  class Conflict < StandardError
+  end
+
+  class FileClobbersDirectory < Conflict
+  end
+
+  class DirectoryClobbersFile < Conflict
+  end
+
+  def initialize
+    @known_directories = Set.new
+    @known_files = Set.new
+  end
+
+  # Adds a directory path to the set of known paths, including
+  # all the directories that contain it. So, calling
+  #    add_directory_path("dir/dir2/dir3")
+  # will add "dir", "dir/dir2", "dir/dir2/dir3".
+  #
+  # @param path[String] the path to the directory to add
+  # @return [void]
+  def add_directory_path(path)
+    path_and_ancestors(path).each do |parent_directory_path|
+      if @known_files.include?(parent_directory_path)
+        # Have to use the old-fashioned heredocs because ZipTricks
+        # aims to be compatible with MRI 2.1+ syntax, and squiggly
+        # heredoc is only available starting 2.3+
+        error_message = <<ERR
+The path #{parent_directory_path.inspect} which has to be added
+as a directory is already used for a file.
+
+The directory at this path would get created implicitly
+to produce #{path.inspect} during decompresison.
+
+This would make some archive utilities refuse to open
+the ZIP.
+ERR
+        raise DirectoryClobbersFile, error_message
+      end
+      @known_directories << parent_directory_path
+    end
+  end
+
+  # Adds a file path to the set of known paths, including
+  # all the directories that contain it. Once a file has been added,
+  # it is no longer possible to add a directory having the same path
+  # as this would cause conflict.
+  #
+  # The operation also adds all the containing directories for the file, so
+  #    add_file_path("dir/dir2/file.doc")
+  # will add "dir" and "dir/dir2" as directories, "dir/dir2/dir3".
+  #
+  # @param file_path[String] the path to the directory to add
+  # @return [void]
+  def add_file_path(file_path)
+    if @known_files.include?(file_path)
+      error_message = <<ERR
+The file at #{file_path.inspect} has already been included
+in the archive. Adding it the second time would cause
+the first file to be overwritten during unarchiving, and
+could also get the archive flagged as invalid.
+ERR
+      raise Conflict, error_message
+    end
+
+    if @known_directories.include?(file_path)
+      error_message = <<ERR
+The path #{file_path.inspect} is already used for
+a directory, but you are trying to add it as a file.
+
+This would make some archive utilities refuse
+to open the ZIP.
+ERR
+      raise FileClobbersDirectory, error_message
+    end
+
+    # Add all the directories which this file is contained in
+    *dir_components, _file_name = non_empty_path_components(file_path)
+    add_directory_path(dir_components.join('/'))
+
+    # ...and then the file itself
+    @known_files << file_path
+  end
+
+  # Tells whether a specific full path is already known to the PathSet.
+  # Can be a path for a directory or for a file.
+  #
+  # @param path_in_archive[String] the path to check for inclusion
+  # @return [Boolean]
+  def include?(path_in_archive)
+    @known_files.include?(path_in_archive) || @known_directories.include?(path_in_archive)
+  end
+
+  # Clears the contained sets
+  # @return [void]
+  def clear
+    @known_files.clear
+    @known_directories.clear
+  end
+
+  private
+
+  def non_empty_path_components(path)
+    path.split('/').reject(&:empty?)
+  end
+
+  def path_and_ancestors(path)
+    path_components = non_empty_path_components(path)
+    path_components.each_with_object([]) do |component, seen|
+      seen << [seen.last, component].compact.join('/')
+    end
+  end
+end

data/lib/zip_tricks/size_estimator.rb

@@ -20,10 +20,11 @@ class ZipTricks::SizeEstimator
   #               uncompressed_size: 89281911, compressed_size: 121908)
   #     end
   #
+  # @param kwargs_for_streamer_new Any options to pass to Streamer, see {Streamer#initialize}
   # @return [Integer] the size of the resulting archive, in bytes
   # @yield [SizeEstimator] the estimator
-  def self.estimate
-    streamer = ZipTricks::Streamer.new(ZipTricks::NullWriter)
+  def self.estimate(**kwargs_for_streamer_new)
+    streamer = ZipTricks::Streamer.new(ZipTricks::NullWriter, **kwargs_for_streamer_new)
     estimator = new(streamer)
     yield(estimator)
     streamer.close # Returns the .tell of the contained IO

data/lib/zip_tricks/stream_crc32.rb

@@ -2,13 +2,26 @@
 
 # A simple stateful class for keeping track of a CRC32 value through multiple writes
 class ZipTricks::StreamCRC32
+  STRINGS_HAVE_CAPACITY_SUPPORT = begin
+    String.new('', capacity: 1)
+    true
+  rescue ArgumentError
+    false
+  end
+  CRC_BUF_SIZE = 1024 * 512
+  private_constant :STRINGS_HAVE_CAPACITY_SUPPORT, :CRC_BUF_SIZE
+
   # 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)
+    # If we can specify the string capacity upfront we will not have to resize
+    # the string during operation. This saves time but is only available on
+    # recent Ruby 2.x versions.
+    blob = STRINGS_HAVE_CAPACITY_SUPPORT ? String.new('', capacity: CRC_BUF_SIZE) : String.new('')
     crc = new
-    crc << io.read(1024 * 512) until io.eof?
+    crc << io.read(CRC_BUF_SIZE, blob) until io.eof?
     crc.to_i
   end
 

data/lib/zip_tricks/streamer.rb

@@ -140,13 +140,19 @@ class ZipTricks::Streamer
   # @param stream[IO] the destination IO for the ZIP. Anything that responds to `<<` can be used.
   # @param writer[ZipTricks::ZipWriter] the object to be used as the writer.
   #    Defaults to an instance of ZipTricks::ZipWriter, normally you won't need to override it
-  def initialize(stream, writer: create_writer)
+  # @param auto_rename_duplicate_filenames[Boolean] whether duplicate filenames, when encountered,
+  #    should be suffixed with (1), (2) etc. Default value is `true` since it
+  #    used to be the default behavior.
+  #
+  # **DEPRECATION NOTICE** In ZipTricks version 5 `auto_rename_duplicate_filenames` will default to `false`
+  def initialize(stream, writer: create_writer, auto_rename_duplicate_filenames: true)
     raise InvalidOutput, 'The stream must respond to #<<' unless stream.respond_to?(:<<)
 
+    @dedupe_filenames = auto_rename_duplicate_filenames
     @out = ZipTricks::WriteAndTell.new(stream)
     @files = []
     @local_header_offsets = []
-    @filenames_set = Set.new
+    @path_set = ZipTricks::PathSet.new
     @writer = writer
   end
 
@@ -387,7 +393,7 @@ class ZipTricks::Streamer
 
     # Clear the files so that GC will not have to trace all the way to here to deallocate them
     @files.clear
-    @filenames_set.clear
+    @path_set.clear
 
     # and return the final offset
     @out.tell
@@ -429,22 +435,31 @@ class ZipTricks::Streamer
   private
 
   def add_file_and_write_local_header(
-filename:,
-modification_time:,
-crc32:,
-storage_mode:,
-compressed_size:,
-uncompressed_size:,
-use_data_descriptor:)
-
-    # Clean backslashes and uniqify filenames if there are duplicates
+      filename:,
+      modification_time:,
+      crc32:,
+      storage_mode:,
+      compressed_size:,
+      uncompressed_size:,
+      use_data_descriptor:)
+
+    # Clean backslashes
     filename = remove_backslash(filename)
-    filename = uniquify_name(filename) if @filenames_set.include?(filename)
-
     raise UnknownMode, "Unknown compression mode #{storage_mode}" unless [STORED, DEFLATED].include?(storage_mode)
-
     raise Overflow, 'Filename is too long' if filename.bytesize > 0xFFFF
 
+    # If we need to massage filenames to enforce uniqueness,
+    # do so before we check for file/directory conflicts
+    filename = ZipTricks::UniquifyFilename.call(filename, @path_set) if @dedupe_filenames
+
+    # Make sure there is no file/directory clobbering (conflicts), or - if deduping is disabled -
+    # no duplicate filenames/paths
+    if filename.end_with?('/')
+      @path_set.add_directory_path(filename)
+    else
+      @path_set.add_file_path(filename)
+    end
+
     if use_data_descriptor
       crc32 = 0
       compressed_size = 0
@@ -460,7 +475,6 @@ use_data_descriptor:)
                   use_data_descriptor)
 
     @files << e
-    @filenames_set << e.filename
     @local_header_offsets << @out.tell
 
     @writer.write_local_file_header(io: @out,
@@ -476,28 +490,4 @@ use_data_descriptor:)
   def remove_backslash(filename)
     filename.tr('\\', '_')
   end
-
-  def uniquify_name(filename)
-    # we add (1), (2), (n) at the end of a filename if there is a duplicate
-    copy_pattern = /\((\d+)\)$/
-    parts = filename.split('.')
-    ext = if parts.last =~ /gz|zip/ && parts.size > 2
-            parts.pop(2)
-          elsif parts.size > 1
-            parts.pop
-          end
-    fn_last_part = parts.pop
-
-    duplicate_counter = 1
-    loop do
-      fn_last_part = if fn_last_part =~ copy_pattern
-                       fn_last_part.sub(copy_pattern, "(#{duplicate_counter})")
-                     else
-                       "#{fn_last_part} (#{duplicate_counter})"
-                     end
-      new_filename = (parts + [fn_last_part, ext]).compact.join('.')
-      return new_filename unless @filenames_set.include?(new_filename)
-      duplicate_counter += 1
-    end
-  end
 end

data/lib/zip_tricks/streamer/deflated_writer.rb

@@ -50,6 +50,8 @@ class ZipTricks::Streamer::DeflatedWriter
   def finish
     @compressed_io << @deflater.finish until @deflater.finished?
     {crc32: @crc.to_i, compressed_size: @compressed_io.tell, uncompressed_size: @uncompressed_size}
+  ensure
+    @deflater.close
   end
 
   private

data/lib/zip_tricks/uniquify_filename.rb

@@ -0,0 +1,38 @@
+module ZipTricks::UniquifyFilename
+
+  # Makes a given filename unique by appending a (n) suffix
+  # between just before the filename extension. So "file.txt" gets
+  # transformed into "file (1).txt". The transformation is applied
+  # repeatedly as long as the generated filename is present
+  # in `while_included_in` object
+  #
+  # @param path[String] the path to make unique
+  # @param while_included_in[#include?] an object that stores the list of already used paths
+  # @return [String] the path as is, or with the suffix required to make it unique
+  def self.call(path, while_included_in)
+    return path unless while_included_in.include?(path)
+
+    # we add (1), (2), (n) at the end of a filename before the filename extension,
+    # but only if there is a duplicate
+    copy_pattern = /\((\d+)\)$/
+    parts = path.split('.')
+    ext = if parts.last =~ /gz|zip/ && parts.size > 2
+            parts.pop(2)
+          elsif parts.size > 1
+            parts.pop
+          end
+    fn_last_part = parts.pop
+
+    duplicate_counter = 1
+    loop do
+      fn_last_part = if fn_last_part =~ copy_pattern
+                       fn_last_part.sub(copy_pattern, "(#{duplicate_counter})")
+                     else
+                       "#{fn_last_part} (#{duplicate_counter})"
+                     end
+      new_path = (parts + [fn_last_part, ext]).compact.join('.')
+      return new_path unless while_included_in.include?(new_path)
+      duplicate_counter += 1
+    end
+  end
+end

data/lib/zip_tricks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ZipTricks
-  VERSION = '4.7.3'
+  VERSION = '4.8.3'
 end

data/lib/zip_tricks/write_buffer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Some operations (such as CRC32) benefit when they are performed
 # on larger chunks of data. In certain use cases, it is possible that
 # the consumer of ZipTricks is going to be writing small chunks

data/lib/zip_tricks/zip_writer.rb

@@ -57,7 +57,7 @@ class ZipTricks::ZipWriter
   C_UINT2 = 'v'    # Encode a 2-byte unsigned little-endian uint
   C_UINT8 = 'Q<'  # Encode an 8-byte unsigned little-endian uint
   C_CHAR = 'C' # For bit-encoded strings
-  C_INT4 = 'N' # Encode a 4-byte signed little-endian int
+  C_INT4 = 'l<' # Encode a 4-byte signed little-endian int
 
   private_constant :FOUR_BYTE_MAX_UINT,
                    :TWO_BYTE_MAX_UINT,
@@ -118,7 +118,7 @@ class ZipTricks::ZipWriter
     if requires_zip64
       extra_fields << zip_64_extra_for_local_file_header(compressed_size: compressed_size, uncompressed_size: uncompressed_size)
     end
-    extra_fields << timestamp_extra(mtime)
+    extra_fields << timestamp_extra_for_local_file_header(mtime)
 
     io << [extra_fields.size].pack(C_UINT2)                # extra field length              2 bytes
 
@@ -182,7 +182,7 @@ class ZipTricks::ZipWriter
                                                                      compressed_size: compressed_size,
                                                                      uncompressed_size: uncompressed_size)
     end
-    extra_fields << timestamp_extra(mtime)
+    extra_fields << timestamp_extra_for_central_directory_entry(mtime)
 
     io << [extra_fields.size].pack(C_UINT2)                 # extra field length              2 bytes
 
@@ -345,12 +345,14 @@ class ZipTricks::ZipWriter
     pack_array(data_and_packspecs)
   end
 
-  # Writes the extended timestamp information field. The spec defines 2
+  # Writes the extended timestamp information field for local headers.
+  #
+  # The spec defines 2
   # different formats - the one for the local file header can also accomodate the
   # atime and ctime, whereas the one for the central directory can only take
   # the mtime - and refers the reader to the local header extra to obtain the
   # remaining times
-  def timestamp_extra(mtime)
+  def timestamp_extra_for_local_file_header(mtime)
     #         Local-header version:
     #
     #         Value         Size        Description
@@ -378,16 +380,21 @@ class ZipTricks::ZipWriter
     #       bit 1           if set, access time is present
     #       bit 2           if set, creation time is present
     #       bits 3-7        reserved for additional timestamps; not set
-    flags = 0b10000000 # Set bit 1 only to indicate only mtime is present
+    flags = 0b00000001 # Set the lowest bit only, to indicate that only mtime is present
     data_and_packspecs = [
       0x5455, C_UINT2,  # tag for this extra block type ("UT")
-      (1 + 4), C_UINT2, # the size of this block (1 byte used for the Flag + 1 long used for the timestamp)
+      (1 + 4), C_UINT2, # the size of this block (1 byte used for the Flag + 3 longs used for the timestamp)
       flags, C_CHAR,   # encode a single byte
-      mtime.utc.to_i, C_INT4, # Use a signed long, not the unsigned one used by the rest of the ZIP spec.
+      mtime.utc.to_i, C_INT4, # Use a signed int, not the unsigned one used by the rest of the ZIP spec.
     ]
+    # The atime and ctime can be omitted if not present
     pack_array(data_and_packspecs)
   end
 
+  # Since we do not supply atime or ctime, the contents of the two extra fields (central dir and local header)
+  # is exactly the same, so we can use a method alias.
+  alias_method :timestamp_extra_for_central_directory_entry, :timestamp_extra_for_local_file_header
+
   # 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.
   #

data/zip_tricks.gemspec

@@ -40,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'complexity_assert'
   spec.add_development_dependency 'coderay'
   spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'allocation_stats', '~> 0.1.5'
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.add_development_dependency 'wetransfer_style', '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zip_tricks
 version: !ruby/object:Gem::Version
-  version: 4.7.3
+  version: 4.8.3
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2020-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: allocation_stats
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -214,6 +228,7 @@ files:
 - lib/zip_tricks/file_reader/stored_reader.rb
 - lib/zip_tricks/null_writer.rb
 - lib/zip_tricks/output_enumerator.rb
+- lib/zip_tricks/path_set.rb
 - lib/zip_tricks/rack_body.rb
 - lib/zip_tricks/rails_streaming.rb
 - lib/zip_tricks/remote_io.rb
@@ -225,6 +240,7 @@ files:
 - lib/zip_tricks/streamer/entry.rb
 - lib/zip_tricks/streamer/stored_writer.rb
 - lib/zip_tricks/streamer/writable.rb
+- lib/zip_tricks/uniquify_filename.rb
 - lib/zip_tricks/version.rb
 - lib/zip_tricks/write_and_tell.rb
 - lib/zip_tricks/write_buffer.rb
@@ -258,8 +274,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Stream out ZIP files from Ruby