rubyzip 2.4.1 → 3.2.1

data/lib/zip/entry_set.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
-  class EntrySet #:nodoc:all
+  class EntrySet # :nodoc:all
     include Enumerable
-    attr_accessor :entry_set, :entry_order
+
+    attr_reader :entry_set
+    protected   :entry_set
 
     def initialize(an_enumerable = [])
       super()
@@ -33,10 +37,8 @@ module Zip
       entry if @entry_set.delete(to_key(entry))
     end
 
-    def each
-      @entry_set = sorted_entries.dup.each do |_, value|
-        yield(value)
-      end
+    def each(&block)
+      entries.each(&block)
     end
 
     def entries
@@ -59,18 +61,18 @@ module Zip
     end
 
     def glob(pattern, flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH | ::File::FNM_EXTGLOB)
-      entries.map do |entry|
+      entries.filter_map do |entry|
         next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
 
         yield(entry) if block_given?
         entry
-      end.compact
+      end
     end
 
     protected
 
     def sorted_entries
-      ::Zip.sort_entries ? Hash[@entry_set.sort] : @entry_set
+      ::Zip.sort_entries ? @entry_set.sort.to_h : @entry_set
     end
 
     private

data/lib/zip/errors.rb

@@ -1,19 +1,139 @@
+# frozen_string_literal: true
+
 module Zip
+  # The superclass for all rubyzip error types. Simply rescue this one if
+  # you don't need to know what sort of error has been raised.
   class Error < StandardError; end
-  class EntryExistsError < Error; end
-  class DestinationFileExistsError < Error; end
-  class CompressionMethodError < Error; end
-  class EntryNameError < Error; end
-  class EntrySizeError < Error; end
-  class InternalError < Error; end
-  class GPFBit3Error < Error; end
-  class DecompressionError < Error; end
-
-  # Backwards compatibility with v1 (delete in v2)
-  ZipError = Error
-  ZipEntryExistsError = EntryExistsError
-  ZipDestinationFileExistsError = DestinationFileExistsError
-  ZipCompressionMethodError = CompressionMethodError
-  ZipEntryNameError = EntryNameError
-  ZipInternalError = InternalError
+
+  # Error raised if an unsupported compression method is used.
+  class CompressionMethodError < Error
+    # The compression method that has caused this error.
+    attr_reader :compression_method
+
+    # Create a new CompressionMethodError with the specified incorrect
+    # compression method.
+    def initialize(method)
+      super()
+      @compression_method = method
+    end
+
+    # The message returned by this error.
+    def message
+      "Unsupported compression method: #{COMPRESSION_METHODS[@compression_method]}."
+    end
+  end
+
+  # Error raised if there is a problem while decompressing an archive entry.
+  class DecompressionError < Error
+    # The error from the underlying Zlib library that caused this error.
+    attr_reader :zlib_error
+
+    # Create a new DecompressionError with the specified underlying Zlib
+    # error.
+    def initialize(zlib_error)
+      super()
+      @zlib_error = zlib_error
+    end
+
+    # The message returned by this error.
+    def message
+      "Zlib error ('#{@zlib_error.message}') while inflating."
+    end
+  end
+
+  # Error raised when trying to extract an archive entry over an
+  # existing file.
+  class DestinationExistsError < Error
+    # Create a new DestinationExistsError with the clashing destination.
+    def initialize(destination)
+      super()
+      @destination = destination
+    end
+
+    # The message returned by this error.
+    def message
+      "Cannot create file or directory '#{@destination}'. " \
+        'A file already exists with that name.'
+    end
+  end
+
+  # Error raised when trying to add an entry to an archive where the
+  # entry name already exists.
+  class EntryExistsError < Error
+    # Create a new EntryExistsError with the specified source and name.
+    def initialize(source, name)
+      super()
+      @source = source
+      @name = name
+    end
+
+    # The message returned by this error.
+    def message
+      "'#{@source}' failed. Entry #{@name} already exists."
+    end
+  end
+
+  # Error raised when an entry name is invalid.
+  class EntryNameError < Error
+    # Create a new EntryNameError with the specified name.
+    def initialize(name = nil)
+      super()
+      @name = name
+    end
+
+    # The message returned by this error.
+    def message
+      if @name.nil?
+        'Illegal entry name. Names must have fewer than 65,536 characters.'
+      else
+        "Illegal entry name '#{@name}'. Names must not start with '/'."
+      end
+    end
+  end
+
+  # Error raised if an entry is larger on extraction than it is advertised
+  # to be.
+  class EntrySizeError < Error
+    # The entry that has caused this error.
+    attr_reader :entry
+
+    # Create a new EntrySizeError with the specified entry.
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    # The message returned by this error.
+    def message
+      "Entry '#{@entry.name}' should be #{@entry.size}B, but is larger when inflated."
+    end
+  end
+
+  # Error raised if a split archive is read. Rubyzip does not support reading
+  # split archives.
+  class SplitArchiveError < Error
+    # The message returned by this error.
+    def message
+      'Rubyzip cannot extract from split archives at this time.'
+    end
+  end
+
+  # Error raised if there is not enough metadata for the entry to be streamed.
+  class StreamingError < Error
+    # The entry that has caused this error.
+    attr_reader :entry
+
+    # Create a new StreamingError with the specified entry.
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    # The message returned by this error.
+    def message
+      "The local header of this entry ('#{@entry.name}') does not contain " \
+        'the correct metadata for `Zip::InputStream` to be able to ' \
+        'uncompress it. Please use `Zip::File` instead of `Zip::InputStream`.'
+    end
+  end
 end

data/lib/zip/extra_field/aes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Zip
+  # Info-ZIP Extra for AES encryption
+  class ExtraField::AES < ExtraField::Generic # :nodoc:
+    attr_reader :vendor_version, :vendor_id, :encryption_strength, :compression_method
+
+    HEADER_ID = [0x9901].pack('v')
+    register_map
+
+    def initialize(binstr = nil)
+      @vendor_version = nil
+      @vendor_id = nil
+      @encryption_strength = nil
+      @compression_method = nil
+      binstr && merge(binstr)
+    end
+
+    def ==(other)
+      @vendor_version == other.vendor_version &&
+        @vendor_id == other.vendor_id &&
+        @encryption_strength == other.encryption_strength &&
+        @compression_method == other.compression_method
+    end
+
+    def merge(binstr)
+      return if binstr.empty?
+
+      size, content = initial_parse(binstr)
+      (size && content) || return
+
+      @vendor_version, @vendor_id,
+        @encryption_strength, @compression_method = content.unpack('va2Cv')
+    end
+
+    # We can never suppress the AES extra field as it is needed to read the file.
+    def suppress?
+      false
+    end
+
+    def pack_for_local
+      [@vendor_version, @vendor_id,
+       @encryption_strength, @compression_method].pack('va2Cv')
+    end
+
+    def pack_for_c_dir
+      pack_for_local
+    end
+  end
+end

data/lib/zip/extra_field/generic.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class ExtraField::Generic
+  class ExtraField::Generic # :nodoc:
     def self.register_map
       return unless const_defined?(:HEADER_ID)
 
@@ -7,7 +9,7 @@ module Zip
     end
 
     def self.name
-      @name ||= to_s.split('::')[-1]
+      @name ||= to_s.split('::').last.downcase.to_sym
     end
 
     # return field [size, content] or false
@@ -19,26 +21,23 @@ module Zip
         return false
       end
 
-      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
+      [binstr[2, 2].unpack1('v'), binstr[4..]]
     end
 
-    def ==(other)
-      return false if self.class != other.class
-
-      each do |k, v|
-        return false if v != other[k]
-      end
+    # Default strategy is to suppress all extra fields if we're asked to.
+    # Specific extra field types can override this if they need to be kept.
+    def suppress?
       true
     end
 
     def to_local_bin
       s = pack_for_local
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
+      (self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v')) << s
     end
 
     def to_c_dir_bin
       s = pack_for_c_dir
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
+      (self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v')) << s
     end
   end
 end

data/lib/zip/extra_field/ntfs.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Zip
   # PKWARE NTFS Extra Field (0x000a)
   # Only Tag 0x0001 is supported
-  class ExtraField::NTFS < ExtraField::Generic
+  class ExtraField::NTFS < ExtraField::Generic # :nodoc:
     HEADER_ID = [0x000A].pack('v')
     register_map
 
@@ -23,7 +25,7 @@ module Zip
       size, content = initial_parse(binstr)
       (size && content) || return
 
-      content = content[4..-1]
+      content = content[4..]
       tags = parse_tags(content)
 
       tag1 = tags[1]
@@ -51,7 +53,7 @@ module Zip
       # reserved 0 and tag 1
       s = [0, 1].pack('Vv')
 
-      tag1 = ''.b
+      tag1 = (+'').force_encoding(Encoding::BINARY)
       if @mtime
         tag1 << [to_ntfs_time(@mtime)].pack('Q<')
         if @atime
@@ -84,7 +86,7 @@ module Zip
     end
 
     def from_ntfs_time(ntfs_time)
-      ::Zip::DOSTime.at(ntfs_time / WINDOWS_TICK - SEC_TO_UNIX_EPOCH)
+      ::Zip::DOSTime.at((ntfs_time / WINDOWS_TICK) - SEC_TO_UNIX_EPOCH)
     end
 
     def to_ntfs_time(time)

data/lib/zip/extra_field/old_unix.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Zip
   # Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
-  class ExtraField::OldUnix < ExtraField::Generic
+  class ExtraField::OldUnix < ExtraField::Generic # :nodoc:
     HEADER_ID = 'UX'
     register_map
 

data/lib/zip/extra_field/universal_time.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Zip
   # Info-ZIP Additional timestamp field
-  class ExtraField::UniversalTime < ExtraField::Generic
+  class ExtraField::UniversalTime < ExtraField::Generic # :nodoc:
     HEADER_ID = 'UT'
     register_map
 

data/lib/zip/extra_field/unix.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Zip
   # Info-ZIP Extra for UNIX uid/gid
-  class ExtraField::IUnix < ExtraField::Generic
+  class ExtraField::IUnix < ExtraField::Generic # :nodoc:
     HEADER_ID = 'Ux'
     register_map
 
@@ -20,8 +22,8 @@ module Zip
       return if !size || size == 0
 
       uid, gid = content.unpack('vv')
-      @uid ||= uid
-      @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
+      @uid = uid
+      @gid = gid
     end
 
     def ==(other)

data/lib/zip/extra_field/unknown.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'generic'
+
+module Zip
+  # A class to hold unknown extra fields so that they are preserved.
+  class ExtraField::Unknown < ExtraField::Generic # :nodoc:
+    def initialize
+      @local_bin = +''
+      @cdir_bin = +''
+    end
+
+    def merge(binstr, local: false)
+      return if binstr.empty?
+
+      if local
+        @local_bin << binstr
+      else
+        @cdir_bin << binstr
+      end
+    end
+
+    def to_local_bin
+      @local_bin
+    end
+
+    def to_c_dir_bin
+      @cdir_bin
+    end
+
+    def ==(other)
+      @local_bin == other.to_local_bin && @cdir_bin == other.to_c_dir_bin
+    end
+  end
+end

data/lib/zip/extra_field/zip64.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
   # Info-ZIP Extra for Zip64 size
-  class ExtraField::Zip64 < ExtraField::Generic
-    attr_accessor :original_size, :compressed_size, :relative_header_offset, :disk_start_number
+  class ExtraField::Zip64 < ExtraField::Generic # :nodoc:
+    attr_accessor :compressed_size, :disk_start_number,
+                  :original_size, :relative_header_offset
+
     HEADER_ID = ['0100'].pack('H*')
     register_map
 
@@ -36,7 +40,9 @@ module Zip
     def parse(original_size, compressed_size, relative_header_offset = nil, disk_start_number = nil)
       @original_size = extract(8, 'Q<') if original_size == 0xFFFFFFFF
       @compressed_size = extract(8, 'Q<') if compressed_size == 0xFFFFFFFF
-      @relative_header_offset = extract(8, 'Q<') if relative_header_offset && relative_header_offset == 0xFFFFFFFF
+      if relative_header_offset && relative_header_offset == 0xFFFFFFFF
+        @relative_header_offset = extract(8, 'Q<')
+      end
       @disk_start_number = extract(4, 'V') if disk_start_number && disk_start_number == 0xFFFF
       @content = nil
       [@original_size || original_size,
@@ -50,8 +56,16 @@ module Zip
     end
     private :extract
 
+    # We can suppress the zip64 extra field unless we know the size is large or
+    # the relative header offset is large (for central directory entries).
+    def suppress?
+      !(@original_size && @original_size >= 0xFFFFFFFF) ||
+        (@relative_header_offset && @relative_header_offset >= 0xFFFFFFFF)
+    end
+
     def pack_for_local
-      # local header entries must contain original size and compressed size; other fields do not apply
+      # Local header entries must contain original size and compressed size;
+      # other fields do not apply.
       return '' unless @original_size && @compressed_size
 
       [@original_size, @compressed_size].pack('Q<Q<')
@@ -59,7 +73,7 @@ module Zip
 
     def pack_for_c_dir
       # central directory entries contain only fields that didn't fit in the main entry part
-      packed = ''.b
+      packed = (+'').force_encoding('BINARY')
       packed << [@original_size].pack('Q<') if @original_size
       packed << [@compressed_size].pack('Q<') if @compressed_size
       packed << [@relative_header_offset].pack('Q<') if @relative_header_offset

data/lib/zip/extra_field.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
-  class ExtraField < Hash
+  class ExtraField < Hash # :nodoc:all
     ID_MAP = {}
 
-    def initialize(binstr = nil)
-      merge(binstr) if binstr
+    def initialize(binstr = nil, local: false)
+      merge(binstr, local: local) if binstr
     end
 
     def extra_field_type_exist(binstr, id, len, index)
@@ -16,25 +18,18 @@ module Zip
       end
     end
 
-    def extra_field_type_unknown(binstr, len, index)
-      create_unknown_item unless self['Unknown']
-      if !len || len + 4 > binstr[index..-1].bytesize
-        self['Unknown'] << binstr[index..-1]
+    def extra_field_type_unknown(binstr, len, index, local)
+      self[:unknown] ||= Unknown.new
+
+      if !len || len + 4 > binstr[index..].bytesize
+        self[:unknown].merge(binstr[index..], local: local)
         return
       end
-      self['Unknown'] << binstr[index, len + 4]
-    end
 
-    def create_unknown_item
-      s = +''
-      class << s
-        alias_method :to_c_dir_bin, :to_s
-        alias_method :to_local_bin, :to_s
-      end
-      self['Unknown'] = s
+      self[:unknown].merge(binstr[index, len + 4], local: local)
     end
 
-    def merge(binstr)
+    def merge(binstr, local: false)
       return if binstr.empty?
 
       i = 0
@@ -44,8 +39,7 @@ module Zip
         if id && ID_MAP.member?(id)
           extra_field_type_exist(binstr, id, len, i)
         elsif id
-          create_unknown_item unless self['Unknown']
-          break unless extra_field_type_unknown(binstr, len, i)
+          break unless extra_field_type_unknown(binstr, len, i, local)
         end
         i += len + 4
       end
@@ -59,14 +53,21 @@ module Zip
       self[name] = field_class.new
     end
 
-    # place Unknown last, so "extra" data that is missing the proper signature/size
-    # does not prevent known fields from being read back in
+    # Place Unknown last, so "extra" data that is missing the proper
+    # signature/size does not prevent known fields from being read back in.
     def ordered_values
       result = []
-      each { |k, v| k == 'Unknown' ? result.push(v) : result.unshift(v) }
+      each { |k, v| k == :unknown ? result.push(v) : result.unshift(v) }
       result
     end
 
+    # Remove any extra fields that indicate they can be safely suppressed.
+    def suppress_fields!(fields)
+      reject! do |k, v|
+        v.suppress? if fields == true || [*fields].include?(k)
+      end
+    end
+
     def to_local_bin
       ordered_values.map! { |v| v.to_local_bin.force_encoding('BINARY') }.join
     end
@@ -90,13 +91,14 @@ module Zip
   end
 end
 
+require 'zip/extra_field/unknown'
 require 'zip/extra_field/generic'
 require 'zip/extra_field/universal_time'
 require 'zip/extra_field/old_unix'
 require 'zip/extra_field/unix'
 require 'zip/extra_field/zip64'
-require 'zip/extra_field/zip64_placeholder'
 require 'zip/extra_field/ntfs'
+require 'zip/extra_field/aes'
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard
 # rubyzip is free software; you can redistribute it and/or