class Zip64::Writer

Overview

Writes (streams) zip entries to an IO.

Example

require "zip64"

File.open("./file.zip", "w") do |file|
  Zip64::Writer.open(file) do |zip|
    # Add a file with a String content
    zip.add "foo.txt", "contents of foo"

    # Add a file and write data to it through an IO
    zip.add("bar.txt") do |io|
      io << "contents of bar"
    end

    # Add a file by referencing a file in the filesystem
    # (the file is automatically closed after this call)
    zip.add("baz.txt", File.open("./some_file.txt"))
  end
end

Defined in:

zip64/writer.cr

Constructors

Class Method Summary

Instance Method Summary

Constructor Detail

def self.new(io : IO, sync_close : Bool = false) #

Creates a new writer to the given io.


[View source]
def self.new(filename : Path | String) #

Creates a new writer to the given filename.


[View source]

Class Method Detail

def self.open(io : IO, sync_close = false, &) #

Creates a new writer to the given io, yields it to the given block, and closes it at the end.


[View source]
def self.open(filename : Path | String, &) #

Creates a new writer to the given filename, yields it to the given block, and closes it at the end.


[View source]

Instance Method Detail

def add(filename : Path | String, &) #

Adds an entry that will have the given filename and current time (Time.utc) and yields an IO to write that entry's contents.


[View source]
def add(entry : Entry, &) #

Adds an Entry and yields IO for writing that entry's contents. After the IO has been written and the block terminates will write out the accumulated CRC32 for the entry and the sizes as the data descriptor.

Entry can be configured the same way as for #add() without the block, however the bit 3 of the general_purpose_bit_flag is going to be forcibly set, and the compressed/uncompressed sizes and CRC32 are going to be reset to 0.


[View source]
def add(filename_or_entry : Path | String | Entry, string : String) : Nil #

Adds an entry that will have string as its contents.


[View source]
def add(filename_or_entry : Path | String | Entry, bytes : Bytes) : Nil #

Adds an entry that will have bytes as its contents.


[View source]
def add(filename_or_entry : Path | String | Entry, data : IO) : Nil #

Adds an entry that will have its data copied from the given data. If the given data is a ::File, it is automatically closed after data is copied from it.


[View source]
def add(entry : Entry) #

Adds an Entry to the Writer and writes out its local file header.

Calling the method without the block does not enable data descriptors, so the CRC32 for the entry has to be set upfront, as well as the correct compressed_size and uncompressed_size

You can choose the Entry's compression method before adding it. You can also set the Entry's time (which is Time.utc by default) and extra data before adding it to the zip stream.


[View source]
def add_dir(name) : Nil #

Adds a directory entry that will have the given name.


[View source]
def close : Nil #

Closes this zip writer.


[View source]
def closed? : Bool #

Returns true if this writer is closed.


[View source]
def comment=(comment : String) #

Sets the zip file comment


[View source]
def simulate_write(by : Int) #

Advance the internal offset by a number of bytes. This can be useful for esimating the size of the resulting ZIP archive without having access to the contents of files that are going to be included in the archive later.


[View source]
def sync_close=(sync_close : Bool) #

Whether to close the enclosed IO when closing this writer.


[View source]
def sync_close? : Bool #

Whether to close the enclosed IO when closing this writer.


[View source]
def written #

How many bytes have been written into the destination IO so far


[View source]