rubyzip 2.4.1 → 3.7.0

data/lib/zip/null_decompressor.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullDecompressor #:nodoc:all
+  module NullDecompressor # :nodoc:all
     module_function
 
     def read(_length = nil, _outbuf = nil)
       nil
     end
 
-    def eof
+    def eof?
       true
     end
 
-    alias eof? eof
+    # Alias for compatibility. Remove for version 4.
+    alias eof eof?
   end
 end
 

data/lib/zip/null_input_stream.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullInputStream #:nodoc:all
+  module NullInputStream # :nodoc:all
     include ::Zip::NullDecompressor
     include ::Zip::IOExtras::AbstractInputStream
   end

data/lib/zip/output_stream.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+##
 module Zip
   # ZipOutputStream is the basic class for writing zip files. It is
   # possible to create a ZipOutputStream object directly, passing
@@ -16,57 +21,59 @@ module Zip
   #
   # java.util.zip.ZipOutputStream is the original inspiration for this
   # class.
-
   class OutputStream
+    extend Forwardable
     include ::Zip::IOExtras::AbstractOutputStream
 
-    attr_accessor :comment
+    def_delegators :@cdir, :comment, :comment=
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(file_name, dep_stream = false, dep_encrypter = nil, stream: false, encrypter: nil)
-      super()
-
-      Zip.warn_about_v3_api('Zip::OutputStream.new') if dep_stream || !dep_encrypter.nil?
-
+    def initialize(file_name, stream: false, encrypter: nil, suppress_extra_fields: false, **opts)
+      super(**opts)
       @file_name = file_name
-      @output_stream = if stream || dep_stream
-                         iostream = @file_name.dup
+      @output_stream = if stream
+                         iostream = Zip::RUNNING_ON_WINDOWS ? @file_name : @file_name.dup
                          iostream.reopen(@file_name)
                          iostream.rewind
                          iostream
                        else
                          ::File.new(@file_name, 'wb')
                        end
-      @entry_set = ::Zip::EntrySet.new
+      @cdir = ::Zip::CentralDirectory.new
       @compressor = ::Zip::NullCompressor.instance
-      @encrypter = encrypter || dep_encrypter || ::Zip::NullEncrypter.new
+      @encrypter = encrypter || ::Zip::NullEncrypter.new
+      @suppress_extra_fields = suppress_extra_fields
       @closed = false
       @current_entry = nil
-      @comment = nil
     end
 
-    # Same as #initialize but if a block is passed the opened
-    # stream is passed to the block and closed when the block
-    # returns.
     class << self
-      def open(file_name, dep_encrypter = nil, encrypter: nil)
-        return new(file_name) unless block_given?
-
-        Zip.warn_about_v3_api('Zip::OutputStream.open') unless dep_encrypter.nil?
-
-        zos = new(file_name, stream: false, encrypter: (encrypter || dep_encrypter))
+      # Same as #initialize but if a block is passed the opened
+      # stream is passed to the block and closed when the block
+      # returns.
+      def open(file_name, encrypter: nil, suppress_extra_fields: false, **opts)
+        unless block_given?
+          return new(
+            file_name,
+            encrypter:             encrypter,
+            suppress_extra_fields: suppress_extra_fields,
+            **opts
+          )
+        end
+
+        zos = new(file_name, stream: false, encrypter: encrypter,
+                  suppress_extra_fields: suppress_extra_fields, **opts)
         yield zos
       ensure
         zos.close if zos
       end
 
       # Same as #open but writes to a filestream instead
-      def write_buffer(io = ::StringIO.new, dep_encrypter = nil, encrypter: nil)
-        Zip.warn_about_v3_api('Zip::OutputStream.write_buffer') unless dep_encrypter.nil?
-
+      def write_buffer(io = ::StringIO.new, encrypter: nil, suppress_extra_fields: false, **opts)
         io.binmode if io.respond_to?(:binmode)
-        zos = new(io, stream: true, encrypter: (encrypter || dep_encrypter))
+        zos = new(io, stream: true, encrypter: encrypter,
+                  suppress_extra_fields: suppress_extra_fields, **opts)
         yield zos
         zos.close_buffer
       end
@@ -78,7 +85,7 @@ module Zip
 
       finalize_current_entry
       update_local_headers
-      write_central_directory
+      @cdir.write_to_stream(@output_stream, suppress_extra_fields: @suppress_extra_fields)
       @output_stream.close
       @closed = true
     end
@@ -89,37 +96,41 @@ module Zip
 
       finalize_current_entry
       update_local_headers
-      write_central_directory
+      @cdir.write_to_stream(@output_stream, suppress_extra_fields: @suppress_extra_fields)
       @closed = true
+      @output_stream.flush
       @output_stream
     end
 
     # Closes the current entry and opens a new for writing.
     # +entry+ can be a ZipEntry object or a string.
-    def put_next_entry(entry_name, comment = nil, extra = nil, compression_method = Entry::DEFLATED, level = Zip.default_compression)
+    def put_next_entry(
+      entry_name, comment = '', extra = ExtraField.new,
+      compression_method = Entry::DEFLATED, level = Zip.default_compression
+    )
       raise Error, 'zip stream is closed' if @closed
 
-      new_entry = if entry_name.kind_of?(Entry)
-                    entry_name
-                  else
-                    Entry.new(@file_name, entry_name.to_s)
-                  end
-      new_entry.comment = comment unless comment.nil?
-      unless extra.nil?
-        new_entry.extra = extra.kind_of?(ExtraField) ? extra : ExtraField.new(extra.to_s)
-      end
-      new_entry.compression_method = compression_method unless compression_method.nil?
-      init_next_entry(new_entry, level)
+      new_entry =
+        if entry_name.kind_of?(Entry) || entry_name.kind_of?(StreamableStream)
+          entry_name
+        else
+          Entry.new(
+            @file_name, entry_name.to_s, comment: comment, extra: extra,
+            compression_method: compression_method, compression_level: level
+          )
+        end
+
+      init_next_entry(new_entry)
       @current_entry = new_entry
     end
 
-    def copy_raw_entry(entry)
+    def copy_raw_entry(entry) # :nodoc:
       entry = entry.dup
       raise Error, 'zip stream is closed' if @closed
       raise Error, 'entry is not a ZipEntry' unless entry.kind_of?(Entry)
 
       finalize_current_entry
-      @entry_set << entry
+      @cdir << entry
       src_pos = entry.local_header_offset
       entry.write_local_entry(@output_stream)
       @compressor = NullCompressor.instance
@@ -138,55 +149,56 @@ module Zip
       return unless @current_entry
 
       finish
-      @current_entry.compressed_size = @output_stream.tell - \
-                                       @current_entry.local_header_offset - \
+      @output_stream << @encrypter.trailer unless @current_entry.directory?
+      @current_entry.compressed_size = @output_stream.tell -
+                                       @current_entry.local_header_offset -
                                        @current_entry.calculate_local_header_size
       @current_entry.size = @compressor.size
-      @current_entry.crc = @compressor.crc
-      @output_stream << @encrypter.data_descriptor(@current_entry.crc, @current_entry.compressed_size, @current_entry.size)
-      @current_entry.gp_flags |= @encrypter.gp_flags
+      @current_entry.crc = @encrypter.crc(@compressor.crc)
+      @output_stream << @encrypter.data_descriptor(
+        @current_entry.crc,
+        @current_entry.compressed_size,
+        @current_entry.size
+      )
+      @current_entry.gp_flags |= @encrypter.gp_flags unless @current_entry.directory?
       @current_entry = nil
       @compressor = ::Zip::NullCompressor.instance
     end
 
-    def init_next_entry(entry, level = Zip.default_compression)
+    def init_next_entry(entry)
       finalize_current_entry
-      @entry_set << entry
-      entry.write_local_entry(@output_stream)
+      @encrypter.prepare_entry(entry)
+      @cdir << entry
+      entry.write_local_entry(@output_stream, suppress_extra_fields: @suppress_extra_fields)
       @encrypter.reset!
-      @output_stream << @encrypter.header(entry.mtime)
-      @compressor = get_compressor(entry, level)
+      @output_stream << @encrypter.header(entry.mtime) unless entry.directory?
+      @compressor = get_compressor(entry)
     end
 
-    def get_compressor(entry, level)
+    def get_compressor(entry)
       case entry.compression_method
       when Entry::DEFLATED
-        ::Zip::Deflater.new(@output_stream, level, @encrypter)
+        ::Zip::Deflater.new(@output_stream, entry.compression_level, @encrypter)
       when Entry::STORED
-        ::Zip::PassThruCompressor.new(@output_stream)
+        ::Zip::PassThruCompressor.new(@output_stream, @encrypter)
       else
-        raise ::Zip::CompressionMethodError,
-              "Invalid compression method: '#{entry.compression_method}'"
+        raise ::Zip::CompressionMethodError, entry.compression_method
       end
     end
 
     def update_local_headers
       pos = @output_stream.pos
-      @entry_set.each do |entry|
+      @cdir.each do |entry|
         @output_stream.pos = entry.local_header_offset
-        entry.write_local_entry(@output_stream, true)
+        entry.write_local_entry(@output_stream, suppress_extra_fields: @suppress_extra_fields,
+                                                rewrite:               true)
       end
       @output_stream.pos = pos
     end
 
-    def write_central_directory
-      cdir = CentralDirectory.new(@entry_set, @comment)
-      cdir.write_to_stream(@output_stream)
-    end
-
     protected
 
-    def finish
+    def finish # :nodoc:
       @compressor.finish
     end
 

data/lib/zip/pass_thru_compressor.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
-  class PassThruCompressor < Compressor #:nodoc:all
-    def initialize(output_stream)
+  class PassThruCompressor < Compressor # :nodoc:all
+    def initialize(output_stream, encrypter = NullEncrypter.new)
       super()
       @output_stream = output_stream
+      @encrypter = encrypter
       @crc = Zlib.crc32
       @size = 0
     end
@@ -11,7 +14,7 @@ module Zip
       val = data.to_s
       @crc = Zlib.crc32(val, @crc)
       @size += val.bytesize
-      @output_stream << val
+      @output_stream << @encrypter.encrypt(val)
     end
 
     attr_reader :size, :crc

data/lib/zip/pass_thru_decompressor.rb

@@ -1,26 +1,29 @@
+# frozen_string_literal: true
+
 module Zip
-  class PassThruDecompressor < Decompressor #:nodoc:all
+  class PassThruDecompressor < Decompressor # :nodoc:all
     def initialize(*args)
       super
       @read_so_far = 0
     end
 
-    def read(length = nil, outbuf = ''.b)
-      return (length.nil? || length.zero? ? '' : nil) if eof
+    def read(maxlen = nil)
+      return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
 
-      if length.nil? || (@read_so_far + length) > decompressed_size
-        length = decompressed_size - @read_so_far
+      if maxlen.nil? || (@read_so_far + maxlen) > decompressed_size
+        maxlen = decompressed_size - @read_so_far
       end
 
-      @read_so_far += length
-      input_stream.read(length, outbuf)
+      @read_so_far += maxlen
+      input_stream.read(maxlen)
     end
 
-    def eof
+    def eof?
       @read_so_far >= decompressed_size
     end
 
-    alias eof? eof
+    # Alias for compatibility. Remove for version 4.
+    alias eof eof?
   end
 
   ::Zip::Decompressor.register(::Zip::COMPRESSION_METHOD_STORE, ::Zip::PassThruDecompressor)

data/lib/zip/streamable_directory.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class StreamableDirectory < Entry
+  class StreamableDirectory < Entry # :nodoc:
     def initialize(zipfile, entry, src_path = nil, permission = nil)
       super(zipfile, entry)
 

data/lib/zip/streamable_stream.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Zip
   class StreamableStream < DelegateClass(Entry) # :nodoc:all
     def initialize(entry)
-      super(entry)
+      super
       @temp_file = Tempfile.new(::File.basename(name))
       @temp_file.binmode
     end
@@ -42,6 +44,7 @@ module Zip
     end
 
     def clean_up
+      super
       @temp_file.unlink
     end
   end

data/lib/zip/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module Zip
-  VERSION = '2.4.1'
+  # The version of the Rubyzip library.
+  VERSION = '3.7.0'
 end

data/lib/zip.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'English'
 require 'delegate'
 require 'singleton'
@@ -5,6 +7,7 @@ require 'tempfile'
 require 'fileutils'
 require 'stringio'
 require 'zlib'
+require 'zip/version'
 require 'zip/constants'
 require 'zip/dos_time'
 require 'zip/ioextras'
@@ -27,33 +30,21 @@ require 'zip/crypto/decrypted_io'
 require 'zip/crypto/encryption'
 require 'zip/crypto/null_encryption'
 require 'zip/crypto/traditional_encryption'
+require 'zip/crypto/aes_encryption'
 require 'zip/inflater'
 require 'zip/deflater'
 require 'zip/streamable_stream'
 require 'zip/streamable_directory'
 require 'zip/errors'
 
+# Rubyzip is a ruby module for reading and writing zip files.
+#
+# The main entry points are File, InputStream and OutputStream. For a
+# file/directory interface in the style of the standard ruby ::File and
+# ::Dir APIs then `require 'zip/filesystem'` and see FileSystem.
 module Zip
-  V3_API_WARNING_MSG = <<~END_MSG
-    You have called '%s' (from %s).
-    This method is changing or deprecated in version 3.0.0. Please see
-      https://github.com/rubyzip/rubyzip/wiki/Updating-to-version-3.x
-    for more information.
-  END_MSG
-
-  def self.warn_about_v3_api(method)
-    return unless ENV['RUBYZIP_V3_API_WARN']
-
-    loc = caller_locations(2, 1)[0]
-    from = "#{loc.path.split('/').last}:#{loc.lineno}"
-    warn format(V3_API_WARNING_MSG, method, from)
-  end
-
-  if ENV['RUBYZIP_V3_API_WARN'] && RUBY_VERSION < '3.0'
-    warn 'RubyZip 3.0 will require Ruby 3.0 or later.'
-  end
-
   extend self
+
   attr_accessor :unicode_names,
                 :on_exists_proc,
                 :continue_on_exists_proc,
@@ -63,21 +54,35 @@ module Zip
                 :warn_invalid_date,
                 :case_insensitive_match,
                 :force_entry_names_encoding,
-                :validate_entry_sizes
+                :validate_entry_sizes,
+                :validate_declared_number_of_entries
+
+  DEFAULT_RESTORE_OPTIONS = {
+    restore_ownership:   false,
+    restore_permissions: true,
+    restore_times:       true
+  }.freeze # :nodoc:
+
+  # :nodoc:
+  # Remove this when JRuby#3962 is fixed.
+  ZLIB_FLUSHING_STRATEGY = defined?(JRUBY_VERSION) ? Zlib::SYNC_FLUSH : Zlib::NO_FLUSH
 
-  def reset!
+  def reset! # :nodoc:
     @_ran_once = false
     @unicode_names = false
     @on_exists_proc = false
     @continue_on_exists_proc = false
     @sort_entries = false
-    @default_compression = ::Zlib::DEFAULT_COMPRESSION
-    @write_zip64_support = false
+    @default_compression = Zlib::DEFAULT_COMPRESSION
+    @write_zip64_support = true
     @warn_invalid_date = true
     @case_insensitive_match = false
+    @force_entry_names_encoding = nil
     @validate_entry_sizes = true
+    @validate_declared_number_of_entries = false # Set this to `true` in v4.0.0?
   end
 
+  # Set options for RubyZip in one block.
   def setup
     yield self unless @_ran_once
     @_ran_once = true

data/rubyzip.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'lib/zip/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'rubyzip'
+  s.version       = Zip::VERSION
+  s.authors       = ['Robert Haines', 'John Lees-Miller', 'Alexander Simonov']
+  s.email         = [
+    'hainesr@gmail.com', 'jdleesmiller@gmail.com', 'alex@simonov.me'
+  ]
+  s.homepage      = 'http://github.com/rubyzip/rubyzip'
+  s.platform      = Gem::Platform::RUBY
+  s.summary       = 'rubyzip is a ruby module for reading and writing zip files'
+  s.files         = Dir.glob('{samples,lib}/**/*.rb') +
+                    %w[LICENSE.md README.md Changelog.md Rakefile rubyzip.gemspec]
+  s.require_paths = ['lib']
+  s.license       = 'BSD-2-Clause'
+
+  s.metadata      = {
+    'bug_tracker_uri'       => 'https://github.com/rubyzip/rubyzip/issues',
+    'changelog_uri'         => "https://github.com/rubyzip/rubyzip/blob/v#{s.version}/Changelog.md",
+    'documentation_uri'     => "https://www.rubydoc.info/gems/rubyzip/#{s.version}",
+    'source_code_uri'       => "https://github.com/rubyzip/rubyzip/tree/v#{s.version}",
+    'wiki_uri'              => 'https://github.com/rubyzip/rubyzip/wiki',
+    'rubygems_mfa_required' => 'true'
+  }
+
+  s.required_ruby_version = '>= 3.0'
+
+  s.add_development_dependency 'minitest', '~> 5.25'
+  s.add_development_dependency 'rake', '~> 13.2'
+  s.add_development_dependency 'rdoc', '~> 6.11'
+  s.add_development_dependency 'rubocop', '~> 1.80.2'
+  s.add_development_dependency 'rubocop-performance', '~> 1.26.0'
+  s.add_development_dependency 'rubocop-rake', '~> 0.7.1'
+  s.add_development_dependency 'simplecov', '~> 0.22.0'
+  s.add_development_dependency 'simplecov-lcov', '~> 0.8'
+end

data/samples/example.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH << '../lib'
 system('zip example.zip example.rb gtk_ruby_zip.rb')
@@ -20,7 +21,8 @@ end
 
 zf = Zip::File.new('example.zip')
 zf.each_with_index do |entry, index|
-  puts "entry #{index} is #{entry.name}, size = #{entry.size}, compressed size = #{entry.compressed_size}"
+  puts "entry #{index} is #{entry.name}, size = #{entry.size}, " \
+       "compressed size = #{entry.compressed_size}"
   # use zf.get_input_stream(entry) to get a ZipInputStream for the entry
   # entry can be the ZipEntry object or any object which has a to_s method that
   # returns the name of the entry.
@@ -70,8 +72,11 @@ part_zips_count = Zip::File.split('large_zip_file.zip', 2_097_152, false)
 puts "Zip file splitted in #{part_zips_count} parts"
 
 # Track splitting an archive
-Zip::File.split('large_zip_file.zip', 1_048_576, true, 'part_zip_file') do |part_count, part_index, chunk_bytes, segment_bytes|
-  puts "#{part_index} of #{part_count} part splitting: #{(chunk_bytes.to_f / segment_bytes * 100).to_i}%"
+Zip::File.split(
+  'large_zip_file.zip', 1_048_576, true, 'part_zip_file'
+) do |part_count, part_index, chunk_bytes, segment_bytes|
+  puts "#{part_index} of #{part_count} part splitting: " \
+       "#{(chunk_bytes.to_f / segment_bytes * 100).to_i}%"
 end
 
 # For other examples, look at zip.rb and ziptest.rb

data/samples/example_filesystem.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH << '../lib'
 
@@ -6,9 +7,9 @@ require 'zip/filesystem'
 
 EXAMPLE_ZIP = 'filesystem.zip'
 
-File.delete(EXAMPLE_ZIP) if File.exist?(EXAMPLE_ZIP)
+FileUtils.rm_f(EXAMPLE_ZIP)
 
-Zip::File.open(EXAMPLE_ZIP, Zip::File::CREATE) do |zf|
+Zip::File.open(EXAMPLE_ZIP, create: true) do |zf|
   zf.file.open('file1.txt', 'w') { |os| os.write 'first file1.txt' }
   zf.dir.mkdir('dir1')
   zf.dir.chdir('dir1')

data/samples/example_recursive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'zip'
 
 # This is a simple example which uses rubyzip to
@@ -21,7 +23,7 @@ class ZipFileGenerator
   def write
     entries = Dir.entries(@input_dir) - %w[. ..]
 
-    ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+    ::Zip::File.open(@output_file, create: true) do |zipfile|
       write_entries entries, '', zipfile
     end
   end

data/samples/gtk_ruby_zip.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH << '../lib'
 
@@ -9,7 +10,7 @@ require 'zip'
 
 class MainApp < Gtk::Window
   def initialize
-    super()
+    super
     set_usize(400, 256)
     set_title('rubyzip')
     signal_connect(Gtk::Window::SIGNAL_DESTROY) { Gtk.main_quit }
@@ -42,7 +43,8 @@ class MainApp < Gtk::Window
   end
 
   class ButtonPanel < Gtk::HButtonBox
-    attr_reader :open_button, :extract_button
+    attr_reader :extract_button, :open_button
+
     def initialize
       super
       set_layout(Gtk::BUTTONBOX_START)
@@ -72,7 +74,7 @@ class MainApp < Gtk::Window
     @zipfile.each do |entry|
       @clist.append([entry.name,
                      entry.size.to_s,
-                     (100.0 * entry.compressedSize / entry.size).to_s + '%'])
+                     "#{100.0 * entry.compressedSize / entry.size}%"])
     end
   end
 end

data/samples/qtzip.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $VERBOSE = true
 
@@ -6,14 +7,14 @@ $LOAD_PATH << '../lib'
 
 require 'Qt'
 system('rbuic -o zipdialogui.rb zipdialogui.ui')
-require 'zipdialogui.rb'
+require 'zipdialogui'
 require 'zip'
 
 a = Qt::Application.new(ARGV)
 
 class ZipDialog < ZipDialogUI
   def initialize
-    super()
+    super
     connect(child('add_button'), SIGNAL('clicked()'),
             self, SLOT('add_files()'))
     connect(child('extract_button'), SIGNAL('clicked()'),
@@ -65,14 +66,14 @@ class ZipDialog < ZipDialogUI
     end
     puts "selected_items.size = #{selected_items.size}"
     puts "unselected_items.size = #{unselected_items.size}"
-    items = !selected_items.empty? ? selected_items : unselected_items
+    items = selected_items.empty? ? unselected_items : selected_items
     puts "items.size = #{items.size}"
 
     d = Qt::FileDialog.get_existing_directory(nil, self)
-    if !d
-      puts 'No directory chosen'
-    else
+    if d
       zipfile { |zf| items.each { |e| zf.extract(e, File.join(d, e)) } }
+    else
+      puts 'No directory chosen'
     end
   end
 

data/samples/write_simple.rb

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $LOAD_PATH << '../lib'
 
 require 'zip'
 
-::Zip::OutputStream.open('simple.zip') do |zos|
+Zip::OutputStream.open('simple.zip') do |zos|
   zos.put_next_entry 'entry.txt'
   zos.puts 'Hello world'
 end

data/samples/zipfind.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 $VERBOSE = true