Merge improvements from master

.github/workflows/ci.yaml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
-        rust: [stable]
+        rust: [stable, 1.34.0]
 
     steps:
     - uses: actions/checkout@master

README.md

@@ -49,6 +49,17 @@ The features available are:
 
 All of these are enabled by default.
 
+MSRV
+----
+
+Our current Minimum Supported Rust Version is **1.34.0**. When adding features,
+we will follow these guidelines:
+
+- We will always support the latest four minor Rust versions. This gives you a 6
+  month window to upgrade your compiler.
+- Any change to the MSRV will be accompanied with a **minor** version bump
+   - While the crate is pre-1.0, this will be a change to the PATCH version.
+
 Examples
 --------
 

examples/write_dir.rs

@@ -14,9 +14,17 @@ fn main() {
 
 const METHOD_STORED: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Stored);
 
-#[cfg(feature = "deflate")]
+#[cfg(any(
+    feature = "deflate",
+    feature = "deflate-miniz",
+    feature = "deflate-zlib"
+))]
 const METHOD_DEFLATED: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Deflated);
-#[cfg(not(feature = "deflate"))]
+#[cfg(not(any(
+    feature = "deflate",
+    feature = "deflate-miniz",
+    feature = "deflate-zlib"
+)))]
 const METHOD_DEFLATED: Option<zip::CompressionMethod> = None;
 
 #[cfg(feature = "bzip2")]

src/compression.rs

@@ -2,13 +2,18 @@
 
 use std::fmt;
 
+#[allow(deprecated)]
 /// Compression methods for the contents of a ZIP file.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum CompressionMethod {
     /// The file is stored (no compression)
     Stored,
-    /// Deflate in pure rust
+    /// Deflate using any flate2 backend
-    #[cfg(feature = "deflate")]
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
     Deflated,
     /// File is compressed using BZIP2 algorithm
     #[cfg(feature = "bzip2")]
@@ -28,13 +33,18 @@ impl CompressionMethod {
         note = "implementation details are being removed from the public API"
     )]
     pub fn from_u16(val: u16) -> CompressionMethod {
+        #[allow(deprecated)]
         match val {
             0 => CompressionMethod::Stored,
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             8 => CompressionMethod::Deflated,
             #[cfg(feature = "bzip2")]
             12 => CompressionMethod::Bzip2,
-            #[allow(deprecated)]
+
             v => CompressionMethod::Unsupported(v),
         }
     }
@@ -45,13 +55,17 @@ impl CompressionMethod {
         note = "implementation details are being removed from the public API"
     )]
     pub fn to_u16(self) -> u16 {
+        #[allow(deprecated)]
         match self {
             CompressionMethod::Stored => 0,
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             CompressionMethod::Deflated => 8,
             #[cfg(feature = "bzip2")]
             CompressionMethod::Bzip2 => 12,
-            #[allow(deprecated)]
             CompressionMethod::Unsupported(v) => v,
         }
     }
@@ -82,7 +96,11 @@ mod test {
     fn methods() -> Vec<CompressionMethod> {
         let mut methods = Vec::new();
         methods.push(CompressionMethod::Stored);
-        #[cfg(feature = "deflate")]
+        #[cfg(any(
+            feature = "deflate",
+            feature = "deflate-miniz",
+            feature = "deflate-zlib"
+        ))]
         methods.push(CompressionMethod::Deflated);
         #[cfg(feature = "bzip2")]
         methods.push(CompressionMethod::Bzip2);

src/read.rs

@@ -15,7 +15,11 @@ use crate::cp437::FromCp437;
 use crate::types::{DateTime, System, ZipFileData};
 use byteorder::{LittleEndian, ReadBytesExt};
 
-#[cfg(feature = "deflate")]
+#[cfg(any(
+    feature = "deflate",
+    feature = "deflate-miniz",
+    feature = "deflate-zlib"
+))]
 use flate2::read::DeflateDecoder;
 
 #[cfg(feature = "bzip2")]
@@ -84,7 +88,11 @@ impl<'a> CryptoReader<'a> {
 enum ZipFileReader<'a> {
     NoReader,
     Stored(Crc32Reader<CryptoReader<'a>>),
-    #[cfg(feature = "deflate")]
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
     Deflated(Crc32Reader<flate2::read::DeflateDecoder<CryptoReader<'a>>>),
     #[cfg(feature = "bzip2")]
     Bzip2(Crc32Reader<BzDecoder<CryptoReader<'a>>>),
@@ -95,7 +103,11 @@ impl<'a> Read for ZipFileReader<'a> {
         match self {
             ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
             ZipFileReader::Stored(r) => r.read(buf),
-            #[cfg(feature = "deflate")]
+			#[cfg(any(
+				feature = "deflate",
+				feature = "deflate-miniz",
+				feature = "deflate-zlib"
+			))]
             ZipFileReader::Deflated(r) => r.read(buf),
             #[cfg(feature = "bzip2")]
             ZipFileReader::Bzip2(r) => r.read(buf),
@@ -109,7 +121,11 @@ impl<'a> ZipFileReader<'a> {
         match self {
             ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
             ZipFileReader::Stored(r) => r.into_inner().into_inner(),
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+				feature = "deflate",
+				feature = "deflate-miniz",
+				feature = "deflate-zlib"
+			))]
             ZipFileReader::Deflated(r) => r.into_inner().into_inner().into_inner(),
             #[cfg(feature = "bzip2")]
             ZipFileReader::Bzip2(r) => r.into_inner().into_inner().into_inner(),
@@ -139,7 +155,11 @@ fn make_reader<'a>(
 
     match compression_method {
         CompressionMethod::Stored => Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32))),
-        #[cfg(feature = "deflate")]
+        #[cfg(any(
+			feature = "deflate",
+			feature = "deflate-miniz",
+			feature = "deflate-zlib"
+		))]
         CompressionMethod::Deflated => {
             let deflate_reader = DeflateDecoder::new(reader);
             Ok(ZipFileReader::Deflated(Crc32Reader::new(
@@ -793,7 +813,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"");
     }
 
     #[test]

src/types.rs

@@ -1,6 +1,5 @@
 //! Types that specify what is contained in a ZIP.
 
-#[non_exhaustive]
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum System {
     Dos = 0,

src/write.rs

@@ -11,7 +11,11 @@ use std::io;
 use std::io::prelude::*;
 use std::mem;
 
-#[cfg(feature = "deflate")]
+#[cfg(any(
+    feature = "deflate",
+    feature = "deflate-miniz",
+    feature = "deflate-zlib"
+))]
 use flate2::write::DeflateEncoder;
 
 #[cfg(feature = "bzip2")]
@@ -20,7 +24,11 @@ use bzip2::write::BzEncoder;
 enum GenericZipWriter<W: Write + io::Seek> {
     Closed,
     Storer(W),
-    #[cfg(feature = "deflate")]
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
     Deflater(DeflateEncoder<W>),
     #[cfg(feature = "bzip2")]
     Bzip2(BzEncoder<W>),
@@ -77,9 +85,17 @@ impl FileOptions {
     /// Construct a new FileOptions object
     pub fn default() -> FileOptions {
         FileOptions {
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             compression_method: CompressionMethod::Deflated,
-            #[cfg(not(feature = "deflate"))]
+            #[cfg(not(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            )))]
             compression_method: CompressionMethod::Stored,
             #[cfg(feature = "time")]
             last_modified_time: DateTime::from_time(time::now()).unwrap_or_default(),
@@ -176,7 +192,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             files: Vec::new(),
             stats: Default::default(),
             writing_to_file: false,
-            comment: "zip-rs".into(),
+            comment: String::new(),
         }
     }
 
@@ -384,7 +400,11 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
 
         let bare = match mem::replace(self, GenericZipWriter::Closed) {
             GenericZipWriter::Storer(w) => w,
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             GenericZipWriter::Deflater(w) => w.finish()?,
             #[cfg(feature = "bzip2")]
             GenericZipWriter::Bzip2(w) => w.finish()?,
@@ -397,20 +417,26 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
             }
         };
 
-        *self = match compression {
+        *self = {
-            CompressionMethod::Stored => GenericZipWriter::Storer(bare),
-            #[cfg(feature = "deflate")]
-            CompressionMethod::Deflated => GenericZipWriter::Deflater(DeflateEncoder::new(
-                bare,
-                flate2::Compression::default(),
-            )),
-            #[cfg(feature = "bzip2")]
-            CompressionMethod::Bzip2 => {
-                GenericZipWriter::Bzip2(BzEncoder::new(bare, bzip2::Compression::Default))
-            }
             #[allow(deprecated)]
-            CompressionMethod::Unsupported(..) => {
+            match compression {
-                return Err(ZipError::UnsupportedArchive("Unsupported compression"))
+                CompressionMethod::Stored => GenericZipWriter::Storer(bare),
+                #[cfg(any(
+                    feature = "deflate",
+                    feature = "deflate-miniz",
+                    feature = "deflate-zlib"
+                ))]
+                CompressionMethod::Deflated => GenericZipWriter::Deflater(DeflateEncoder::new(
+                    bare,
+                    flate2::Compression::default(),
+                )),
+                #[cfg(feature = "bzip2")]
+                CompressionMethod::Bzip2 => {
+                    GenericZipWriter::Bzip2(BzEncoder::new(bare, bzip2::Compression::Default))
+                }
+                CompressionMethod::Unsupported(..) => {
+                    return Err(ZipError::UnsupportedArchive("Unsupported compression"))
+                }
             }
         };
 
@@ -420,7 +446,11 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
     fn ref_mut(&mut self) -> Option<&mut dyn Write> {
         match *self {
             GenericZipWriter::Storer(ref mut w) => Some(w as &mut dyn Write),
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             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),
@@ -445,7 +475,11 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
     fn current_compression(&self) -> Option<CompressionMethod> {
         match *self {
             GenericZipWriter::Storer(..) => Some(CompressionMethod::Stored),
-            #[cfg(feature = "deflate")]
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
             GenericZipWriter::Deflater(..) => Some(CompressionMethod::Deflated),
             #[cfg(feature = "bzip2")]
             GenericZipWriter::Bzip2(..) => Some(CompressionMethod::Bzip2),
@@ -616,7 +650,7 @@ mod test {
             .write(b"writing to a directory is not allowed, and will not write any data")
             .is_err());
         let result = writer.finish().unwrap();
-        assert_eq!(result.get_ref().len(), 114);
+        assert_eq!(result.get_ref().len(), 108);
         assert_eq!(
             *result.get_ref(),
             &[
@@ -624,7 +658,7 @@ mod test {
                 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 47, 80, 75, 1, 2, 46, 3, 20, 0, 0, 0, 0, 0,
                 163, 165, 15, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 0, 0, 237, 65, 0, 0, 0, 0, 116, 101, 115, 116, 47, 80, 75, 5, 6, 0, 0, 0, 0, 1, 0,
-                1, 0, 51, 0, 0, 0, 35, 0, 0, 0, 6, 0, 122, 105, 112, 45, 114, 115
+                1, 0, 51, 0, 0, 0, 35, 0, 0, 0, 0, 0,
             ] as &[u8]
         );
     }
@@ -642,7 +676,8 @@ mod test {
             .write(b"application/vnd.oasis.opendocument.text")
             .unwrap();
         let result = writer.finish().unwrap();
-        assert_eq!(result.get_ref().len(), 159);
+
+        assert_eq!(result.get_ref().len(), 153);
         let mut v = Vec::new();
         v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
         assert_eq!(result.get_ref(), &v);

tests/end_to_end.rs

@@ -39,7 +39,7 @@ fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<Strin
     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 expected_file_names = HashSet::from_iter(expected_file_names.iter().map(|&v| v));
     let file_names = archive.file_names().collect::<HashSet<_>>();
     assert_eq!(file_names, expected_file_names);