rubyzip 1.3.0 → 2.4.1

data/lib/zip/inflater.rb

@@ -1,64 +1,52 @@
 module Zip
   class Inflater < Decompressor #:nodoc:all
-    def initialize(input_stream, decrypter = NullDecrypter.new)
-      super(input_stream)
-      @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      @output_buffer           = ''.dup
-      @has_returned_empty_string = false
-      @decrypter = decrypter
-    end
+    def initialize(*args)
+      super
 
-    def sysread(number_of_bytes = nil, buf = '')
-      readEverything = number_of_bytes.nil?
-      while readEverything || @output_buffer.bytesize < number_of_bytes
-        break if internal_input_finished?
-        @output_buffer << internal_produce_input(buf)
-      end
-      return value_when_finished if @output_buffer.bytesize == 0 && input_finished?
-      end_index = number_of_bytes.nil? ? @output_buffer.bytesize : number_of_bytes
-      @output_buffer.slice!(0...end_index)
+      @buffer = ''.b
+      @zlib_inflater = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
     end
 
-    def produce_input
-      if @output_buffer.empty?
-        internal_produce_input
-      else
-        @output_buffer.slice!(0...(@output_buffer.length))
+    def read(length = nil, outbuf = ''.b)
+      return (length.nil? || length.zero? ? '' : nil) if eof
+
+      while length.nil? || (@buffer.bytesize < length)
+        break if input_finished?
+
+        @buffer << produce_input
       end
+
+      outbuf.replace(@buffer.slice!(0...(length || @buffer.bytesize)))
     end
 
-    # to be used with produce_input, not read (as read may still have more data cached)
-    # is data cached anywhere other than @outputBuffer?  the comment above may be wrong
-    def input_finished?
-      @output_buffer.empty? && internal_input_finished?
+    def eof
+      @buffer.empty? && input_finished?
     end
 
-    alias :eof input_finished?
-    alias :eof? input_finished?
+    alias eof? eof
 
     private
 
-    def internal_produce_input(buf = '')
+    def produce_input
       retried = 0
       begin
-        @zlib_inflater.inflate(@decrypter.decrypt(@input_stream.read(Decompressor::CHUNK_SIZE, buf)))
+        @zlib_inflater.inflate(input_stream.read(Decompressor::CHUNK_SIZE))
       rescue Zlib::BufError
         raise if retried >= 5 # how many times should we retry?
+
         retried += 1
         retry
       end
+    rescue Zlib::Error
+      raise(::Zip::DecompressionError, 'zlib error while inflating')
     end
 
-    def internal_input_finished?
+    def input_finished?
       @zlib_inflater.finished?
     end
-
-    def value_when_finished # mimic behaviour of ruby File object.
-      return if @has_returned_empty_string
-      @has_returned_empty_string = true
-      ''
-    end
   end
+
+  ::Zip::Decompressor.register(::Zip::COMPRESSION_METHOD_DEFLATE, ::Zip::Inflater)
 end
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard

data/lib/zip/input_stream.rb

@@ -39,6 +39,8 @@ module Zip
   # class.
 
   class InputStream
+    CHUNK_SIZE = 32_768
+
     include ::Zip::IOExtras::AbstractInputStream
 
     # Opens the indicated zip file. An exception is thrown
@@ -47,11 +49,17 @@ module Zip
     #
     # @param context [String||IO||StringIO] file path or IO/StringIO object
     # @param offset [Integer] offset in the IO/StringIO
-    def initialize(context, offset = 0, decrypter = nil)
+    def initialize(context, dep_offset = 0, dep_decrypter = nil, offset: 0, decrypter: nil)
       super()
-      @archive_io = get_io(context, offset)
+
+      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 || ::Zip::NullDecrypter.new
+      @decrypter     = decrypter || dep_decrypter || ::Zip::NullDecrypter.new
       @current_entry = nil
     end
 
@@ -71,6 +79,7 @@ module Zip
     # Rewinds the stream to the beginning of the current entry
     def rewind
       return if @current_entry.nil?
+
       @lineno = 0
       @pos    = 0
       @archive_io.seek(@current_entry.local_header_offset, IO::SEEK_SET)
@@ -78,23 +87,24 @@ module Zip
     end
 
     # Modeled after IO.sysread
-    def sysread(number_of_bytes = nil, buf = nil)
-      @decompressor.sysread(number_of_bytes, buf)
+    def sysread(length = nil, outbuf = '')
+      @decompressor.read(length, outbuf)
     end
 
-    def eof
-      @output_buffer.empty? && @decompressor.eof
-    end
-
-    alias :eof? eof
-
     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, offset = 0, decrypter = nil)
-        zio = new(filename_or_io, offset, decrypter)
+      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)
         return zio unless block_given?
+
         begin
           yield zio
         ensure
@@ -103,8 +113,9 @@ module Zip
       end
 
       def open_buffer(filename_or_io, offset = 0)
-        puts 'open_buffer is deprecated!!! Use open instead!'
-        open(filename_or_io, offset)
+        Zip.warn_about_v3_api('Zip::InputStream.open_buffer')
+
+        ::Zip::InputStream.open(filename_or_io, offset)
       end
     end
 
@@ -124,46 +135,55 @@ module Zip
 
     def open_entry
       @current_entry = ::Zip::Entry.read_local_entry(@archive_io)
-      if @current_entry && @current_entry.gp_flags & 1 == 1 && @decrypter.is_a?(NullEncrypter)
+      if @current_entry && @current_entry.encrypted? && @decrypter.kind_of?(NullEncrypter)
         raise Error, 'password required to decode zip file'
       end
-      if @current_entry && @current_entry.gp_flags & 8 == 8 && @current_entry.crc == 0 \
+
+      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'
       end
+      @decrypted_io = get_decrypted_io
       @decompressor = get_decompressor
       flush
       @current_entry
     end
 
+    def get_decrypted_io
+      header = @archive_io.read(@decrypter.header_bytesize)
+      @decrypter.reset!(header)
+
+      ::Zip::DecryptedIo.new(@archive_io, @decrypter)
+    end
+
     def get_decompressor
-      if @current_entry.nil?
-        ::Zip::NullDecompressor
-      elsif @current_entry.compression_method == ::Zip::Entry::STORED
-        if @current_entry.gp_flags & 8 == 8 && @current_entry.crc == 0 && @current_entry.size == 0 && @complete_entry
-          ::Zip::PassThruDecompressor.new(@archive_io, @complete_entry.size)
+      return ::Zip::NullDecompressor if @current_entry.nil?
+
+      decompressed_size =
+        if @current_entry.incomplete? && @current_entry.crc == 0 && @current_entry.size == 0 && @complete_entry
+          @complete_entry.size
         else
-          ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
+          @current_entry.size
         end
-      elsif @current_entry.compression_method == ::Zip::Entry::DEFLATED
-        header = @archive_io.read(@decrypter.header_bytesize)
-        @decrypter.reset!(header)
-        ::Zip::Inflater.new(@archive_io, @decrypter)
-      else
+
+      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}"
       end
+
+      decompressor_class.new(@decrypted_io, decompressed_size)
     end
 
     def produce_input
-      @decompressor.produce_input
+      @decompressor.read(CHUNK_SIZE)
     end
 
     def input_finished?
-      @decompressor.input_finished?
+      @decompressor.eof
     end
   end
 end

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -11,13 +11,13 @@ module Zip
         super
         @lineno        = 0
         @pos           = 0
-        @output_buffer = ''
+        @output_buffer = ''.b
       end
 
       attr_accessor :lineno
       attr_reader :pos
 
-      def read(number_of_bytes = nil, buf = '')
+      def read(number_of_bytes = nil, buf = ''.b)
         tbuf = if @output_buffer.bytesize > 0
                  if number_of_bytes <= @output_buffer.bytesize
                    @output_buffer.slice!(0, number_of_bytes)
@@ -26,7 +26,7 @@ module Zip
                    rbuf = sysread(number_of_bytes, buf)
                    out  = @output_buffer
                    out << rbuf if rbuf
-                   @output_buffer = ''
+                   @output_buffer = ''.b
                    out
                  end
                else
@@ -35,6 +35,7 @@ module Zip
 
         if tbuf.nil? || tbuf.empty?
           return nil if number_of_bytes
+
           return ''
         end
 
@@ -48,13 +49,13 @@ module Zip
         buf
       end
 
-      def readlines(a_sep_string = $/)
+      def readlines(a_sep_string = $INPUT_RECORD_SEPARATOR)
         ret_val = []
         each_line(a_sep_string) { |line| ret_val << line }
         ret_val
       end
 
-      def gets(a_sep_string = $/, number_of_bytes = nil)
+      def gets(a_sep_string = $INPUT_RECORD_SEPARATOR, number_of_bytes = nil)
         @lineno = @lineno.next
 
         if number_of_bytes.respond_to?(:to_int)
@@ -62,20 +63,22 @@ module Zip
           a_sep_string = a_sep_string.to_str if a_sep_string
         elsif a_sep_string.respond_to?(:to_int)
           number_of_bytes = a_sep_string.to_int
-          a_sep_string    = $/
+          a_sep_string    = $INPUT_RECORD_SEPARATOR
         else
           number_of_bytes = nil
           a_sep_string = a_sep_string.to_str if a_sep_string
         end
 
         return read(number_of_bytes) if a_sep_string.nil?
-        a_sep_string = "#{$/}#{$/}" if a_sep_string.empty?
+
+        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)
         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)
         end
@@ -90,22 +93,30 @@ module Zip
 
       def flush
         ret_val        = @output_buffer
-        @output_buffer = ''
+        @output_buffer = ''.b
         ret_val
       end
 
-      def readline(a_sep_string = $/)
+      def readline(a_sep_string = $INPUT_RECORD_SEPARATOR)
         ret_val = gets(a_sep_string)
         raise EOFError unless ret_val
+
         ret_val
       end
 
-      def each_line(a_sep_string = $/)
-        yield readline(a_sep_string) while true
+      def each_line(a_sep_string = $INPUT_RECORD_SEPARATOR)
+        loop { yield readline(a_sep_string) }
       rescue EOFError
+        # We just need to catch this; we don't need to handle it.
+      end
+
+      alias each each_line
+
+      def eof
+        @output_buffer.empty? && input_finished?
       end
 
-      alias_method :each, :each_line
+      alias eof? eof
     end
   end
 end

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -11,7 +11,7 @@ module Zip
       end
 
       def print(*params)
-        self << params.join($,) << $\.to_s
+        self << params.join($OUTPUT_FIELD_SEPARATOR) << $OUTPUT_RECORD_SEPARATOR.to_s
       end
 
       def printf(a_format_string, *params)

data/lib/zip/ioextras.rb

@@ -6,14 +6,14 @@ module Zip
 
     class << self
       def copy_stream(ostream, istream)
-        ostream.write(istream.read(CHUNK_SIZE, '')) until istream.eof?
+        ostream.write(istream.read(CHUNK_SIZE, ''.b)) 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, ''))
+          ostream.write(istream.read(tr, ''.b))
           toread -= tr
         end
       end
@@ -25,7 +25,7 @@ module Zip
         object == IO || super
       end
     end
-  end # IOExtras namespace module
+  end
 end
 
 require 'zip/ioextras/abstract_input_stream'

data/lib/zip/null_decompressor.rb

@@ -2,18 +2,10 @@ module Zip
   module NullDecompressor #:nodoc:all
     module_function
 
-    def sysread(_numberOfBytes = nil, _buf = nil)
+    def read(_length = nil, _outbuf = nil)
       nil
     end
 
-    def produce_input
-      nil
-    end
-
-    def input_finished?
-      true
-    end
-
     def eof
       true
     end

data/lib/zip/output_stream.rb

@@ -24,10 +24,13 @@ module Zip
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(file_name, stream = false, encrypter = nil)
+    def initialize(file_name, dep_stream = false, dep_encrypter = nil, 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
+      @output_stream = if stream || dep_stream
                          iostream = @file_name.dup
                          iostream.reopen(@file_name)
                          iostream.rewind
@@ -37,7 +40,7 @@ module Zip
                        end
       @entry_set = ::Zip::EntrySet.new
       @compressor = ::Zip::NullCompressor.instance
-      @encrypter = encrypter || ::Zip::NullEncrypter.new
+      @encrypter = encrypter || dep_encrypter || ::Zip::NullEncrypter.new
       @closed = false
       @current_entry = nil
       @comment = nil
@@ -47,17 +50,23 @@ module Zip
     # stream is passed to the block and closed when the block
     # returns.
     class << self
-      def open(file_name, encrypter = nil)
+      def open(file_name, dep_encrypter = nil, encrypter: nil)
         return new(file_name) unless block_given?
-        zos = new(file_name, false, encrypter)
+
+        Zip.warn_about_v3_api('Zip::OutputStream.open') unless dep_encrypter.nil?
+
+        zos = new(file_name, stream: false, encrypter: (encrypter || dep_encrypter))
         yield zos
       ensure
         zos.close if zos
       end
 
       # Same as #open but writes to a filestream instead
-      def write_buffer(io = ::StringIO.new(''), encrypter = nil)
-        zos = new(io, true, encrypter)
+      def write_buffer(io = ::StringIO.new, dep_encrypter = nil, encrypter: nil)
+        Zip.warn_about_v3_api('Zip::OutputStream.write_buffer') unless dep_encrypter.nil?
+
+        io.binmode if io.respond_to?(:binmode)
+        zos = new(io, stream: true, encrypter: (encrypter || dep_encrypter))
         yield zos
         zos.close_buffer
       end
@@ -66,6 +75,7 @@ module Zip
     # Closes the stream and writes the central directory to the zip file
     def close
       return if @closed
+
       finalize_current_entry
       update_local_headers
       write_central_directory
@@ -76,6 +86,7 @@ module Zip
     # Closes the stream and writes the central directory to the zip file
     def close_buffer
       return @output_stream if @closed
+
       finalize_current_entry
       update_local_headers
       write_central_directory
@@ -87,6 +98,7 @@ module Zip
     # +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)
       raise Error, 'zip stream is closed' if @closed
+
       new_entry = if entry_name.kind_of?(Entry)
                     entry_name
                   else
@@ -94,7 +106,7 @@ module Zip
                   end
       new_entry.comment = comment unless comment.nil?
       unless extra.nil?
-        new_entry.extra = extra.is_a?(ExtraField) ? extra : ExtraField.new(extra.to_s)
+        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)
@@ -104,7 +116,8 @@ module Zip
     def copy_raw_entry(entry)
       entry = entry.dup
       raise Error, 'zip stream is closed' if @closed
-      raise Error, 'entry is not a ZipEntry' unless entry.is_a?(Entry)
+      raise Error, 'entry is not a ZipEntry' unless entry.kind_of?(Entry)
+
       finalize_current_entry
       @entry_set << entry
       src_pos = entry.local_header_offset
@@ -123,8 +136,11 @@ module Zip
 
     def finalize_current_entry
       return unless @current_entry
+
       finish
-      @current_entry.compressed_size = @output_stream.tell - @current_entry.local_header_offset - @current_entry.calculate_local_header_size
+      @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)
@@ -144,9 +160,9 @@ module Zip
 
     def get_compressor(entry, level)
       case entry.compression_method
-      when Entry::DEFLATED then
+      when Entry::DEFLATED
         ::Zip::Deflater.new(@output_stream, level, @encrypter)
-      when Entry::STORED then
+      when Entry::STORED
         ::Zip::PassThruCompressor.new(@output_stream)
       else
         raise ::Zip::CompressionMethodError,

data/lib/zip/pass_thru_compressor.rb

@@ -1,8 +1,8 @@
 module Zip
   class PassThruCompressor < Compressor #:nodoc:all
-    def initialize(outputStream)
+    def initialize(output_stream)
       super()
-      @output_stream = outputStream
+      @output_stream = output_stream
       @crc = Zlib.crc32
       @size = 0
     end

data/lib/zip/pass_thru_decompressor.rb

@@ -1,38 +1,29 @@
 module Zip
   class PassThruDecompressor < Decompressor #:nodoc:all
-    def initialize(input_stream, chars_to_read)
-      super(input_stream)
-      @chars_to_read = chars_to_read
+    def initialize(*args)
+      super
       @read_so_far = 0
-      @has_returned_empty_string = false
     end
 
-    def sysread(number_of_bytes = nil, buf = '')
-      if input_finished?
-        has_returned_empty_string_val = @has_returned_empty_string
-        @has_returned_empty_string = true
-        return '' unless has_returned_empty_string_val
-        return
-      end
+    def read(length = nil, outbuf = ''.b)
+      return (length.nil? || length.zero? ? '' : nil) if eof
 
-      if number_of_bytes.nil? || @read_so_far + number_of_bytes > @chars_to_read
-        number_of_bytes = @chars_to_read - @read_so_far
+      if length.nil? || (@read_so_far + length) > decompressed_size
+        length = decompressed_size - @read_so_far
       end
-      @read_so_far += number_of_bytes
-      @input_stream.read(number_of_bytes, buf)
-    end
 
-    def produce_input
-      sysread(::Zip::Decompressor::CHUNK_SIZE)
+      @read_so_far += length
+      input_stream.read(length, outbuf)
     end
 
-    def input_finished?
-      @read_so_far >= @chars_to_read
+    def eof
+      @read_so_far >= decompressed_size
     end
 
-    alias eof input_finished?
-    alias eof? input_finished?
+    alias eof? eof
   end
+
+  ::Zip::Decompressor.register(::Zip::COMPRESSION_METHOD_STORE, ::Zip::PassThruDecompressor)
 end
 
 # Copyright (C) 2002, 2003 Thomas Sondergaard

data/lib/zip/streamable_directory.rb

@@ -1,11 +1,11 @@
 module Zip
   class StreamableDirectory < Entry
-    def initialize(zipfile, entry, srcPath = nil, permissionInt = nil)
+    def initialize(zipfile, entry, src_path = nil, permission = nil)
       super(zipfile, entry)
 
       @ftype = :directory
-      entry.get_extra_attributes_from_path(srcPath) if srcPath
-      @unix_perms = permissionInt if permissionInt
+      entry.get_extra_attributes_from_path(src_path) if src_path
+      @unix_perms = permission if permission
     end
   end
 end

data/lib/zip/streamable_stream.rb

@@ -1,13 +1,8 @@
 module Zip
-  class StreamableStream < DelegateClass(Entry) # nodoc:all
+  class StreamableStream < DelegateClass(Entry) # :nodoc:all
     def initialize(entry)
       super(entry)
-      dirname = if zipfile.is_a?(::String)
-                  ::File.dirname(zipfile)
-                else
-                  nil
-                end
-      @temp_file = Tempfile.new(::File.basename(name), dirname)
+      @temp_file = Tempfile.new(::File.basename(name))
       @temp_file.binmode
     end
 
@@ -27,6 +22,7 @@ module Zip
       unless @temp_file.closed?
         raise StandardError, "cannot open entry for reading while its open for writing - #{name}"
       end
+
       @temp_file.open # reopens tempfile from top
       @temp_file.binmode
       if block_given?
@@ -40,9 +36,9 @@ module Zip
       end
     end
 
-    def write_to_zip_output_stream(aZipOutputStream)
-      aZipOutputStream.put_next_entry(self)
-      get_input_stream { |is| ::Zip::IOExtras.copy_stream(aZipOutputStream, is) }
+    def write_to_zip_output_stream(output_stream)
+      output_stream.put_next_entry(self)
+      get_input_stream { |is| ::Zip::IOExtras.copy_stream(output_stream, is) }
     end
 
     def clean_up

data/lib/zip/version.rb

@@ -1,3 +1,3 @@
 module Zip
-  VERSION = '1.3.0'
+  VERSION = '2.4.1'
 end