From f508aac0cd7e8e04bd9f08aec37fccbf6767ac1b Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 12:20:43 +0100 Subject: [PATCH 01/18] docs: elaborate on usage of CompressionMethod --- src/compression.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/compression.rs b/src/compression.rs index 5888fe7c..3183e851 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -3,19 +3,25 @@ use std::fmt; #[allow(deprecated)] -/// Compression methods for the contents of a ZIP file. +/// Identifies the storage format used to compress a file within a ZIP archive. +/// +/// Each file's compression method is stored alongside it, allowing the +/// contents to be read without context. +/// +/// When creating ZIP files, you may choose the method to use with +/// [`zip::write::FileOptions::compression_method`] #[derive(Copy, Clone, PartialEq, Debug)] pub enum CompressionMethod { - /// The file is stored (no compression) + /// Store the file as is Stored, - /// Deflate using any flate2 backend + /// Compress the file using Deflate #[cfg(any( feature = "deflate", feature = "deflate-miniz", feature = "deflate-zlib" ))] Deflated, - /// File is compressed using BZIP2 algorithm + /// Compress the file using BZIP2 #[cfg(feature = "bzip2")] Bzip2, /// Unsupported compression method From df8f377f92c20e624882a42322e0fbe0dfbf6041 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 12:21:48 +0100 Subject: [PATCH 02/18] docs: warn users about DateTime implementation --- src/types.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/types.rs b/src/types.rs index a855c923..8738cb51 100644 --- a/src/types.rs +++ b/src/types.rs @@ -26,6 +26,12 @@ impl System { /// When constructed manually from a date and time, it will also check if the input is sensible /// (e.g. months are from [1, 12]), but when read from a zip some parts may be out of their normal /// bounds (e.g. month 0, or hour 31). +/// +/// # Warning +/// +/// Some utilities use alternative timestamps to improve the accuracy of their +/// ZIPs, but we don't parse them yet. [We're working on this](https://github.com/mvdnes/zip-rs/issues/156#issuecomment-652981904), +/// however this API shouldn't be considered complete. #[derive(Debug, Clone, Copy)] pub struct DateTime { year: u16, From f86c310fdcfcec8a5a2e530c698f44e0b29f1593 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:23:00 +0100 Subject: [PATCH 03/18] docs: deprecate `Path` handling methods These methods were implemented in a non-intuitive way that could easily lead to bugs. They may be replaced in a future release --- src/write.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/write.rs b/src/write.rs index 6a12816f..92be7c67 100644 --- a/src/write.rs +++ b/src/write.rs @@ -290,6 +290,10 @@ impl ZipWriter { /// /// This function ensures that the '/' path seperator is used. It also ignores all non 'Normal' /// Components, such as a starting '/' or '..' and '.'. + #[deprecated( + since = "0.5.7", + note = "by stripping `..`s from the path, the meaning of paths can change. Use `start_file` instead." + )] pub fn start_file_from_path( &mut self, path: &std::path::Path, @@ -327,6 +331,10 @@ impl ZipWriter { /// /// This function ensures that the '/' path seperator is used. It also ignores all non 'Normal' /// Components, such as a starting '/' or '..' and '.'. + #[deprecated( + since = "0.5.7", + note = "by stripping `..`s from the path, the meaning of paths can change. Use `add_directory` instead." + )] pub fn add_directory_from_path( &mut self, path: &std::path::Path, From 0e482afe2ee558559a24aa762d2fa51ddeefc695 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:23:59 +0100 Subject: [PATCH 04/18] docs: the default comment was removed --- src/write.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/write.rs b/src/write.rs index 92be7c67..945a3ad3 100644 --- a/src/write.rs +++ b/src/write.rs @@ -196,7 +196,7 @@ impl ZipWriter { } } - /// Set ZIP archive comment. Defaults to 'zip-rs' if not set. + /// Set ZIP archive comment. pub fn set_comment(&mut self, comment: S) where S: Into, From 33de808d0f06fef4a6bc8100ebb15f01798fc621 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:25:21 +0100 Subject: [PATCH 05/18] docs: use more descriptive langauge --- src/write.rs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/write.rs b/src/write.rs index 945a3ad3..192706d5 100644 --- a/src/write.rs +++ b/src/write.rs @@ -1,4 +1,4 @@ -//! Structs for creating a new zip archive +//! Types for creating ZIP archives use crate::compression::CompressionMethod; use crate::result::{ZipError, ZipResult}; @@ -34,7 +34,10 @@ enum GenericZipWriter { Bzip2(BzEncoder), } -/// Generator for ZIP files. +/// ZIP archive generator +/// +/// Handles the bookkeeping involved in building an archive, and provides an +/// API to edit its contents. /// /// ``` /// fn doit() -> zip::result::ZipResult<()> @@ -183,9 +186,9 @@ impl ZipWriterStats { } impl ZipWriter { - /// Initializes the ZipWriter. + /// Initializes the archive. /// - /// Before writing to this object, the start_file command should be called. + /// Before writing to this object, the [`ZipWriter::start_file`] function should be called. pub fn new(inner: W) -> ZipWriter { ZipWriter { inner: GenericZipWriter::Storer(inner), @@ -272,7 +275,9 @@ impl ZipWriter { Ok(()) } - /// Starts a file. + /// Create a file in the archive and start writing its' contents. + /// + /// The data should be written using the [`io::Write`] implementation on this [`ZipWriter`] pub fn start_file(&mut self, name: S, mut options: FileOptions) -> ZipResult<()> where S: Into, From 4091167222fdc81a042ef1209c8aa1b54ca14104 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:25:31 +0100 Subject: [PATCH 06/18] docs: simplify test --- src/write.rs | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/src/write.rs b/src/write.rs index 192706d5..0a861cd9 100644 --- a/src/write.rs +++ b/src/write.rs @@ -40,26 +40,27 @@ enum GenericZipWriter { /// API to edit its contents. /// /// ``` -/// fn doit() -> zip::result::ZipResult<()> -/// { -/// use std::io::Write; +/// # fn doit() -> zip::result::ZipResult<()> +/// # { +/// # use zip::ZipWriter; +/// use std::io::Write; +/// use zip::write::FileOptions; /// -/// // For this example we write to a buffer, but normally you should use a File -/// let mut buf: &mut [u8] = &mut [0u8; 65536]; -/// let mut w = std::io::Cursor::new(buf); -/// let mut zip = zip::ZipWriter::new(w); +/// // We use a buffer here, though you'd normally use a `File` +/// let mut buf = [0; 65536]; +/// let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf)); /// -/// let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); -/// zip.start_file("hello_world.txt", options)?; -/// zip.write(b"Hello, World!")?; +/// let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); +/// zip.start_file("hello_world.txt", options)?; +/// zip.write(b"Hello, World!")?; /// -/// // Optionally finish the zip. (this is also done on drop) -/// zip.finish()?; +/// // Apply the changes you've made. +/// // Dropping the `ZipWriter` will have the same effect, but may silently fail +/// zip.finish()?; /// -/// Ok(()) -/// } -/// -/// println!("Result: {:?}", doit().unwrap()); +/// # Ok(()) +/// # } +/// # doit().unwrap(); /// ``` pub struct ZipWriter { inner: GenericZipWriter, From 33cd959b11e41f4373c149f4afee88c4d90f6718 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:33:37 +0100 Subject: [PATCH 07/18] docs: elaborate on purpose of crate --- src/lib.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index fdcb8fb5..9bda2fd4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,7 @@ -//! A basic ZipReader/Writer crate +//! An ergonomic API for reading and writing ZIP files. +//! +//! The current implementation is based on [PKWARE's APPNOTE.TXT v6.3.9](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) +// TODO: Decide on the crate's bias: Do we prioritise permissiveness/correctness/speed/ergonomics? #![warn(missing_docs)] From 54e532f26e97e4d2a9e726172959b5d427ffcab5 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:36:17 +0100 Subject: [PATCH 08/18] fix: arrays aren't io::Write --- src/write.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/write.rs b/src/write.rs index 0a861cd9..cf43c3fb 100644 --- a/src/write.rs +++ b/src/write.rs @@ -48,7 +48,7 @@ enum GenericZipWriter { /// /// // We use a buffer here, though you'd normally use a `File` /// let mut buf = [0; 65536]; -/// let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf)); +/// let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf[..])); /// /// let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); /// zip.start_file("hello_world.txt", options)?; From 8f36598cac76381c4313b497fda7f65459f162b2 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:36:35 +0100 Subject: [PATCH 09/18] refactor: use deprecated API in example --- examples/write_dir.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/write_dir.rs b/examples/write_dir.rs index a89801c9..793bd6ba 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -80,6 +80,7 @@ where // Some unzip tools unzip files with directory paths correctly, some do not! if path.is_file() { println!("adding file {:?} as {:?} ...", path, name); + #[allow(deprecated)] zip.start_file_from_path(name, options)?; let mut f = File::open(path)?; @@ -90,6 +91,7 @@ where // Only if not root! Avoids path spec / warning // and mapname conversion failed error on unzip println!("adding dir {:?} as {:?} ...", path, name); + #[allow(deprecated)] zip.add_directory_from_path(name, options)?; } } From e8eb019e999fcfaa1c1d8bf7711f1f0e715218b6 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:51:50 +0100 Subject: [PATCH 10/18] docs: simplify doctest --- src/read.rs | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/src/read.rs b/src/read.rs index cfe4078b..c27200c8 100644 --- a/src/read.rs +++ b/src/read.rs @@ -34,24 +34,21 @@ mod ffi { /// Wrapper for reading the contents of a ZIP file. /// /// ```no_run -/// use std::io::prelude::*; -/// fn main() -> zip::result::ZipResult<()> { +/// # use std::io::prelude::*; +/// # fn main() -> zip::result::ZipResult<()> { +/// # let buf: &[u8] = &[0u8; 128]; +/// # let mut reader = std::io::Cursor::new(buf); +/// # let mut stdout = std::io::stdout(); +/// # let mut stdout = stdout.lock(); +/// let mut zip = zip::ZipArchive::new(reader)?; /// -/// // For demonstration purposes we read from an empty buffer. -/// // Normally a File object would be used. -/// let buf: &[u8] = &[0u8; 128]; -/// let mut reader = std::io::Cursor::new(buf); -/// -/// let mut zip = zip::ZipArchive::new(reader)?; -/// -/// for i in 0..zip.len() { -/// let mut file = zip.by_index(i).unwrap(); -/// println!("Filename: {}", file.name()); -/// let first_byte = file.bytes().next().unwrap()?; -/// println!("{}", first_byte); -/// } -/// Ok(()) +/// for i in 0..zip.len() { +/// let mut file = zip.by_index(i)?; +/// println!("Filename: {}", file.name()); +/// std::io::copy(&mut file, &mut stdout); /// } +/// # Ok(()) +/// # } /// ``` #[derive(Clone, Debug)] pub struct ZipArchive { From bebecb8301098f2858a9d4e9afd2254afd6ec538 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:52:27 +0100 Subject: [PATCH 11/18] docs: use more descriptive language --- src/read.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/read.rs b/src/read.rs index c27200c8..2a8dcff5 100644 --- a/src/read.rs +++ b/src/read.rs @@ -1,4 +1,4 @@ -//! Structs for reading a ZIP archive +//! Types for reading ZIP archives use crate::compression::CompressionMethod; use crate::crc32::Crc32Reader; @@ -31,7 +31,7 @@ mod ffi { pub const S_IFREG: u32 = 0o0100000; } -/// Wrapper for reading the contents of a ZIP file. +/// ZIP archive reader /// /// ```no_run /// # use std::io::prelude::*; @@ -276,7 +276,9 @@ impl ZipArchive { } } - /// Opens a Zip archive and parses the central directory + /// Read a ZIP archive, collecting the files it contains + /// + /// This uses the central directory record of the ZIP file, and ignores local file headers pub fn new(mut reader: R) -> ZipResult> { let (footer, cde_start_pos) = spec::CentralDirectoryEnd::find_and_parse(&mut reader)?; From 599640c1ebea92fc70a560037cb402c08fabc68b Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:52:46 +0100 Subject: [PATCH 12/18] docs: remove redundant example --- src/read.rs | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/read.rs b/src/read.rs index 2a8dcff5..9a977359 100644 --- a/src/read.rs +++ b/src/read.rs @@ -356,15 +356,6 @@ impl ZipArchive { } /// Number of files contained in this zip. - /// - /// ```no_run - /// let mut zip = zip::ZipArchive::new(std::io::Cursor::new(vec![])).unwrap(); - /// - /// for i in 0..zip.len() { - /// let mut file = zip.by_index(i).unwrap(); - /// // Do something with file i - /// } - /// ``` pub fn len(&self) -> usize { self.files.len() } From d92a06adec90ec3f1d92dfc071280d84008dce78 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:53:21 +0100 Subject: [PATCH 13/18] docs: deprecate poor Path sanitization --- src/read.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/read.rs b/src/read.rs index 9a977359..2368ab64 100644 --- a/src/read.rs +++ b/src/read.rs @@ -607,6 +607,11 @@ impl<'a> ZipFile<'a> { /// Get the name of the file in a sanitized form. It truncates the name to the first NULL byte, /// removes a leading '/' and removes '..' parts. + #[deprecated( + since = "0.5.7", + note = "by stripping `..`s from the path, the meaning of paths can change. + You must use a sanitization strategy that's appropriate for your input" + )] pub fn sanitized_name(&self) -> ::std::path::PathBuf { self.data.file_name_sanitized() } From 4eba55cb7a28b89e208ad6b22378000b238f4906 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 13:59:48 +0100 Subject: [PATCH 14/18] refactor: use deprecated API in tests --- examples/extract.rs | 1 + examples/file_info.rs | 1 + tests/zip64_large.rs | 1 + tests/zip_crypto.rs | 1 + 4 files changed, 4 insertions(+) diff --git a/examples/extract.rs b/examples/extract.rs index 83ecebaf..fcd23e3a 100644 --- a/examples/extract.rs +++ b/examples/extract.rs @@ -18,6 +18,7 @@ fn real_main() -> i32 { for i in 0..archive.len() { let mut file = archive.by_index(i).unwrap(); + #[allow(deprecated)] let outpath = file.sanitized_name(); { diff --git a/examples/file_info.rs b/examples/file_info.rs index c02cda48..bed1b818 100644 --- a/examples/file_info.rs +++ b/examples/file_info.rs @@ -19,6 +19,7 @@ fn real_main() -> i32 { for i in 0..archive.len() { let file = archive.by_index(i).unwrap(); + #[allow(deprecated)] let outpath = file.sanitized_name(); { diff --git a/tests/zip64_large.rs b/tests/zip64_large.rs index 738a8beb..c4b5a6b4 100644 --- a/tests/zip64_large.rs +++ b/tests/zip64_large.rs @@ -195,6 +195,7 @@ fn zip64_large() { for i in 0..archive.len() { let mut file = archive.by_index(i).unwrap(); + #[allow(deprecated)] let outpath = file.sanitized_name(); println!( "Entry {} has name \"{}\" ({} bytes)", diff --git a/tests/zip_crypto.rs b/tests/zip_crypto.rs index da137cec..9b527bd1 100644 --- a/tests/zip_crypto.rs +++ b/tests/zip_crypto.rs @@ -70,6 +70,7 @@ fn encrypted_file() { { // Correct password, read contents let mut file = archive.by_index_decrypt(0, "test".as_bytes()).unwrap(); + #[allow(deprecated)] let file_name = file.sanitized_name(); assert_eq!(file_name, std::path::PathBuf::from("test.txt")); From 0b46263eac1541d885dcee65582e2726056acd1a Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Wed, 19 Aug 2020 14:02:35 +0100 Subject: [PATCH 15/18] fix: ZipArchive::extract incomplete Path sanitization needs to be implemented before we can make this public --- src/read.rs | 9 +++++++-- tests/extract.rs | 10 +++++----- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/read.rs b/src/read.rs index 2368ab64..ab310132 100644 --- a/src/read.rs +++ b/src/read.rs @@ -322,10 +322,14 @@ impl ZipArchive { /// # Platform-specific behaviour /// /// On unix systems permissions from the zip file are preserved, if they exist. - pub fn extract>(&mut self, directory: P) -> ZipResult<()> { + // FIXME: Implement path sanitization to allow this to be public API. + // This probably means failing on paths that would escape the directory + #[allow(dead_code)] + fn extract>(&mut self, directory: P) -> ZipResult<()> { for i in 0..self.len() { let mut file = self.by_index(i)?; - let filepath = file.sanitized_name(); + let filepath: std::path::PathBuf = + (|| unimplemented!("the sanitized path of {}", file.name()))(); let outpath = directory.as_ref().join(filepath); @@ -936,6 +940,7 @@ mod test { for i in 0..zip.len() { let zip_file = zip.by_index(i).unwrap(); + #[allow(deprecated)] let full_name = zip_file.sanitized_name(); let file_name = full_name.file_name().unwrap().to_str().unwrap(); assert!( diff --git a/tests/extract.rs b/tests/extract.rs index f71c9822..2f05e1df 100644 --- a/tests/extract.rs +++ b/tests/extract.rs @@ -2,20 +2,20 @@ extern crate zip; use std::fs; use std::io; -use std::path::PathBuf; use zip::ZipArchive; // This tests extracting the contents of a zip file #[test] +#[ignore] fn extract() { let mut v = Vec::new(); v.extend_from_slice(include_bytes!("../tests/data/files_and_dirs.zip")); - let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file"); + let mut _archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file"); - archive - .extract(&PathBuf::from("test_directory")) - .expect("extract failed"); + // archive + // .extract("test_directory") + // .expect("extract failed"); // Cleanup fs::remove_dir_all("test_directory").expect("failed to remove extracted files"); From 1be80f12de821a9e8aabb4b1010db420522ac89f Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Tue, 25 Aug 2020 22:01:12 +0100 Subject: [PATCH 16/18] docs: add reference to GitHub issue --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 9bda2fd4..3b39ab4f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,7 +1,7 @@ //! An ergonomic API for reading and writing ZIP files. //! //! The current implementation is based on [PKWARE's APPNOTE.TXT v6.3.9](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) -// TODO: Decide on the crate's bias: Do we prioritise permissiveness/correctness/speed/ergonomics? +// TODO(#184): Decide on the crate's bias: Do we prioritise permissiveness/correctness/speed/ergonomics? #![warn(missing_docs)] From 25d479e65d91cd6536b9bd3b3cd984a99b3eb9f9 Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Tue, 25 Aug 2020 22:03:44 +0100 Subject: [PATCH 17/18] chore: remove dead code for 0.5.7 --- src/read.rs | 48 ------------------------------------------------ tests/extract.rs | 22 ---------------------- 2 files changed, 70 deletions(-) delete mode 100644 tests/extract.rs diff --git a/src/read.rs b/src/read.rs index ab310132..0d47bd59 100644 --- a/src/read.rs +++ b/src/read.rs @@ -8,9 +8,7 @@ use crate::zipcrypto::ZipCryptoReader; use crate::zipcrypto::ZipCryptoReaderValid; use std::borrow::Cow; use std::collections::HashMap; -use std::fs; use std::io::{self, prelude::*}; -use std::path::Path; use crate::cp437::FromCp437; use crate::types::{DateTime, System, ZipFileData}; @@ -313,52 +311,6 @@ impl ZipArchive { }) } - /// Extract a Zip archive into a directory. - /// - /// Paths are sanitized so that they cannot escape the given directory. - /// - /// This bails on the first error and does not attempt cleanup. - /// - /// # Platform-specific behaviour - /// - /// On unix systems permissions from the zip file are preserved, if they exist. - // FIXME: Implement path sanitization to allow this to be public API. - // This probably means failing on paths that would escape the directory - #[allow(dead_code)] - fn extract>(&mut self, directory: P) -> ZipResult<()> { - for i in 0..self.len() { - let mut file = self.by_index(i)?; - let filepath: std::path::PathBuf = - (|| unimplemented!("the sanitized path of {}", file.name()))(); - - let outpath = directory.as_ref().join(filepath); - - if (file.name()).ends_with('/') { - fs::create_dir_all(&outpath)?; - } else { - if let Some(p) = outpath.parent() { - if !p.exists() { - fs::create_dir_all(&p)?; - } - } - let mut outfile = fs::File::create(&outpath)?; - io::copy(&mut file, &mut outfile)?; - } - - // Get and Set permissions - #[cfg(unix)] - { - use std::os::unix::fs::PermissionsExt; - - if let Some(mode) = file.unix_mode() { - fs::set_permissions(&outpath, fs::Permissions::from_mode(mode))?; - } - } - } - - Ok(()) - } - /// Number of files contained in this zip. pub fn len(&self) -> usize { self.files.len() diff --git a/tests/extract.rs b/tests/extract.rs deleted file mode 100644 index 2f05e1df..00000000 --- a/tests/extract.rs +++ /dev/null @@ -1,22 +0,0 @@ -extern crate zip; - -use std::fs; -use std::io; - -use zip::ZipArchive; - -// This tests extracting the contents of a zip file -#[test] -#[ignore] -fn extract() { - let mut v = Vec::new(); - v.extend_from_slice(include_bytes!("../tests/data/files_and_dirs.zip")); - let mut _archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file"); - - // archive - // .extract("test_directory") - // .expect("extract failed"); - - // Cleanup - fs::remove_dir_all("test_directory").expect("failed to remove extracted files"); -} From 9d978e3c51034cfc4062d966d606a9e13a5284ef Mon Sep 17 00:00:00 2001 From: Marli Frost Date: Tue, 25 Aug 2020 22:17:28 +0100 Subject: [PATCH 18/18] docs: remove clutter from doctest --- src/read.rs | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/src/read.rs b/src/read.rs index 0d47bd59..443cb305 100644 --- a/src/read.rs +++ b/src/read.rs @@ -32,21 +32,18 @@ mod ffi { /// ZIP archive reader /// /// ```no_run -/// # use std::io::prelude::*; -/// # fn main() -> zip::result::ZipResult<()> { -/// # let buf: &[u8] = &[0u8; 128]; -/// # let mut reader = std::io::Cursor::new(buf); -/// # let mut stdout = std::io::stdout(); -/// # let mut stdout = stdout.lock(); -/// let mut zip = zip::ZipArchive::new(reader)?; +/// use std::io::prelude::*; +/// fn list_zip_contents(reader: impl Read + Seek) -> zip::result::ZipResult<()> { +/// let mut zip = zip::ZipArchive::new(reader)?; /// -/// for i in 0..zip.len() { -/// let mut file = zip.by_index(i)?; -/// println!("Filename: {}", file.name()); -/// std::io::copy(&mut file, &mut stdout); +/// for i in 0..zip.len() { +/// let mut file = zip.by_index(i)?; +/// println!("Filename: {}", file.name()); +/// std::io::copy(&mut file, &mut std::io::stdout()); +/// } +/// +/// Ok(()) /// } -/// # Ok(()) -/// # } /// ``` #[derive(Clone, Debug)] pub struct ZipArchive {