rubyzip 1.0.0 → 1.2.0

data/lib/zip/file.rb

@@ -43,13 +43,13 @@ module Zip
   # interface for accessing the filesystem, ie. the File and Dir classes.
 
   class File < CentralDirectory
-
-    CREATE           = 1
-    SPLIT_SIGNATURE  = 0x08074b50
+    CREATE               = 1
+    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, :close]
 
     attr_reader :name
 
@@ -64,69 +64,78 @@ module Zip
 
     # 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(file_name, create = nil, buffer = false, options = {})
       super()
-      @name    = fileName
+      @name    = file_name
       @comment = ''
-      @create = create
+      @create  = create
       case
-      when ::File.exists?(fileName) && !buffer
+      when !buffer && ::File.size?(file_name)
         @create = nil
+        @file_permissions = ::File.stat(file_name).mode
         ::File.open(name, 'rb') do |f|
           read_from_stream(f)
         end
       when create
+        @file_permissions = create_file_permissions
         @entry_set = EntrySet.new
+      when ::File.zero?(file_name)
+        raise Error, "File #{file_name} has zero size. Did you mean to pass the create flag?"
       else
-        raise ZipError, "File #{fileName} not found"
+        raise Error, "File #{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]    || false
+      @restore_permissions = options[:restore_permissions]  || true
+      @restore_times       = options[:restore_times]        || true
     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
+      def open(file_name, create = nil)
+        zf = ::Zip::File.new(file_name, create)
+        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)
+        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}"
+      def open_buffer(io, options = {})
+        unless IO_METHODS.map { |method| io.respond_to?(method) }.all? || io.is_a?(String)
+          raise "Zip::File.open_buffer expects a String or IO-like argument (responds to #{IO_METHODS.join(', ')}). Found: #{io.class}"
         end
-        zf = ::Zip::File.new('', true, true)
-        if io.is_a(::String)
+        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
+        zf = ::Zip::File.new(io, true, true, options)
         zf.read_from_stream(io)
         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
@@ -173,9 +182,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 +194,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?
@@ -195,14 +204,14 @@ module Zip
 
       # 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)
+        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
-        self.open(zip_file_name) {}
+        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|
@@ -216,7 +225,6 @@ module Zip
       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.
@@ -224,19 +232,26 @@ module Zip
       get_entry(entry).get_input_stream(&aProc)
     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.
+    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)
+      new_entry =
+        if entry.kind_of?(Entry)
+          entry
+        else
+          Entry.new(@name, entry.to_s, comment, extra, compressed_size, crc, compression_method, size, 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
+      zip_streamable_entry = StreamableStream.new(new_entry)
+      @entry_set << zip_streamable_entry
+      zip_streamable_entry.get_output_stream(&aProc)
     end
 
     # Returns the name of the zip archive
@@ -250,12 +265,13 @@ module Zip
     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
 
     # Removes the specified entry.
@@ -282,7 +298,7 @@ module Zip
 
     # Extracts entry to file dest_path.
     def extract(entry, dest_path, &block)
-      block       ||= proc { ::Zip.on_exists_proc }
+      block ||= proc { ::Zip.on_exists_proc }
       found_entry = get_entry(entry)
       found_entry.extract(dest_path, &block)
     end
@@ -290,31 +306,27 @@ module Zip
     # 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 unless 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(''))
+      ::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,7 +340,7 @@ 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 == ::Zip::File::CREATE
     end
 
     # Searches for entry with the specified name. Returns nil if
@@ -345,73 +357,73 @@ 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 unless selected_entry
+      selected_entry.restore_ownership   = @restore_ownership
+      selected_entry.restore_permissions = @restore_permissions
+      selected_entry.restore_times       = @restore_times
+      selected_entry
     end
 
     # Creates a directory
     def mkdir(entryName, permissionInt = 0755)
-      if find_entry(entryName)
-        raise Errno::EEXIST, "File exists - #{entryName}"
-      end
+      raise Errno::EEXIST, "File exists - #{entryName}" if find_entry(entryName)
       entryName = entryName.dup.to_s
       entryName << '/' unless entryName.end_with?('/')
-      @entry_set << StreamableDirectory.new(@name, entryName, nil, permissionInt)
+      @entry_set << ::Zip::StreamableDirectory.new(@name, entryName, nil, permissionInt)
     end
 
     private
 
-    def is_directory(newEntry, srcPath)
+    def directory?(newEntry, srcPath)
       srcPathIsDirectory = ::File.directory?(srcPath)
-      if newEntry.is_directory && !srcPathIsDirectory
+      if newEntry.directory? && !srcPathIsDirectory
         raise ArgumentError,
-              "entry name '#{newEntry}' indicates directory entry, but "+
-                "'#{srcPath}' is not a directory"
-      elsif !newEntry.is_directory && srcPathIsDirectory
-        newEntry.name += "/"
+              "entry name '#{newEntry}' indicates directory entry, but " \
+                  "'#{srcPath}' is not a directory"
+      elsif !newEntry.directory? && srcPathIsDirectory
+        newEntry.name += '/'
       end
-      newEntry.is_directory && srcPathIsDirectory
+      newEntry.directory? && srcPathIsDirectory
     end
 
     def check_entry_exists(entryName, continue_on_exists_proc, procedureName)
       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?(entryName)
+      if continue_on_exists_proc.call
+        remove get_entry(entryName)
+      else
+        raise ::Zip::EntryExistsError,
+              procedureName + " failed. Entry #{entryName} 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
+      tmp_filename = create_tmpname
+      if yield tmp_filename
+        ::File.rename(tmp_filename, name)
+        ::File.chmod(@file_permissions, name) if defined?(@file_permissions)
       end
+    ensure
+      ::File.unlink(tmp_filename) if ::File.exist?(tmp_filename)
     end
 
-    def get_tempfile
-      tempFile = Tempfile.new(::File.basename(name), ::File.dirname(name))
-      tempFile.binmode
-      tempFile
+    def create_tmpname
+      dirname, basename = ::File.split(name)
+      ::Dir::Tmpname.create(basename, dirname) do |tmpname|
+        opts = {perm: 0600, mode: ::File::CREAT | ::File::WRONLY | ::File::EXCL}
+        f = File.open(tmpname, opts)
+        f.close
+      end
     end
 
+    def create_file_permissions
+      ::Zip::RUNNING_ON_WINDOWS ? 0644 : 0666 - ::File.umask
+    end
   end
 end