rubyzip 1.0.0 → 2.4.1

data/lib/zip/inflater.rb

@@ -1,63 +1,52 @@
 module Zip
   class Inflater < Decompressor #:nodoc:all
-    def initialize(input_stream)
+    def initialize(*args)
       super
-      @zlib_inflater           = ::Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      @output_buffer           = ''
-      @has_returned_empty_string = false
-    end
 
-    def sysread(number_of_bytes = nil, buf = nil)
-      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 = nil)
+    def produce_input
       retried = 0
       begin
-        @zlib_inflater.inflate(@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

@@ -1,141 +1,189 @@
 module Zip
-  # ZipInputStream is the basic class for reading zip entries in a 
-  # zip file. It is possible to create a ZipInputStream object directly, 
-  # passing the zip file name to the constructor, but more often than not 
-  # the ZipInputStream will be obtained from a ZipFile (perhaps using the 
-  # ZipFileSystem interface) object for a particular entry in the zip 
+  # InputStream is the basic class for reading zip entries in a
+  # zip file. It is possible to create a InputStream object directly,
+  # passing the zip file name to the constructor, but more often than not
+  # the InputStream will be obtained from a File (perhaps using the
+  # ZipFileSystem interface) object for a particular entry in the zip
   # archive.
   #
-  # A ZipInputStream inherits IOExtras::AbstractInputStream in order
-  # to provide an IO-like interface for reading from a single zip 
-  # entry. Beyond methods for mimicking an IO-object it contains 
-  # the method get_next_entry for iterating through the entries of 
-  # an archive. get_next_entry returns a ZipEntry object that describes
-  # the zip entry the ZipInputStream is currently reading from.
+  # A InputStream inherits IOExtras::AbstractInputStream in order
+  # to provide an IO-like interface for reading from a single zip
+  # entry. Beyond methods for mimicking an IO-object it contains
+  # the method get_next_entry for iterating through the entries of
+  # an archive. get_next_entry returns a Entry object that describes
+  # the zip entry the InputStream is currently reading from.
   #
-  # Example that creates a zip archive with ZipOutputStream and reads it 
-  # back again with a ZipInputStream.
+  # Example that creates a zip archive with ZipOutputStream and reads it
+  # back again with a InputStream.
+  #
+  #   require 'zip'
+  #
+  #   Zip::OutputStream.open("my.zip") do |io|
   #
-  #   require 'zip/zip'
-  #   
-  #   Zip::ZipOutputStream::open("my.zip") { 
-  #     |io|
-  #   
   #     io.put_next_entry("first_entry.txt")
   #     io.write "Hello world!"
-  #   
+  #
   #     io.put_next_entry("adir/first_entry.txt")
   #     io.write "Hello again!"
-  #   }
+  #   end
+  #
+  #
+  #   Zip::InputStream.open("my.zip") do |io|
   #
-  #   
-  #   Zip::ZipInputStream::open("my.zip") {
-  #     |io|
-  #   
   #     while (entry = io.get_next_entry)
   #       puts "Contents of #{entry.name}: '#{io.read}'"
   #     end
-  #   }
+  #   end
   #
-  # java.util.zip.ZipInputStream is the original inspiration for this 
+  # java.util.zip.ZipInputStream is the original inspiration for this
   # class.
 
   class InputStream
+    CHUNK_SIZE = 32_768
+
     include ::Zip::IOExtras::AbstractInputStream
 
     # Opens the indicated zip file. An exception is thrown
     # if the specified offset in the specified filename is
     # not a local zip entry header.
-    def initialize(filename, offset = 0, io = nil)
+    #
+    # @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)
       super()
-      if (io.nil?) 
-        @archiveIO = ::File.open(filename, "rb")
-        @archiveIO.seek(offset, IO::SEEK_SET)
-      else
-        @archiveIO = io
+
+      if !dep_offset.zero? || !dep_decrypter.nil?
+        Zip.warn_about_v3_api('Zip::InputStream.new')
       end
-      @decompressor = NullDecompressor.instance
-      @currentEntry = nil
-    end
-    
-    def close
-      @archiveIO.close
-    end
 
-    # Same as #initialize but if a block is passed the opened
-    # stream is passed to the block and closed when the block
-    # returns.    
-    def InputStream.open(filename)
-      return new(filename) unless block_given?
-      
-      zio = new(filename)
-      yield zio
-    ensure
-      zio.close if zio
+      offset         = dep_offset if offset.zero?
+      @archive_io    = get_io(context, offset)
+      @decompressor  = ::Zip::NullDecompressor
+      @decrypter     = decrypter || dep_decrypter || ::Zip::NullDecrypter.new
+      @current_entry = nil
     end
 
-    def InputStream.open_buffer(io)
-      return new('',0,io) unless block_given?
-      zio = new('',0,io)
-      yield zio
-    ensure
-      zio.close if zio
+    def close
+      @archive_io.close
     end
 
-    # Returns a ZipEntry object. It is necessary to call this
-    # method on a newly created ZipInputStream before reading from 
-    # the first entry in the archive. Returns nil when there are 
+    # 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.
-
     def get_next_entry
-      @archiveIO.seek(@currentEntry.next_header_offset, IO::SEEK_SET) if @currentEntry
+      @archive_io.seek(@current_entry.next_header_offset, IO::SEEK_SET) if @current_entry
       open_entry
     end
 
     # Rewinds the stream to the beginning of the current entry
     def rewind
-      return if @currentEntry.nil?
+      return if @current_entry.nil?
+
       @lineno = 0
-      @pos = 0
-      @archiveIO.seek(@currentEntry.local_header_offset,
-		      IO::SEEK_SET)
+      @pos    = 0
+      @archive_io.seek(@current_entry.local_header_offset, IO::SEEK_SET)
       open_entry
     end
 
     # Modeled after IO.sysread
-    def sysread(numberOfBytes = nil, buf = nil)
-      @decompressor.sysread(numberOfBytes, buf)
+    def sysread(length = nil, outbuf = '')
+      @decompressor.read(length, outbuf)
     end
 
-    def eof
-      @output_buffer.empty? && @decompressor.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, 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
+          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
-    alias :eof? :eof
 
     protected
 
-    def open_entry
-      @currentEntry = Entry.read_local_entry(@archiveIO)
-      if @currentEntry.nil?
-	      @decompressor = NullDecompressor.instance
-      elsif @currentEntry.compression_method == Entry::STORED
-	      @decompressor = PassThruDecompressor.new(@archiveIO, @currentEntry.size)
-      elsif @currentEntry.compression_method == Entry::DEFLATED
-	      @decompressor = Inflater.new(@archiveIO)
+    def get_io(io_or_file, offset = 0)
+      if io_or_file.respond_to?(:seek)
+        io = io_or_file.dup
+        io.seek(offset, ::IO::SEEK_SET)
+        io
       else
-	      raise ZipCompressionMethodError,
-              "Unsupported compression method #{@currentEntry.compression_method}"
+        file = ::File.open(io_or_file, 'rb')
+        file.seek(offset, ::IO::SEEK_SET)
+        file
+      end
+    end
+
+    def open_entry
+      @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'
+      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'
       end
+      @decrypted_io = get_decrypted_io
+      @decompressor = get_decompressor
       flush
-      return @currentEntry
+      @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
+      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,
+              "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 = nil)
+      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,16 +26,20 @@ module Zip
                    rbuf = sysread(number_of_bytes, buf)
                    out  = @output_buffer
                    out << rbuf if rbuf
-                   @output_buffer = ''
+                   @output_buffer = ''.b
                    out
                  end
                else
                  sysread(number_of_bytes, buf)
                end
 
-        @pos += tbuf.length
+        if tbuf.nil? || tbuf.empty?
+          return nil if number_of_bytes
+
+          return ''
+        end
 
-        return nil unless tbuf
+        @pos += tbuf.length
 
         if buf
           buf.replace(tbuf)
@@ -45,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)
@@ -59,50 +63,60 @@ 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
-          if input_finished?
-            return @output_buffer.empty? ? nil : flush
-          end
+          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
         sep_index = [match_index + a_sep_string.bytesize, number_of_bytes || @output_buffer.bytesize].min
-        @pos     += sep_index
-        return @output_buffer.slice!(0...sep_index)
+        @pos += sep_index
+        @output_buffer.slice!(0...sep_index)
+      end
+
+      def ungetc(byte)
+        @output_buffer = byte.chr + @output_buffer
       end
 
       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 = $/)
-        while true
-          yield readline(a_sep_string)
-        end
+      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
+end

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -10,23 +10,22 @@ module Zip
         data.to_s.bytesize
       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)
-        self << sprintf(a_format_string, *params)
+        self << format(a_format_string, *params)
       end
 
       def putc(an_object)
         self << case an_object
-                when Fixnum
+                when Integer
                   an_object.chr
                 when String
                   an_object
                 else
-                  raise TypeError, 'putc: Only Fixnum and String supported'
+                  raise TypeError, 'putc: Only Integer and String supported'
                 end
         an_object
       end
@@ -39,7 +38,6 @@ module Zip
           self << "\n" unless val[-1, 1] == "\n"
         end
       end
-
     end
   end
 end

data/lib/zip/ioextras.rb

@@ -1,20 +1,19 @@
 module Zip
   module IOExtras #:nodoc:
-
-    CHUNK_SIZE = 131072
+    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, ''.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
@@ -26,8 +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_compressor.rb

@@ -2,8 +2,8 @@ module Zip
   class NullCompressor < Compressor #:nodoc:all
     include Singleton
 
-    def <<(data)
-      raise IOError, "closed stream"
+    def <<(_data)
+      raise IOError, 'closed stream'
     end
 
     attr_reader :size, :compressed_size

data/lib/zip/null_decompressor.rb

@@ -1,24 +1,16 @@
 module Zip
-  class NullDecompressor #:nodoc:all
-    include Singleton
+  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
 
-    alias :eof? :eof
+    alias eof? eof
   end
 end
 

data/lib/zip/null_input_stream.rb

@@ -1,5 +1,6 @@
 module Zip
-  class NullInputStream < NullDecompressor #:nodoc:all
+  module NullInputStream #:nodoc:all
+    include ::Zip::NullDecompressor
     include ::Zip::IOExtras::AbstractInputStream
   end
 end