From 6ea3d553bf623a4a4f7b014c4aa87120dc3d6fc7 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Tue, 18 May 2021 03:26:14 +0100 Subject: [PATCH 01/12] Added zstd method, compiling & tests running --- Cargo.toml | 3 ++- README.md | 4 +++- examples/write_dir.rs | 7 ++++++- src/compression.rs | 14 ++++++++++++++ src/read.rs | 14 ++++++++++++++ src/write.rs | 15 +++++++++++++++ 6 files changed, 54 insertions(+), 3 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 7bb5a260..ed0cb4b7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,7 @@ byteorder = "1.3" bzip2 = { version = "0.4", optional = true } crc32fast = "1.0" thiserror = "1.0" +zstd = { version = "0.8", optional = true } [dev-dependencies] bencher = "0.1" @@ -28,7 +29,7 @@ deflate = ["flate2/rust_backend"] deflate-miniz = ["flate2/default"] deflate-zlib = ["flate2/zlib"] unreserved = [] -default = ["bzip2", "deflate", "time"] +default = ["bzip2", "deflate", "time", "zstd"] [[bench]] name = "read_entry" diff --git a/README.md b/README.md index f6a28ccc..86f65066 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ Supported compression formats: * stored (i.e. none) * deflate * bzip2 +* zstd (in progress...) Currently unsupported zip extensions: @@ -42,9 +43,10 @@ zip = { version = "0.5", default-features = false } The features available are: -* `deflate`: Enables the deflate compression algorithm, which is the default for zipfiles +* `deflate`: Enables the deflate compression algorithm, which is the default for zipfiles. * `bzip2`: Enables the BZip2 compression algorithm. * `time`: Enables features using the [time](https://github.com/rust-lang-deprecated/time) crate. +* `zstd`: Enables the Zstandard compression algorithm. All of these are enabled by default. diff --git a/examples/write_dir.rs b/examples/write_dir.rs index 793bd6ba..a78bc43e 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -32,6 +32,11 @@ const METHOD_BZIP2: Option = Some(zip::CompressionMethod #[cfg(not(feature = "bzip2"))] const METHOD_BZIP2: Option = None; +#[cfg(feature = "zstd")] +const METHOD_ZSTD: Option = Some(zip::CompressionMethod::Zstd); +#[cfg(not(feature = "zstd"))] +const METHOD_ZSTD: Option = None; + fn real_main() -> i32 { let args: Vec<_> = std::env::args().collect(); if args.len() < 3 { @@ -44,7 +49,7 @@ fn real_main() -> i32 { let src_dir = &*args[1]; let dst_file = &*args[2]; - for &method in [METHOD_STORED, METHOD_DEFLATED, METHOD_BZIP2].iter() { + for &method in [METHOD_STORED, METHOD_DEFLATED, METHOD_BZIP2, METHOD_ZSTD].iter() { if method.is_none() { continue; } diff --git a/src/compression.rs b/src/compression.rs index 5fdde070..e0cc7d41 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -24,6 +24,9 @@ pub enum CompressionMethod { /// Compress the file using BZIP2 #[cfg(feature = "bzip2")] Bzip2, + /// Compress the file using ZStandard + #[cfg(feature = "zstd")] + Zstd, /// Unsupported compression method #[deprecated(since = "0.5.7", note = "use the constants instead")] Unsupported(u16), @@ -60,6 +63,9 @@ impl CompressionMethod { pub const IBM_ZOS_CMPSC: Self = CompressionMethod::Unsupported(16); pub const IBM_TERSE: Self = CompressionMethod::Unsupported(18); pub const ZSTD_DEPRECATED: Self = CompressionMethod::Unsupported(20); + #[cfg(feature = "zstd")] + pub const ZSTD: Self = CompressionMethod::Zstd; + #[cfg(not(feature = "zstd"))] pub const ZSTD: Self = CompressionMethod::Unsupported(93); pub const MP3: Self = CompressionMethod::Unsupported(94); pub const XZ: Self = CompressionMethod::Unsupported(95); @@ -85,6 +91,8 @@ impl CompressionMethod { 8 => CompressionMethod::Deflated, #[cfg(feature = "bzip2")] 12 => CompressionMethod::Bzip2, + #[cfg(feature = "zstd")] + 93 => CompressionMethod::Zstd, v => CompressionMethod::Unsupported(v), } @@ -107,6 +115,9 @@ impl CompressionMethod { CompressionMethod::Deflated => 8, #[cfg(feature = "bzip2")] CompressionMethod::Bzip2 => 12, + #[cfg(feature = "zstd")] + CompressionMethod::Zstd => 93, + CompressionMethod::Unsupported(v) => v, } } @@ -145,6 +156,9 @@ mod test { methods.push(CompressionMethod::Deflated); #[cfg(feature = "bzip2")] methods.push(CompressionMethod::Bzip2); + #[cfg(feature = "zstd")] + methods.push(CompressionMethod::Zstd); + methods } diff --git a/src/read.rs b/src/read.rs index a79b0099..2ba20d37 100644 --- a/src/read.rs +++ b/src/read.rs @@ -24,6 +24,9 @@ use flate2::read::DeflateDecoder; #[cfg(feature = "bzip2")] use bzip2::read::BzDecoder; +#[cfg(feature = "zstd")] +use zstd::stream::read::Decoder as ZstdDecoder; + mod ffi { pub const S_IFDIR: u32 = 0o0040000; pub const S_IFREG: u32 = 0o0100000; @@ -90,6 +93,8 @@ enum ZipFileReader<'a> { Deflated(Crc32Reader>>), #[cfg(feature = "bzip2")] Bzip2(Crc32Reader>>), + #[cfg(feature = "zstd")] + Zstd(Crc32Reader>>>), } impl<'a> Read for ZipFileReader<'a> { @@ -106,6 +111,8 @@ impl<'a> Read for ZipFileReader<'a> { ZipFileReader::Deflated(r) => r.read(buf), #[cfg(feature = "bzip2")] ZipFileReader::Bzip2(r) => r.read(buf), + #[cfg(feature = "zstd")] + ZipFileReader::Zstd(r) => r.read(buf), } } } @@ -125,6 +132,8 @@ impl<'a> ZipFileReader<'a> { ZipFileReader::Deflated(r) => r.into_inner().into_inner().into_inner(), #[cfg(feature = "bzip2")] ZipFileReader::Bzip2(r) => r.into_inner().into_inner().into_inner(), + #[cfg(feature = "zstd")] + ZipFileReader::Zstd(r) => r.into_inner().finish().into_inner().into_inner(), } } } @@ -210,6 +219,11 @@ fn make_reader<'a>( let bzip2_reader = BzDecoder::new(reader); ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32)) } + #[cfg(feature = "zstd")] + CompressionMethod::Zstd => { + let zstd_reader = ZstdDecoder::new(reader).unwrap(); + ZipFileReader::Zstd(Crc32Reader::new(zstd_reader, crc32)) + } _ => panic!("Compression method not supported"), } } diff --git a/src/write.rs b/src/write.rs index 05c3666a..fc1459ea 100644 --- a/src/write.rs +++ b/src/write.rs @@ -22,6 +22,9 @@ use flate2::write::DeflateEncoder; #[cfg(feature = "bzip2")] use bzip2::write::BzEncoder; +#[cfg(feature = "zstd")] +use zstd::stream::write::Encoder as ZstdEncoder; + enum GenericZipWriter { Closed, Storer(W), @@ -33,6 +36,8 @@ enum GenericZipWriter { Deflater(DeflateEncoder), #[cfg(feature = "bzip2")] Bzip2(BzEncoder), + #[cfg(feature = "zstd")] + Zstd(ZstdEncoder<'static, W>), } /// ZIP archive generator @@ -804,6 +809,8 @@ impl GenericZipWriter { GenericZipWriter::Deflater(w) => w.finish()?, #[cfg(feature = "bzip2")] GenericZipWriter::Bzip2(w) => w.finish()?, + #[cfg(feature = "zstd")] + GenericZipWriter::Zstd(w) => w.finish()?, GenericZipWriter::Closed => { return Err(io::Error::new( io::ErrorKind::BrokenPipe, @@ -830,6 +837,10 @@ impl GenericZipWriter { CompressionMethod::Bzip2 => { GenericZipWriter::Bzip2(BzEncoder::new(bare, bzip2::Compression::default())) } + #[cfg(feature = "zstd")] + CompressionMethod::Zstd => { + GenericZipWriter::Zstd(ZstdEncoder::new(bare, 0).unwrap()) + } CompressionMethod::Unsupported(..) => { return Err(ZipError::UnsupportedArchive("Unsupported compression")) } @@ -850,6 +861,8 @@ impl GenericZipWriter { GenericZipWriter::Deflater(ref mut w) => Some(w as &mut dyn Write), #[cfg(feature = "bzip2")] GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut dyn Write), + #[cfg(feature = "zstd")] + GenericZipWriter::Zstd(ref mut w) => Some(w as &mut dyn Write), GenericZipWriter::Closed => None, } } @@ -879,6 +892,8 @@ impl GenericZipWriter { GenericZipWriter::Deflater(..) => Some(CompressionMethod::Deflated), #[cfg(feature = "bzip2")] GenericZipWriter::Bzip2(..) => Some(CompressionMethod::Bzip2), + #[cfg(feature = "zstd")] + GenericZipWriter::Zstd(..) => Some(CompressionMethod::Zstd), GenericZipWriter::Closed => None, } } From 48f9d0151a44da9316f0e5822f9a71bc9fa6bbea Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 24 May 2021 00:59:22 +0100 Subject: [PATCH 02/12] Use all supported methods in end_to_end test --- tests/end_to_end.rs | 130 +++++++++++++++++++++++++++++++------------- 1 file changed, 93 insertions(+), 37 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index baebd287..50911f6d 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -10,81 +10,102 @@ use zip::CompressionMethod; // the extracted data will *always* be exactly the same as the original data. #[test] fn end_to_end() { - let file = &mut Cursor::new(Vec::new()); + for method in SUPPORTED_METHODS.iter() { + let file = &mut Cursor::new(Vec::new()); - write_to_zip(file).expect("file written"); + write_to_zip(file, *method).expect("Couldn't write to test file"); - check_zip_contents(file, ENTRY_NAME); + check_zip_contents(file, ENTRY_NAME, Some(*method)); + } } // This test asserts that after copying a `ZipFile` to a new `ZipWriter`, then reading its // contents back out, the extracted data will *always* be exactly the same as the original data. #[test] fn copy() { - let src_file = &mut Cursor::new(Vec::new()); - write_to_zip(src_file).expect("file written"); + for method in SUPPORTED_METHODS.iter() { + let src_file = &mut Cursor::new(Vec::new()); + write_to_zip(src_file, *method).expect("Couldn't write to test file"); - let mut tgt_file = &mut Cursor::new(Vec::new()); - - { - let mut src_archive = zip::ZipArchive::new(src_file).unwrap(); - let mut zip = zip::ZipWriter::new(&mut tgt_file); + let mut tgt_file = &mut Cursor::new(Vec::new()); { - let file = src_archive.by_name(ENTRY_NAME).expect("file found"); - zip.raw_copy_file(file).unwrap(); + let mut src_archive = zip::ZipArchive::new(src_file).unwrap(); + let mut zip = zip::ZipWriter::new(&mut tgt_file); + + { + let file = src_archive + .by_name(ENTRY_NAME) + .expect("Missing expected file"); + + zip.raw_copy_file(file).expect("Couldn't copy file"); + } + + { + let file = src_archive + .by_name(ENTRY_NAME) + .expect("Missing expected file"); + + zip.raw_copy_file_rename(file, COPY_ENTRY_NAME) + .expect("Couldn't copy and rename file"); + } } - { - let file = src_archive.by_name(ENTRY_NAME).expect("file found"); - zip.raw_copy_file_rename(file, COPY_ENTRY_NAME).unwrap(); - } + let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap(); + + check_zip_file_contents(&mut tgt_archive, ENTRY_NAME); + check_zip_file_contents(&mut tgt_archive, COPY_ENTRY_NAME); } - - let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap(); - - check_zip_file_contents(&mut tgt_archive, ENTRY_NAME); - check_zip_file_contents(&mut tgt_archive, COPY_ENTRY_NAME); } // This test asserts that after appending to a `ZipWriter`, then reading its contents back out, // both the prior data and the appended data will be exactly the same as their originals. #[test] fn append() { - let mut file = &mut Cursor::new(Vec::new()); - write_to_zip(file).expect("file written"); + for method in SUPPORTED_METHODS.iter() { + let mut file = &mut Cursor::new(Vec::new()); + write_to_zip(file, *method).expect("Couldn't write to test file"); - { - let mut zip = zip::ZipWriter::new_append(&mut file).unwrap(); - zip.start_file(COPY_ENTRY_NAME, Default::default()).unwrap(); - zip.write_all(LOREM_IPSUM).unwrap(); - zip.finish().unwrap(); + { + let mut zip = zip::ZipWriter::new_append(&mut file).unwrap(); + zip.start_file( + COPY_ENTRY_NAME, + FileOptions::default().compression_method(*method), + ) + .unwrap(); + zip.write_all(LOREM_IPSUM).unwrap(); + zip.finish().unwrap(); + } + + let mut zip = zip::ZipArchive::new(&mut file).unwrap(); + check_zip_file_contents(&mut zip, ENTRY_NAME); + check_zip_file_contents(&mut zip, COPY_ENTRY_NAME); } - - let mut zip = zip::ZipArchive::new(&mut file).unwrap(); - check_zip_file_contents(&mut zip, ENTRY_NAME); - check_zip_file_contents(&mut zip, COPY_ENTRY_NAME); } -fn write_to_zip(file: &mut Cursor>) -> zip::result::ZipResult<()> { +fn write_to_zip( + file: &mut Cursor>, + method: CompressionMethod, +) -> zip::result::ZipResult<()> { let mut zip = zip::ZipWriter::new(file); zip.add_directory("test/", Default::default())?; let options = FileOptions::default() - .compression_method(CompressionMethod::Stored) + .compression_method(method) .unix_permissions(0o755); + zip.start_file("test/☃.txt", options)?; zip.write_all(b"Hello, World!\n")?; - zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", Default::default())?; + zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", options)?; zip.write_u16::(0xbeef)?; zip.write_u16::(EXTRA_DATA.len() as u16)?; zip.write_all(EXTRA_DATA)?; zip.end_extra_data()?; zip.write_all(b"Hello, World! Again.\n")?; - zip.start_file(ENTRY_NAME, Default::default())?; + zip.start_file(ENTRY_NAME, options)?; zip.write_all(LOREM_IPSUM)?; zip.finish()?; @@ -127,8 +148,26 @@ fn read_zip_file( Ok(contents) } -fn check_zip_contents(zip_file: &mut Cursor>, name: &str) { +fn check_zip_contents( + zip_file: &mut Cursor>, + name: &str, + expected_method: Option, +) { let mut archive = read_zip(zip_file).unwrap(); + + match expected_method { + Some(method) => { + let file = archive.by_name(name).unwrap(); + + assert_eq!( + method, + file.compression(), + "File does not have expected compression method" + ) + } + None => {} + } + check_zip_file_contents(&mut archive, name); } @@ -149,3 +188,20 @@ const EXTRA_DATA: &'static [u8] = b"Extra Data"; const ENTRY_NAME: &str = "test/lorem_ipsum.txt"; const COPY_ENTRY_NAME: &str = "test/lorem_ipsum_renamed.txt"; + +const SUPPORTED_METHODS: &'static [CompressionMethod] = &[ + CompressionMethod::Stored, + // + #[cfg(any( + feature = "deflate", + feature = "deflate-miniz", + feature = "deflate-zlib" + ))] + CompressionMethod::Deflated, + // + #[cfg(feature = "bzip2")] + CompressionMethod::Bzip2, + // + #[cfg(feature = "zstd")] + CompressionMethod::Zstd, +]; From 4a7c0d4e5c48eec2a5ef7505f4c319f76d5ef306 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Sun, 6 Jun 2021 22:33:46 +0100 Subject: [PATCH 03/12] Fix broken benchmark --- benches/read_entry.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/benches/read_entry.rs b/benches/read_entry.rs index 25c0b94a..97417312 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -13,8 +13,11 @@ fn generate_random_archive(size: usize) -> Vec { zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); writer.start_file("random.dat", options).unwrap(); + + // Generate some random data. let mut bytes = vec![0u8; size]; - rand::thread_rng().fill_bytes(&mut bytes); + rand::thread_rng().fill(bytes.as_mut_slice()); + writer.write_all(&bytes).unwrap(); writer.finish().unwrap().into_inner() From e43ac72f7df8d58f909bbdd2cb42af5182b64295 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 7 Jun 2021 00:45:06 +0100 Subject: [PATCH 04/12] Add supported_methods() to CompressionMethod enum --- src/compression.rs | 21 +++++++++++++++++++++ tests/end_to_end.rs | 23 +++-------------------- 2 files changed, 24 insertions(+), 20 deletions(-) diff --git a/src/compression.rs b/src/compression.rs index e0cc7d41..b8ecb264 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -121,6 +121,27 @@ impl CompressionMethod { CompressionMethod::Unsupported(v) => v, } } + + pub fn supported_methods() -> &'static [CompressionMethod] { + static METHODS: [CompressionMethod; 4] = [ + CompressionMethod::Stored, + // + #[cfg(any( + feature = "deflate", + feature = "deflate-miniz", + feature = "deflate-zlib" + ))] + CompressionMethod::Deflated, + // + #[cfg(feature = "bzip2")] + CompressionMethod::Bzip2, + // + #[cfg(feature = "zstd")] + CompressionMethod::Zstd, + ]; + + &METHODS + } } impl fmt::Display for CompressionMethod { diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 50911f6d..d0d6ea0b 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -10,7 +10,7 @@ use zip::CompressionMethod; // the extracted data will *always* be exactly the same as the original data. #[test] fn end_to_end() { - for method in SUPPORTED_METHODS.iter() { + for method in CompressionMethod::supported_methods().iter() { let file = &mut Cursor::new(Vec::new()); write_to_zip(file, *method).expect("Couldn't write to test file"); @@ -23,7 +23,7 @@ fn end_to_end() { // contents back out, the extracted data will *always* be exactly the same as the original data. #[test] fn copy() { - for method in SUPPORTED_METHODS.iter() { + for method in CompressionMethod::supported_methods().iter() { let src_file = &mut Cursor::new(Vec::new()); write_to_zip(src_file, *method).expect("Couldn't write to test file"); @@ -62,7 +62,7 @@ fn copy() { // both the prior data and the appended data will be exactly the same as their originals. #[test] fn append() { - for method in SUPPORTED_METHODS.iter() { + for method in CompressionMethod::supported_methods().iter() { let mut file = &mut Cursor::new(Vec::new()); write_to_zip(file, *method).expect("Couldn't write to test file"); @@ -188,20 +188,3 @@ const EXTRA_DATA: &'static [u8] = b"Extra Data"; const ENTRY_NAME: &str = "test/lorem_ipsum.txt"; const COPY_ENTRY_NAME: &str = "test/lorem_ipsum_renamed.txt"; - -const SUPPORTED_METHODS: &'static [CompressionMethod] = &[ - CompressionMethod::Stored, - // - #[cfg(any( - feature = "deflate", - feature = "deflate-miniz", - feature = "deflate-zlib" - ))] - CompressionMethod::Deflated, - // - #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2, - // - #[cfg(feature = "zstd")] - CompressionMethod::Zstd, -]; From 6c1bd78a6b78c3f5f053858c79fb5adb79b4999c Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 7 Jun 2021 02:51:06 +0100 Subject: [PATCH 05/12] Use Criterion for benchmarks --- Cargo.toml | 2 +- benches/read_entry.rs | 72 ++++++++++++++++++++++++++++++------------- 2 files changed, 51 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2286b58f..1afd00d3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,7 @@ thiserror = "1.0" zstd = { version = "0.8", optional = true } [dev-dependencies] -bencher = "0.1" +criterion = "0.3" rand = "0.7" walkdir = "2" diff --git a/benches/read_entry.rs b/benches/read_entry.rs index 97417312..79288cbd 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -1,16 +1,16 @@ -use bencher::{benchmark_group, benchmark_main}; +use criterion::{BenchmarkId, Criterion, Throughput}; +use criterion::{criterion_group, criterion_main}; use std::io::{Cursor, Read, Write}; -use bencher::Bencher; use rand::Rng; -use zip::{ZipArchive, ZipWriter}; +use zip::{CompressionMethod, ZipArchive, ZipWriter}; -fn generate_random_archive(size: usize) -> Vec { +fn generate_random_archive(size: usize, method: Option) -> Vec { let data = Vec::new(); let mut writer = ZipWriter::new(Cursor::new(data)); - let options = - zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); + let options = zip::write::FileOptions::default() + .compression_method(method.unwrap_or(CompressionMethod::Stored)); writer.start_file("random.dat", options).unwrap(); @@ -23,24 +23,52 @@ fn generate_random_archive(size: usize) -> Vec { writer.finish().unwrap().into_inner() } -fn read_entry(bench: &mut Bencher) { +fn read_entry(bench: &mut Criterion) { let size = 1024 * 1024; - let bytes = generate_random_archive(size); - let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap(); + let bytes = generate_random_archive(size, None); - bench.iter(|| { - let mut file = archive.by_name("random.dat").unwrap(); - let mut buf = [0u8; 1024]; - loop { - let n = file.read(&mut buf).unwrap(); - if n == 0 { - break; - } - } - }); + // + let mut group = bench.benchmark_group("read_entry"); - bench.bytes = size as u64; + // + for method in CompressionMethod::supported_methods().iter() { + group.bench_with_input(BenchmarkId::from_parameter(method), method, |b, method| { + b.iter(|| { + let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap(); + let mut file = archive.by_name("random.dat").unwrap(); + let mut buf = [0u8; 1024]; + + let mut total_bytes = 0; + + loop { + let n = file.read(&mut buf).unwrap(); + total_bytes += n; + if n == 0 { + return total_bytes + } + } + }); + }); + } } -benchmark_group!(benches, read_entry); -benchmark_main!(benches); +fn write_random_archive(bench: &mut Criterion) { + let size = 1024 * 1024; + + // + let mut group = bench.benchmark_group("write_random_archive"); + + // + for method in CompressionMethod::supported_methods().iter() { + group.bench_with_input(BenchmarkId::from_parameter(method), method, |b, method| { + b.iter(|| { + generate_random_archive(size, Some(method.clone())); + }) + }); + } + + group.finish(); +} + +criterion_group!(benches, read_entry, write_random_archive); +criterion_main!(benches); From 10dab713771d97a516ee2f9e1b844093b3813e0a Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 7 Jun 2021 02:51:28 +0100 Subject: [PATCH 06/12] Apply linter fixes --- benches/read_entry.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/benches/read_entry.rs b/benches/read_entry.rs index 79288cbd..a7be726d 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -1,5 +1,5 @@ -use criterion::{BenchmarkId, Criterion, Throughput}; use criterion::{criterion_group, criterion_main}; +use criterion::{BenchmarkId, Criterion, Throughput}; use std::io::{Cursor, Read, Write}; @@ -44,7 +44,7 @@ fn read_entry(bench: &mut Criterion) { let n = file.read(&mut buf).unwrap(); total_bytes += n; if n == 0 { - return total_bytes + return total_bytes; } } }); From 71ee4838ca6a3260bf6e085f46811d0d190cb829 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Tue, 8 Jun 2021 02:13:28 +0100 Subject: [PATCH 07/12] Update bench tests... --- benches/read_entry.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/benches/read_entry.rs b/benches/read_entry.rs index a7be726d..bb91d6dc 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -1,5 +1,5 @@ use criterion::{criterion_group, criterion_main}; -use criterion::{BenchmarkId, Criterion, Throughput}; +use criterion::{BenchmarkId, Criterion}; use std::io::{Cursor, Read, Write}; @@ -25,15 +25,16 @@ fn generate_random_archive(size: usize, method: Option) -> Ve fn read_entry(bench: &mut Criterion) { let size = 1024 * 1024; - let bytes = generate_random_archive(size, None); // let mut group = bench.benchmark_group("read_entry"); // for method in CompressionMethod::supported_methods().iter() { - group.bench_with_input(BenchmarkId::from_parameter(method), method, |b, method| { - b.iter(|| { + group.bench_with_input(BenchmarkId::from_parameter(method), method, |bench, method| { + let bytes = generate_random_archive(size, Some(*method)); + + bench.iter(|| { let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap(); let mut file = archive.by_name("random.dat").unwrap(); let mut buf = [0u8; 1024]; @@ -62,7 +63,7 @@ fn write_random_archive(bench: &mut Criterion) { for method in CompressionMethod::supported_methods().iter() { group.bench_with_input(BenchmarkId::from_parameter(method), method, |b, method| { b.iter(|| { - generate_random_archive(size, Some(method.clone())); + generate_random_archive(size, Some(*method)); }) }); } From 7a630e21b373dd039c874aed528c3ae8f151fc27 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 24 Jan 2022 18:13:33 +0000 Subject: [PATCH 08/12] Sync changes from upstream --- .github/workflows/ci.yaml | 23 ++++++++++- CODE_OF_CONDUCT.md | 1 - Cargo.toml | 11 +++--- README.md | 7 ++-- benches/read_entry.rs | 80 ++++++++++++--------------------------- examples/extract.rs | 3 +- examples/extract_lorem.rs | 2 +- examples/file_info.rs | 3 +- examples/stdin_info.rs | 3 +- examples/write_dir.rs | 6 +-- examples/write_sample.rs | 4 +- tests/issue_234.rs | 31 +++++++++++++++ 12 files changed, 97 insertions(+), 77 deletions(-) create mode 100644 tests/issue_234.rs diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 83741894..6f0e4b9d 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -16,7 +16,7 @@ jobs: strategy: matrix: os: [ubuntu-latest, macOS-latest, windows-latest] - rust: [stable, 1.36.0] + rust: [stable, 1.54.0] steps: - uses: actions/checkout@master @@ -39,6 +39,25 @@ jobs: command: test args: --all + clippy: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: nightly + override: true + components: clippy + + - name: clippy + uses: actions-rs/cargo@v1 + with: + command: clippy + args: --all-targets --all-features -- -D warnings + check_fmt_and_docs: name: Checking fmt and docs runs-on: ubuntu-latest @@ -54,4 +73,4 @@ jobs: run: cargo fmt --all -- --check - name: Docs - run: cargo doc \ No newline at end of file + run: cargo doc diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 845634eb..2290ec2b 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -1,4 +1,3 @@ - # Contributor Covenant Code of Conduct ## Our Pledge diff --git a/Cargo.toml b/Cargo.toml index 1afd00d3..34af3ea2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,16 +12,15 @@ edition = "2018" [dependencies] flate2 = { version = "1.0.0", default-features = false, optional = true } -time = { version = "0.1", optional = true } +time = { version = "0.3", features = ["formatting", "macros" ], optional = true } byteorder = "1.3" bzip2 = { version = "0.4", optional = true } -crc32fast = "1.0" -thiserror = "1.0" -zstd = { version = "0.8", optional = true } +crc32fast = "1.1.1" +zstd = { version = "0.10", optional = true } [dev-dependencies] -criterion = "0.3" -rand = "0.7" +bencher = "0.1" +getrandom = "0.2" walkdir = "2" [features] diff --git a/README.md b/README.md index e1e3385d..be471f6d 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,7 @@ zip-rs [![Build Status](https://img.shields.io/github/workflow/status/zip-rs/zip/CI)](https://github.com/zip-rs/zip/actions?query=branch%3Amaster+workflow%3ACI) [![Crates.io version](https://img.shields.io/crates/v/zip.svg)](https://crates.io/crates/zip) +[![Discord](https://badgen.net/badge/icon/discord?icon=discord&label)](https://discord.gg/rQ7H9cSsF4) [Documentation](https://docs.rs/zip/0.5.13/zip/) @@ -17,7 +18,7 @@ Supported compression formats: * stored (i.e. none) * deflate * bzip2 -* zstd (in progress...) +* zstd Currently unsupported zip extensions: @@ -43,7 +44,7 @@ zip = { version = "0.5", default-features = false } The features available are: -* `deflate`: Enables the deflate compression algorithm, which is the default for zipfiles. +* `deflate`: Enables the deflate compression algorithm, which is the default for zip files. * `bzip2`: Enables the BZip2 compression algorithm. * `time`: Enables features using the [time](https://github.com/rust-lang-deprecated/time) crate. * `zstd`: Enables the Zstandard compression algorithm. @@ -53,7 +54,7 @@ All of these are enabled by default. MSRV ---- -Our current Minimum Supported Rust Version is **1.36.0**. When adding features, +Our current Minimum Supported Rust Version is **1.54.0**. When adding features, we will follow these guidelines: - We will always support the latest four minor Rust versions. This gives you a 6 diff --git a/benches/read_entry.rs b/benches/read_entry.rs index bb91d6dc..af9affe3 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -1,75 +1,43 @@ -use criterion::{criterion_group, criterion_main}; -use criterion::{BenchmarkId, Criterion}; +use bencher::{benchmark_group, benchmark_main}; use std::io::{Cursor, Read, Write}; -use rand::Rng; -use zip::{CompressionMethod, ZipArchive, ZipWriter}; +use bencher::Bencher; +use getrandom::getrandom; +use zip::{ZipArchive, ZipWriter}; -fn generate_random_archive(size: usize, method: Option) -> Vec { +fn generate_random_archive(size: usize) -> Vec { let data = Vec::new(); let mut writer = ZipWriter::new(Cursor::new(data)); - let options = zip::write::FileOptions::default() - .compression_method(method.unwrap_or(CompressionMethod::Stored)); + let options = + zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored); writer.start_file("random.dat", options).unwrap(); - - // Generate some random data. let mut bytes = vec![0u8; size]; - rand::thread_rng().fill(bytes.as_mut_slice()); - + getrandom(&mut bytes).unwrap(); writer.write_all(&bytes).unwrap(); writer.finish().unwrap().into_inner() } -fn read_entry(bench: &mut Criterion) { +fn read_entry(bench: &mut Bencher) { let size = 1024 * 1024; + let bytes = generate_random_archive(size); + let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap(); - // - let mut group = bench.benchmark_group("read_entry"); + bench.iter(|| { + let mut file = archive.by_name("random.dat").unwrap(); + let mut buf = [0u8; 1024]; + loop { + let n = file.read(&mut buf).unwrap(); + if n == 0 { + break; + } + } + }); - // - for method in CompressionMethod::supported_methods().iter() { - group.bench_with_input(BenchmarkId::from_parameter(method), method, |bench, method| { - let bytes = generate_random_archive(size, Some(*method)); - - bench.iter(|| { - let mut archive = ZipArchive::new(Cursor::new(bytes.as_slice())).unwrap(); - let mut file = archive.by_name("random.dat").unwrap(); - let mut buf = [0u8; 1024]; - - let mut total_bytes = 0; - - loop { - let n = file.read(&mut buf).unwrap(); - total_bytes += n; - if n == 0 { - return total_bytes; - } - } - }); - }); - } + bench.bytes = size as u64; } -fn write_random_archive(bench: &mut Criterion) { - let size = 1024 * 1024; - - // - let mut group = bench.benchmark_group("write_random_archive"); - - // - for method in CompressionMethod::supported_methods().iter() { - group.bench_with_input(BenchmarkId::from_parameter(method), method, |b, method| { - b.iter(|| { - generate_random_archive(size, Some(*method)); - }) - }); - } - - group.finish(); -} - -criterion_group!(benches, read_entry, write_random_archive); -criterion_main!(benches); +benchmark_group!(benches, read_entry); +benchmark_main!(benches); diff --git a/examples/extract.rs b/examples/extract.rs index 05c5a4aa..b02eb4cd 100644 --- a/examples/extract.rs +++ b/examples/extract.rs @@ -59,5 +59,6 @@ fn real_main() -> i32 { } } } - return 0; + + 0 } diff --git a/examples/extract_lorem.rs b/examples/extract_lorem.rs index 89e33ef9..a34a04f4 100644 --- a/examples/extract_lorem.rs +++ b/examples/extract_lorem.rs @@ -27,5 +27,5 @@ fn real_main() -> i32 { file.read_to_string(&mut contents).unwrap(); println!("{}", contents); - return 0; + 0 } diff --git a/examples/file_info.rs b/examples/file_info.rs index 315b5c38..824278df 100644 --- a/examples/file_info.rs +++ b/examples/file_info.rs @@ -49,5 +49,6 @@ fn real_main() -> i32 { ); } } - return 0; + + 0 } diff --git a/examples/stdin_info.rs b/examples/stdin_info.rs index 606944ce..10d7aa8b 100644 --- a/examples/stdin_info.rs +++ b/examples/stdin_info.rs @@ -30,5 +30,6 @@ fn real_main() -> i32 { } } } - return 0; + + 0 } diff --git a/examples/write_dir.rs b/examples/write_dir.rs index a78bc43e..8cc561ff 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -59,7 +59,7 @@ fn real_main() -> i32 { } } - return 0; + 0 } fn zip_dir( @@ -92,7 +92,7 @@ where f.read_to_end(&mut buffer)?; zip.write_all(&*buffer)?; buffer.clear(); - } else if name.as_os_str().len() != 0 { + } else if !name.as_os_str().is_empty() { // Only if not root! Avoids path spec / warning // and mapname conversion failed error on unzip println!("adding dir {:?} as {:?} ...", path, name); @@ -116,7 +116,7 @@ fn doit( let path = Path::new(dst_file); let file = File::create(&path).unwrap(); - let walkdir = WalkDir::new(src_dir.to_string()); + let walkdir = WalkDir::new(src_dir); let it = walkdir.into_iter(); zip_dir(&mut it.filter_map(|e| e.ok()), src_dir, file, method)?; diff --git a/examples/write_sample.rs b/examples/write_sample.rs index 4ef5ce34..b5749509 100644 --- a/examples/write_sample.rs +++ b/examples/write_sample.rs @@ -18,7 +18,7 @@ fn real_main() -> i32 { Err(e) => println!("Error: {:?}", e), } - return 0; + 0 } fn doit(filename: &str) -> zip::result::ZipResult<()> { @@ -42,7 +42,7 @@ fn doit(filename: &str) -> zip::result::ZipResult<()> { Ok(()) } -const LOREM_IPSUM : &'static [u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet +const LOREM_IPSUM : &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet molestie. Proin blandit ornare dui, a tempor nisl accumsan in. Praesent a consequat felis. Morbi metus diam, auctor in auctor vel, feugiat id odio. Curabitur ex ex, dictum quis auctor quis, suscipit id lorem. Aliquam vestibulum dolor nec enim vehicula, porta tristique augue tincidunt. Vivamus ut gravida est. Sed pellentesque, dolor vitae tristique consectetur, neque lectus pulvinar dui, sed feugiat purus diam id lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per diff --git a/tests/issue_234.rs b/tests/issue_234.rs new file mode 100644 index 00000000..bd01d1d0 --- /dev/null +++ b/tests/issue_234.rs @@ -0,0 +1,31 @@ +use zip::result::ZipError; + +const BUF: &[u8] = &[ + 0, 80, 75, 1, 2, 127, 120, 0, 3, 3, 75, 80, 232, 3, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 7, 0, 0, 0, + 0, 65, 0, 1, 0, 0, 0, 4, 0, 0, 224, 255, 0, 255, 255, 255, 255, 255, 255, 20, 39, 221, 221, + 221, 221, 221, 221, 205, 221, 221, 221, 42, 221, 221, 221, 221, 221, 221, 221, 221, 38, 34, 34, + 219, 80, 75, 5, 6, 0, 0, 0, 0, 5, 96, 0, 1, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 234, 236, 124, + 221, 221, 37, 221, 221, 221, 221, 221, 129, 4, 0, 0, 221, 221, 80, 75, 1, 2, 127, 120, 0, 4, 0, + 0, 2, 127, 120, 0, 79, 75, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, + 234, 0, 0, 0, 3, 8, 4, 232, 3, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 3, 0, + 221, 209, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 58, 58, 42, 75, 9, 2, 127, + 120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213, 213, 213, 213, 213, 213, 213, + 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213, 213, + 213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 234, 0, 0, 0, 3, 8, + 0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0, 0, 0, 58, 58, 58, 42, 175, 221, 253, 221, + 221, 221, 221, 221, 80, 75, 9, 2, 127, 120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, + 213, 213, 213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 221, 221, + 221, 221, 221, 80, 75, 9, 2, 127, 120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213, + 213, 213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, +]; + +#[test] +fn invalid_header() { + let reader = std::io::Cursor::new(&BUF); + let archive = zip::ZipArchive::new(reader); + match archive { + Err(ZipError::InvalidArchive(_)) => {} + value => panic!("Unexpected value: {:?}", value), + } +} From 31c5fe816948461d9015350d173d5c8b7bad5885 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 24 Jan 2022 20:05:54 +0000 Subject: [PATCH 09/12] Add SUPPORTED_METHODS constant --- src/compression.rs | 58 ++++++++++++++-------------------------------- src/lib.rs | 2 +- 2 files changed, 19 insertions(+), 41 deletions(-) diff --git a/src/compression.rs b/src/compression.rs index c2e8ce44..18da9b0b 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -121,27 +121,6 @@ impl CompressionMethod { CompressionMethod::Unsupported(v) => v, } } - - pub fn supported_methods() -> &'static [CompressionMethod] { - static METHODS: [CompressionMethod; 4] = [ - CompressionMethod::Stored, - // - #[cfg(any( - feature = "deflate", - feature = "deflate-miniz", - feature = "deflate-zlib" - ))] - CompressionMethod::Deflated, - // - #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2, - // - #[cfg(feature = "zstd")] - CompressionMethod::Zstd, - ]; - - &METHODS - } } impl fmt::Display for CompressionMethod { @@ -151,9 +130,24 @@ impl fmt::Display for CompressionMethod { } } +/// The compression methods which have been implemented. +pub const SUPPORTED_METHODS: &[CompressionMethod] = &[ + CompressionMethod::Stored, + #[cfg(any( + feature = "deflate", + feature = "deflate-miniz", + feature = "deflate-zlib" + ))] + CompressionMethod::Deflated, + #[cfg(feature = "bzip2")] + CompressionMethod::Bzip2, + #[cfg(feature = "zstd")] + CompressionMethod::Zstd, +]; + #[cfg(test)] mod test { - use super::CompressionMethod; + use super::{CompressionMethod, SUPPORTED_METHODS}; #[test] fn from_eq_to() { @@ -166,22 +160,6 @@ mod test { } } - fn methods() -> Vec { - vec![ - CompressionMethod::Stored, - #[cfg(any( - feature = "deflate", - feature = "deflate-miniz", - feature = "deflate-zlib" - ))] - CompressionMethod::Deflated, - #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2, - #[cfg(feature = "zstd")] - CompressionMethod::Zstd, - ] - } - #[test] fn to_eq_from() { fn check_match(method: CompressionMethod) { @@ -194,7 +172,7 @@ mod test { assert_eq!(to, back); } - for method in methods() { + for &method in SUPPORTED_METHODS { check_match(method); } } @@ -207,7 +185,7 @@ mod test { assert_eq!(debug_str, display_str); } - for method in methods() { + for &method in SUPPORTED_METHODS { check_match(method); } } diff --git a/src/lib.rs b/src/lib.rs index 3b39ab4f..f2b8cf7b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,7 +5,7 @@ #![warn(missing_docs)] -pub use crate::compression::CompressionMethod; +pub use crate::compression::{CompressionMethod, SUPPORTED_METHODS}; pub use crate::read::ZipArchive; pub use crate::types::DateTime; pub use crate::write::ZipWriter; From 2d752acecfa19960cbc97124a3e36a23024d98c6 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 24 Jan 2022 20:06:12 +0000 Subject: [PATCH 10/12] Use SUPPORTED_METHODS in tests --- tests/end_to_end.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 31d6a1ea..51daebad 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -4,18 +4,20 @@ use std::io::prelude::*; use std::io::{Cursor, Seek}; use std::iter::FromIterator; use zip::write::FileOptions; -use zip::CompressionMethod; +use zip::{CompressionMethod, SUPPORTED_METHODS}; // 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. #[test] fn end_to_end() { - for method in CompressionMethod::supported_methods().iter() { + for &method in SUPPORTED_METHODS { let file = &mut Cursor::new(Vec::new()); - write_to_zip(file, *method).expect("Couldn't write to test file"); + println!("Writing file with {} compression", method); + write_to_zip(file, method).expect("Couldn't write to test file"); - check_zip_contents(file, ENTRY_NAME, Some(*method)); + println!("Checking file contents"); + check_zip_contents(file, ENTRY_NAME, Some(method)); } } @@ -23,9 +25,9 @@ fn end_to_end() { // contents back out, the extracted data will *always* be exactly the same as the original data. #[test] fn copy() { - for method in CompressionMethod::supported_methods().iter() { + for &method in SUPPORTED_METHODS { let src_file = &mut Cursor::new(Vec::new()); - write_to_zip(src_file, *method).expect("Couldn't write to test file"); + write_to_zip(src_file, method).expect("Couldn't write to test file"); let mut tgt_file = &mut Cursor::new(Vec::new()); @@ -62,15 +64,15 @@ fn copy() { // both the prior data and the appended data will be exactly the same as their originals. #[test] fn append() { - for method in CompressionMethod::supported_methods().iter() { + for &method in SUPPORTED_METHODS { let mut file = &mut Cursor::new(Vec::new()); - write_to_zip(file, *method).expect("Couldn't write to test file"); + write_to_zip(file, method).expect("Couldn't write to test file"); { let mut zip = zip::ZipWriter::new_append(&mut file).unwrap(); zip.start_file( COPY_ENTRY_NAME, - FileOptions::default().compression_method(*method), + FileOptions::default().compression_method(method), ) .unwrap(); zip.write_all(LOREM_IPSUM).unwrap(); From 083d95bcd1957af796504a0fd2b15512ae5e7be2 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Sun, 30 Jan 2022 20:37:46 +0000 Subject: [PATCH 11/12] Update SUPPORTED_METHODS const name --- src/compression.rs | 8 ++++---- src/lib.rs | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compression.rs b/src/compression.rs index 18da9b0b..1729deb5 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -131,7 +131,7 @@ impl fmt::Display for CompressionMethod { } /// The compression methods which have been implemented. -pub const SUPPORTED_METHODS: &[CompressionMethod] = &[ +pub const SUPPORTED_COMPRESSION_METHODS: &[CompressionMethod] = &[ CompressionMethod::Stored, #[cfg(any( feature = "deflate", @@ -147,7 +147,7 @@ pub const SUPPORTED_METHODS: &[CompressionMethod] = &[ #[cfg(test)] mod test { - use super::{CompressionMethod, SUPPORTED_METHODS}; + use super::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS}; #[test] fn from_eq_to() { @@ -172,7 +172,7 @@ mod test { assert_eq!(to, back); } - for &method in SUPPORTED_METHODS { + for &method in SUPPORTED_COMPRESSION_METHODS { check_match(method); } } @@ -185,7 +185,7 @@ mod test { assert_eq!(debug_str, display_str); } - for &method in SUPPORTED_METHODS { + for &method in SUPPORTED_COMPRESSION_METHODS { check_match(method); } } diff --git a/src/lib.rs b/src/lib.rs index f2b8cf7b..03005634 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,7 +5,7 @@ #![warn(missing_docs)] -pub use crate::compression::{CompressionMethod, SUPPORTED_METHODS}; +pub use crate::compression::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS}; pub use crate::read::ZipArchive; pub use crate::types::DateTime; pub use crate::write::ZipWriter; From b444664d71a33e519cdc7450343ef24b9dfa6b52 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Sun, 30 Jan 2022 20:39:43 +0000 Subject: [PATCH 12/12] Apply formatter fixes --- src/compression.rs | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/compression.rs b/src/compression.rs index 1729deb5..8b351478 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -132,17 +132,17 @@ impl fmt::Display for CompressionMethod { /// The compression methods which have been implemented. pub const SUPPORTED_COMPRESSION_METHODS: &[CompressionMethod] = &[ - CompressionMethod::Stored, - #[cfg(any( - feature = "deflate", - feature = "deflate-miniz", - feature = "deflate-zlib" - ))] - CompressionMethod::Deflated, - #[cfg(feature = "bzip2")] - CompressionMethod::Bzip2, - #[cfg(feature = "zstd")] - CompressionMethod::Zstd, + CompressionMethod::Stored, + #[cfg(any( + feature = "deflate", + feature = "deflate-miniz", + feature = "deflate-zlib" + ))] + CompressionMethod::Deflated, + #[cfg(feature = "bzip2")] + CompressionMethod::Bzip2, + #[cfg(feature = "zstd")] + CompressionMethod::Zstd, ]; #[cfg(test)]