rubyzip 0.9.9 → 1.3.0

data/lib/zip/inflater.rb

@@ -1,61 +1,62 @@
 module Zip
-  class Inflater < Decompressor  #:nodoc:all
-    def initialize(inputStream)
-      super
-      @zlibInflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      @outputBuffer=""
-      @hasReturnedEmptyString = ! EMPTY_FILE_RETURNS_EMPTY_STRING_FIRST
+  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 sysread(numberOfBytes = nil, buf = nil)
-      readEverything = numberOfBytes.nil?
-      while (readEverything || @outputBuffer.bytesize < numberOfBytes)
+    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?
-        @outputBuffer << internal_produce_input(buf)
+        @output_buffer << internal_produce_input(buf)
       end
-      return value_when_finished if @outputBuffer.bytesize == 0 && input_finished?
-      endIndex = numberOfBytes.nil? ? @outputBuffer.bytesize : numberOfBytes
-      return @outputBuffer.slice!(0...endIndex)
+      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)
     end
 
     def produce_input
-      if (@outputBuffer.empty?)
-        return internal_produce_input
+      if @output_buffer.empty?
+        internal_produce_input
       else
-        return @outputBuffer.slice!(0...(@outputBuffer.length))
+        @output_buffer.slice!(0...(@output_buffer.length))
       end
     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?
-      @outputBuffer.empty? && internal_input_finished?
+      @output_buffer.empty? && internal_input_finished?
     end
-    alias :eof :input_finished?
-    alias :eof? :input_finished?
+
+    alias :eof input_finished?
+    alias :eof? input_finished?
 
     private
 
-    def internal_produce_input(buf = nil)
+    def internal_produce_input(buf = '')
       retried = 0
       begin
-        @zlibInflater.inflate(@inputStream.read(Decompressor::CHUNK_SIZE, buf))
+        @zlib_inflater.inflate(@decrypter.decrypt(@input_stream.read(Decompressor::CHUNK_SIZE, buf)))
       rescue Zlib::BufError
-        raise if (retried >= 5) # how many times should we retry?
+        raise if retried >= 5 # how many times should we retry?
         retried += 1
         retry
       end
     end
 
     def internal_input_finished?
-      @zlibInflater.finished?
+      @zlib_inflater.finished?
     end
 
-    # TODO: Specialize to handle different behaviour in ruby > 1.7.0 ?
-    def value_when_finished   # mimic behaviour of ruby File object.
-      return if @hasReturnedEmptyString
-      @hasReturnedEmptyString = true
-      return ""
+    def value_when_finished # mimic behaviour of ruby File object.
+      return if @has_returned_empty_string
+      @has_returned_empty_string = true
+      ''
     end
   end
 end

data/lib/zip/input_stream.rb

@@ -0,0 +1,173 @@
+module 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 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 InputStream.
+  #
+  #   require 'zip'
+  #
+  #   Zip::OutputStream.open("my.zip") do |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|
+  #
+  #     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
+  # class.
+
+  class InputStream
+    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.
+    #
+    # @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()
+      @archive_io = get_io(context, offset)
+      @decompressor  = ::Zip::NullDecompressor
+      @decrypter     = decrypter || ::Zip::NullDecrypter.new
+      @current_entry = nil
+    end
+
+    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.
+    def get_next_entry
+      @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 @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
+
+    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)
+        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)
+      if io_or_file.respond_to?(:seek)
+        io = io_or_file.dup
+        io.seek(offset, ::IO::SEEK_SET)
+        io
+      else
+        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 && !@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
+      @decompressor = get_decompressor
+      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)
+        else
+          ::Zip::PassThruDecompressor.new(@archive_io, @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
+        raise ::Zip::CompressionMethodError,
+              "Unsupported compression method #{@current_entry.compression_method}"
+      end
+    end
+
+    def produce_input
+      @decompressor.produce_input
+    end
+
+    def input_finished?
+      @decompressor.input_finished?
+    end
+  end
+end
+
+# Copyright (C) 2002, 2003 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/ioextras/abstract_input_stream.rb

@@ -0,0 +1,111 @@
+module Zip
+  module IOExtras
+    # 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
+      include Enumerable
+      include FakeIO
+
+      def initialize
+        super
+        @lineno        = 0
+        @pos           = 0
+        @output_buffer = ''
+      end
+
+      attr_accessor :lineno
+      attr_reader :pos
+
+      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)
+                 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 = ''
+                   out
+                 end
+               else
+                 sysread(number_of_bytes, buf)
+               end
+
+        if tbuf.nil? || tbuf.empty?
+          return nil if number_of_bytes
+          return ''
+        end
+
+        @pos += tbuf.length
+
+        if buf
+          buf.replace(tbuf)
+        else
+          buf = tbuf
+        end
+        buf
+      end
+
+      def readlines(a_sep_string = $/)
+        ret_val = []
+        each_line(a_sep_string) { |line| ret_val << line }
+        ret_val
+      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
+        end
+
+        return read(number_of_bytes) if a_sep_string.nil?
+        a_sep_string = "#{$/}#{$/}" 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
+        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
+
+      def ungetc(byte)
+        @output_buffer = byte.chr + @output_buffer
+      end
+
+      def flush
+        ret_val        = @output_buffer
+        @output_buffer = ''
+        ret_val
+      end
+
+      def readline(a_sep_string = $/)
+        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
+      rescue EOFError
+      end
+
+      alias_method :each, :each_line
+    end
+  end
+end

data/lib/zip/ioextras/abstract_output_stream.rb

@@ -0,0 +1,43 @@
+module Zip
+  module IOExtras
+    # Implements many of the output convenience methods of IO.
+    # relies on <<
+    module AbstractOutputStream
+      include FakeIO
+
+      def write(data)
+        self << data
+        data.to_s.bytesize
+      end
+
+      def print(*params)
+        self << params.join($,) << $\.to_s
+      end
+
+      def printf(a_format_string, *params)
+        self << format(a_format_string, *params)
+      end
+
+      def putc(an_object)
+        self << case an_object
+                when Integer
+                  an_object.chr
+                when String
+                  an_object
+                else
+                  raise TypeError, 'putc: Only Integer and String supported'
+                end
+        an_object
+      end
+
+      def puts(*params)
+        params << "\n" if params.empty?
+        params.flatten.each do |element|
+          val = element.to_s
+          self << val
+          self << "\n" unless val[-1, 1] == "\n"
+        end
+      end
+    end
+  end
+end

data/lib/zip/ioextras.rb

@@ -1,163 +1,35 @@
-module IOExtras  #:nodoc:
+module Zip
+  module IOExtras #:nodoc:
+    CHUNK_SIZE = 131_072
 
-  CHUNK_SIZE = 131072
+    RANGE_ALL = 0..-1
 
-  RANGE_ALL = 0..-1
-
-  def self.copy_stream(ostream, istream)
-    s = ''
-    ostream.write(istream.read(CHUNK_SIZE, s)) until istream.eof? 
-  end
-
-  def self.copy_stream_n(ostream, istream, nbytes)
-    s = ''
-    toread = nbytes
-    while (toread > 0 && ! istream.eof?) 
-      tr = toread > CHUNK_SIZE ? CHUNK_SIZE : toread
-      ostream.write(istream.read(tr, s))
-      toread -= tr
-    end 
-  end
-
-
-  # Implements kind_of? in order to pretend to be an IO object
-  module FakeIO
-    def kind_of?(object)
-      object == IO || super
-    end
-  end
-
-  # 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  
-    include Enumerable
-    include FakeIO
-
-    def initialize
-      super
-      @lineno = 0
-      @outputBuffer = ""
-    end
-
-    attr_accessor :lineno
-
-    def read(numberOfBytes = nil, buf = nil)
-      tbuf = nil
-
-      if @outputBuffer.bytesize > 0
-        if numberOfBytes <= @outputBuffer.bytesize
-          tbuf = @outputBuffer.slice!(0, numberOfBytes)
-        else
-          numberOfBytes -= @outputBuffer.bytesize if (numberOfBytes)
-          rbuf = sysread(numberOfBytes, buf)
-          tbuf = @outputBuffer
-          tbuf << rbuf if (rbuf)
-          @outputBuffer = ""
-        end
-      else
-        tbuf = sysread(numberOfBytes, buf)
-      end
-
-      return nil unless (tbuf)
-
-      if buf
-        buf.replace(tbuf)
-      else
-        buf = tbuf
+    class << self
+      def copy_stream(ostream, istream)
+        ostream.write(istream.read(CHUNK_SIZE, '')) until istream.eof?
       end
 
-      buf
-    end
-
-    def readlines(aSepString = $/)
-      retVal = []
-      each_line(aSepString) { |line| retVal << line }
-      retVal
-    end
-
-    def gets(aSepString = $/)
-      @lineno = @lineno.next
-      return read if aSepString.nil?
-      aSepString = "#{$/}#{$/}" if aSepString.empty?
-
-      bufferIndex = 0
-      while ((matchIndex = @outputBuffer.index(aSepString, bufferIndex)) == nil)
-        bufferIndex = @outputBuffer.bytesize
-        if input_finished?
-          return @outputBuffer.empty? ? nil : flush
+      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, ''))
+          toread -= tr
         end
-        @outputBuffer << produce_input
       end
-      sepIndex = matchIndex + aSepString.bytesize
-      return @outputBuffer.slice!(0...sepIndex)
-    end
-
-    def flush
-      retVal = @outputBuffer
-      @outputBuffer=""
-      return retVal
     end
 
-    def readline(aSepString = $/)
-      retVal = gets(aSepString)
-      raise EOFError if retVal == nil
-      retVal
-    end
-
-    def each_line(aSepString = $/)
-      while true
-        yield readline(aSepString)
+    # Implements kind_of? in order to pretend to be an IO object
+    module FakeIO
+      def kind_of?(object)
+        object == IO || super
       end
-    rescue EOFError
     end
+  end # IOExtras namespace module
+end
 
-    alias_method :each, :each_line
-  end
-
-
-  # Implements many of the output convenience methods of IO.
-  # relies on <<
-  module AbstractOutputStream 
-    include FakeIO
-
-    def write(data)
-      self << data
-      data.to_s.bytesize
-    end
-
-
-    def print(*params)
-      self << params.join($,) << $\.to_s
-    end
-
-    def printf(aFormatString, *params)
-      self << sprintf(aFormatString, *params)
-    end
-
-    def putc(anObject)
-      self << case anObject
-      when Fixnum then anObject.chr
-      when String then anObject
-      else raise TypeError, "putc: Only Fixnum and String supported"
-      end
-      anObject
-    end
-
-    def puts(*params)
-      params << "\n" if params.empty?
-      params.flatten.each do |element|
-        val = element.to_s
-        self << val
-        self << "\n" unless val[-1,1] == "\n"
-      end
-    end
-
-  end
-
-end # IOExtras namespace module
-
-
+require 'zip/ioextras/abstract_input_stream'
+require 'zip/ioextras/abstract_output_stream'
 
 # Copyright (C) 2002-2004 Thomas Sondergaard
 # rubyzip is free software; you can redistribute it and/or

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,14 +1,15 @@
 module Zip
-  class NullDecompressor  #:nodoc:all
-    include Singleton
-    def sysread(numberOfBytes = nil, buf = nil)
+  module NullDecompressor #:nodoc:all
+    module_function
+
+    def sysread(_numberOfBytes = nil, _buf = nil)
       nil
     end
-    
+
     def produce_input
       nil
     end
-    
+
     def input_finished?
       true
     end
@@ -16,7 +17,8 @@ module Zip
     def eof
       true
     end
-    alias :eof? :eof
+
+    alias eof? eof
   end
 end
 

data/lib/zip/null_input_stream.rb

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