rubyzip 1.0.0 → 1.2.0

data/lib/zip/input_stream.rb

@@ -1,43 +1,41 @@
 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
@@ -46,88 +44,115 @@ module Zip
     # 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, offset = 0, decrypter = nil)
       super()
-      if (io.nil?) 
-        @archiveIO = ::File.open(filename, "rb")
-        @archiveIO.seek(offset, IO::SEEK_SET)
-      else
-        @archiveIO = io
-      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
+      @archive_io = get_io(context, offset)
+      @decompressor  = ::Zip::NullDecompressor
+      @decrypter     = 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(number_of_bytes = nil, buf = nil)
+      @decompressor.sysread(number_of_bytes, buf)
     end
 
     def eof
       @output_buffer.empty? && @decompressor.eof
     end
-    alias :eof? :eof
+
+    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)
+        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 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.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 && !@internal
+        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
+      @decompressor  = get_decompressor
       flush
-      return @currentEntry
+      @current_entry
+    end
+
+    def get_decompressor
+      case
+      when @current_entry.nil?
+        ::Zip::NullDecompressor
+      when @current_entry.compression_method == ::Zip::Entry::STORED
+        ::Zip::PassThruDecompressor.new(@archive_io, @current_entry.size)
+      when @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}"
+      end
     end
 
     def produce_input

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -17,7 +17,7 @@ module Zip
       attr_accessor :lineno
       attr_reader :pos
 
-      def read(number_of_bytes = nil, buf = nil)
+      def read(number_of_bytes = nil, buf = '')
         tbuf = if @output_buffer.bytesize > 0
                  if number_of_bytes <= @output_buffer.bytesize
                    @output_buffer.slice!(0, number_of_bytes)
@@ -33,9 +33,12 @@ module Zip
                  sysread(number_of_bytes, buf)
                end
 
-        @pos += tbuf.length
+        if tbuf.nil? || tbuf.length == 0
+          return nil if number_of_bytes
+          return ''
+        end
 
-        return nil unless tbuf
+        @pos += tbuf.length
 
         if buf
           buf.replace(tbuf)
@@ -72,15 +75,17 @@ module Zip
         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
@@ -96,13 +101,11 @@ module Zip
       end
 
       def each_line(a_sep_string = $/)
-        while true
-          yield readline(a_sep_string)
-        end
+        yield readline(a_sep_string) while true
       rescue EOFError
       end
 
       alias_method :each, :each_line
     end
   end
-end
+end

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -10,7 +10,6 @@ module Zip
         data.to_s.bytesize
       end
 
-
       def print(*params)
         self << params.join($,) << $\.to_s
       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,7 +1,6 @@
 module Zip
   module IOExtras #:nodoc:
-
-    CHUNK_SIZE = 131072
+    CHUNK_SIZE = 131_072
 
     RANGE_ALL = 0..-1
 
@@ -26,7 +25,6 @@ module Zip
         object == IO || super
       end
     end
-
   end # IOExtras namespace module
 end
 

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,8 +1,8 @@
 module Zip
-  class NullDecompressor #:nodoc:all
-    include Singleton
+  module NullDecompressor #:nodoc:all
+    module_function
 
-    def sysread(numberOfBytes = nil, buf = nil)
+    def sysread(_numberOfBytes = nil, _buf = nil)
       nil
     end
 
@@ -18,7 +18,7 @@ module Zip
       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

data/lib/zip/output_stream.rb

@@ -24,18 +24,22 @@ module Zip
 
     # Opens the indicated zip file. If a file with that name already
     # exists it will be overwritten.
-    def initialize(fileName, stream=false)
+    def initialize(file_name, stream = false, encrypter = nil)
       super()
-      @fileName = fileName
-      if stream
-        @output_stream = ::StringIO.new
-      else
-        @output_stream = ::File.new(@fileName, "wb")
-      end
+      @file_name = file_name
+      @output_stream = if stream
+                         iostream = @file_name.dup
+                         iostream.reopen(@file_name)
+                         iostream.rewind
+                         iostream
+                       else
+                         ::File.new(@file_name, 'wb')
+                       end
       @entry_set = ::Zip::EntrySet.new
       @compressor = ::Zip::NullCompressor.instance
+      @encrypter = encrypter || ::Zip::NullEncrypter.new
       @closed = false
-      @currentEntry = nil
+      @current_entry = nil
       @comment = nil
     end
 
@@ -43,19 +47,19 @@ module Zip
     # stream is passed to the block and closed when the block
     # returns.
     class << self
-      def open(fileName)
-        return new(fileName) unless block_given?
-        zos = new(fileName)
+      def open(file_name, encrypter = nil)
+        return new(file_name) unless block_given?
+        zos = new(file_name, false, encrypter)
         yield zos
       ensure
         zos.close if zos
       end
 
-	    # Same as #open but writes to a filestream instead
-      def write_buffer
-        zos = new('', true)
+      # Same as #open but writes to a filestream instead
+      def write_buffer(io = ::StringIO.new(''), encrypter = nil)
+        zos = new(io, true, encrypter)
         yield zos
-        return zos.close_buffer
+        zos.close_buffer
       end
     end
 
@@ -79,66 +83,74 @@ module Zip
       @output_stream
     end
 
-	  # Closes the current entry and opens a new for writing.
+    # Closes the current entry and opens a new for writing.
     # +entry+ can be a ZipEntry object or a string.
-    def put_next_entry(entryname, comment = nil, extra = nil, compression_method = Entry::DEFLATED,  level = Zlib::DEFAULT_COMPRESSION)
-      raise ZipError, "zip stream is closed" if @closed
-      if entryname.kind_of?(Entry)
-        new_entry = entryname
+    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
+      if entry_name.kind_of?(Entry)
+        new_entry = entry_name
       else
-        new_entry = Entry.new(@fileName, entryname.to_s)
+        new_entry = Entry.new(@file_name, entry_name.to_s)
       end
-      new_entry.comment = comment if !comment.nil?
-      if (!extra.nil?)
-        new_entry.extra = ExtraField === extra ? extra : ExtraField.new(extra.to_s)
+      new_entry.comment = comment unless comment.nil?
+      unless extra.nil?
+        new_entry.extra = extra.is_a?(ExtraField) ? extra : ExtraField.new(extra.to_s)
       end
-      new_entry.compression_method = compression_method if !compression_method.nil?
+      new_entry.compression_method = compression_method unless compression_method.nil?
       init_next_entry(new_entry, level)
-      @currentEntry = new_entry
+      @current_entry = new_entry
     end
 
     def copy_raw_entry(entry)
       entry = entry.dup
-      raise ZipError, "zip stream is closed" if @closed
-      raise ZipError, "entry is not a ZipEntry" if !entry.kind_of?(Entry)
+      raise Error, 'zip stream is closed' if @closed
+      raise Error, 'entry is not a ZipEntry' unless entry.is_a?(Entry)
       finalize_current_entry
       @entry_set << entry
-      src_pos = entry.local_entry_offset
+      src_pos = entry.local_header_offset
       entry.write_local_entry(@output_stream)
       @compressor = NullCompressor.instance
       entry.get_raw_input_stream do |is|
         is.seek(src_pos, IO::SEEK_SET)
+        ::Zip::Entry.read_local_entry(is)
         IOExtras.copy_stream_n(@output_stream, is, entry.compressed_size)
       end
       @compressor = NullCompressor.instance
-      @currentEntry = nil
+      @current_entry = nil
     end
 
     private
 
     def finalize_current_entry
-      return unless @currentEntry
+      return unless @current_entry
       finish
-      @currentEntry.compressed_size = @output_stream.tell - @currentEntry.local_header_offset - @currentEntry.calculate_local_header_size
-      @currentEntry.size = @compressor.size
-      @currentEntry.crc = @compressor.crc
-      @currentEntry = nil
-      @compressor = NullCompressor.instance
+      @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)
+      @current_entry.gp_flags |= @encrypter.gp_flags
+      @current_entry = nil
+      @compressor = ::Zip::NullCompressor.instance
     end
 
-    def init_next_entry(entry, level = Zlib::DEFAULT_COMPRESSION)
+    def init_next_entry(entry, level = Zip.default_compression)
       finalize_current_entry
       @entry_set << entry
       entry.write_local_entry(@output_stream)
+      @encrypter.reset!
+      @output_stream << @encrypter.header(entry.mtime)
       @compressor = get_compressor(entry, level)
     end
 
     def get_compressor(entry, level)
       case entry.compression_method
-        when Entry::DEFLATED then Deflater.new(@output_stream, level)
-        when Entry::STORED   then PassThruCompressor.new(@output_stream)
-      else raise ZipCompressionMethodError,
-        "Invalid compression method: '#{entry.compression_method}'"
+      when Entry::DEFLATED then
+        ::Zip::Deflater.new(@output_stream, level, @encrypter)
+      when Entry::STORED then
+        ::Zip::PassThruCompressor.new(@output_stream)
+      else
+        raise ::Zip::CompressionMethodError,
+              "Invalid compression method: '#{entry.compression_method}'"
       end
     end
 
@@ -146,7 +158,7 @@ module Zip
       pos = @output_stream.pos
       @entry_set.each do |entry|
         @output_stream.pos = entry.local_header_offset
-        entry.write_local_entry(@output_stream)
+        entry.write_local_entry(@output_stream, true)
       end
       @output_stream.pos = pos
     end
@@ -163,9 +175,11 @@ module Zip
     end
 
     public
+
     # Modeled after IO.<<
-    def << (data)
+    def <<(data)
       @compressor << data
+      self
     end
   end
 end

data/lib/zip/pass_thru_compressor.rb

@@ -3,13 +3,13 @@ module Zip
     def initialize(outputStream)
       super()
       @output_stream = outputStream
-      @crc = Zlib::crc32
+      @crc = Zlib.crc32
       @size = 0
     end
-    
-    def << (data)
+
+    def <<(data)
       val = data.to_s
-      @crc = Zlib::crc32(val, @crc)
+      @crc = Zlib.crc32(val, @crc)
       @size += val.bytesize
       @output_stream << val
     end

data/lib/zip/pass_thru_decompressor.rb

@@ -1,6 +1,5 @@
 module Zip
   class PassThruDecompressor < Decompressor  #:nodoc:all
-
     def initialize(input_stream, chars_to_read)
       super(input_stream)
       @chars_to_read = chars_to_read
@@ -8,7 +7,7 @@ module Zip
       @has_returned_empty_string = false
     end
 
-    def sysread(number_of_bytes = nil, buf = nil)
+    def sysread(number_of_bytes = nil, buf = '')
       if input_finished?
         has_returned_empty_string_val = @has_returned_empty_string
         @has_returned_empty_string = true
@@ -16,7 +15,7 @@ module Zip
         return
       end
 
-      if (number_of_bytes == nil || @read_so_far + number_of_bytes > @chars_to_read)
+      if number_of_bytes.nil? || @read_so_far + number_of_bytes > @chars_to_read
         number_of_bytes = @chars_to_read - @read_so_far
       end
       @read_so_far += number_of_bytes
@@ -31,8 +30,8 @@ module Zip
       @read_so_far >= @chars_to_read
     end
 
-    alias :eof :input_finished?
-    alias :eof? :input_finished?
+    alias eof input_finished?
+    alias eof? input_finished?
   end
 end
 

data/lib/zip/streamable_directory.rb

@@ -4,8 +4,8 @@ module Zip
       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(srcPath) if srcPath
+      @unix_perms = permissionInt if permissionInt
     end
   end
 end