rubyzip 2.4.1 → 3.0.0.rc1

data/lib/zip/input_stream.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+##
 module Zip
   # InputStream is the basic class for reading zip entries in a
   # zip file. It is possible to create a InputStream object directly,
@@ -37,9 +40,8 @@ module Zip
   #
   # java.util.zip.ZipInputStream is the original inspiration for this
   # class.
-
   class InputStream
-    CHUNK_SIZE = 32_768
+    CHUNK_SIZE = 32_768 # :nodoc:
 
     include ::Zip::IOExtras::AbstractInputStream
 
@@ -49,34 +51,35 @@ module Zip
     #
     # @param context [String||IO||StringIO] file path or IO/StringIO object
     # @param offset [Integer] offset in the IO/StringIO
-    def initialize(context, dep_offset = 0, dep_decrypter = nil, offset: 0, decrypter: nil)
+    def initialize(context, offset: 0, decrypter: nil)
       super()
-
-      if !dep_offset.zero? || !dep_decrypter.nil?
-        Zip.warn_about_v3_api('Zip::InputStream.new')
-      end
-
-      offset         = dep_offset if offset.zero?
-      @archive_io    = get_io(context, offset)
-      @decompressor  = ::Zip::NullDecompressor
-      @decrypter     = decrypter || dep_decrypter || ::Zip::NullDecrypter.new
+      @archive_io = get_io(context, offset)
+      @decompressor = ::Zip::NullDecompressor
+      @decrypter = decrypter || ::Zip::NullDecrypter.new
       @current_entry = nil
+      @complete_entry = nil
     end
 
+    # Close this InputStream. All further IO will raise an IOError.
     def close
       @archive_io.close
     end
 
-    # Returns a Entry object. It is necessary to call this
-    # method on a newly created InputStream before reading from
-    # the first entry in the archive. Returns nil when there are
-    # no more entries.
+    # Returns an Entry object and positions the stream at the beginning of
+    # the entry data. It is necessary to call this method on a newly created
+    # InputStream before reading from the first entry in the archive.
+    # Returns nil when there are no more entries.
     def get_next_entry
-      @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET) if @current_entry
+      unless @current_entry.nil?
+        raise StreamingError, @current_entry if @current_entry.incomplete?
+
+        @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET)
+      end
+
       open_entry
     end
 
-    # Rewinds the stream to the beginning of the current entry
+    # Rewinds the stream to the beginning of the current entry.
     def rewind
       return if @current_entry.nil?
 
@@ -91,18 +94,19 @@ module Zip
       @decompressor.read(length, outbuf)
     end
 
+    # Returns the size of the current entry, or `nil` if there isn't one.
+    def size
+      return if @current_entry.nil?
+
+      @current_entry.size
+    end
+
     class << self
       # Same as #initialize but if a block is passed the opened
       # stream is passed to the block and closed when the block
       # returns.
-      def open(filename_or_io, dep_offset = 0, dep_decrypter = nil, offset: 0, decrypter: nil)
-        if !dep_offset.zero? || !dep_decrypter.nil?
-          Zip.warn_about_v3_api('Zip::InputStream.new')
-        end
-
-        offset = dep_offset if offset.zero?
-
-        zio = new(filename_or_io, offset: offset, decrypter: decrypter || dep_decrypter)
+      def open(filename_or_io, offset: 0, decrypter: nil)
+        zio = new(filename_or_io, offset: offset, decrypter: decrypter)
         return zio unless block_given?
 
         begin
@@ -111,17 +115,11 @@ module Zip
           zio.close if zio
         end
       end
-
-      def open_buffer(filename_or_io, offset = 0)
-        Zip.warn_about_v3_api('Zip::InputStream.open_buffer')
-
-        ::Zip::InputStream.open(filename_or_io, offset)
-      end
     end
 
     protected
 
-    def get_io(io_or_file, offset = 0)
+    def get_io(io_or_file, offset = 0) # :nodoc:
       if io_or_file.respond_to?(:seek)
         io = io_or_file.dup
         io.seek(offset, ::IO::SEEK_SET)
@@ -133,56 +131,58 @@ module Zip
       end
     end
 
-    def open_entry
+    def open_entry # :nodoc:
       @current_entry = ::Zip::Entry.read_local_entry(@archive_io)
-      if @current_entry && @current_entry.encrypted? && @decrypter.kind_of?(NullEncrypter)
-        raise Error, 'password required to decode zip file'
+      return if @current_entry.nil?
+
+      if @current_entry.encrypted? && @decrypter.kind_of?(NullDecrypter)
+        raise Error,
+              'A password is required to decode this zip file'
       end
 
-      if @current_entry && @current_entry.incomplete? && @current_entry.crc == 0 \
-        && @current_entry.compressed_size == 0 \
-        && @current_entry.size == 0 && !@complete_entry
-        raise GPFBit3Error,
-              'General purpose flag Bit 3 is set so not possible to get proper info from local header.' \
-              'Please use ::Zip::File instead of ::Zip::InputStream'
+      if @current_entry.incomplete? && @current_entry.compressed_size == 0 && !@complete_entry
+        raise StreamingError, @current_entry
       end
+
       @decrypted_io = get_decrypted_io
       @decompressor = get_decompressor
       flush
       @current_entry
     end
 
-    def get_decrypted_io
+    def get_decrypted_io # :nodoc:
       header = @archive_io.read(@decrypter.header_bytesize)
       @decrypter.reset!(header)
 
       ::Zip::DecryptedIo.new(@archive_io, @decrypter)
     end
 
-    def get_decompressor
+    def get_decompressor # :nodoc:
       return ::Zip::NullDecompressor if @current_entry.nil?
 
       decompressed_size =
-        if @current_entry.incomplete? && @current_entry.crc == 0 && @current_entry.size == 0 && @complete_entry
+        if @current_entry.incomplete? && @current_entry.crc == 0 &&
+           @current_entry.size == 0 && @complete_entry
           @complete_entry.size
         else
           @current_entry.size
         end
 
-      decompressor_class = ::Zip::Decompressor.find_by_compression_method(@current_entry.compression_method)
+      decompressor_class = ::Zip::Decompressor.find_by_compression_method(
+        @current_entry.compression_method
+      )
       if decompressor_class.nil?
-        raise ::Zip::CompressionMethodError,
-              "Unsupported compression method #{@current_entry.compression_method}"
+        raise ::Zip::CompressionMethodError, @current_entry.compression_method
       end
 
       decompressor_class.new(@decrypted_io, decompressed_size)
     end
 
-    def produce_input
+    def produce_input # :nodoc:
       @decompressor.read(CHUNK_SIZE)
     end
 
-    def input_finished?
+    def input_finished? # :nodoc:
       @decompressor.eof
     end
   end

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Zip
-  module IOExtras
+  module IOExtras # :nodoc:
     # Implements many of the convenience methods of IO
     # such as gets, getc, readline and readlines
     # depends on: input_finished?, produce_input and read
-    module AbstractInputStream
+    module AbstractInputStream # :nodoc:
       include Enumerable
       include FakeIO
 
@@ -11,22 +13,22 @@ module Zip
         super
         @lineno        = 0
         @pos           = 0
-        @output_buffer = ''.b
+        @output_buffer = +''
       end
 
       attr_accessor :lineno
       attr_reader :pos
 
-      def read(number_of_bytes = nil, buf = ''.b)
+      def read(number_of_bytes = nil, buf = +'')
         tbuf = if @output_buffer.bytesize > 0
-                 if number_of_bytes <= @output_buffer.bytesize
+                 if number_of_bytes && number_of_bytes <= @output_buffer.bytesize
                    @output_buffer.slice!(0, number_of_bytes)
                  else
                    number_of_bytes -= @output_buffer.bytesize if number_of_bytes
                    rbuf = sysread(number_of_bytes, buf)
                    out  = @output_buffer
                    out << rbuf if rbuf
-                   @output_buffer = ''.b
+                   @output_buffer = ''
                    out
                  end
                else
@@ -34,7 +36,7 @@ module Zip
                end
 
         if tbuf.nil? || tbuf.empty?
-          return nil if number_of_bytes
+          return nil if number_of_bytes&.positive?
 
           return ''
         end
@@ -74,15 +76,18 @@ module Zip
         a_sep_string = "#{$INPUT_RECORD_SEPARATOR}#{$INPUT_RECORD_SEPARATOR}" if a_sep_string.empty?
 
         buffer_index = 0
-        over_limit   = (number_of_bytes && @output_buffer.bytesize >= number_of_bytes)
+        over_limit   = number_of_bytes && @output_buffer.bytesize >= number_of_bytes
         while (match_index = @output_buffer.index(a_sep_string, buffer_index)).nil? && !over_limit
           buffer_index = [buffer_index, @output_buffer.bytesize - a_sep_string.bytesize].max
           return @output_buffer.empty? ? nil : flush if input_finished?
 
           @output_buffer << produce_input
-          over_limit = (number_of_bytes && @output_buffer.bytesize >= number_of_bytes)
+          over_limit = number_of_bytes && @output_buffer.bytesize >= number_of_bytes
         end
-        sep_index = [match_index + a_sep_string.bytesize, number_of_bytes || @output_buffer.bytesize].min
+        sep_index = [
+          match_index + a_sep_string.bytesize,
+          number_of_bytes || @output_buffer.bytesize
+        ].min
         @pos += sep_index
         @output_buffer.slice!(0...sep_index)
       end
@@ -93,7 +98,7 @@ module Zip
 
       def flush
         ret_val        = @output_buffer
-        @output_buffer = ''.b
+        @output_buffer = +''
         ret_val
       end
 

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Zip
-  module IOExtras
+  module IOExtras # :nodoc:
     # Implements many of the output convenience methods of IO.
     # relies on <<
-    module AbstractOutputStream
+    module AbstractOutputStream # :nodoc:
       include FakeIO
 
       def write(data)
@@ -11,7 +13,7 @@ module Zip
       end
 
       def print(*params)
-        self << params.join($OUTPUT_FIELD_SEPARATOR) << $OUTPUT_RECORD_SEPARATOR.to_s
+        self << params.join << $OUTPUT_RECORD_SEPARATOR.to_s
       end
 
       def printf(a_format_string, *params)

data/lib/zip/ioextras.rb

@@ -1,26 +1,26 @@
+# frozen_string_literal: true
+
 module Zip
-  module IOExtras #:nodoc:
+  module IOExtras # :nodoc:
     CHUNK_SIZE = 131_072
 
-    RANGE_ALL = 0..-1
-
     class << self
       def copy_stream(ostream, istream)
-        ostream.write(istream.read(CHUNK_SIZE, ''.b)) until istream.eof?
+        ostream.write(istream.read(CHUNK_SIZE, +'')) until istream.eof?
       end
 
       def copy_stream_n(ostream, istream, nbytes)
         toread = nbytes
         while toread > 0 && !istream.eof?
-          tr = toread > CHUNK_SIZE ? CHUNK_SIZE : toread
-          ostream.write(istream.read(tr, ''.b))
+          tr = [toread, CHUNK_SIZE].min
+          ostream.write(istream.read(tr, +''))
           toread -= tr
         end
       end
     end
 
     # Implements kind_of? in order to pretend to be an IO object
-    module FakeIO
+    module FakeIO # :nodoc:
       def kind_of?(object)
         object == IO || super
       end

data/lib/zip/null_compressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class NullCompressor < Compressor #:nodoc:all
+  class NullCompressor < Compressor # :nodoc:all
     include Singleton
 
     def <<(_data)

data/lib/zip/null_decompressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullDecompressor #:nodoc:all
+  module NullDecompressor # :nodoc:all
     module_function
 
     def read(_length = nil, _outbuf = nil)

data/lib/zip/null_input_stream.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  module NullInputStream #:nodoc:all
+  module NullInputStream # :nodoc:all
     include ::Zip::NullDecompressor
     include ::Zip::IOExtras::AbstractInputStream
   end

data/lib/zip/output_stream.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+##
 module Zip
   # ZipOutputStream is the basic class for writing zip files. It is
   # possible to create a ZipOutputStream object directly, passing
@@ -16,57 +21,49 @@ module Zip
   #
   # java.util.zip.ZipOutputStream is the original inspiration for this
   # class.
-
   class OutputStream
+    extend Forwardable
     include ::Zip::IOExtras::AbstractOutputStream
 
-    attr_accessor :comment
+    def_delegators :@cdir, :comment, :comment=
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(file_name, dep_stream = false, dep_encrypter = nil, stream: false, encrypter: nil)
+    def initialize(file_name, stream: false, encrypter: nil)
       super()
-
-      Zip.warn_about_v3_api('Zip::OutputStream.new') if dep_stream || !dep_encrypter.nil?
-
       @file_name = file_name
-      @output_stream = if stream || dep_stream
-                         iostream = @file_name.dup
+      @output_stream = if stream
+                         iostream = Zip::RUNNING_ON_WINDOWS ? @file_name : @file_name.dup
                          iostream.reopen(@file_name)
                          iostream.rewind
                          iostream
                        else
                          ::File.new(@file_name, 'wb')
                        end
-      @entry_set = ::Zip::EntrySet.new
+      @cdir = ::Zip::CentralDirectory.new
       @compressor = ::Zip::NullCompressor.instance
-      @encrypter = encrypter || dep_encrypter || ::Zip::NullEncrypter.new
+      @encrypter = encrypter || ::Zip::NullEncrypter.new
       @closed = false
       @current_entry = nil
-      @comment = nil
     end
 
-    # Same as #initialize but if a block is passed the opened
-    # stream is passed to the block and closed when the block
-    # returns.
     class << self
-      def open(file_name, dep_encrypter = nil, encrypter: nil)
+      # Same as #initialize but if a block is passed the opened
+      # stream is passed to the block and closed when the block
+      # returns.
+      def open(file_name, encrypter: nil)
         return new(file_name) unless block_given?
 
-        Zip.warn_about_v3_api('Zip::OutputStream.open') unless dep_encrypter.nil?
-
-        zos = new(file_name, stream: false, encrypter: (encrypter || dep_encrypter))
+        zos = new(file_name, stream: false, encrypter: encrypter)
         yield zos
       ensure
         zos.close if zos
       end
 
       # Same as #open but writes to a filestream instead
-      def write_buffer(io = ::StringIO.new, dep_encrypter = nil, encrypter: nil)
-        Zip.warn_about_v3_api('Zip::OutputStream.write_buffer') unless dep_encrypter.nil?
-
+      def write_buffer(io = ::StringIO.new, encrypter: nil)
         io.binmode if io.respond_to?(:binmode)
-        zos = new(io, stream: true, encrypter: (encrypter || dep_encrypter))
+        zos = new(io, stream: true, encrypter: encrypter)
         yield zos
         zos.close_buffer
       end
@@ -78,7 +75,7 @@ module Zip
 
       finalize_current_entry
       update_local_headers
-      write_central_directory
+      @cdir.write_to_stream(@output_stream)
       @output_stream.close
       @closed = true
     end
@@ -89,37 +86,41 @@ module Zip
 
       finalize_current_entry
       update_local_headers
-      write_central_directory
+      @cdir.write_to_stream(@output_stream)
       @closed = true
+      @output_stream.flush
       @output_stream
     end
 
     # Closes the current entry and opens a new for writing.
     # +entry+ can be a ZipEntry object or a string.
-    def put_next_entry(entry_name, comment = nil, extra = nil, compression_method = Entry::DEFLATED, level = Zip.default_compression)
+    def put_next_entry(
+      entry_name, comment = '', extra = ExtraField.new,
+      compression_method = Entry::DEFLATED, level = Zip.default_compression
+    )
       raise Error, 'zip stream is closed' if @closed
 
-      new_entry = if entry_name.kind_of?(Entry)
-                    entry_name
-                  else
-                    Entry.new(@file_name, entry_name.to_s)
-                  end
-      new_entry.comment = comment unless comment.nil?
-      unless extra.nil?
-        new_entry.extra = extra.kind_of?(ExtraField) ? extra : ExtraField.new(extra.to_s)
-      end
-      new_entry.compression_method = compression_method unless compression_method.nil?
-      init_next_entry(new_entry, level)
+      new_entry =
+        if entry_name.kind_of?(Entry) || entry_name.kind_of?(StreamableStream)
+          entry_name
+        else
+          Entry.new(
+            @file_name, entry_name.to_s, comment: comment, extra: extra,
+            compression_method: compression_method, compression_level: level
+          )
+        end
+
+      init_next_entry(new_entry)
       @current_entry = new_entry
     end
 
-    def copy_raw_entry(entry)
+    def copy_raw_entry(entry) # :nodoc:
       entry = entry.dup
       raise Error, 'zip stream is closed' if @closed
       raise Error, 'entry is not a ZipEntry' unless entry.kind_of?(Entry)
 
       finalize_current_entry
-      @entry_set << entry
+      @cdir << entry
       src_pos = entry.local_header_offset
       entry.write_local_entry(@output_stream)
       @compressor = NullCompressor.instance
@@ -138,55 +139,53 @@ module Zip
       return unless @current_entry
 
       finish
-      @current_entry.compressed_size = @output_stream.tell - \
-                                       @current_entry.local_header_offset - \
+      @current_entry.compressed_size = @output_stream.tell -
+                                       @current_entry.local_header_offset -
                                        @current_entry.calculate_local_header_size
       @current_entry.size = @compressor.size
       @current_entry.crc = @compressor.crc
-      @output_stream << @encrypter.data_descriptor(@current_entry.crc, @current_entry.compressed_size, @current_entry.size)
+      @output_stream << @encrypter.data_descriptor(
+        @current_entry.crc,
+        @current_entry.compressed_size,
+        @current_entry.size
+      )
       @current_entry.gp_flags |= @encrypter.gp_flags
       @current_entry = nil
       @compressor = ::Zip::NullCompressor.instance
     end
 
-    def init_next_entry(entry, level = Zip.default_compression)
+    def init_next_entry(entry)
       finalize_current_entry
-      @entry_set << entry
+      @cdir << entry
       entry.write_local_entry(@output_stream)
       @encrypter.reset!
       @output_stream << @encrypter.header(entry.mtime)
-      @compressor = get_compressor(entry, level)
+      @compressor = get_compressor(entry)
     end
 
-    def get_compressor(entry, level)
+    def get_compressor(entry)
       case entry.compression_method
       when Entry::DEFLATED
-        ::Zip::Deflater.new(@output_stream, level, @encrypter)
+        ::Zip::Deflater.new(@output_stream, entry.compression_level, @encrypter)
       when Entry::STORED
         ::Zip::PassThruCompressor.new(@output_stream)
       else
-        raise ::Zip::CompressionMethodError,
-              "Invalid compression method: '#{entry.compression_method}'"
+        raise ::Zip::CompressionMethodError, entry.compression_method
       end
     end
 
     def update_local_headers
       pos = @output_stream.pos
-      @entry_set.each do |entry|
+      @cdir.each do |entry|
         @output_stream.pos = entry.local_header_offset
-        entry.write_local_entry(@output_stream, true)
+        entry.write_local_entry(@output_stream, rewrite: true)
       end
       @output_stream.pos = pos
     end
 
-    def write_central_directory
-      cdir = CentralDirectory.new(@entry_set, @comment)
-      cdir.write_to_stream(@output_stream)
-    end
-
     protected
 
-    def finish
+    def finish # :nodoc:
       @compressor.finish
     end
 

data/lib/zip/pass_thru_compressor.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class PassThruCompressor < Compressor #:nodoc:all
+  class PassThruCompressor < Compressor # :nodoc:all
     def initialize(output_stream)
       super()
       @output_stream = output_stream

data/lib/zip/pass_thru_decompressor.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Zip
-  class PassThruDecompressor < Decompressor #:nodoc:all
+  class PassThruDecompressor < Decompressor # :nodoc:all
     def initialize(*args)
       super
       @read_so_far = 0
     end
 
-    def read(length = nil, outbuf = ''.b)
+    def read(length = nil, outbuf = +'')
       return (length.nil? || length.zero? ? '' : nil) if eof
 
       if length.nil? || (@read_so_far + length) > decompressed_size

data/lib/zip/streamable_directory.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Zip
-  class StreamableDirectory < Entry
+  class StreamableDirectory < Entry # :nodoc:
     def initialize(zipfile, entry, src_path = nil, permission = nil)
       super(zipfile, entry)
 

data/lib/zip/streamable_stream.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Zip
   class StreamableStream < DelegateClass(Entry) # :nodoc:all
     def initialize(entry)
@@ -42,6 +44,7 @@ module Zip
     end
 
     def clean_up
+      super
       @temp_file.unlink
     end
   end

data/lib/zip/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Zip
-  VERSION = '2.4.1'
+  VERSION = '3.0.0.rc1' # :nodoc:
 end