rubyzip 1.2.2 → 2.3.0

data/lib/zip/extra_field/generic.rb

@@ -1,9 +1,9 @@
 module Zip
   class ExtraField::Generic
     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,18 +12,19 @@ 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]]
+
+      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
     end
 
     def ==(other)
       return false if self.class != other.class
+
       each do |k, v|
         return false if v != other[k]
       end

data/lib/zip/extra_field/ntfs.rb

@@ -19,6 +19,7 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       size, content = initial_parse(binstr)
       (size && content) || return
 
@@ -27,6 +28,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)
@@ -65,12 +67,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

@@ -16,14 +16,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

@@ -4,24 +4,54 @@ module Zip
     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
+
+    def ctime=(time)
+      @flag = time.nil? ? @flag & ~CTIME_MASK : @flag | CTIME_MASK
+      @ctime = time
     end
 
-    attr_accessor :atime, :ctime, :mtime, :flag
+    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 +62,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

@@ -14,12 +14,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
+      @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
     end
 
     def ==(other)

data/lib/zip/extra_field/zip64.rb

@@ -9,7 +9,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 +26,7 @@ module Zip
 
     def merge(binstr)
       return if binstr.empty?
+
       _, @content = initial_parse(binstr)
     end
 
@@ -45,13 +46,14 @@ 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
       return '' unless @original_size && @compressed_size
+
       [@original_size, @compressed_size].pack('Q<Q<')
     end
 

data/lib/zip/file.rb

@@ -49,53 +49,78 @@ module Zip
     MAX_SEGMENT_SIZE     = 3_221_225_472
     MIN_SEGMENT_SIZE     = 65_536
     DATA_BUFFER_SIZE     = 8192
-    IO_METHODS           = [:tell, :seek, :read, :close]
+    IO_METHODS           = [:tell, :seek, :read, :eof, :close]
+
+    DEFAULT_OPTIONS = {
+      restore_ownership:   false,
+      restore_permissions: false,
+      restore_times:       false
+    }.freeze
 
     attr_reader :name
 
-    # default -> false
+    # default -> false.
     attr_accessor :restore_ownership
-    # default -> false
+
+    # default -> false, but will be set to true in a future version.
     attr_accessor :restore_permissions
-    # default -> true
+
+    # default -> false, but will be set to true in a future version.
     attr_accessor :restore_times
+
     # Returns the zip files comment, if it has one
     attr_accessor :comment
 
     # Opens a zip archive. Pass true as the second parameter to create
     # a new archive if it doesn't exist already.
-    def initialize(file_name, create = false, buffer = false, options = {})
+    def initialize(path_or_io, create = false, buffer = false, options = {})
       super()
-      @name    = file_name
+      options  = DEFAULT_OPTIONS.merge(options)
+      @name    = path_or_io.respond_to?(:path) ? path_or_io.path : path_or_io
       @comment = ''
       @create  = create ? true : false # allow any truthy value to mean true
-      if !buffer && ::File.size?(file_name)
+
+      if ::File.size?(@name.to_s)
+        # There is a file, which exists, that is associated with this zip.
         @create = false
-        @file_permissions = ::File.stat(file_name).mode
-        ::File.open(name, 'rb') do |f|
-          read_from_stream(f)
+        @file_permissions = ::File.stat(@name).mode
+
+        if buffer
+          read_from_stream(path_or_io)
+        else
+          ::File.open(@name, 'rb') do |f|
+            read_from_stream(f)
+          end
         end
+      elsif buffer && path_or_io.size > 0
+        # This zip is probably a non-empty StringIO.
+        read_from_stream(path_or_io)
       elsif @create
+        # This zip is completely new/empty and is to be created.
         @entry_set = EntrySet.new
-      elsif ::File.zero?(file_name)
-        raise Error, "File #{file_name} has zero size. Did you mean to pass the create flag?"
+      elsif ::File.zero?(@name)
+        # A file exists, but it is empty.
+        raise Error, "File #{@name} has zero size. Did you mean to pass the create flag?"
       else
-        raise Error, "File #{file_name} not found"
+        # Everything is wrong.
+        raise Error, "File #{@name} not found"
       end
+
       @stored_entries      = @entry_set.dup
       @stored_comment      = @comment
-      @restore_ownership   = options[:restore_ownership]    || false
-      @restore_permissions = options[:restore_permissions]  || true
-      @restore_times       = options[:restore_times]        || true
+      @restore_ownership   = options[:restore_ownership]
+      @restore_permissions = options[:restore_permissions]
+      @restore_times       = options[:restore_times]
     end
 
     class << self
-      # Same as #new. If a block is passed the ZipFile object is passed
-      # to the block and is automatically closed afterwards just as with
-      # ruby's builtin File.open method.
-      def open(file_name, create = false)
-        zf = ::Zip::File.new(file_name, create)
+      # Similar to ::new. If a block is passed the Zip::File object is passed
+      # to the block and is automatically closed afterwards, just as with
+      # ruby's builtin File::open method.
+      def open(file_name, create = false, options = {})
+        zf = ::Zip::File.new(file_name, create, false, options)
         return zf unless block_given?
+
         begin
           yield zf
         ensure
@@ -116,20 +141,20 @@ module Zip
       # (This can be used to extract data from a
       # downloaded zip archive without first saving it to disk.)
       def open_buffer(io, options = {})
-        unless IO_METHODS.map { |method| io.respond_to?(method) }.all? || io.is_a?(String)
+        unless IO_METHODS.map { |method| io.respond_to?(method) }.all? || io.kind_of?(String)
           raise "Zip::File.open_buffer expects a String or IO-like argument (responds to #{IO_METHODS.join(', ')}). Found: #{io.class}"
         end
-        if io.is_a?(::String)
-          require 'stringio'
-          io = ::StringIO.new(io)
-        elsif io.respond_to?(:binmode)
-          # https://github.com/rubyzip/rubyzip/issues/119
-          io.binmode
-        end
+
+        io = ::StringIO.new(io) if io.kind_of?(::String)
+
+        # https://github.com/rubyzip/rubyzip/issues/119
+        io.binmode if io.respond_to?(:binmode)
+
         zf = ::Zip::File.new(io, true, true, options)
-        zf.read_from_stream(io)
         return zf unless block_given?
+
         yield zf
+
         begin
           zf.write_buffer(io)
         rescue IOError => e
@@ -143,9 +168,9 @@ module Zip
       # whereas ZipInputStream jumps through the entire archive accessing the
       # local entry headers (which contain the same information as the
       # central directory).
-      def foreach(aZipFileName, &block)
-        open(aZipFileName) do |zipFile|
-          zipFile.each(&block)
+      def foreach(zip_file_name, &block)
+        ::Zip::File.open(zip_file_name) do |zip_file|
+          zip_file.each(&block)
         end
       end
 
@@ -206,12 +231,14 @@ module Zip
       def split(zip_file_name, segment_size = MAX_SEGMENT_SIZE, delete_zip_file = true, partial_zip_file_name = nil)
         raise Error, "File #{zip_file_name} not found" unless ::File.exist?(zip_file_name)
         raise Errno::ENOENT, zip_file_name unless ::File.readable?(zip_file_name)
+
         zip_file_size = ::File.size(zip_file_name)
         segment_size  = get_segment_size_for_split(segment_size)
         return if zip_file_size <= segment_size
+
         segment_count = get_segment_count_for_split(zip_file_size, segment_size)
         # Checking for correct zip structure
-        open(zip_file_name) {}
+        ::Zip::File.open(zip_file_name) {}
         partial_zip_file_name = get_partial_zip_file_name(zip_file_name, partial_zip_file_name)
         szip_file_index       = 0
         ::File.open(zip_file_name, 'rb') do |zip_file|
@@ -228,8 +255,8 @@ module Zip
     # Returns an input stream to the specified entry. If a block is passed
     # the stream object is passed to the block and the stream is automatically
     # closed afterwards just as with ruby's builtin File.open method.
-    def get_input_stream(entry, &aProc)
-      get_entry(entry).get_input_stream(&aProc)
+    def get_input_stream(entry, &a_proc)
+      get_entry(entry).get_input_stream(&a_proc)
     end
 
     # Returns an output stream to the specified entry. If entry is not an instance
@@ -237,7 +264,11 @@ module Zip
     # specified. If a block is passed the stream object is passed to the block and
     # the stream is automatically closed afterwards just as with ruby's builtin
     # File.open method.
-    def get_output_stream(entry, permission_int = nil, comment = nil, extra = nil, compressed_size = nil, crc = nil, compression_method = nil, size = nil, time = nil, &aProc)
+    def get_output_stream(entry, permission_int = nil, comment = nil,
+                          extra = nil, compressed_size = nil, crc = nil,
+                          compression_method = nil, size = nil, time = nil,
+                          &a_proc)
+
       new_entry =
         if entry.kind_of?(Entry)
           entry
@@ -251,7 +282,7 @@ module Zip
       new_entry.unix_perms = permission_int
       zip_streamable_entry = StreamableStream.new(new_entry)
       @entry_set << zip_streamable_entry
-      zip_streamable_entry.get_output_stream(&aProc)
+      zip_streamable_entry.get_output_stream(&a_proc)
     end
 
     # Returns the name of the zip archive
@@ -261,7 +292,7 @@ module Zip
 
     # Returns a string containing the contents of the specified entry
     def read(entry)
-      get_input_stream(entry) { |is| is.read }
+      get_input_stream(entry, &:read)
     end
 
     # Convenience method for adding the contents of a file to the archive
@@ -274,6 +305,13 @@ module Zip
       @entry_set << new_entry
     end
 
+    # Convenience method for adding the contents of a file to the archive
+    # in Stored format (uncompressed)
+    def add_stored(entry, src_path, &continue_on_exists_proc)
+      entry = ::Zip::Entry.new(@name, entry.to_s, nil, nil, nil, nil, ::Zip::Entry::STORED)
+      add(entry, src_path, &continue_on_exists_proc)
+    end
+
     # Removes the specified entry.
     def remove(entry)
       @entry_set.delete(get_entry(entry))
@@ -281,19 +319,19 @@ module Zip
 
     # Renames the specified entry.
     def rename(entry, new_name, &continue_on_exists_proc)
-      foundEntry = get_entry(entry)
+      found_entry = get_entry(entry)
       check_entry_exists(new_name, continue_on_exists_proc, 'rename')
-      @entry_set.delete(foundEntry)
-      foundEntry.name = new_name
-      @entry_set << foundEntry
+      @entry_set.delete(found_entry)
+      found_entry.name = new_name
+      @entry_set << found_entry
     end
 
-    # Replaces the specified entry with the contents of srcPath (from
+    # Replaces the specified entry with the contents of src_path (from
     # the file system).
-    def replace(entry, srcPath)
-      check_file(srcPath)
+    def replace(entry, src_path)
+      check_file(src_path)
       remove(entry)
-      add(entry, srcPath)
+      add(entry, src_path)
     end
 
     # Extracts entry to file dest_path.
@@ -306,7 +344,8 @@ module Zip
     # Commits changes that has been made since the previous commit to
     # the zip archive.
     def commit
-      return if name.is_a?(StringIO) || !commit_required?
+      return if name.kind_of?(StringIO) || !commit_required?
+
       on_success_replace do |tmp_file|
         ::Zip::OutputStream.open(tmp_file) do |zos|
           @entry_set.each do |e|
@@ -346,7 +385,13 @@ module Zip
     # Searches for entry with the specified name. Returns nil if
     # no entry is found. See also get_entry
     def find_entry(entry_name)
-      @entry_set.find_entry(entry_name)
+      selected_entry = @entry_set.find_entry(entry_name)
+      return if selected_entry.nil?
+
+      selected_entry.restore_ownership   = @restore_ownership
+      selected_entry.restore_permissions = @restore_permissions
+      selected_entry.restore_times       = @restore_times
+      selected_entry
     end
 
     # Searches for entries given a glob
@@ -358,43 +403,43 @@ module Zip
     # if no entry is found.
     def get_entry(entry)
       selected_entry = find_entry(entry)
-      raise Errno::ENOENT, entry unless selected_entry
-      selected_entry.restore_ownership   = @restore_ownership
-      selected_entry.restore_permissions = @restore_permissions
-      selected_entry.restore_times       = @restore_times
+      raise Errno::ENOENT, entry if selected_entry.nil?
+
       selected_entry
     end
 
     # Creates a directory
-    def mkdir(entryName, permissionInt = 0o755)
-      raise Errno::EEXIST, "File exists - #{entryName}" if find_entry(entryName)
-      entryName = entryName.dup.to_s
-      entryName << '/' unless entryName.end_with?('/')
-      @entry_set << ::Zip::StreamableDirectory.new(@name, entryName, nil, permissionInt)
+    def mkdir(entry_name, permission = 0o755)
+      raise Errno::EEXIST, "File exists - #{entry_name}" if find_entry(entry_name)
+
+      entry_name = entry_name.dup.to_s
+      entry_name << '/' unless entry_name.end_with?('/')
+      @entry_set << ::Zip::StreamableDirectory.new(@name, entry_name, nil, permission)
     end
 
     private
 
-    def directory?(newEntry, srcPath)
-      srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.directory? && !srcPathIsDirectory
+    def directory?(new_entry, src_path)
+      path_is_directory = ::File.directory?(src_path)
+      if new_entry.directory? && !path_is_directory
         raise ArgumentError,
-              "entry name '#{newEntry}' indicates directory entry, but " \
-                  "'#{srcPath}' is not a directory"
-      elsif !newEntry.directory? && srcPathIsDirectory
-        newEntry.name += '/'
+              "entry name '#{new_entry}' indicates directory entry, but " \
+                  "'#{src_path}' is not a directory"
+      elsif !new_entry.directory? && path_is_directory
+        new_entry.name += '/'
       end
-      newEntry.directory? && srcPathIsDirectory
+      new_entry.directory? && path_is_directory
     end
 
-    def check_entry_exists(entryName, continue_on_exists_proc, procedureName)
+    def check_entry_exists(entry_name, continue_on_exists_proc, proc_name)
       continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
-      return unless @entry_set.include?(entryName)
+      return unless @entry_set.include?(entry_name)
+
       if continue_on_exists_proc.call
-        remove get_entry(entryName)
+        remove get_entry(entry_name)
       else
         raise ::Zip::EntryExistsError,
-              procedureName + " failed. Entry #{entryName} already exists"
+              proc_name + " failed. Entry #{entry_name} already exists"
       end
     end