From 96354ffa09358580ef3f776ac13d467508daf885 Mon Sep 17 00:00:00 2001 From: Ryan Levick Date: Mon, 15 Jun 2020 18:09:10 +0200 Subject: [PATCH 1/2] More cleanup --- src/read.rs | 126 +++++++++++++++++++++++++++------------------------- 1 file changed, 66 insertions(+), 60 deletions(-) diff --git a/src/read.rs b/src/read.rs index d3e0960c..8155c810 100644 --- a/src/read.rs +++ b/src/read.rs @@ -26,10 +26,9 @@ mod ffi { /// Wrapper for reading the contents of a ZIP file. /// -/// ``` -/// fn doit() -> zip::result::ZipResult<()> -/// { -/// use std::io::prelude::*; +/// ```no_run +/// use std::io::prelude::*; +/// fn main() -> zip::result::ZipResult<()> { /// /// // For demonstration purposes we read from an empty buffer. /// // Normally a File object would be used. @@ -38,8 +37,7 @@ mod ffi { /// /// let mut zip = zip::ZipArchive::new(reader)?; /// -/// for i in 0..zip.len() -/// { +/// 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()?; @@ -47,8 +45,6 @@ mod ffi { /// } /// Ok(()) /// } -/// -/// println!("Result: {:?}", doit()); /// ``` #[derive(Clone, Debug)] pub struct ZipArchive { @@ -59,49 +55,6 @@ pub struct ZipArchive { comment: Vec, } -enum ZipFileReader<'a> { - NoReader, - Stored(Crc32Reader>), - #[cfg(feature = "deflate")] - Deflated(Crc32Reader>>), - #[cfg(feature = "bzip2")] - Bzip2(Crc32Reader>>), -} - -/// A struct for reading a zip file -pub struct ZipFile<'a> { - data: Cow<'a, ZipFileData>, - reader: ZipFileReader<'a>, -} - -fn unsupported_zip_error(detail: &'static str) -> ZipResult { - Err(ZipError::UnsupportedArchive(detail)) -} - -fn make_reader<'a>( - compression_method: crate::compression::CompressionMethod, - crc32: u32, - reader: io::Take<&'a mut dyn io::Read>, -) -> ZipResult> { - match compression_method { - CompressionMethod::Stored => Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32))), - #[cfg(feature = "deflate")] - CompressionMethod::Deflated => { - let deflate_reader = DeflateDecoder::new(reader); - Ok(ZipFileReader::Deflated(Crc32Reader::new( - deflate_reader, - crc32, - ))) - } - #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2 => { - let bzip2_reader = BzDecoder::new(reader); - Ok(ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32))) - } - _ => unsupported_zip_error("Compression method not supported"), - } -} - impl ZipArchive { /// Get the directory start offset and number of files. This is done in a /// separate function to ease the control flow design. @@ -236,13 +189,11 @@ impl ZipArchive { /// Number of files contained in this zip. /// /// ``` - /// fn iter() { - /// let mut zip = zip::ZipArchive::new(std::io::Cursor::new(vec![])).unwrap(); + /// 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 - /// } + /// for i in 0..zip.len() { + /// let mut file = zip.by_index(i).unwrap(); + /// // Do something with file i /// } /// ``` pub fn len(&self) -> usize { @@ -325,6 +276,43 @@ impl ZipArchive { } } +enum ZipFileReader<'a> { + NoReader, + Stored(Crc32Reader>), + #[cfg(feature = "deflate")] + Deflated(Crc32Reader>>), + #[cfg(feature = "bzip2")] + Bzip2(Crc32Reader>>), +} + +fn unsupported_zip_error(detail: &'static str) -> ZipResult { + Err(ZipError::UnsupportedArchive(detail)) +} + +fn make_reader<'a>( + compression_method: crate::compression::CompressionMethod, + crc32: u32, + reader: io::Take<&'a mut dyn io::Read>, +) -> ZipResult> { + match compression_method { + CompressionMethod::Stored => Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32))), + #[cfg(feature = "deflate")] + CompressionMethod::Deflated => { + let deflate_reader = DeflateDecoder::new(reader); + Ok(ZipFileReader::Deflated(Crc32Reader::new( + deflate_reader, + crc32, + ))) + } + #[cfg(feature = "bzip2")] + CompressionMethod::Bzip2 => { + let bzip2_reader = BzDecoder::new(reader); + Ok(ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32))) + } + _ => unsupported_zip_error("Compression method not supported"), + } +} + fn central_header_to_zip_file( reader: &mut R, archive_offset: u64, @@ -439,11 +427,18 @@ fn get_reader<'a>(reader: &'a mut ZipFileReader<'_>) -> &'a mut dyn Read { } } +/// A struct for reading a zip file +pub struct ZipFile<'a> { + data: Cow<'a, ZipFileData>, + reader: ZipFileReader<'a>, +} + /// Methods for retrieving information on zip files impl<'a> ZipFile<'a> { fn get_reader(&mut self) -> &mut dyn Read { get_reader(&mut self.reader) } + /// Get the version of the file pub fn version_made_by(&self) -> (u8, u8) { ( @@ -451,35 +446,43 @@ impl<'a> ZipFile<'a> { self.data.version_made_by % 10, ) } + /// Get the name of the file pub fn name(&self) -> &str { - &*self.data.file_name + &self.data.file_name } + /// Get the name of the file, in the raw (internal) byte representation. pub fn name_raw(&self) -> &[u8] { - &*self.data.file_name_raw + &self.data.file_name_raw } + /// 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. pub fn sanitized_name(&self) -> ::std::path::PathBuf { self.data.file_name_sanitized() } + /// Get the comment of the file pub fn comment(&self) -> &str { - &*self.data.file_comment + &self.data.file_comment } + /// Get the compression method used to store the file pub fn compression(&self) -> CompressionMethod { self.data.compression_method } + /// Get the size of the file in the archive pub fn compressed_size(&self) -> u64 { self.data.compressed_size } + /// Get the size of the file when uncompressed pub fn size(&self) -> u64 { self.data.uncompressed_size } + /// Get the time the file was last modified pub fn last_modified(&self) -> DateTime { self.data.last_modified_time @@ -492,10 +495,12 @@ impl<'a> ZipFile<'a> { .next() .map_or(false, |c| c == '/' || c == '\\') } + /// Returns whether the file is a regular file pub fn is_file(&self) -> bool { !self.is_dir() } + /// Get unix mode for the file pub fn unix_mode(&self) -> Option { if self.data.external_attributes == 0 { @@ -520,6 +525,7 @@ impl<'a> ZipFile<'a> { _ => None, } } + /// Get the CRC32 hash of the original file pub fn crc32(&self) -> u32 { self.data.crc32 From 5e76689f49a600e198cebbc7e0be802899bc6ec8 Mon Sep 17 00:00:00 2001 From: Ryan Levick Date: Tue, 16 Jun 2020 18:54:42 +0200 Subject: [PATCH 2/2] Don't run doc test since it will panic --- src/read.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/read.rs b/src/read.rs index 8155c810..52fe75cf 100644 --- a/src/read.rs +++ b/src/read.rs @@ -188,7 +188,7 @@ 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() {