rubyzip 2.3.1 → 3.0.0.alpha

data/Rakefile

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rdoc/task'
 require 'rubocop/rake_task'
 
 task default: :test
@@ -11,11 +14,12 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-RuboCop::RakeTask.new
+RDoc::Task.new do |rdoc|
+  rdoc.main = 'README.md'
+  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
+  rdoc.options << '--markup=markdown'
+  rdoc.options << '--tab-width=2'
+  rdoc.options << "-t Rubyzip version #{::Zip::VERSION}"
+end
 
-# Rake::TestTask.new(:zip64_full_test) do |test|
-#  test.libs << File.join(File.dirname(__FILE__), 'lib')
-#  test.libs << File.join(File.dirname(__FILE__), 'test')
-#  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
-#  test.verbose = true
-# end
+RuboCop::RakeTask.new

data/lib/zip/central_directory.rb

@@ -1,45 +1,77 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'dirtyable'
+
 module Zip
-  class CentralDirectory
-    include Enumerable
+  class CentralDirectory # :nodoc:
+    extend Forwardable
+    include Dirtyable
+
+    END_OF_CD_SIG          = 0x06054b50
+    ZIP64_END_OF_CD_SIG    = 0x06064b50
+    ZIP64_EOCD_LOCATOR_SIG = 0x07064b50
 
-    END_OF_CDS             = 0x06054b50
-    ZIP64_END_OF_CDS       = 0x06064b50
-    ZIP64_EOCD_LOCATOR     = 0x07064b50
-    MAX_END_OF_CDS_SIZE    = 65_536 + 18
     STATIC_EOCD_SIZE       = 22
+    ZIP64_STATIC_EOCD_SIZE = 56
+    ZIP64_EOCD_LOC_SIZE    = 20
+    MAX_FILE_COMMENT_SIZE  = (1 << 16) - 1
+    MAX_END_OF_CD_SIZE     =
+      MAX_FILE_COMMENT_SIZE + STATIC_EOCD_SIZE + ZIP64_EOCD_LOC_SIZE
 
-    attr_reader :comment
+    attr_accessor :comment
 
-    # Returns an Enumerable containing the entries.
-    def entries
-      @entry_set.entries
-    end
+    def_delegators :@entry_set,
+                   :<<, :delete, :each, :entries, :find_entry, :glob,
+                   :include?, :size
+
+    mark_dirty :<<, :comment=, :delete
 
     def initialize(entries = EntrySet.new, comment = '') #:nodoc:
-      super()
+      super(dirty_on_create: false)
       @entry_set = entries.kind_of?(EntrySet) ? entries : EntrySet.new(entries)
       @comment   = comment
     end
 
+    def read_from_stream(io)
+      read_eocds(io)
+      read_central_directory_entries(io)
+    end
+
     def write_to_stream(io) #:nodoc:
       cdir_offset = io.tell
       @entry_set.each { |entry| entry.write_c_dir_entry(io) }
       eocd_offset = io.tell
       cdir_size = eocd_offset - cdir_offset
-      if ::Zip.write_zip64_support
-        need_zip64_eocd = cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
-        need_zip64_eocd ||= @entry_set.any? { |entry| entry.extra['Zip64'] }
-        if need_zip64_eocd
-          write_64_e_o_c_d(io, cdir_offset, cdir_size)
-          write_64_eocd_locator(io, eocd_offset)
-        end
+      if Zip.write_zip64_support &&
+         (cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF)
+        write_64_e_o_c_d(io, cdir_offset, cdir_size)
+        write_64_eocd_locator(io, eocd_offset)
       end
       write_e_o_c_d(io, cdir_offset, cdir_size)
     end
 
+    # Reads the End of Central Directory Record (and the Zip64 equivalent if
+    # needs be) and returns the number of entries in the archive. This is a
+    # convenience method that avoids reading in all of the entry data to get a
+    # very quick entry count.
+    def count_entries(io)
+      read_eocds(io)
+      @size
+    end
+
+    def ==(other) #:nodoc:
+      return false unless other.kind_of?(CentralDirectory)
+
+      @entry_set.entries.sort == other.entries.sort && comment == other.comment
+    end
+
+    private
+
     def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
       tmp = [
-        END_OF_CDS,
+        END_OF_CD_SIG,
         0, # @numberOfThisDisk
         0, # @numberOfDiskWithStartOfCDir
         @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
@@ -52,11 +84,9 @@ module Zip
       io << @comment
     end
 
-    private :write_e_o_c_d
-
     def write_64_e_o_c_d(io, offset, cdir_size) #:nodoc:
       tmp = [
-        ZIP64_END_OF_CDS,
+        ZIP64_END_OF_CD_SIG,
         44, # size of zip64 end of central directory record (excludes signature and field itself)
         VERSION_MADE_BY,
         VERSION_NEEDED_TO_EXTRACT_ZIP64,
@@ -70,11 +100,9 @@ module Zip
       io << tmp.pack('VQ<vvVVQ<Q<Q<Q<')
     end
 
-    private :write_64_e_o_c_d
-
     def write_64_eocd_locator(io, zip64_eocd_offset)
       tmp = [
-        ZIP64_EOCD_LOCATOR,
+        ZIP64_EOCD_LOCATOR_SIG,
         0, # number of disk containing the start of zip64 eocd record
         zip64_eocd_offset, # offset of the start of zip64 eocd record in its disk
         1 # total number of disks
@@ -82,127 +110,145 @@ module Zip
       io << tmp.pack('VVQ<V')
     end
 
-    private :write_64_eocd_locator
-
-    def read_64_e_o_c_d(buf) #:nodoc:
-      buf                                           = get_64_e_o_c_d(buf)
-      @size_of_zip64_e_o_c_d                        = Entry.read_zip_64_long(buf)
-      @version_made_by                              = Entry.read_zip_short(buf)
-      @version_needed_for_extract                   = Entry.read_zip_short(buf)
-      @number_of_this_disk                          = Entry.read_zip_long(buf)
-      @number_of_disk_with_start_of_cdir            = Entry.read_zip_long(buf)
-      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_64_long(buf)
-      @size                                         = Entry.read_zip_64_long(buf)
-      @size_in_bytes                                = Entry.read_zip_64_long(buf)
-      @cdir_offset                                  = Entry.read_zip_64_long(buf)
-      @zip_64_extensible                            = buf.slice!(0, buf.bytesize)
-      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    def unpack_64_e_o_c_d(buffer) #:nodoc:
+      _, # ZIP64_END_OF_CD_SIG. We know we have this at this point.
+      @size_of_zip64_e_o_c_d,
+      @version_made_by,
+      @version_needed_for_extract,
+      @number_of_this_disk,
+      @number_of_disk_with_start_of_cdir,
+      @total_number_of_entries_in_cdir_on_this_disk,
+      @size,
+      @size_in_bytes,
+      @cdir_offset = buffer.unpack('VQ<vvVVQ<Q<Q<Q<')
+
+      zip64_extensible_data_size =
+        @size_of_zip64_e_o_c_d - ZIP64_STATIC_EOCD_SIZE + 12
+      @zip64_extensible_data = if zip64_extensible_data_size.zero?
+                                 ''
+                               else
+                                 buffer.slice(
+                                   ZIP64_STATIC_EOCD_SIZE,
+                                   zip64_extensible_data_size
+                                 )
+                               end
+    end
+
+    def unpack_64_eocd_locator(buffer) #:nodoc:
+      _, # ZIP64_EOCD_LOCATOR_SIG. We know we have this at this point.
+      _, zip64_eocd_offset, = buffer.unpack('VVQ<V')
+
+      zip64_eocd_offset
     end
 
-    def read_e_o_c_d(buf) #:nodoc:
-      buf                                           = get_e_o_c_d(buf)
-      @number_of_this_disk                          = Entry.read_zip_short(buf)
-      @number_of_disk_with_start_of_cdir            = Entry.read_zip_short(buf)
-      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_short(buf)
-      @size                                         = Entry.read_zip_short(buf)
-      @size_in_bytes                                = Entry.read_zip_long(buf)
-      @cdir_offset                                  = Entry.read_zip_long(buf)
-      comment_length                                = Entry.read_zip_short(buf)
-      @comment                                      = if comment_length.to_i <= 0
-                                                        buf.slice!(0, buf.size)
-                                                      else
-                                                        buf.read(comment_length)
-                                                      end
-      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    def unpack_e_o_c_d(buffer) #:nodoc:
+      _, # END_OF_CD_SIG. We know we have this at this point.
+      num_disk,
+      num_disk_cdir,
+      num_cdir_disk,
+      num_entries,
+      size_in_bytes,
+      cdir_offset,
+      comment_length = buffer.unpack('VvvvvVVv')
+
+      @number_of_this_disk = num_disk unless num_disk == 0xFFFF
+      @number_of_disk_with_start_of_cdir = num_disk_cdir unless num_disk_cdir == 0xFFFF
+      @total_number_of_entries_in_cdir_on_this_disk = num_cdir_disk unless num_cdir_disk == 0xFFFF
+      @size = num_entries unless num_entries == 0xFFFF
+      @size_in_bytes = size_in_bytes unless size_in_bytes == 0xFFFFFFFF
+      @cdir_offset = cdir_offset unless cdir_offset == 0xFFFFFFFF
+
+      @comment = if comment_length.positive?
+                   buffer.slice(STATIC_EOCD_SIZE, comment_length)
+                 else
+                   ''
+                 end
     end
 
     def read_central_directory_entries(io) #:nodoc:
+      # `StringIO` doesn't raise `EINVAL` if you seek beyond the current end,
+      # so we need to catch that *and* query `io#eof?` here.
+      eof = false
       begin
         io.seek(@cdir_offset, IO::SEEK_SET)
       rescue Errno::EINVAL
-        raise Error, 'Zip consistency problem while reading central directory entry'
+        eof = true
       end
+      raise Error, 'Zip consistency problem while reading central directory entry' if eof || io.eof?
+
       @entry_set = EntrySet.new
       @size.times do
-        @entry_set << Entry.read_c_dir_entry(io)
-      end
-    end
+        entry = Entry.read_c_dir_entry(io)
+        next unless entry
+
+        offset = if entry.zip64?
+                   entry.extra['Zip64'].relative_header_offset
+                 else
+                   entry.local_header_offset
+                 end
+
+        unless offset.nil?
+          io_save = io.tell
+          io.seek(offset, IO::SEEK_SET)
+          entry.read_extra_field(read_local_extra_field(io), local: true)
+          io.seek(io_save, IO::SEEK_SET)
+        end
 
-    def read_from_stream(io) #:nodoc:
-      buf = start_buf(io)
-      if zip64_file?(buf)
-        read_64_e_o_c_d(buf)
-      else
-        read_e_o_c_d(buf)
+        @entry_set << entry
       end
-      read_central_directory_entries(io)
     end
 
-    def get_e_o_c_d(buf) #:nodoc:
-      sig_index = buf.rindex([END_OF_CDS].pack('V'))
-      raise Error, 'Zip end of central directory signature not found' unless sig_index
+    def read_local_extra_field(io)
+      buf = io.read(::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH) || ''
+      return '' unless buf.bytesize == ::Zip::LOCAL_ENTRY_STATIC_HEADER_LENGTH
 
-      buf = buf.slice!((sig_index + 4)..(buf.bytesize))
+      head, _, _, _, _, _, _, _, _, _, n_len, e_len = buf.unpack('VCCvvvvVVVvv')
+      return '' unless head == ::Zip::LOCAL_ENTRY_SIGNATURE
 
-      def buf.read(count)
-        slice!(0, count)
-      end
-
-      buf
+      io.seek(n_len, IO::SEEK_CUR) # Skip over the entry name.
+      io.read(e_len)
     end
 
-    def zip64_file?(buf)
-      buf.rindex([ZIP64_END_OF_CDS].pack('V')) && buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
-    end
+    def read_eocds(io) #:nodoc:
+      base_location, data = eocd_data(io)
 
-    def start_buf(io)
-      begin
-        io.seek(-MAX_END_OF_CDS_SIZE, IO::SEEK_END)
-      rescue Errno::EINVAL
-        io.seek(0, IO::SEEK_SET)
-      end
-      io.read
-    end
+      eocd_location = data.rindex([END_OF_CD_SIG].pack('V'))
+      raise Error, 'Zip end of central directory signature not found' unless eocd_location
 
-    def get_64_e_o_c_d(buf) #:nodoc:
-      zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
-      raise Error, 'Zip64 end of central directory signature not found' unless zip_64_start
+      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'))
 
-      zip_64_locator = buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
-      raise Error, 'Zip64 end of central directory signature locator not found' unless zip_64_locator
+      if zip64_eocd_locator
+        zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'))
 
-      buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
+        zip64_eocd_data =
+          if zip64_eocd_location
+            data.slice(zip64_eocd_location..zip64_eocd_locator)
+          else
+            zip64_eocd_location = unpack_64_eocd_locator(
+              data.slice(zip64_eocd_locator..eocd_location)
+            )
+            unless zip64_eocd_location
+              raise Error, 'Zip64 end of central directory signature not found'
+            end
 
-      def buf.read(count)
-        slice!(0, count)
-      end
+            io.seek(zip64_eocd_location, IO::SEEK_SET)
+            io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+          end
 
-      buf
-    end
-
-    # For iterating over the entries.
-    def each(&a_proc)
-      @entry_set.each(&a_proc)
-    end
-
-    # Returns the number of entries in the central directory (and
-    # consequently in the zip archive).
-    def size
-      @entry_set.size
-    end
+        unpack_64_e_o_c_d(zip64_eocd_data)
+      end
 
-    def self.read_from_stream(io) #:nodoc:
-      cdir = new
-      cdir.read_from_stream(io)
-      cdir
-    rescue Error
-      nil
+      unpack_e_o_c_d(data.slice(eocd_location..-1))
     end
 
-    def ==(other) #:nodoc:
-      return false unless other.kind_of?(CentralDirectory)
+    def eocd_data(io)
+      begin
+        io.seek(-MAX_END_OF_CD_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+        io.seek(0, IO::SEEK_SET)
+      end
 
-      @entry_set.entries.sort == other.entries.sort && comment == other.comment
+      [io.tell, io.read]
     end
   end
 end

data/lib/zip/compressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Compressor #:nodoc:all
+  class Compressor # :nodoc:all
     def finish; end
   end
 end

data/lib/zip/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Zip
   RUNNING_ON_WINDOWS = RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/i
 
@@ -11,6 +13,8 @@ module Zip
   VERSION_NEEDED_TO_EXTRACT              = 20
   VERSION_NEEDED_TO_EXTRACT_ZIP64        = 45
 
+  SPLIT_FILE_SIGNATURE = 0x08074b50
+
   FILE_TYPE_FILE    = 0o10
   FILE_TYPE_DIR     = 0o04
   FILE_TYPE_SYMLINK = 0o12
@@ -38,27 +42,27 @@ module Zip
   FSTYPE_ATHEOS   = 30
 
   FSTYPES = {
-    FSTYPE_FAT      => 'FAT'.freeze,
-    FSTYPE_AMIGA    => 'Amiga'.freeze,
-    FSTYPE_VMS      => 'VMS (Vax or Alpha AXP)'.freeze,
-    FSTYPE_UNIX     => 'Unix'.freeze,
-    FSTYPE_VM_CMS   => 'VM/CMS'.freeze,
-    FSTYPE_ATARI    => 'Atari ST'.freeze,
-    FSTYPE_HPFS     => 'OS/2 or NT HPFS'.freeze,
-    FSTYPE_MAC      => 'Macintosh'.freeze,
-    FSTYPE_Z_SYSTEM => 'Z-System'.freeze,
-    FSTYPE_CPM      => 'CP/M'.freeze,
-    FSTYPE_TOPS20   => 'TOPS-20'.freeze,
-    FSTYPE_NTFS     => 'NTFS'.freeze,
-    FSTYPE_QDOS     => 'SMS/QDOS'.freeze,
-    FSTYPE_ACORN    => 'Acorn RISC OS'.freeze,
-    FSTYPE_VFAT     => 'Win32 VFAT'.freeze,
-    FSTYPE_MVS      => 'MVS'.freeze,
-    FSTYPE_BEOS     => 'BeOS'.freeze,
-    FSTYPE_TANDEM   => 'Tandem NSK'.freeze,
-    FSTYPE_THEOS    => 'Theos'.freeze,
-    FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)'.freeze,
-    FSTYPE_ATHEOS   => 'AtheOS'.freeze
+    FSTYPE_FAT      => 'FAT',
+    FSTYPE_AMIGA    => 'Amiga',
+    FSTYPE_VMS      => 'VMS (Vax or Alpha AXP)',
+    FSTYPE_UNIX     => 'Unix',
+    FSTYPE_VM_CMS   => 'VM/CMS',
+    FSTYPE_ATARI    => 'Atari ST',
+    FSTYPE_HPFS     => 'OS/2 or NT HPFS',
+    FSTYPE_MAC      => 'Macintosh',
+    FSTYPE_Z_SYSTEM => 'Z-System',
+    FSTYPE_CPM      => 'CP/M',
+    FSTYPE_TOPS20   => 'TOPS-20',
+    FSTYPE_NTFS     => 'NTFS',
+    FSTYPE_QDOS     => 'SMS/QDOS',
+    FSTYPE_ACORN    => 'Acorn RISC OS',
+    FSTYPE_VFAT     => 'Win32 VFAT',
+    FSTYPE_MVS      => 'MVS',
+    FSTYPE_BEOS     => 'BeOS',
+    FSTYPE_TANDEM   => 'Tandem NSK',
+    FSTYPE_THEOS    => 'Theos',
+    FSTYPE_MAC_OSX  => 'Mac OS/X (Darwin)',
+    FSTYPE_ATHEOS   => 'AtheOS'
   }.freeze
 
   COMPRESSION_METHOD_STORE = 0

data/lib/zip/crypto/decrypted_io.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class DecryptedIo #:nodoc:all
+  class DecryptedIo # :nodoc:all
     CHUNK_SIZE = 32_768
 
     def initialize(io, decrypter)

data/lib/zip/crypto/encryption.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Zip
-  class Encrypter #:nodoc:all
+  class Encrypter # :nodoc:all
   end
 
-  class Decrypter
+  class Decrypter # :nodoc:all
   end
 end
 

data/lib/zip/crypto/null_encryption.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullEncryption
+  module NullEncryption # :nodoc:
     def header_bytesize
       0
     end
@@ -9,7 +11,7 @@ module Zip
     end
   end
 
-  class NullEncrypter < Encrypter
+  class NullEncrypter < Encrypter # :nodoc:
     include NullEncryption
 
     def header(_mtime)
@@ -27,7 +29,7 @@ module Zip
     def reset!; end
   end
 
-  class NullDecrypter < Decrypter
+  class NullDecrypter < Decrypter # :nodoc:
     include NullEncryption
 
     def decrypt(data)

data/lib/zip/crypto/traditional_encryption.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module TraditionalEncryption
+  module TraditionalEncryption # :nodoc:
     def initialize(password)
       @password = password
       reset_keys!
@@ -36,7 +38,7 @@ module Zip
     end
   end
 
-  class TraditionalEncrypter < Encrypter
+  class TraditionalEncrypter < Encrypter # :nodoc:
     include TraditionalEncryption
 
     def header(mtime)
@@ -70,7 +72,7 @@ module Zip
     end
   end
 
-  class TraditionalDecrypter < Decrypter
+  class TraditionalDecrypter < Decrypter # :nodoc:
     include TraditionalEncryption
 
     def decrypt(data)

data/lib/zip/decompressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Decompressor #:nodoc:all
+  class Decompressor # :nodoc:all
     CHUNK_SIZE = 32_768
 
     def self.decompressor_classes
@@ -14,8 +16,7 @@ module Zip
       decompressor_classes[compression_method]
     end
 
-    attr_reader :input_stream
-    attr_reader :decompressed_size
+    attr_reader :decompressed_size, :input_stream
 
     def initialize(input_stream, decompressed_size = nil)
       super()

data/lib/zip/deflater.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class Deflater < Compressor #:nodoc:all
+  class Deflater < Compressor # :nodoc:all
     def initialize(output_stream, level = Zip.default_compression, encrypter = NullEncrypter.new)
       super()
       @output_stream = output_stream
@@ -13,16 +15,16 @@ module Zip
       val   = data.to_s
       @crc  = Zlib.crc32(val, @crc)
       @size += val.bytesize
-      buffer = @zlib_deflater.deflate(data)
-      if buffer.empty?
-        @output_stream
-      else
-        @output_stream << @encrypter.encrypt(buffer)
-      end
+      buffer = @zlib_deflater.deflate(data, Zlib::SYNC_FLUSH)
+      return @output_stream if buffer.empty?
+
+      @output_stream << @encrypter.encrypt(buffer)
     end
 
     def finish
-      @output_stream << @encrypter.encrypt(@zlib_deflater.finish) until @zlib_deflater.finished?
+      buffer = @zlib_deflater.finish
+      @output_stream << @encrypter.encrypt(buffer) unless buffer.empty?
+      @zlib_deflater.close
     end
 
     attr_reader :size, :crc

data/lib/zip/dirtyable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Zip
+  module Dirtyable # :nodoc:all
+    def initialize(dirty_on_create: true)
+      @dirty = dirty_on_create
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    module ClassMethods # :nodoc:
+      def mark_dirty(*symbols) # :nodoc:
+        # Move the original method and call it after we've set the dirty flag.
+        symbols.each do |symbol|
+          orig_name = "orig_#{symbol}"
+          alias_method orig_name, symbol
+
+          define_method(symbol) do |param|
+            @dirty = true
+            send(orig_name, param)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end