rubyzip 1.3.0 → 3.0.0.alpha

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
@@ -50,6 +52,7 @@ module Zip
 
     def ==(other)
       return false unless other.kind_of?(EntrySet)
+
       @entry_set.values == other.entry_set.values
     end
 
@@ -60,6 +63,7 @@ module Zip
     def glob(pattern, flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH | ::File::FNM_EXTGLOB)
       entries.map do |entry|
         next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
+
         yield(entry) if block_given?
         entry
       end.compact
@@ -68,7 +72,7 @@ module Zip
     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,18 +1,118 @@
+# 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
-
-  # 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
+    attr_reader :compression_method
+
+    def initialize(method)
+      super()
+      @compression_method = method
+    end
+
+    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
+    attr_reader :zlib_error
+
+    def initialize(zlib_error)
+      super()
+      @zlib_error = zlib_error
+    end
+
+    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
+    def initialize(destination)
+      super()
+      @destination = destination
+    end
+
+    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
+    def initialize(source, name)
+      super()
+      @source = source
+      @name = name
+    end
+
+    def message
+      "'#{@source}' failed. Entry #{@name} already exists."
+    end
+  end
+
+  # Error raised when an entry name is invalid.
+  class EntryNameError < Error
+    def initialize(name = nil)
+      super()
+      @name = name
+    end
+
+    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
+    attr_reader :entry
+
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    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
+    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
+    attr_reader :entry
+
+    def initialize(entry)
+      super()
+      @entry = entry
+    end
+
+    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/generic.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
-  class ExtraField::Generic
+  class ExtraField::Generic # :nodoc:
     def self.register_map
-      if const_defined?(:HEADER_ID)
-        ::Zip::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
-      end
+      return unless const_defined?(:HEADER_ID)
+
+      ::Zip::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
     end
 
     def self.name
@@ -12,22 +14,14 @@ module Zip
 
     # return field [size, content] or false
     def initial_parse(binstr)
-      if !binstr
-        # If nil, start with empty.
-        return false
-      elsif binstr[0, 2] != self.class.const_get(:HEADER_ID)
-        $stderr.puts 'Warning: weired extra feild header ID. skip parsing'
+      return false unless binstr
+
+      if binstr[0, 2] != self.class.const_get(:HEADER_ID)
+        warn 'WARNING: weird extra field header ID. Skip parsing it.'
         return false
       end
-      [binstr[2, 2].unpack('v')[0], binstr[4..-1]]
-    end
 
-    def ==(other)
-      return false if self.class != other.class
-      each do |k, v|
-        return false if v != other[k]
-      end
-      true
+      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
     end
 
     def to_local_bin

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
 
@@ -19,6 +21,7 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       size, content = initial_parse(binstr)
       (size && content) || return
 
@@ -27,6 +30,7 @@ module Zip
 
       tag1 = tags[1]
       return unless tag1
+
       ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack('Q<Q<Q<')
       ntfs_mtime && @mtime ||= from_ntfs_time(ntfs_mtime)
       ntfs_atime && @atime ||= from_ntfs_time(ntfs_atime)
@@ -49,7 +53,7 @@ module Zip
       # reserved 0 and tag 1
       s = [0, 1].pack('Vv')
 
-      tag1 = ''.force_encoding(Encoding::BINARY)
+      tag1 = (+'').force_encoding(Encoding::BINARY)
       if @mtime
         tag1 << [to_ntfs_time(@mtime)].pack('Q<')
         if @atime
@@ -65,12 +69,14 @@ module Zip
 
     def parse_tags(content)
       return {} if content.nil?
+
       tags = {}
       i = 0
       while i < content.bytesize
         tag, size = content[i, 4].unpack('vv')
         i += 4
         break unless tag && size
+
         value = content[i, size]
         i += size
         tags[tag] = value

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
 
@@ -16,14 +18,16 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       size, content = initial_parse(binstr)
       # size: 0 for central directory. 4 for local header
       return if !size || size == 0
+
       atime, mtime, uid, gid = content.unpack('VVvv')
       @uid ||= uid
       @gid ||= gid
       @atime ||= atime
-      @mtime ||= mtime
+      @mtime ||= mtime # rubocop:disable Naming/MemoizedInstanceVariableName
     end
 
     def ==(other)

data/lib/zip/extra_field/universal_time.rb

@@ -1,27 +1,59 @@
+# 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
 
+    ATIME_MASK = 0b010
+    CTIME_MASK = 0b100
+    MTIME_MASK = 0b001
+
     def initialize(binstr = nil)
       @ctime = nil
       @mtime = nil
       @atime = nil
-      @flag  = nil
-      binstr && merge(binstr)
+      @flag  = 0
+
+      merge(binstr) unless binstr.nil?
+    end
+
+    attr_reader :atime, :ctime, :mtime, :flag
+
+    def atime=(time)
+      @flag = time.nil? ? @flag & ~ATIME_MASK : @flag | ATIME_MASK
+      @atime = time
     end
 
-    attr_accessor :atime, :ctime, :mtime, :flag
+    def ctime=(time)
+      @flag = time.nil? ? @flag & ~CTIME_MASK : @flag | CTIME_MASK
+      @ctime = time
+    end
+
+    def mtime=(time)
+      @flag = time.nil? ? @flag & ~MTIME_MASK : @flag | MTIME_MASK
+      @mtime = time
+    end
 
     def merge(binstr)
       return if binstr.empty?
+
       size, content = initial_parse(binstr)
-      size || return
-      @flag, mtime, atime, ctime = content.unpack('CVVV')
-      mtime && @mtime ||= ::Zip::DOSTime.at(mtime)
-      atime && @atime ||= ::Zip::DOSTime.at(atime)
-      ctime && @ctime ||= ::Zip::DOSTime.at(ctime)
+      return if !size || size <= 0
+
+      @flag, *times = content.unpack('Cl<l<l<')
+
+      # Parse the timestamps, in order, based on which flags are set.
+      return if times[0].nil?
+
+      @mtime ||= ::Zip::DOSTime.at(times.shift) unless @flag & MTIME_MASK == 0
+      return if times[0].nil?
+
+      @atime ||= ::Zip::DOSTime.at(times.shift) unless @flag & ATIME_MASK == 0
+      return if times[0].nil?
+
+      @ctime ||= ::Zip::DOSTime.at(times.shift) unless @flag & CTIME_MASK == 0
     end
 
     def ==(other)
@@ -32,15 +64,15 @@ module Zip
 
     def pack_for_local
       s = [@flag].pack('C')
-      @flag & 1 != 0 && s << [@mtime.to_i].pack('V')
-      @flag & 2 != 0 && s << [@atime.to_i].pack('V')
-      @flag & 4 != 0 && s << [@ctime.to_i].pack('V')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
+      s << [@atime.to_i].pack('l<') unless @flag & ATIME_MASK == 0
+      s << [@ctime.to_i].pack('l<') unless @flag & CTIME_MASK == 0
       s
     end
 
     def pack_for_c_dir
       s = [@flag].pack('C')
-      @flag & 1 == 1 && s << [@mtime.to_i].pack('V')
+      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
       s
     end
   end

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
 
@@ -14,12 +16,14 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       size, content = initial_parse(binstr)
       # size: 0 for central directory. 4 for local header
       return if !size || size == 0
+
       uid, gid = content.unpack('vv')
-      @uid ||= uid
-      @gid ||= gid
+      @uid = uid
+      @gid = gid
     end
 
     def ==(other)

data/lib/zip/extra_field/unknown.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Zip
+  # A class to hold unknown extra fields so that they are preserved.
+  class ExtraField::Unknown # :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
 
@@ -9,7 +13,7 @@ module Zip
       # unparsed binary; we don't actually know what this contains
       # without looking for FFs in the associated file header
       # call parse after initializing with a binary string
-      @content = nil
+      @content                = nil
       @original_size          = nil
       @compressed_size        = nil
       @relative_header_offset = nil
@@ -26,6 +30,7 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       _, @content = initial_parse(binstr)
     end
 
@@ -35,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,
@@ -45,19 +52,21 @@ module Zip
     end
 
     def extract(size, format)
-      @content.slice!(0, size).unpack(format)[0]
+      @content.slice!(0, size).unpack1(format)
     end
     private :extract
 
     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<')
     end
 
     def pack_for_c_dir
       # central directory entries contain only fields that didn't fit in the main entry part
-      packed = ''.force_encoding('BINARY')
+      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,50 +1,45 @@
+# 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, i)
+    def extra_field_type_exist(binstr, id, len, index)
       field_name = ID_MAP[id].name
       if member?(field_name)
-        self[field_name].merge(binstr[i, len + 4])
+        self[field_name].merge(binstr[index, len + 4])
       else
-        field_obj        = ID_MAP[id].new(binstr[i, len + 4])
+        field_obj        = ID_MAP[id].new(binstr[index, len + 4])
         self[field_name] = field_obj
       end
     end
 
-    def extra_field_type_unknown(binstr, len, i)
-      create_unknown_item unless self['Unknown']
-      if !len || len + 4 > binstr[i..-1].bytesize
-        self['Unknown'] << binstr[i..-1]
+    def extra_field_type_unknown(binstr, len, index, local)
+      self['Unknown'] ||= Unknown.new
+
+      if !len || len + 4 > binstr[index..-1].bytesize
+        self['Unknown'].merge(binstr[index..-1], local: local)
         return
       end
-      self['Unknown'] << binstr[i, len + 4]
-    end
 
-    def create_unknown_item
-      s = ''.dup
-      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
       while i < binstr.bytesize
         id  = binstr[i, 2]
-        len = binstr[i + 2, 2].to_s.unpack('v').first
+        len = binstr[i + 2, 2].to_s.unpack1('v')
         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
@@ -54,11 +49,12 @@ module Zip
       unless (field_class = ID_MAP.values.find { |k| k.name == name })
         raise Error, "Unknown extra field '#{name}'"
       end
+
       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) }
@@ -88,12 +84,12 @@ 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'
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard