From 6fbcc33d8285dc0396cb727aba8852f8771346a9 Mon Sep 17 00:00:00 2001 From: Mathijs van de Nes Date: Fri, 8 Nov 2019 16:58:11 +0100 Subject: [PATCH 01/10] Update README Post a notice that this project will no longer be actively maintained. --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 154167fc..ab6ab5c6 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +**Unfortunately, due to a lack of time and loss of interest, this project will no longer be actively maintained.** + zip-rs ====== @@ -7,6 +9,7 @@ zip-rs [Documentation](http://mvdnes.github.io/rust-docs/zip-rs/zip/index.html) + Info ---- From 99dba6b3975c2df9c9212058bd89574f574b5518 Mon Sep 17 00:00:00 2001 From: Lachezar Lechev Date: Mon, 11 Nov 2019 08:58:59 +0200 Subject: [PATCH 02/10] run `cargo fix --edition` --- examples/write_dir.rs | 2 +- src/cp437.rs | 2 +- src/lib.rs | 8 ++++---- src/read.rs | 36 ++++++++++++++++++------------------ src/result.rs | 8 ++++---- src/spec.rs | 2 +- src/types.rs | 6 +++--- src/write.rs | 20 ++++++++++---------- tests/zip64_large.rs | 8 ++++---- 9 files changed, 46 insertions(+), 46 deletions(-) diff --git a/examples/write_dir.rs b/examples/write_dir.rs index fb36ccaf..fb957742 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -48,7 +48,7 @@ fn real_main() -> i32 { return 0; } -fn zip_dir(it: &mut Iterator, prefix: &str, writer: T, method: zip::CompressionMethod) +fn zip_dir(it: &mut dyn Iterator, prefix: &str, writer: T, method: zip::CompressionMethod) -> zip::result::ZipResult<()> where T: Write+Seek { diff --git a/src/cp437.rs b/src/cp437.rs index 69547219..a1ef6d27 100644 --- a/src/cp437.rs +++ b/src/cp437.rs @@ -41,7 +41,7 @@ fn to_char(input: u8) -> char { let output = match input { - 0x00 ... 0x7f => input as u32, + 0x00 ..= 0x7f => input as u32, 0x80 => 0x00c7, 0x81 => 0x00fc, 0x82 => 0x00e9, diff --git a/src/lib.rs b/src/lib.rs index cfe4a598..3de71965 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -11,10 +11,10 @@ extern crate podio; #[cfg(feature = "time")] extern crate time; -pub use read::ZipArchive; -pub use write::ZipWriter; -pub use compression::CompressionMethod; -pub use types::DateTime; +pub use crate::read::ZipArchive; +pub use crate::write::ZipWriter; +pub use crate::compression::CompressionMethod; +pub use crate::types::DateTime; mod spec; mod crc32; diff --git a/src/read.rs b/src/read.rs index 2eb3d83b..a55e2eb6 100644 --- a/src/read.rs +++ b/src/read.rs @@ -1,17 +1,17 @@ //! Structs for reading a ZIP archive -use crc32::Crc32Reader; -use compression::CompressionMethod; -use spec; -use result::{ZipResult, ZipError}; +use crate::crc32::Crc32Reader; +use crate::compression::CompressionMethod; +use crate::spec; +use crate::result::{ZipResult, ZipError}; use std::io; use std::io::prelude::*; use std::collections::HashMap; use std::borrow::Cow; use podio::{ReadPodExt, LittleEndian}; -use types::{ZipFileData, System, DateTime}; -use cp437::FromCp437; +use crate::types::{ZipFileData, System, DateTime}; +use crate::cp437::FromCp437; #[cfg(feature = "deflate")] use flate2; @@ -64,11 +64,11 @@ pub struct ZipArchive enum ZipFileReader<'a> { NoReader, - Stored(Crc32Reader>), + Stored(Crc32Reader>), #[cfg(feature = "deflate")] - Deflated(Crc32Reader>>), + Deflated(Crc32Reader>>), #[cfg(feature = "bzip2")] - Bzip2(Crc32Reader>>), + Bzip2(Crc32Reader>>), } /// A struct for reading a zip file @@ -84,9 +84,9 @@ fn unsupported_zip_error(detail: &'static str) -> ZipResult fn make_reader<'a>( - compression_method: ::compression::CompressionMethod, + compression_method: crate::compression::CompressionMethod, crc32: u32, - reader: io::Take<&'a mut io::Read>) + reader: io::Take<&'a mut dyn io::Read>) -> ZipResult> { match compression_method { @@ -289,7 +289,7 @@ impl ZipArchive data.data_start = data.header_start + magic_and_header + file_name_length + extra_field_length; self.reader.seek(io::SeekFrom::Start(data.data_start))?; - let limit_reader = (self.reader.by_ref() as &mut Read).take(data.compressed_size); + let limit_reader = (self.reader.by_ref() as &mut dyn Read).take(data.compressed_size); Ok(ZipFile { reader: make_reader(data.compression_method, data.crc32, limit_reader)?, data: Cow::Borrowed(data) }) } @@ -414,20 +414,20 @@ fn parse_extra_field(file: &mut ZipFileData, data: &[u8]) -> ZipResult<()> Ok(()) } -fn get_reader<'a>(reader: &'a mut ZipFileReader) -> &'a mut Read { +fn get_reader<'a>(reader: &'a mut ZipFileReader) -> &'a mut dyn Read { match *reader { ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"), - ZipFileReader::Stored(ref mut r) => r as &mut Read, + ZipFileReader::Stored(ref mut r) => r as &mut dyn Read, #[cfg(feature = "deflate")] - ZipFileReader::Deflated(ref mut r) => r as &mut Read, + ZipFileReader::Deflated(ref mut r) => r as &mut dyn Read, #[cfg(feature = "bzip2")] - ZipFileReader::Bzip2(ref mut r) => r as &mut Read, + ZipFileReader::Bzip2(ref mut r) => r as &mut dyn Read, } } /// Methods for retrieving information on zip files impl<'a> ZipFile<'a> { - fn get_reader(&mut self) -> &mut Read { + fn get_reader(&mut self) -> &mut dyn Read { get_reader(&mut self.reader) } /// Get the version of the file @@ -630,7 +630,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult return unsupported_zip_error("The file length is not available in the local header"); } - let limit_reader = (reader as &'a mut io::Read).take(result.compressed_size as u64); + let limit_reader = (reader as &'a mut dyn io::Read).take(result.compressed_size as u64); let result_crc32 = result.crc32; let result_compression_method = result.compression_method; diff --git a/src/result.rs b/src/result.rs index d82259ea..a7e5d4b0 100644 --- a/src/result.rs +++ b/src/result.rs @@ -34,7 +34,7 @@ impl ZipError match *self { ZipError::Io(ref io_err) => { - ("Io Error: ".to_string() + (io_err as &error::Error).description()).into() + ("Io Error: ".to_string() + (io_err as &dyn error::Error).description()).into() }, ZipError::InvalidArchive(msg) | ZipError::UnsupportedArchive(msg) => { (self.description().to_string() + ": " + msg).into() @@ -76,18 +76,18 @@ impl error::Error for ZipError { match *self { - ZipError::Io(ref io_err) => (io_err as &error::Error).description(), + ZipError::Io(ref io_err) => (io_err as &dyn error::Error).description(), ZipError::InvalidArchive(..) => "Invalid Zip archive", ZipError::UnsupportedArchive(..) => "Unsupported Zip archive", ZipError::FileNotFound => "Specified file not found in archive", } } - fn cause(&self) -> Option<&error::Error> + fn cause(&self) -> Option<&dyn error::Error> { match *self { - ZipError::Io(ref io_err) => Some(io_err as &error::Error), + ZipError::Io(ref io_err) => Some(io_err as &dyn error::Error), _ => None, } } diff --git a/src/spec.rs b/src/spec.rs index 9da07caa..8a165391 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -1,6 +1,6 @@ use std::io; use std::io::prelude::*; -use result::{ZipResult, ZipError}; +use crate::result::{ZipResult, ZipError}; use podio::{ReadPodExt, WritePodExt, LittleEndian}; pub const LOCAL_FILE_HEADER_SIGNATURE : u32 = 0x04034b50; diff --git a/src/types.rs b/src/types.rs index e0ed8006..640e0c52 100644 --- a/src/types.rs +++ b/src/types.rs @@ -202,7 +202,7 @@ pub struct ZipFileData /// True if the file is encrypted. pub encrypted: bool, /// Compression method used to store the file - pub compression_method: ::compression::CompressionMethod, + pub compression_method: crate::compression::CompressionMethod, /// Last modified time. This will only have a 2 second precision. pub last_modified_time: DateTime, /// CRC32 checksum @@ -258,7 +258,7 @@ impl ZipFileData { pub fn version_needed(&self) -> u16 { match self.compression_method { #[cfg(feature = "bzip2")] - ::compression::CompressionMethod::Bzip2 => 46, + crate::compression::CompressionMethod::Bzip2 => 46, _ => 20, } } @@ -283,7 +283,7 @@ mod test { system: System::Dos, version_made_by: 0, encrypted: false, - compression_method: ::compression::CompressionMethod::Stored, + compression_method: crate::compression::CompressionMethod::Stored, last_modified_time: DateTime::default(), crc32: 0, compressed_size: 0, diff --git a/src/write.rs b/src/write.rs index 5e4c223f..c08472e0 100644 --- a/src/write.rs +++ b/src/write.rs @@ -1,10 +1,10 @@ //! Structs for creating a new zip archive -use compression::CompressionMethod; -use types::{ZipFileData, System, DEFAULT_VERSION, DateTime}; -use spec; +use crate::compression::CompressionMethod; +use crate::types::{ZipFileData, System, DEFAULT_VERSION, DateTime}; +use crate::spec; use crc32fast::Hasher; -use result::{ZipResult, ZipError}; +use crate::result::{ZipResult, ZipError}; use std::default::Default; use std::io; use std::io::prelude::*; @@ -395,13 +395,13 @@ impl GenericZipWriter Ok(()) } - fn ref_mut(&mut self) -> Option<&mut Write> { + fn ref_mut(&mut self) -> Option<&mut dyn Write> { match *self { - GenericZipWriter::Storer(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Storer(ref mut w) => Some(w as &mut dyn Write), #[cfg(feature = "deflate")] - GenericZipWriter::Deflater(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Deflater(ref mut w) => Some(w as &mut dyn Write), #[cfg(feature = "bzip2")] - GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut Write), + GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut dyn Write), GenericZipWriter::Closed => None, } } @@ -563,9 +563,9 @@ fn path_to_string(path: &std::path::Path) -> String { mod test { use std::io; use std::io::Write; - use types::DateTime; + use crate::types::DateTime; use super::{FileOptions, ZipWriter}; - use compression::CompressionMethod; + use crate::compression::CompressionMethod; #[test] fn write_empty_zip() { diff --git a/tests/zip64_large.rs b/tests/zip64_large.rs index d10c91e8..6aeeedfb 100644 --- a/tests/zip64_large.rs +++ b/tests/zip64_large.rs @@ -167,16 +167,16 @@ impl Read for Zip64File { return Ok(0); } match self.pointer { - BLOCK1_START ... BLOCK1_END => { + BLOCK1_START ..= BLOCK1_END => { buf[0] = BLOCK1[(self.pointer - BLOCK1_START) as usize]; }, - BLOCK2_START ... BLOCK2_END => { + BLOCK2_START ..= BLOCK2_END => { buf[0] = BLOCK2[(self.pointer - BLOCK2_START) as usize]; }, - BLOCK3_START ... BLOCK3_END => { + BLOCK3_START ..= BLOCK3_END => { buf[0] = BLOCK3[(self.pointer - BLOCK3_START) as usize]; }, - BLOCK4_START ... BLOCK4_END => { + BLOCK4_START ..= BLOCK4_END => { buf[0] = BLOCK4[(self.pointer - BLOCK4_START) as usize]; }, _ => { From 29517e9a6bc13d7efc9b289cf09dd8cd41d63f5d Mon Sep 17 00:00:00 2001 From: Lachezar Lechev Date: Mon, 11 Nov 2019 09:20:31 +0200 Subject: [PATCH 03/10] run `cargo fix --edition-idioms` and manually fix other things --- Cargo.toml | 1 + benches/read_entry.rs | 5 +---- examples/extract.rs | 2 -- examples/extract_lorem.rs | 2 -- examples/file_info.rs | 2 -- examples/stdin_info.rs | 2 -- examples/write_dir.rs | 2 -- examples/write_sample.rs | 2 -- src/compression.rs | 2 +- src/lib.rs | 9 --------- src/read.rs | 6 ++---- src/result.rs | 4 ++-- src/write.rs | 6 ------ tests/end_to_end.rs | 2 -- tests/invalid_date.rs | 2 -- tests/zip64_large.rs | 3 --- 16 files changed, 7 insertions(+), 45 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index dff93da4..77a958de 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,7 @@ keywords = ["zip", "archive"] description = """ Library to support the reading and writing of zip files. """ +edition = "2018" [dependencies] flate2 = { version = "1.0", default-features = false, optional = true } diff --git a/benches/read_entry.rs b/benches/read_entry.rs index 104e97c1..7b345240 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -1,7 +1,4 @@ -#[macro_use] -extern crate bencher; -extern crate rand; -extern crate zip; +use bencher::{benchmark_group, benchmark_main}; use std::io::{Cursor, Read, Write}; diff --git a/examples/extract.rs b/examples/extract.rs index 3d3a0939..1ec429d3 100644 --- a/examples/extract.rs +++ b/examples/extract.rs @@ -1,5 +1,3 @@ -extern crate zip; - use std::io; use std::fs; diff --git a/examples/extract_lorem.rs b/examples/extract_lorem.rs index eb49bbe3..207fd530 100644 --- a/examples/extract_lorem.rs +++ b/examples/extract_lorem.rs @@ -1,7 +1,5 @@ use std::io::prelude::*; -extern crate zip; - fn main() { std::process::exit(real_main()); diff --git a/examples/file_info.rs b/examples/file_info.rs index 63f7d87e..af7abdd4 100644 --- a/examples/file_info.rs +++ b/examples/file_info.rs @@ -1,5 +1,3 @@ -extern crate zip; - use std::fs; use std::io::BufReader; diff --git a/examples/stdin_info.rs b/examples/stdin_info.rs index 910ba8e8..8d3f7c43 100644 --- a/examples/stdin_info.rs +++ b/examples/stdin_info.rs @@ -1,5 +1,3 @@ -extern crate zip; - use std::io::{self, Read}; fn main() { diff --git a/examples/write_dir.rs b/examples/write_dir.rs index fb957742..6b2bac0a 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -1,5 +1,3 @@ -extern crate zip; -extern crate walkdir; use std::io::prelude::*; use std::io::{Write, Seek}; diff --git a/examples/write_sample.rs b/examples/write_sample.rs index 6ff12f0b..ab0ef1a2 100644 --- a/examples/write_sample.rs +++ b/examples/write_sample.rs @@ -1,8 +1,6 @@ use std::io::prelude::*; use zip::write::FileOptions; -extern crate zip; - fn main() { std::process::exit(real_main()); diff --git a/src/compression.rs b/src/compression.rs index 9585ef3b..3ec9dbf3 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -45,7 +45,7 @@ impl CompressionMethod { } impl fmt::Display for CompressionMethod { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // Just duplicate what the Debug format looks like, i.e, the enum key: write!(f, "{:?}", self) } diff --git a/src/lib.rs b/src/lib.rs index 3de71965..4685e18a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,15 +2,6 @@ #![warn(missing_docs)] -#[cfg(feature = "bzip2")] -extern crate bzip2; -extern crate crc32fast; -#[cfg(feature = "deflate")] -extern crate flate2; -extern crate podio; -#[cfg(feature = "time")] -extern crate time; - pub use crate::read::ZipArchive; pub use crate::write::ZipWriter; pub use crate::compression::CompressionMethod; diff --git a/src/read.rs b/src/read.rs index a55e2eb6..9b4bad43 100644 --- a/src/read.rs +++ b/src/read.rs @@ -13,8 +13,6 @@ use podio::{ReadPodExt, LittleEndian}; use crate::types::{ZipFileData, System, DateTime}; use crate::cp437::FromCp437; -#[cfg(feature = "deflate")] -use flate2; #[cfg(feature = "deflate")] use flate2::read::DeflateDecoder; @@ -414,7 +412,7 @@ fn parse_extra_field(file: &mut ZipFileData, data: &[u8]) -> ZipResult<()> Ok(()) } -fn get_reader<'a>(reader: &'a mut ZipFileReader) -> &'a mut dyn Read { +fn get_reader<'a>(reader: &'a mut ZipFileReader<'_>) -> &'a mut dyn Read { match *reader { ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"), ZipFileReader::Stored(ref mut r) => r as &mut dyn Read, @@ -563,7 +561,7 @@ impl<'a> Drop for ZipFile<'a> { /// * `comment`: set to an empty string /// * `data_start`: set to 0 /// * `external_attributes`: `unix_mode()`: will return None -pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult> { +pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult>> { let signature = reader.read_u32::()?; match signature { diff --git a/src/result.rs b/src/result.rs index a7e5d4b0..c826d1d4 100644 --- a/src/result.rs +++ b/src/result.rs @@ -27,7 +27,7 @@ pub enum ZipError impl ZipError { - fn detail(&self) -> ::std::borrow::Cow + fn detail(&self) -> ::std::borrow::Cow<'_, str> { use std::error::Error; @@ -64,7 +64,7 @@ impl convert::From for io::Error impl fmt::Display for ZipError { - fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { fmt.write_str(&*self.detail()) } diff --git a/src/write.rs b/src/write.rs index c08472e0..da3a4aae 100644 --- a/src/write.rs +++ b/src/write.rs @@ -9,17 +9,11 @@ use std::default::Default; use std::io; use std::io::prelude::*; use std::mem; -#[cfg(feature = "time")] -use time; use podio::{WritePodExt, LittleEndian}; -#[cfg(feature = "deflate")] -use flate2; #[cfg(feature = "deflate")] use flate2::write::DeflateEncoder; -#[cfg(feature = "bzip2")] -use bzip2; #[cfg(feature = "bzip2")] use bzip2::write::BzEncoder; diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index cd69ce3c..6af89ced 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -1,5 +1,3 @@ -extern crate zip; - use std::io::prelude::*; use zip::write::FileOptions; use std::io::Cursor; diff --git a/tests/invalid_date.rs b/tests/invalid_date.rs index e5c24200..b245d2c0 100644 --- a/tests/invalid_date.rs +++ b/tests/invalid_date.rs @@ -1,5 +1,3 @@ -extern crate zip; - use zip::read::ZipArchive; use std::io::Cursor; diff --git a/tests/zip64_large.rs b/tests/zip64_large.rs index 6aeeedfb..f537edc1 100644 --- a/tests/zip64_large.rs +++ b/tests/zip64_large.rs @@ -53,9 +53,6 @@ // 22c400260 00 00 50 4b 05 06 00 00 00 00 03 00 03 00 27 01 |..PK..........'.| // 22c400270 00 00 ff ff ff ff 00 00 |........| // 22c400278 - -extern crate zip; - use std::io::{self, Seek, SeekFrom, Read}; const BLOCK1_LENGTH : u64 = 0x60; From 120732780f4a3ca7e93ceadb4cbf3c3ef832098d Mon Sep 17 00:00:00 2001 From: Johannes Maibaum Date: Fri, 3 Jan 2020 09:53:20 +0100 Subject: [PATCH 04/10] Add bounds test for `DateTime::from_time()` Fails for 1980-01-01 00:00:00. --- src/types.rs | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/src/types.rs b/src/types.rs index 640e0c52..93cb03c1 100644 --- a/src/types.rs +++ b/src/types.rs @@ -333,6 +333,60 @@ mod test { assert!(DateTime::from_date_and_time(2107, 12, 32, 0, 0, 0).is_err()); } + #[cfg(feature = "time")] + #[test] + fn datetime_from_time_bounds() { + use super::DateTime; + + // 1979-12-31 23:59:59 + assert!(DateTime::from_time(::time::Tm { + tm_sec: 59, + tm_min: 59, + tm_hour: 23, + tm_mday: 31, + tm_mon: 11, // tm_mon has number range [0, 11] + tm_year: 79, // 1979 - 1900 = 79 + ..::time::empty_tm() + }) + .is_err()); + + // 1980-01-01 00:00:00 + assert!(DateTime::from_time(::time::Tm { + tm_sec: 0, + tm_min: 0, + tm_hour: 0, + tm_mday: 1, + tm_mon: 0, // tm_mon has number range [0, 11] + tm_year: 80, // 1980 - 1900 = 80 + ..::time::empty_tm() + }) + .is_ok()); + + // 2107-12-31 23:59:59 + assert!(DateTime::from_time(::time::Tm { + tm_sec: 59, + tm_min: 59, + tm_hour: 23, + tm_mday: 31, + tm_mon: 11, // tm_mon has number range [0, 11] + tm_year: 207, // 2107 - 1900 = 207 + ..::time::empty_tm() + }) + .is_ok()); + + // 2108-01-01 00:00:00 + assert!(DateTime::from_time(::time::Tm { + tm_sec: 0, + tm_min: 0, + tm_hour: 0, + tm_mday: 1, + tm_mon: 0, // tm_mon has number range [0, 11] + tm_year: 208, // 2108 - 1900 = 208 + ..::time::empty_tm() + }) + .is_err()); + } + #[test] fn time_conversion() { use super::DateTime; From b2a669bd335cd3c49aa3d42003405537d8ba98f6 Mon Sep 17 00:00:00 2001 From: Johannes Maibaum Date: Fri, 3 Jan 2020 10:04:58 +0100 Subject: [PATCH 05/10] Fix bounds check in `DateTime::from_time()` `::time::Tm.tm_mon` has number range [0, 11], see: https://docs.rs/time/0.1.42/time/struct.Tm.html#structfield.tm_mon --- src/types.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/types.rs b/src/types.rs index 93cb03c1..29a089e1 100644 --- a/src/types.rs +++ b/src/types.rs @@ -111,7 +111,7 @@ impl DateTime { /// Returns `Err` when this object is out of bounds pub fn from_time(tm: ::time::Tm) -> Result { if tm.tm_year >= 80 && tm.tm_year <= 207 - && tm.tm_mon >= 1 && tm.tm_mon <= 31 + && tm.tm_mon >= 0 && tm.tm_mon <= 11 && tm.tm_mday >= 1 && tm.tm_mday <= 31 && tm.tm_hour >= 0 && tm.tm_hour <= 23 && tm.tm_min >= 0 && tm.tm_min <= 59 From a85e3eb809a78eb4a2187d6ef661b860c5581a8c Mon Sep 17 00:00:00 2001 From: Mathijs van de Nes Date: Mon, 6 Jan 2020 22:27:46 +0100 Subject: [PATCH 06/10] Fix error checking tm_mon in time::Tm conversion Fixes #128 --- src/types.rs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/types.rs b/src/types.rs index 640e0c52..fcbfc06e 100644 --- a/src/types.rs +++ b/src/types.rs @@ -111,7 +111,7 @@ impl DateTime { /// Returns `Err` when this object is out of bounds pub fn from_time(tm: ::time::Tm) -> Result { if tm.tm_year >= 80 && tm.tm_year <= 207 - && tm.tm_mon >= 1 && tm.tm_mon <= 31 + && tm.tm_mon >= 0 && tm.tm_mon <= 11 && tm.tm_mday >= 1 && tm.tm_mday <= 31 && tm.tm_hour >= 0 && tm.tm_hour <= 23 && tm.tm_min >= 0 && tm.tm_min <= 59 @@ -373,4 +373,15 @@ mod test { #[cfg(feature = "time")] assert_eq!(format!("{}", dt.to_time().rfc3339()), "1980-00-00T00:00:00Z"); } + + #[cfg(feature = "time")] + #[test] + fn time_at_january() { + use super::DateTime; + + // 2020-01-01 00:00:00 + let clock = ::time::Timespec::new(1577836800, 0); + let tm = ::time::at_utc(clock); + assert!(DateTime::from_time(tm).is_ok()); + } } From 59ef02091858546c845a65885901189b2bb2f4ce Mon Sep 17 00:00:00 2001 From: Mathijs van de Nes Date: Mon, 6 Jan 2020 22:28:38 +0100 Subject: [PATCH 07/10] Bump version --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 77a958de..d5cacad6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "zip" -version = "0.5.3" +version = "0.5.4" authors = ["Mathijs van de Nes "] license = "MIT" repository = "https://github.com/mvdnes/zip-rs.git" From 69ad3bd2a4237516e2dc25dd9c5e7f2a8e81220e Mon Sep 17 00:00:00 2001 From: Manu Thambi Date: Mon, 30 Dec 2019 17:42:10 -0500 Subject: [PATCH 08/10] Enable reading/writing ZIP archive comment. --- src/read.rs | 7 ++++++- src/write.rs | 14 +++++++++++--- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/src/read.rs b/src/read.rs index 9b4bad43..1b734c17 100644 --- a/src/read.rs +++ b/src/read.rs @@ -251,6 +251,11 @@ impl ZipArchive self.offset } + /// Get the comment of the zip archive. + pub fn comment(&self) -> &[u8] { + &self.comment + } + /// Search for a file entry by name pub fn by_name<'a>(&'a mut self, name: &str) -> ZipResult> { @@ -670,7 +675,7 @@ mod test { let mut v = Vec::new(); v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip")); let reader = ZipArchive::new(io::Cursor::new(v)).unwrap(); - assert!(reader.comment == b"zip-rs"); + assert!(reader.comment() == b"zip-rs"); } #[test] diff --git a/src/write.rs b/src/write.rs index da3a4aae..d09accd3 100644 --- a/src/write.rs +++ b/src/write.rs @@ -57,6 +57,7 @@ pub struct ZipWriter files: Vec, stats: ZipWriterStats, writing_to_file: bool, + comment: String, } #[derive(Default)] @@ -174,9 +175,15 @@ impl ZipWriter files: Vec::new(), stats: Default::default(), writing_to_file: false, + comment: "zip-rs".into(), } } + /// Set ZIP archive comment. Defaults to 'zip-rs' if not set. + pub fn set_comment(&mut self, comment: S) where S: Into { + self.comment = comment.into(); + } + /// Start a new file for with the requested options. fn start_entry(&mut self, name: S, options: FileOptions) -> ZipResult<()> where S: Into @@ -333,7 +340,7 @@ impl ZipWriter number_of_files: self.files.len() as u16, central_directory_size: central_size as u32, central_directory_offset: central_start as u32, - zip_file_comment: b"zip-rs".to_vec(), + zip_file_comment: self.comment.as_bytes().to_vec(), }; footer.write(writer)?; @@ -564,9 +571,10 @@ mod test { #[test] fn write_empty_zip() { let mut writer = ZipWriter::new(io::Cursor::new(Vec::new())); + writer.set_comment("ZIP"); let result = writer.finish().unwrap(); - assert_eq!(result.get_ref().len(), 28); - assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 122, 105, 112, 45, 114, 115]); + assert_eq!(result.get_ref().len(), 25); + assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 90, 73, 80]); } #[test] From 91c93579f27d2455cefaf90365528df56c764109 Mon Sep 17 00:00:00 2001 From: Manu Thambi Date: Thu, 9 Jan 2020 12:35:28 -0500 Subject: [PATCH 09/10] Added ZipArchive::file_names() method to return an iterator of all the file names in the archive. Using ZipArchive::by_index() to obtain a list of files is slow, if the files are not read, because it creates the decompressor internally before returning ZipFile. Fixes #122 --- src/read.rs | 5 +++++ tests/end_to_end.rs | 7 +++++++ 2 files changed, 12 insertions(+) diff --git a/src/read.rs b/src/read.rs index 1b734c17..6d0a0517 100644 --- a/src/read.rs +++ b/src/read.rs @@ -256,6 +256,11 @@ impl ZipArchive &self.comment } + /// Returns an iterator over all the file and directory names in this archive. + pub fn file_names(&self) -> impl Iterator { + self.names_map.keys().map(|s| s.as_str()) + } + /// Search for a file entry by name pub fn by_name<'a>(&'a mut self, name: &str) -> ZipResult> { diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 6af89ced..840912f3 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -1,6 +1,8 @@ use std::io::prelude::*; use zip::write::FileOptions; use std::io::Cursor; +use std::iter::FromIterator; +use std::collections::HashSet; // This test asserts that after creating a zip file, then reading its contents back out, // the extracted data will *always* be exactly the same as the original data. @@ -36,6 +38,11 @@ fn write_to_zip_file(file: &mut Cursor>) -> zip::result::ZipResult<()> { fn read_zip_file(zip_file: &mut Cursor>) -> zip::result::ZipResult { let mut archive = zip::ZipArchive::new(zip_file).unwrap(); + let expected_file_names = [ "test/", "test/☃.txt", "test/lorem_ipsum.txt" ]; + let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied()); + let file_names = archive.file_names().collect::>(); + assert_eq!(file_names, expected_file_names); + let mut file = archive.by_name("test/lorem_ipsum.txt")?; let mut contents = String::new(); From 85153ecd4be1bc84988f6ceb42b67c52ae3a0b61 Mon Sep 17 00:00:00 2001 From: Mathijs van de Nes Date: Sun, 1 Mar 2020 13:50:57 +0100 Subject: [PATCH 10/10] Bump version --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index d5cacad6..a351ec9a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "zip" -version = "0.5.4" +version = "0.5.5" authors = ["Mathijs van de Nes "] license = "MIT" repository = "https://github.com/mvdnes/zip-rs.git"