rubyzip 1.3.0 → 3.0.0.alpha

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,
@@ -65,16 +95,14 @@ module Zip
         @entry_set ? @entry_set.size : 0, # number of entries on this disk
         @entry_set ? @entry_set.size : 0, # number of entries total
         cdir_size, # size of central directory
-        offset, # offset of start of central directory in its disk
+        offset # offset of start of central directory in its disk
       ]
       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,123 +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
 
-    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)
+        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
+
+        @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
-      buf = buf.slice!((sig_index + 4)..(buf.bytesize))
+    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
 
-      def buf.read(count)
-        slice!(0, count)
-      end
+      head, _, _, _, _, _, _, _, _, _, n_len, e_len = buf.unpack('VCCvvvvVVVvv')
+      return '' unless head == ::Zip::LOCAL_ENTRY_SIGNATURE
 
-      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
-      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
-      buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
+      zip64_eocd_locator = data.rindex([ZIP64_EOCD_LOCATOR_SIG].pack('V'))
 
-      def buf.read(count)
-        slice!(0, count)
-      end
+      if zip64_eocd_locator
+        zip64_eocd_location = data.rindex([ZIP64_END_OF_CD_SIG].pack('V'))
 
-      buf
-    end
+        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
 
-    # For iterating over the entries.
-    def each(&proc)
-      @entry_set.each(&proc)
-    end
+            io.seek(zip64_eocd_location, IO::SEEK_SET)
+            io.read(base_location + zip64_eocd_locator - zip64_eocd_location)
+          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)
-      return cdir
-    rescue Error
-      return nil
+      unpack_e_o_c_d(data.slice(eocd_location..-1))
     end
 
-    def ==(other) #:nodoc:
-      return false unless other.kind_of?(CentralDirectory)
-      @entry_set.entries.sort == other.entries.sort && comment == other.comment
+    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
+
+      [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,26 +42,78 @@ 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
+  COMPRESSION_METHOD_SHRINK = 1
+  COMPRESSION_METHOD_REDUCE_1 = 2
+  COMPRESSION_METHOD_REDUCE_2 = 3
+  COMPRESSION_METHOD_REDUCE_3 = 4
+  COMPRESSION_METHOD_REDUCE_4 = 5
+  COMPRESSION_METHOD_IMPLODE = 6
+  # RESERVED = 7
+  COMPRESSION_METHOD_DEFLATE = 8
+  COMPRESSION_METHOD_DEFLATE_64 = 9
+  COMPRESSION_METHOD_PKWARE_DCLI = 10
+  # RESERVED = 11
+  COMPRESSION_METHOD_BZIP2 = 12
+  # RESERVED = 13
+  COMPRESSION_METHOD_LZMA = 14
+  # RESERVED = 15
+  COMPRESSION_METHOD_IBM_CMPSC = 16
+  # RESERVED = 17
+  COMPRESSION_METHOD_IBM_TERSE = 18
+  COMPRESSION_METHOD_IBM_LZ77 = 19
+  COMPRESSION_METHOD_JPEG = 96
+  COMPRESSION_METHOD_WAVPACK = 97
+  COMPRESSION_METHOD_PPMD = 98
+  COMPRESSION_METHOD_AES = 99
+
+  COMPRESSION_METHODS = {
+    COMPRESSION_METHOD_STORE       => 'Store (no compression)',
+    COMPRESSION_METHOD_SHRINK      => 'Shrink',
+    COMPRESSION_METHOD_REDUCE_1    => 'Reduce with compression factor 1',
+    COMPRESSION_METHOD_REDUCE_2    => 'Reduce with compression factor 2',
+    COMPRESSION_METHOD_REDUCE_3    => 'Reduce with compression factor 3',
+    COMPRESSION_METHOD_REDUCE_4    => 'Reduce with compression factor 4',
+    COMPRESSION_METHOD_IMPLODE     => 'Implode',
+    # RESERVED = 7
+    COMPRESSION_METHOD_DEFLATE     => 'Deflate',
+    COMPRESSION_METHOD_DEFLATE_64  => 'Deflate64(tm)',
+    COMPRESSION_METHOD_PKWARE_DCLI => 'PKWARE Data Compression Library Imploding (old IBM TERSE)',
+    # RESERVED = 11
+    COMPRESSION_METHOD_BZIP2       => 'BZIP2',
+    # RESERVED = 13
+    COMPRESSION_METHOD_LZMA        => 'LZMA',
+    # RESERVED = 15
+    COMPRESSION_METHOD_IBM_CMPSC   => 'IBM z/OS CMPSC Compression',
+    # RESERVED = 17
+    COMPRESSION_METHOD_IBM_TERSE   => 'IBM TERSE (new)',
+    COMPRESSION_METHOD_IBM_LZ77    => 'IBM LZ77 z Architecture (PFS)',
+    COMPRESSION_METHOD_JPEG        => 'JPEG variant',
+    COMPRESSION_METHOD_WAVPACK     => 'WavPack compressed data',
+    COMPRESSION_METHOD_PPMD        => 'PPMd version I, Rev 1',
+    COMPRESSION_METHOD_AES         => 'AES encryption'
   }.freeze
 end

data/lib/zip/crypto/decrypted_io.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Zip
+  class DecryptedIo # :nodoc:all
+    CHUNK_SIZE = 32_768
+
+    def initialize(io, decrypter)
+      @io = io
+      @decrypter = decrypter
+    end
+
+    def read(length = nil, outbuf = +'')
+      return (length.nil? || length.zero? ? '' : nil) if eof
+
+      while length.nil? || (buffer.bytesize < length)
+        break if input_finished?
+
+        buffer << produce_input
+      end
+
+      outbuf.replace(buffer.slice!(0...(length || output_buffer.bytesize)))
+    end
+
+    private
+
+    def eof
+      buffer.empty? && input_finished?
+    end
+
+    def buffer
+      @buffer ||= +''
+    end
+
+    def input_finished?
+      @io.eof
+    end
+
+    def produce_input
+      @decrypter.decrypt(@io.read(CHUNK_SIZE))
+    end
+  end
+end

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!
@@ -24,8 +26,8 @@ module Zip
       end
     end
 
-    def update_keys(n)
-      @key0 = ~Zlib.crc32(n, ~@key0)
+    def update_keys(num)
+      @key0 = ~Zlib.crc32(num, ~@key0)
       @key1 = ((@key1 + (@key0 & 0xff)) * 134_775_813 + 1) & 0xffffffff
       @key2 = ~Zlib.crc32((@key1 >> 24).chr, ~@key2)
     end
@@ -36,7 +38,7 @@ module Zip
     end
   end
 
-  class TraditionalEncrypter < Encrypter
+  class TraditionalEncrypter < Encrypter # :nodoc:
     include TraditionalEncryption
 
     def header(mtime)
@@ -63,14 +65,14 @@ module Zip
 
     private
 
-    def encode(n)
+    def encode(num)
       t = decrypt_byte
-      update_keys(n.chr)
-      t ^ n
+      update_keys(num.chr)
+      t ^ num
     end
   end
 
-  class TraditionalDecrypter < Decrypter
+  class TraditionalDecrypter < Decrypter # :nodoc:
     include TraditionalEncryption
 
     def decrypt(data)
@@ -86,10 +88,10 @@ module Zip
 
     private
 
-    def decode(n)
-      n ^= decrypt_byte
-      update_keys(n.chr)
-      n
+    def decode(num)
+      num ^= decrypt_byte
+      update_keys(num.chr)
+      num
     end
   end
 end

data/lib/zip/decompressor.rb

@@ -1,9 +1,28 @@
+# frozen_string_literal: true
+
 module Zip
-  class Decompressor #:nodoc:all
+  class Decompressor # :nodoc:all
     CHUNK_SIZE = 32_768
-    def initialize(input_stream)
+
+    def self.decompressor_classes
+      @decompressor_classes ||= {}
+    end
+
+    def self.register(compression_method, decompressor_class)
+      decompressor_classes[compression_method] = decompressor_class
+    end
+
+    def self.find_by_compression_method(compression_method)
+      decompressor_classes[compression_method]
+    end
+
+    attr_reader :decompressed_size, :input_stream
+
+    def initialize(input_stream, decompressed_size = nil)
       super()
+
       @input_stream = input_stream
+      @decompressed_size = decompressed_size
     end
   end
 end