Class: Zip::ZipInputStream

Inherits:
Object
  • Object
show all
Includes:
IOExtras::AbstractInputStream
Defined in:
lib/zip/zip_input_stream.rb

Overview

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.

Instance Attribute Summary

Attributes included from IOExtras::AbstractInputStream

#lineno

Class Method Summary collapse

Instance Method Summary collapse

Methods included from IOExtras::AbstractInputStream

#each_line, #flush, #gets, #read, #readline, #readlines

Methods included from IOExtras::FakeIO

#kind_of?

Constructor Details

#initialize(filename, offset = 0, io = nil) ⇒ ZipInputStream

Opens the indicated zip file. An exception is thrown if the specified offset in the specified filename is not a local zip entry header.



49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/zip/zip_input_stream.rb', line 49

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

Class Method Details

.open(filename) ⇒ Object

Same as #initialize but if a block is passed the opened stream is passed to the block and closed when the block returns.



68
69
70
71
72
73
74
75
 
# File 'lib/zip/zip_input_stream.rb', line 68

def ZipInputStream.open(filename)
  return new(filename) unless block_given?
  
  zio = new(filename)
  yield zio
ensure
  zio.close if zio
end

.open_buffer(io) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/zip/zip_input_stream.rb', line 77

def ZipInputStream.open_buffer(io)
  return new('',0,io) unless block_given?
  zio = new('',0,io)
  yield zio
ensure
  zio.close if zio
end

Instance Method Details

#close ⇒ Object 



61
62
63
 
# File 'lib/zip/zip_input_stream.rb', line 61

def close
  @archiveIO.close
end

#eof ⇒ Object Also known as: eof? 



109
110
111
 
# File 'lib/zip/zip_input_stream.rb', line 109

def eof
  @outputBuffer.empty? && @decompressor.eof
end

#get_next_entry ⇒ Object

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.



90
91
92
93
 
# File 'lib/zip/zip_input_stream.rb', line 90

def get_next_entry
  @archiveIO.seek(@currentEntry.next_header_offset, IO::SEEK_SET) if @currentEntry
  open_entry
end

#rewind ⇒ Object

Rewinds the stream to the beginning of the current entry



96
97
98
99
100
101
102
 
# File 'lib/zip/zip_input_stream.rb', line 96

def rewind
  return if @currentEntry.nil?
  @lineno = 0
  @archiveIO.seek(@currentEntry.localHeaderOffset, 
    IO::SEEK_SET)
  open_entry
end

#sysread(numberOfBytes = nil, buf = nil) ⇒ Object

Modeled after IO.sysread



105
106
107
 
# File 'lib/zip/zip_input_stream.rb', line 105

def sysread(numberOfBytes = nil, buf = nil)
  @decompressor.sysread(numberOfBytes, buf)
end