superp-rubyzip 0.1.0

data/lib/zip/inflater.rb

@@ -0,0 +1,65 @@
+module Zip
+  class Inflater < Decompressor #:nodoc:all
+    def initialize(input_stream)
+      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)
+    end
+
+    def produce_input
+      if (@output_buffer.empty?)
+        internal_produce_input
+      else
+        @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?
+      @output_buffer.empty? && internal_input_finished?
+    end
+
+    alias :eof :input_finished?
+    alias :eof? :input_finished?
+
+    private
+
+    def internal_produce_input(buf = nil)
+      retried = 0
+      begin
+        @zlib_inflater.inflate(@input_stream.read(Decompressor::CHUNK_SIZE, buf))
+      rescue Zlib::BufError
+        raise if retried >= 5 # how many times should we retry?
+        retried += 1
+        retry
+      end
+    end
+
+    def internal_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
+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/input_stream.rb

@@ -0,0 +1,145 @@
+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 
+  # 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.
+  #
+  # Example that creates a zip archive with ZipOutputStream and reads it 
+  # back again with a ZipInputStream.
+  #
+  #   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!"
+  #   }
+  #
+  #   
+  #   Zip::ZipInputStream::open("my.zip") {
+  #     |io|
+  #   
+  #     while (entry = io.get_next_entry)
+  #       puts "Contents of #{entry.name}: '#{io.read}'"
+  #     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.
+    def initialize(filename, offset = 0, io = 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
+    end
+
+    def InputStream.open_buffer(io)
+      return new('',0,io) unless block_given?
+      zio = new('',0,io)
+      yield zio
+    ensure
+      zio.close if zio
+    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 
+    # no more entries.
+
+    def get_next_entry
+      @archiveIO.seek(@currentEntry.next_header_offset, IO::SEEK_SET) if @currentEntry
+      open_entry
+    end
+
+    # Rewinds the stream to the beginning of the current entry
+    def rewind
+      return if @currentEntry.nil?
+      @lineno = 0
+      @pos = 0
+      @archiveIO.seek(@currentEntry.local_header_offset,
+		      IO::SEEK_SET)
+      open_entry
+    end
+
+    # Modeled after IO.sysread
+    def sysread(numberOfBytes = nil, buf = nil)
+      @decompressor.sysread(numberOfBytes, buf)
+    end
+
+    def eof
+      @output_buffer.empty? && @decompressor.eof
+    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)
+      else
+	      raise ZipCompressionMethodError,
+              "Unsupported compression method #{@currentEntry.compression_method}"
+      end
+      flush
+      return @currentEntry
+    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.rb

@@ -0,0 +1,186 @@
+module Zip
+  module IOExtras #:nodoc:
+
+    CHUNK_SIZE = 131072
+
+    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
+        @pos           = 0
+        @output_buffer = ""
+      end
+
+      attr_accessor :lineno
+      attr_reader :pos
+
+      def read(numberOfBytes = nil, buf = nil)
+        tbuf = nil
+
+        if @output_buffer.bytesize > 0
+          if numberOfBytes <= @output_buffer.bytesize
+            tbuf = @output_buffer.slice!(0, numberOfBytes)
+          else
+            numberOfBytes -= @output_buffer.bytesize if (numberOfBytes)
+            rbuf = sysread(numberOfBytes, buf)
+            tbuf = @output_buffer
+            tbuf << rbuf if (rbuf)
+            @output_buffer = ""
+          end
+        else
+          tbuf = sysread(numberOfBytes, buf)
+        end
+
+        @pos += tbuf.length
+
+        return nil unless (tbuf)
+
+        if buf
+          buf.replace(tbuf)
+        else
+          buf = tbuf
+        end
+
+        buf
+      end
+
+      def readlines(aSepString = $/)
+        retVal = []
+        each_line(aSepString) { |line| retVal << line }
+        retVal
+      end
+
+      def gets(aSepString = $/, numberOfBytes = nil)
+        @lineno = @lineno.next
+
+        if numberOfBytes.respond_to?(:to_int)
+          numberOfBytes = numberOfBytes.to_int
+          aSepString = aSepString.to_str if aSepString
+        elsif aSepString.respond_to?(:to_int)
+          numberOfBytes = aSepString.to_int
+          aSepString    = $/
+        else
+          numberOfBytes = nil
+          aSepString = aSepString.to_str if aSepString
+        end
+
+        return read(numberOfBytes) if aSepString.nil?
+        aSepString = "#{$/}#{$/}" if aSepString.empty?
+
+        bufferIndex = 0
+        overLimit   = (numberOfBytes && @output_buffer.bytesize >= numberOfBytes)
+        while ((matchIndex = @output_buffer.index(aSepString, bufferIndex)) == nil && !overLimit)
+          bufferIndex = [bufferIndex, @output_buffer.bytesize - aSepString.bytesize].max
+          if input_finished?
+            return @output_buffer.empty? ? nil : flush
+          end
+          @output_buffer << produce_input
+          overLimit = (numberOfBytes && @output_buffer.bytesize >= numberOfBytes)
+        end
+        sepIndex = [matchIndex + aSepString.bytesize, numberOfBytes || @output_buffer.bytesize].min
+        @pos     += sepIndex
+        return @output_buffer.slice!(0...sepIndex)
+      end
+
+      def flush
+        retVal        = @output_buffer
+        @output_buffer=""
+        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)
+        end
+      rescue EOFError
+      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
+end
+
+# Copyright (C) 2002-2004 Thomas Sondergaard
+# rubyzip is free software; you can redistribute it and/or
+# modify it under the terms of the ruby license.

data/lib/zip/null_compressor.rb

@@ -0,0 +1,15 @@
+module Zip
+  class NullCompressor < Compressor #:nodoc:all
+    include Singleton
+
+    def <<(data)
+      raise IOError, "closed stream"
+    end
+
+    attr_reader :size, :compressed_size
+  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/null_decompressor.rb

@@ -0,0 +1,27 @@
+module Zip
+  class NullDecompressor #:nodoc:all
+    include Singleton
+
+    def sysread(numberOfBytes = nil, buf = nil)
+      nil
+    end
+
+    def produce_input
+      nil
+    end
+
+    def input_finished?
+      true
+    end
+
+    def eof
+      true
+    end
+
+    alias :eof? :eof
+  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/null_input_stream.rb

@@ -0,0 +1,9 @@
+module Zip
+  class NullInputStream < NullDecompressor #:nodoc:all
+    include ::Zip::IOExtras::AbstractInputStream
+  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.