rubyzip 1.3.0 → 3.4.0

data/lib/zip/inflater.rb

@@ -1,64 +1,55 @@
+# frozen_string_literal: true
+
 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
+  class Inflater < Decompressor # :nodoc:all
+    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(maxlen = nil)
+      return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
+
+      while maxlen.nil? || (@buffer.bytesize < maxlen)
+        break if input_finished?
+
+        @buffer << produce_input
       end
+
+      @buffer.slice!(0...(maxlen || @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 for compatibility. Remove for version 4.
+    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 => e
+      raise ::Zip::DecompressionError, e
     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

@@ -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,8 +40,9 @@ module Zip
   #
   # java.util.zip.ZipInputStream is the original inspiration for this
   # class.
-
   class InputStream
+    CHUNK_SIZE = 32_768 # :nodoc:
+
     include ::Zip::IOExtras::AbstractInputStream
 
     # Opens the indicated zip file. An exception is thrown
@@ -47,70 +51,95 @@ 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, offset: 0, decrypter: nil)
       super()
       @archive_io = get_io(context, offset)
-      @decompressor  = ::Zip::NullDecompressor
-      @decrypter     = decrypter || ::Zip::NullDecrypter.new
+      @decompressor = ::Zip::NullDecompressor
+      @decrypter = decrypter
       @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?
+
       @lineno = 0
       @pos    = 0
       @archive_io.seek(@current_entry.local_header_offset, IO::SEEK_SET)
       open_entry
     end
 
-    # Modeled after IO.sysread
-    def sysread(number_of_bytes = nil, buf = nil)
-      @decompressor.sysread(number_of_bytes, buf)
-    end
+    # Modelled after IO#sysread.
+    #
+    # Reads up to maxlen bytes from the stream; returns a string
+    # (either a new string or the given out_string).
+    # Its encoding is the unchanged encoding of out_string, if out_string is
+    # given; ASCII-8BIT, otherwise. Output contains maxlen bytes from the
+    # stream, if available; otherwise contains all available bytes, if any
+    # available; otherwise is an empty string.
+    #
+    # This method should not be used with buffered input stream-reader methods,
+    # such as #read, #readline, #gets.
+    def sysread(maxlen = nil, out_string = nil)
+      # Remove the default value for maxlen for version 4.
+      return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
 
-    def eof
-      @output_buffer.empty? && @decompressor.eof
+      output = produce_input(maxlen)
+
+      if out_string.nil?
+        output.force_encoding(Encoding::ASCII_8BIT)
+      else
+        encoding = out_string.encoding
+        out_string.replace(output).force_encoding(encoding)
+      end
     end
 
-    alias :eof? eof
+    # 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, offset = 0, decrypter = nil)
-        zio = new(filename_or_io, offset, 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
           yield zio
         ensure
           zio.close if zio
         end
       end
-
-      def open_buffer(filename_or_io, offset = 0)
-        puts 'open_buffer is deprecated!!! Use open instead!'
-        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)
@@ -122,48 +151,78 @@ 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.gp_flags & 1 == 1 && @decrypter.is_a?(NullEncrypter)
-        raise Error, 'password required to decode zip file'
-      end
-      if @current_entry && @current_entry.gp_flags & 8 == 8 && @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'
+      return if @current_entry.nil?
+
+      if @current_entry.incomplete? && @current_entry.compressed_size == 0 && !@complete_entry
+        raise StreamingError, @current_entry
       end
-      @decompressor = get_decompressor
+
+      @decompressor = assemble_io
       flush
       @current_entry
     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)
+    def assemble_io # :nodoc:
+      io = if @current_entry.encrypted?
+             raise Error, 'A password is required to decode this zip file.' if @decrypter.nil?
+
+             get_decrypted_io
+           else
+             @archive_io
+           end
+
+      get_decompressor(io)
+    end
+
+    def get_decrypted_io # :nodoc:
+      header = @archive_io.read(@decrypter.header_bytesize)
+      @decrypter.reset!(header)
+
+      compressed_size =
+        if @current_entry.incomplete? && @current_entry.crc == 0 &&
+           @current_entry.compressed_size == 0 && @complete_entry
+          @complete_entry.compressed_size
         else
-          ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
+          @current_entry.compressed_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
-        raise ::Zip::CompressionMethodError,
-              "Unsupported compression method #{@current_entry.compression_method}"
+
+      if @decrypter.kind_of?(::Zip::AESDecrypter)
+        compressed_size -= @decrypter.header_bytesize
+        compressed_size -= ::Zip::AESEncryption::AUTHENTICATION_CODE_LENGTH
       end
+
+      ::Zip::DecryptedIo.new(@archive_io, @decrypter, compressed_size)
+    end
+
+    def get_decompressor(io) # :nodoc:
+      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
+          @current_entry.size
+        end
+
+      decompressor_class = ::Zip::Decompressor.find_by_compression_method(
+        @current_entry.compression_method
+      )
+      if decompressor_class.nil?
+        raise ::Zip::CompressionMethodError, @current_entry.compression_method
+      end
+
+      decompressor_class.new(io, decompressed_size)
     end
 
-    def produce_input
-      @decompressor.produce_input
+    def produce_input(maxlen = CHUNK_SIZE) # :nodoc:
+      @decompressor.read(maxlen)
     end
 
-    def input_finished?
-      @decompressor.input_finished?
+    def input_finished? # :nodoc:
+      @decompressor.eof?
     end
   end
 end

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -1,111 +1,210 @@
+# 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
+    # such as gets, getc, read, readline and readlines
     # depends on: input_finished?, produce_input and read
     module AbstractInputStream
       include Enumerable
       include FakeIO
 
-      def initialize
+      def initialize # :nodoc:
         super
         @lineno        = 0
         @pos           = 0
-        @output_buffer = ''
+        @output_buffer = +''.b
       end
 
+      # Returns (or sets) the current line number in the decompressed
+      # (possibly decrypted) data stream. See the Line Number documentation
+      # for the IO class for more information.
       attr_accessor :lineno
+
+      # Returns the current position (in bytes) in the decompressed (possibly
+      # decrypted) data stream.
       attr_reader :pos
 
-      def read(number_of_bytes = nil, buf = '')
+      # Reads bytes from the stream decompressed (possibly decrypted) data
+      # stream. If `maxlen` is `nil`, reads all bytes; otherwise, reads up to
+      # `maxlen` bytes. If `maxlen` is zero, returns an empty string.
+      #
+      # Returns a string (either a new string or the given `out_string`)
+      # containing the bytes read. The string's encoding is the unchanged
+      # encoding of `out_string`, if `out_string` is given; `ASCII-8BIT`,
+      # otherwise.
+      def read(maxlen = nil, out_string = nil) # rubocop:disable Metrics/PerceivedComplexity
+        return (maxlen.nil? || maxlen.zero? ? '' : nil) if eof?
+
         tbuf = if @output_buffer.bytesize > 0
-                 if number_of_bytes <= @output_buffer.bytesize
-                   @output_buffer.slice!(0, number_of_bytes)
+                 if maxlen && maxlen <= @output_buffer.bytesize
+                   @output_buffer.slice!(0, maxlen)
                  else
-                   number_of_bytes -= @output_buffer.bytesize if number_of_bytes
-                   rbuf = sysread(number_of_bytes, buf)
+                   maxlen -= @output_buffer.bytesize if maxlen
+                   rbuf = produce_input(maxlen)
                    out  = @output_buffer
                    out << rbuf if rbuf
-                   @output_buffer = ''
+                   @output_buffer = +''.b
                    out
                  end
                else
-                 sysread(number_of_bytes, buf)
+                 produce_input(maxlen)
                end
 
         if tbuf.nil? || tbuf.empty?
-          return nil if number_of_bytes
+          return nil if maxlen&.positive?
+
           return ''
         end
 
         @pos += tbuf.length
 
-        if buf
-          buf.replace(tbuf)
+        if out_string.nil?
+          tbuf.force_encoding(Encoding::ASCII_8BIT)
         else
-          buf = tbuf
+          encoding = out_string.encoding
+          out_string.replace(tbuf).force_encoding(encoding)
         end
-        buf
       end
 
-      def readlines(a_sep_string = $/)
-        ret_val = []
-        each_line(a_sep_string) { |line| ret_val << line }
-        ret_val
+      # Reads and returns all remaining lines from the stream. See the Line IO
+      # documentation in the IO class for more information.
+      #
+      # With no arguments given, returns lines as determined by line
+      # separator `$/`, or `nil` if none.
+      #
+      # With only string argument `sep` given, returns lines as
+      # determined by line separator `sep`, or `nil` if none. See the
+      # Line Separator documentation in the IO class for more information.
+      # The two special values for `sep` (`nil` and `""`) are honoured.
+      #
+      # With only integer argument `limit` given, limits the number of bytes
+      # in each line; see the Line Limit documentation in the IO class for more
+      # information.
+      #
+      # With arguments `sep` and `limit` given, combines the two behaviors.
+      #
+      # Optional keyword argument `chomp` specifies whether line separators
+      # are to be omitted.
+      def readlines(sep = $INPUT_RECORD_SEPARATOR, limit = nil, chomp: false)
+        each(sep, limit, chomp: chomp).to_a
       end
 
-      def gets(a_sep_string = $/, number_of_bytes = nil)
-        @lineno = @lineno.next
-
-        if number_of_bytes.respond_to?(:to_int)
-          number_of_bytes = number_of_bytes.to_int
-          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    = $/
-        else
-          number_of_bytes = nil
-          a_sep_string = a_sep_string.to_str if a_sep_string
+      # Reads and returns a line from the stream. See the Line IO
+      # documentation in the IO class for more information.
+      #
+      # With no arguments given, returns the next line as determined by line
+      # separator `$/`, or `nil` if none.
+      #
+      # With only string argument `sep` given, returns the next line as
+      # determined by line separator `sep`, or `nil` if none. See the
+      # Line Separator documentation in the IO class for more information.
+      # The two special values for `sep` (`nil` and `""`) are honoured.
+      #
+      # With only integer argument `limit` given, limits the number of bytes
+      # in the line; see the Line Limit documentation in the IO class for more
+      # information.
+      #
+      # With arguments `sep` and `limit` given, combines the two behaviors.
+      #
+      # Optional keyword argument `chomp` specifies whether line separators
+      # are to be omitted.
+      def gets(sep = $INPUT_RECORD_SEPARATOR, limit = nil, chomp: false)
+        if sep.nil?
+          return nil if eof?
+
+          @lineno = @lineno.next
+          return read(limit)
         end
 
-        return read(number_of_bytes) if a_sep_string.nil?
-        a_sep_string = "#{$/}#{$/}" if a_sep_string.empty?
+        if sep.respond_to?(:to_int)
+          limit = sep.to_int
+          sep   = $INPUT_RECORD_SEPARATOR
+        elsif sep&.empty?
+          sep = "#{$INPUT_RECORD_SEPARATOR}#{$INPUT_RECORD_SEPARATOR}"
+        end
 
         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?
+        while (sep_index = @output_buffer.index(sep, buffer_index)).nil?
+          break if limit && @output_buffer.bytesize >= limit
+
+          if input_finished?
+            return nil if @output_buffer.empty?
+
+            @lineno = @lineno.next
+            @pos += @output_buffer.bytesize
+            return @output_buffer.slice!(0..)
+          end
+
+          buffer_index = [buffer_index, @output_buffer.bytesize - sep.bytesize].max
           @output_buffer << produce_input
-          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
-        @pos += sep_index
-        @output_buffer.slice!(0...sep_index)
+
+        limit ||= @output_buffer.bytesize
+        cut_index = sep_index ? [sep_index + sep.bytesize, limit].min : limit
+        @lineno = @lineno.next
+        @pos += cut_index
+        chomp ? @output_buffer.slice!(0, cut_index).chomp(sep) : @output_buffer.slice!(0, cut_index)
       end
 
-      def ungetc(byte)
+      def ungetc(byte) # :nodoc:
         @output_buffer = byte.chr + @output_buffer
       end
 
-      def flush
-        ret_val        = @output_buffer
-        @output_buffer = ''
-        ret_val
+      def flush # :nodoc:
+        @output_buffer.slice!(0..)
       end
 
-      def readline(a_sep_string = $/)
-        ret_val = gets(a_sep_string)
-        raise EOFError unless ret_val
-        ret_val
+      # Reads a line as with #gets, but raises `EOFError` if already at
+      # end-of-stream.
+      #
+      # Optional keyword argument `chomp` specifies whether line separators
+      # are to be omitted.
+      def readline(sep = $INPUT_RECORD_SEPARATOR, limit = nil, chomp: false)
+        raise EOFError if eof?
+
+        gets(sep, limit, chomp: chomp)
       end
 
-      def each_line(a_sep_string = $/)
-        yield readline(a_sep_string) while true
-      rescue EOFError
+      # Calls the block with each remaining line read from the stream.
+      # Does nothing if already at end-of-stream. See the Line IO
+      # documentation in the IO class for more information.
+      #
+      # With no arguments given, reads lines as determined by line separator
+      # `$/`. With only string argument `sep` given, reads lines as determined
+      # by line separator `sep`. See the Line Separator documentation in the
+      # IO class for more information. The two special values for `sep`
+      # (`nil` and `""`) are honoured.
+      #
+      # With only integer argument `limit` given, limits the number of bytes
+      # in each line; see the Line Limit documentation in the IO class for
+      # more information.
+      #
+      # With arguments `sep` and `limit` given, combines the two behaviors.
+      #
+      # Optional keyword argument `chomp` specifies whether line separators
+      # are to be omitted.
+      #
+      # Returns an `Enumerator` if no block is given.
+      def each(sep = $INPUT_RECORD_SEPARATOR, limit = nil, chomp: false)
+        return to_enum(:each, sep, limit, chomp: chomp) unless block_given?
+
+        while (line = gets(sep, limit, chomp: chomp))
+          yield line
+        end
+      end
+
+      alias each_line each
+
+      # Returns `true` if the stream is positioned at its end, `false`
+      # otherwise. See Position documentation in the IO class for more
+      # information.
+      def eof?
+        @output_buffer.empty? && input_finished?
       end
 
-      alias_method :each, :each_line
+      # Alias for compatibility. Remove for version 4.
+      alias eof eof? # :nodoc:
     end
   end
 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,11 +13,19 @@ module Zip
       end
 
       def print(*params)
-        self << params.join($,) << $\.to_s
+        self << params.join
+
+        # Deflate doesn't like `nil`s or empty strings!
+        unless $OUTPUT_RECORD_SEPARATOR.nil? || $OUTPUT_RECORD_SEPARATOR.empty?
+          self << $OUTPUT_RECORD_SEPARATOR
+        end
+
+        nil
       end
 
       def printf(a_format_string, *params)
         self << format(a_format_string, *params)
+        nil
       end
 
       def putc(an_object)

data/lib/zip/ioextras.rb

@@ -1,31 +1,31 @@
+# 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, '')) 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, ''))
+          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
     end
-  end # IOExtras namespace module
+  end
 end
 
 require 'zip/ioextras/abstract_input_stream'