Package 'zip'

Description

Compress a raw GZIP stream

Usage

deflate(buffer, level = 6L, pos = 1L, size = NULL)

Arguments

Value

Named list with three entries:

• output: raw vector, the compressed data,

• bytes_read: number of bytes used from buffer,

• bytes_written: number of bytes written to the output buffer.

See Also

base::memCompress() does the same with type = "gzip", but it does not tell you the number of bytes read from the input.

Examples

data_gz <- deflate(charToRaw("Hello world!"))
inflate(data_gz$output)

Description

Uncompress a raw GZIP stream

Usage

inflate(buffer, pos = 1L, size = NULL)

Arguments

Value

Named list with three entries:

• output: raw vector, the uncompressed data,

• bytes_read: number of bytes used from buffer,

• bytes_written: number of bytes written to the output buffer.

See Also

base::memDecompress() does the same with type = "gzip", but it does not tell you the number of bytes read from the input.

Examples

data_gz <- deflate(charToRaw("Hello world!"))
inflate(data_gz$output)

Description

unzip() always restores modification times of the extracted files and directories.

Usage

unzip(
  zipfile,
  files = NULL,
  overwrite = TRUE,
  junkpaths = FALSE,
  exdir = ".",
  encoding = NULL
)

Arguments

Value

A data frame with one row per extracted entry and columns, invisibly: filename (path within the archive), compressed_size, uncompressed_size, timestamp, permissions, crc32, offset, type (same as in zip_list()), and path (absolute path to the extracted file on disk).

Permissions

If the zip archive stores permissions and was created on Unix, the permissions will be restored.

See Also

Other zip/unzip functions: zip_list()

Examples

## temporary directory, to avoid messing up the user's workspace.
dir.create(tmp <- tempfile())
dir.create(file.path(tmp, "mydir"))
cat("first file", file = file.path(tmp, "mydir", "file1"))
cat("second file", file = file.path(tmp, "mydir", "file2"))

zipfile <- tempfile(fileext = ".zip")
zip::zip(zipfile, "mydir", root = tmp)

## List contents
zip_list(zipfile)

## Extract and inspect result
tmp2 <- tempfile()
result <- unzip(zipfile, exdir = tmp2)
result[, c("filename", "path")]

Description

unzip_process() returns an R6 class that represents an unzip process. It is implemented as a subclass of processx::process.

Usage

unzip_process()

Value

An unzip_process R6 class object, a subclass of processx::process.

Using the unzip_process class

up <- unzip_process()$new(zipfile, exdir = ".", poll_connection = TRUE,
                           stderr = tempfile(), ...)

See processx::process for the class methods.

Arguments:

• zipfile: Path to the zip file to uncompress.

• exdir: Directory to uncompress the archive to. If it does not exist, it will be created.

• poll_connection: passed to the initialize method of processx::process, it allows using processx::poll() or the poll_io() method to poll for the completion of the process.

• stderr: passed to the initialize method of processx::process, by default the standard error is written to a temporary file. This file can be used to diagnose errors if the process failed.

• ... passed to the initialize method of processx::process.

Encoding

The unzip_process class does not support the encoding argument of unzip(). Non-UTF-8 filenames are decoded using the IBM CP437 fallback. Use unzip() directly if you need to handle ZIP files with filenames in other encodings (e.g. CP932).

Examples

ex <- system.file("example.zip", package = "zip")
tmp <- tempfile()
up <- unzip_process()$new(ex, exdir = tmp)
up$wait()
up$get_exit_status()
dir(tmp)

Description

zip() creates a new zip archive file.

Usage

zip(
  zipfile,
  files,
  recurse = TRUE,
  compression_level = 9,
  include_directories = TRUE,
  root = ".",
  mode = c("mirror", "cherry-pick"),
  keys = NULL
)

zipr(
  zipfile,
  files,
  recurse = TRUE,
  compression_level = 9,
  include_directories = TRUE,
  root = ".",
  mode = c("cherry-pick", "mirror"),
  keys = NULL
)

zip_append(
  zipfile,
  files,
  recurse = TRUE,
  compression_level = 9,
  include_directories = TRUE,
  root = ".",
  mode = c("mirror", "cherry-pick"),
  keys = NULL
)

zipr_append(
  zipfile,
  files,
  recurse = TRUE,
  compression_level = 9,
  include_directories = TRUE,
  root = ".",
  mode = c("cherry-pick", "mirror"),
  keys = NULL
)

Arguments

Details

zip_append() appends compressed files to an existing 'zip' file.

Relative paths

zip() and zip_append() can run in two different modes: mirror mode and cherry picking mode. They handle the specified files differently.

Mirror mode

Mirror mode is for creating the zip archive of a directory structure, exactly as it is on the disk. The current working directory will be the root of the archive, and the paths will be fully kept. zip changes the current directory to root before creating the archive.

E.g. consider the following directory structure:

.
|-- foo
|   |-- bar
|   |   |-- file1
|   |   `-- file2
|   `-- bar2
`-- foo2
    `-- file3

Assuming the current working directory is foo, the following zip entries are created by zip:

setwd("foo")
zip::zip("../test.zip", c("bar/file1", "bar2", "../foo2"))
#> Warning in warn_for_dotdot(data$key): Some paths reference parent directory,
#> creating non-portable zip file
zip_list("../test.zip")[, "filename", drop = FALSE]
#> # A data frame: 4 x 1
#>   filename     
#>   <chr>        
#> 1 bar/file1    
#> 2 bar2/        
#> 3 ../foo2/     
#> 4 ../foo2/file3

Note that zip refuses to store files with absolute paths, and chops off the leading / character from these file names. This is because only relative paths are allowed in zip files.

Cherry picking mode

In cherry picking mode, the selected files and directories will be at the root of the archive. This mode is handy if you want to select a subset of files and directories, possibly from different paths and put all of them in the archive, at the top level.

Here is an example with the same directory structure as above:

zip::zip(
  "../test2.zip",
  c("bar/file1", "bar2", "../foo2"),
  mode = "cherry-pick"
)
zip_list("../test2.zip")[, "filename", drop = FALSE]
#> # A data frame: 4 x 1
#>   filename  
#>   <chr>     
#> 1 file1     
#> 2 bar2/     
#> 3 foo2/     
#> 4 foo2/file3

From zip version 2.3.0, "." has a special meaning in the files argument: it will include the files (and possibly directories) within the current working directory, but not the working directory itself. Note that this only applies to cherry picking mode.

Permissions:

zip() (and zip_append(), etc.) add the permissions of the archived files and directories to the ZIP archive, on Unix systems. Most zip and unzip implementations support these, so they will be recovered after extracting the archive.

Note, however that the owner and group (uid and gid) are currently omitted, even on Unix.

zipr() and zipr_append()

These functions exist for historical reasons. They are identical to zip() and zip_append() with a different default for the mode argument.

Value

The name of the created zip file, invisibly.

Examples

## Some files to zip up. We will run all this in the R session's
## temporary directory, to avoid messing up the user's workspace.
dir.create(tmp <- tempfile())
dir.create(file.path(tmp, "mydir"))
cat("first file", file = file.path(tmp, "mydir", "file1"))
cat("second file", file = file.path(tmp, "mydir", "file2"))

zipfile <- tempfile(fileext = ".zip")
zip::zip(zipfile, "mydir", root = tmp)

## List contents
zip_list(zipfile)

## Add another file
cat("third file", file = file.path(tmp, "mydir", "file3"))
zip_append(zipfile, file.path("mydir", "file3"), root = tmp)
zip_list(zipfile)

Description

List Files in a 'zip' Archive

Usage

zip_list(zipfile, encoding = NULL)

Arguments

Details

Note that crc32 is formatted using as.hexmode(). offset refers to the start of the local zip header for each entry. Following the approach of seek() it is stored as a numeric rather than an integer vector and can therefore represent values up to 2^53-1 (9 PB).

Value

A data frame with columns: filename, compressed_size, uncompressed_size, timestamp, permissions, crc32, offset and type. type is one of file, block_device, character_device, directory, FIFO, symlink or socket.

See Also

Other zip/unzip functions: unzip()

Description

zip_process() returns an R6 class that represents a zip process. It is implemented as a subclass of processx::process.

Usage

zip_process()

Value

A zip_process R6 class object, a subclass of processx::process.

Using the zip_process class

zp <- zip_process()$new(zipfile, files, recurse = TRUE,
                         poll_connection = TRUE,
                         stderr = tempfile(), ...)

See processx::process for the class methods.

Arguments:

• zipfile: Path to the zip file to create.

• files: Character vector of paths to files to add to the archive. Each specified file or directory in is created as a top-level entry in the zip archive.

• recurse: Whether to add the contents of directories recursively.

• include_directories: Whether to explicitly include directories in the archive. Including directories might confuse MS Office when reading docx files, so set this to FALSE for creating them.

• poll_connection: passed to the initialize method of processx::process, it allows using processx::poll() or the poll_io() method to poll for the completion of the process.

• stderr: passed to the initialize method of processx::process, by default the standard error is written to a temporary file. This file can be used to diagnose errors if the process failed.

• ... passed to the initialize method of processx::process.

Examples

dir.create(tmp <- tempfile())
write.table(iris, file = file.path(tmp, "iris.ssv"))
zipfile <- tempfile(fileext = ".zip")
zp <- zip_process()$new(zipfile, tmp)
zp$wait()
zp$get_exit_status()
zip_list(zipfile)