rubyzip 1.0.0 → 2.4.1

data/lib/zip/file.rb

@@ -43,90 +43,133 @@ module Zip
   # interface for accessing the filesystem, ie. the File and Dir classes.
 
   class File < CentralDirectory
-
-    CREATE           = 1
-    SPLIT_SIGNATURE  = 0x08074b50
+    CREATE               = true
+    SPLIT_SIGNATURE      = 0x08074b50
     ZIP64_EOCD_SIGNATURE = 0x06064b50
-    MAX_SEGMENT_SIZE = 3221225472
-    MIN_SEGMENT_SIZE = 65536
-    DATA_BUFFER_SIZE = 8192
+    MAX_SEGMENT_SIZE     = 3_221_225_472
+    MIN_SEGMENT_SIZE     = 65_536
+    DATA_BUFFER_SIZE     = 8192
+    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(fileName, create = nil, buffer = false)
+    def initialize(path_or_io, dep_create = false, dep_buffer = false,
+                   create: false, buffer: false, **options)
       super()
-      @name    = fileName
+
+      Zip.warn_about_v3_api('File#new') if dep_create || dep_buffer
+
+      options  = DEFAULT_OPTIONS.merge(options)
+      @name    = path_or_io.respond_to?(:path) ? path_or_io.path : path_or_io
       @comment = ''
-      @create = create
-      case
-      when ::File.exists?(fileName) && !buffer
-        @create = nil
-        ::File.open(name, 'rb') do |f|
-          read_from_stream(f)
+      @create  = create || dep_create ? true : false # allow any truthy value to mean true
+      buffer ||= dep_buffer
+
+      if ::File.size?(@name.to_s)
+        # There is a file, which exists, that is associated with this zip.
+        @create = false
+        @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
-      when create
+      elsif buffer && path_or_io.size > 0
+        # This zip is probably a non-empty StringIO.
+        @create = false
+        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?(@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 ZipError, "File #{fileName} not found"
+        # Everything is wrong.
+        raise Error, "File #{@name} not found"
       end
-      @storedEntries       = @entry_set.dup
-      @storedComment       = @comment
-      @restore_ownership   = false
-      @restore_permissions = false
-      @restore_times       = true
+
+      @stored_entries      = @entry_set.dup
+      @stored_comment      = @comment
+      @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(fileName, create = nil)
-        zf = ::Zip::File.new(fileName, create)
-        if block_given?
-          begin
-            yield zf
-          ensure
-            zf.close
-          end
-        else
-          zf
+      # 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, dep_create = false, create: false, **options)
+        Zip.warn_about_v3_api('Zip::File.open') if dep_create
+
+        zf = ::Zip::File.new(file_name, create: (dep_create || create), buffer: false, **options)
+        return zf unless block_given?
+
+        begin
+          yield zf
+        ensure
+          zf.close
         end
       end
 
       # Same as #open. But outputs data to a buffer instead of a file
       def add_buffer
-        zf = ::Zip::File.new('', true, true)
+        Zip.warn_about_v3_api('Zip::File.add_buffer')
+
+        io = ::StringIO.new
+        zf = ::Zip::File.new(io, true, true)
         yield zf
-        zf.write_buffer
+        zf.write_buffer(io)
       end
 
       # Like #open, but reads zip archive contents from a String or open IO
       # stream, and outputs data to a buffer.
-      # (This can be used to extract data from a 
+      # (This can be used to extract data from a
       # downloaded zip archive without first saving it to disk.)
-      def open_buffer(io)
-        unless io.is_a?(IO) && io.is_a?(String)
-          raise "Zip::ZipFile.open_buffer expects an argument of class String or IO. Found: #{io.class}"
-        end
-        zf = ::Zip::File.new('', true, true)
-        if io.is_a(::String)
-          require 'stringio'
-          io = ::StringIO.new(io)
+      def open_buffer(io, **options)
+        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
-        zf.read_from_stream(io)
+
+        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, create: true, buffer: true, **options)
+        return zf unless block_given?
+
         yield zf
-        zf.write_buffer
+
+        begin
+          zf.write_buffer(io)
+        rescue IOError => e
+          raise unless e.message == 'not opened for writing'
+        end
       end
 
       # Iterates over the contents of the ZipFile. This is more efficient
@@ -135,17 +178,16 @@ 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
 
       def get_segment_size_for_split(segment_size)
-        case
-        when MIN_SEGMENT_SIZE > segment_size
+        if MIN_SEGMENT_SIZE > segment_size
           MIN_SEGMENT_SIZE
-        when MAX_SEGMENT_SIZE < segment_size
+        elsif MAX_SEGMENT_SIZE < segment_size
           MAX_SEGMENT_SIZE
         else
           segment_size
@@ -153,8 +195,10 @@ module Zip
       end
 
       def get_partial_zip_file_name(zip_file_name, partial_zip_file_name)
-        partial_zip_file_name = zip_file_name.sub(/#{::File.basename(zip_file_name)}\z/,
-                                                  partial_zip_file_name + ::File.extname(zip_file_name)) unless partial_zip_file_name.nil?
+        unless partial_zip_file_name.nil?
+          partial_zip_file_name = zip_file_name.sub(/#{::File.basename(zip_file_name)}\z/,
+                                                    partial_zip_file_name + ::File.extname(zip_file_name))
+        end
         partial_zip_file_name ||= zip_file_name
         partial_zip_file_name
       end
@@ -173,9 +217,9 @@ module Zip
       # TODO: Make the code more understandable
       #
       def save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count)
-        ssegment_size = zip_file_size - zip_file.pos
-        ssegment_size = segment_size if ssegment_size > segment_size
-        szip_file_name = "#{partial_zip_file_name}.#{'%03d'%(szip_file_index)}"
+        ssegment_size  = zip_file_size - zip_file.pos
+        ssegment_size  = segment_size if ssegment_size > segment_size
+        szip_file_name = "#{partial_zip_file_name}.#{format('%03d', szip_file_index)}"
         ::File.open(szip_file_name, 'wb') do |szip_file|
           if szip_file_index == 1
             ssegment_size = put_split_signature(szip_file, segment_size)
@@ -185,7 +229,7 @@ module Zip
             segment_bytes_left = ssegment_size - chunk_bytes
             buffer_size        = segment_bytes_left < DATA_BUFFER_SIZE ? segment_bytes_left : DATA_BUFFER_SIZE
             chunk              = zip_file.read(buffer_size)
-            chunk_bytes        += buffer_size
+            chunk_bytes += buffer_size
             szip_file << chunk
             # Info for track splitting
             yield segment_count, szip_file_index, chunk_bytes, ssegment_size if block_given?
@@ -194,16 +238,24 @@ module Zip
       end
 
       # Splits an archive into parts with segment size
-      def split(zip_file_name, segment_size = MAX_SEGMENT_SIZE, delete_zip_file = true, partial_zip_file_name = nil)
-        raise ZipError, "File #{zip_file_name} not found" unless ::File.exists?(zip_file_name)
+      def split(zip_file_name,
+                dep_segment_size = MAX_SEGMENT_SIZE, dep_delete_zip_file = true, dep_partial_zip_file_name = nil,
+                segment_size: MAX_SEGMENT_SIZE, delete_zip_file: nil, 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)
+
+        if dep_segment_size != MAX_SEGMENT_SIZE || !dep_delete_zip_file || dep_partial_zip_file_name
+          Zip.warn_about_v3_api('Zip::File.split')
+        end
+
         zip_file_size = ::File.size(zip_file_name)
-        segment_size  = get_segment_size_for_split(segment_size)
+        segment_size  = get_segment_size_for_split(segment_size || dep_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
-        self.open(zip_file_name) {}
-        partial_zip_file_name = get_partial_zip_file_name(zip_file_name, partial_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 || dep_partial_zip_file_name))
         szip_file_index       = 0
         ::File.open(zip_file_name, 'rb') do |zip_file|
           until zip_file.eof?
@@ -211,33 +263,63 @@ module Zip
             save_splited_part(zip_file, partial_zip_file_name, zip_file_size, szip_file_index, segment_size, segment_count)
           end
         end
+        delete_zip_file = delete_zip_file.nil? ? dep_delete_zip_file : delete_zip_file
         ::File.delete(zip_file_name) if delete_zip_file
         szip_file_index
       end
     end
 
-
     # 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 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, permissionInt = nil, &aProc)
-      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
-      if newEntry.directory?
+    # Returns an output stream to the specified entry. If entry is not an instance
+    # of Zip::Entry, a new Zip::Entry will be initialized using the arguments
+    # 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.
+    # rubocop:disable Metrics/ParameterLists, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def get_output_stream(entry,
+                          dep_permission_int = nil, dep_comment = nil,
+                          dep_extra = nil, dep_compressed_size = nil, dep_crc = nil,
+                          dep_compression_method = nil, dep_size = nil, dep_time = nil,
+                          permission_int: nil, comment: nil,
+                          extra: nil, compressed_size: nil, crc: nil,
+                          compression_method: nil, size: nil, time: nil,
+                          &a_proc)
+
+      unless dep_permission_int.nil? && dep_comment.nil? && dep_extra.nil? &&
+             dep_compressed_size.nil? && dep_crc.nil? && dep_compression_method.nil? &&
+             dep_size.nil? && dep_time.nil?
+        Zip.warn_about_v3_api('Zip::File#get_output_stream')
+      end
+
+      new_entry =
+        if entry.kind_of?(Entry)
+          entry
+        else
+          Entry.new(@name, entry.to_s,
+                    comment:            (comment || dep_comment),
+                    extra:              (extra || dep_extra),
+                    compressed_size:    (compressed_size || dep_compressed_size),
+                    crc:                (crc || dep_crc),
+                    compression_method: (compression_method || dep_compression_method),
+                    size:               (size || dep_size),
+                    time:               (time || dep_time))
+        end
+      if new_entry.directory?
         raise ArgumentError,
-              "cannot open stream to directory entry - '#{newEntry}'"
+              "cannot open stream to directory entry - '#{new_entry}'"
       end
-      newEntry.unix_perms = permissionInt
-      zipStreamableEntry  = StreamableStream.new(newEntry)
-      @entry_set << zipStreamableEntry
-      zipStreamableEntry.get_output_stream(&aProc)
+      new_entry.unix_perms = (permission_int || dep_permission_int)
+      zip_streamable_entry = StreamableStream.new(new_entry)
+      @entry_set << zip_streamable_entry
+      zip_streamable_entry.get_output_stream(&a_proc)
     end
+    # rubocop:enable Metrics/ParameterLists, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # Returns the name of the zip archive
     def to_s
@@ -246,16 +328,24 @@ 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
-    def add(entry, srcPath, &continue_on_exists_proc)
-      continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
-      check_entry_exists(entry, continue_on_exists_proc, "add")
-      newEntry = entry.kind_of?(Entry) ? entry : Entry.new(@name, entry.to_s)
-      newEntry.gather_fileinfo_from_srcpath(srcPath)
-      @entry_set << newEntry
+    def add(entry, src_path, &continue_on_exists_proc)
+      continue_on_exists_proc ||= proc { ::Zip.continue_on_exists_proc }
+      check_entry_exists(entry, continue_on_exists_proc, 'add')
+      new_entry = entry.kind_of?(::Zip::Entry) ? entry : ::Zip::Entry.new(@name, entry.to_s)
+      new_entry.gather_fileinfo_from_srcpath(src_path)
+      new_entry.dirty = true
+      @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.
@@ -265,56 +355,69 @@ 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.
     def extract(entry, dest_path, &block)
-      block       ||= proc { ::Zip.on_exists_proc }
+      Zip.warn_about_v3_api('Zip::File#extract')
+
+      block ||= proc { ::Zip.on_exists_proc }
       found_entry = get_entry(entry)
       found_entry.extract(dest_path, &block)
     end
 
+    # Extracts `entry` to a file at `entry_path`, with `destination_directory`
+    # as the base location in the filesystem.
+    #
+    # NB: The caller is responsible for making sure `destination_directory` is
+    # safe, if it is passed.
+    def extract_v3(entry, entry_path = nil, destination_directory: '.', &block)
+      block ||= proc { ::Zip.on_exists_proc }
+      found_entry = get_entry(entry)
+      entry_path ||= found_entry.name
+      found_entry.extract_v3(entry_path, destination_directory: destination_directory, &block)
+    end
+
     # Commits changes that has been made since the previous commit to
     # the zip archive.
     def commit
-      return if !commit_required?
-      on_success_replace(name) {
-        |tmpFile|
-        OutputStream.open(tmpFile) {
-          |zos|
-
-          @entry_set.each {
-            |e|
+      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|
             e.write_to_zip_output_stream(zos)
             e.dirty = false
-          }
+            e.clean_up
+          end
           zos.comment = comment
-        }
+        end
         true
-      }
+      end
       initialize(name)
     end
 
     # Write buffer write changes to buffer and return
-    def write_buffer
-      buffer = OutputStream.write_buffer do |zos|
+    def write_buffer(io = ::StringIO.new)
+      return io unless commit_required?
+
+      ::Zip::OutputStream.write_buffer(io) do |zos|
         @entry_set.each { |e| e.write_to_zip_output_stream(zos) }
         zos.comment = comment
       end
-      return buffer
     end
 
     # Closes the zip file committing any changes that has been made.
@@ -328,13 +431,19 @@ module Zip
       @entry_set.each do |e|
         return true if e.dirty
       end
-      @comment != @storedComment || @entry_set != @storedEntries || @create == File::CREATE
+      @comment != @stored_comment || @entry_set != @stored_entries || @create
     end
 
     # 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
@@ -345,73 +454,64 @@ module Zip
     # Searches for an entry just as find_entry, but throws Errno::ENOENT
     # if no entry is found.
     def get_entry(entry)
-      selectedEntry = find_entry(entry)
-      unless selectedEntry
-        raise Errno::ENOENT, entry
-      end
-      selectedEntry.restore_ownership   = @restore_ownership
-      selectedEntry.restore_permissions = @restore_permissions
-      selectedEntry.restore_times       = @restore_times
-      selectedEntry
+      selected_entry = find_entry(entry)
+      raise Errno::ENOENT, entry if selected_entry.nil?
+
+      selected_entry
     end
 
     # Creates a directory
-    def mkdir(entryName, permissionInt = 0755)
-      if find_entry(entryName)
-        raise Errno::EEXIST, "File exists - #{entryName}"
-      end
-      entryName = entryName.dup.to_s
-      entryName << '/' unless entryName.end_with?('/')
-      @entry_set << 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 is_directory(newEntry, srcPath)
-      srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.is_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.is_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.is_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 }
-      if @entry_set.include?(entryName)
-        if continue_on_exists_proc.call
-          remove get_entry(entryName)
-        else
-          raise ZipEntryExistsError,
-                procedureName + " failed. Entry #{entryName} already exists"
-        end
+      return unless @entry_set.include?(entry_name)
+
+      if continue_on_exists_proc.call
+        remove get_entry(entry_name)
+      else
+        raise ::Zip::EntryExistsError,
+              proc_name + " failed. Entry #{entry_name} already exists"
       end
     end
 
     def check_file(path)
-      unless ::File.readable?(path)
-        raise Errno::ENOENT, path
-      end
+      raise Errno::ENOENT, path unless ::File.readable?(path)
     end
 
-    def on_success_replace(aFilename)
-      tmpfile     = get_tempfile
-      tmpFilename = tmpfile.path
-      tmpfile.close
-      if yield tmpFilename
-        ::File.rename(tmpFilename, name)
+    def on_success_replace
+      dirname, basename = ::File.split(name)
+      ::Dir::Tmpname.create(basename, dirname) do |tmp_filename|
+        begin
+          if yield tmp_filename
+            ::File.rename(tmp_filename, name)
+            ::File.chmod(@file_permissions, name) unless @create
+          end
+        ensure
+          ::File.unlink(tmp_filename) if ::File.exist?(tmp_filename)
+        end
       end
     end
-
-    def get_tempfile
-      tempFile = Tempfile.new(::File.basename(name), ::File.dirname(name))
-      tempFile.binmode
-      tempFile
-    end
-
   end
 end