merge edition 2018 and other improvements from master

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "zip"
-version = "0.5.3"
+version = "0.5.5"
 authors = ["Mathijs van de Nes <git@mathijs.vd-nes.nl>"]
 license = "MIT"
 repository = "https://github.com/mvdnes/zip-rs.git"
@@ -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 }

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
 ----
 

benches/read_entry.rs

@@ -1,7 +1,4 @@
-#[macro_use]
+use bencher::{benchmark_group, benchmark_main};
-extern crate bencher;
-extern crate rand;
-extern crate zip;
 
 use std::io::{Cursor, Read, Write};
 

examples/extract.rs

@@ -1,5 +1,3 @@
-extern crate zip;
-
 use std::io;
 use std::fs;
 

examples/extract_lorem.rs

@@ -1,7 +1,5 @@
 use std::io::prelude::*;
 
-extern crate zip;
-
 fn main()
 {
     std::process::exit(real_main());

examples/file_info.rs

@@ -1,5 +1,3 @@
-extern crate zip;
-
 use std::fs;
 use std::io::BufReader;
 

examples/stdin_info.rs

@@ -1,5 +1,3 @@
-extern crate zip;
-
 use std::io::{self, Read};
 
 fn main() {

examples/write_dir.rs

@@ -1,5 +1,3 @@
-extern crate zip;
-extern crate walkdir;
 
 use std::io::prelude::*;
 use std::io::{Write, Seek};
@@ -48,7 +46,7 @@ fn real_main() -> i32 {
     return 0;
 }
 
-fn zip_dir<T>(it: &mut Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
+fn zip_dir<T>(it: &mut dyn Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
               -> zip::result::ZipResult<()>
     where T: Write+Seek
 {

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());

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)
     }

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,

src/lib.rs

@@ -2,19 +2,10 @@
 
 #![warn(missing_docs)]
 
-#[cfg(feature = "bzip2")]
+pub use crate::read::ZipArchive;
-extern crate bzip2;
+pub use crate::write::ZipWriter;
-extern crate crc32fast;
+pub use crate::compression::CompressionMethod;
-#[cfg(feature = "deflate")]
+pub use crate::types::DateTime;
-extern crate flate2;
-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;
 
 mod spec;
 mod crc32;

src/read.rs

@@ -1,22 +1,20 @@
 //! Structs for reading a ZIP archive
 
-use crc32::Crc32Reader;
+use crate::crc32::Crc32Reader;
-use compression::CompressionMethod;
+use crate::compression::CompressionMethod;
-use zipcrypto::ZipCryptoReader;
+use crate::zipcrypto::ZipCryptoReader;
-use zipcrypto::ZipCryptoReaderValid;
+use crate::zipcrypto::ZipCryptoReaderValid;
-use spec;
+use crate::spec;
-use result::{ZipResult, ZipError};
+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 crate::types::{ZipFileData, System, DateTime};
-use cp437::FromCp437;
+use crate::cp437::FromCp437;
 
-#[cfg(feature = "deflate")]
-use flate2;
 #[cfg(feature = "deflate")]
 use flate2::read::DeflateDecoder;
 
@@ -66,8 +64,8 @@ pub struct ZipArchive<R: Read + io::Seek>
 
 enum CryptoReader<'a>
 {
-    Plaintext(io::Take<&'a mut Read>),
+    Plaintext(io::Take<&'a mut dyn Read>),
-    ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut Read>>),
+    ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut dyn Read>>),
 }
 
 impl<'a> Read for CryptoReader<'a> {
@@ -82,7 +80,7 @@ impl<'a> Read for CryptoReader<'a> {
 impl<'a> CryptoReader<'a>
 {
     /// Consumes this decoder, returning the underlying reader.
-    pub fn into_inner(self) -> io::Take<&'a mut Read> {
+    pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
         match self {
             CryptoReader::Plaintext(r) => r,
             CryptoReader::ZipCrypto(r) => r.into_inner(),
@@ -116,7 +114,7 @@ impl<'a> Read for ZipFileReader<'a> {
 impl<'a> ZipFileReader<'a>
 {
     /// Consumes this decoder, returning the underlying reader.
-    pub fn into_inner(self) -> io::Take<&'a mut Read> {
+    pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
         match self {
             ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
             ZipFileReader::Stored(r) => r.into_inner().into_inner(),
@@ -141,9 +139,9 @@ fn unsupported_zip_error<T>(detail: &'static str) -> ZipResult<T>
 
 
 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>,
     password: Option<&[u8]>)
         -> ZipResult<ZipFileReader<'a>> {
     
@@ -324,7 +322,17 @@ impl<R: Read+io::Seek> ZipArchive<R>
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    
+
+    /// Get the comment of the zip archive.
+    pub fn comment(&self) -> &[u8] {
+        &self.comment
+    }
+
+    /// Returns an iterator over all the file and directory names in this archive.
+    pub fn file_names(&self) -> impl Iterator<Item = &str> {
+        self.names_map.keys().map(|s| s.as_str())
+    }
+
     /// Search for a file entry by name, decrypt with given password
     pub fn by_name_decrypt<'a>(&'a mut self, name: &str, password: &[u8]) -> ZipResult<ZipFile<'a>>
     {
@@ -336,7 +344,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
     {
         self.by_name_internal(name, None)
     }
-    
+
     fn by_name_internal<'a>(&'a mut self, name: &str, password: Option<&[u8]>) -> ZipResult<ZipFile<'a>>
     {
         let index = match self.names_map.get(name) {
@@ -351,7 +359,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
     {
         self.by_index_internal(file_number, Some(password))
     }
-    
+
     /// Get a contained file by index
     pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>>
     {
@@ -391,8 +399,8 @@ impl<R: Read+io::Seek> ZipArchive<R>
         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, password)?, data: Cow::Borrowed(data) })
     }
 
@@ -645,7 +653,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<Option<ZipFile>> {
+pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult<Option<ZipFile<'_>>> {
     let signature = reader.read_u32::<LittleEndian>()?;
 
     match signature {
@@ -712,7 +720,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;
@@ -754,7 +762,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]

src/result.rs

@@ -33,14 +33,14 @@ pub enum ZipError
 
 impl ZipError
 {
-    fn detail(&self) -> ::std::borrow::Cow<str>
+    fn detail(&self) -> ::std::borrow::Cow<'_, str>
     {
         use std::error::Error;
 
         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()
@@ -70,7 +70,7 @@ impl convert::From<ZipError> 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())
     }
@@ -82,7 +82,7 @@ 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",
@@ -91,11 +91,11 @@ impl error::Error for ZipError
         }
     }
 
-    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,
         }
     }

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;

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<DateTime, ()> {
         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
@@ -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,
@@ -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;
@@ -373,4 +427,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());
+    }
 }

src/write.rs

@@ -1,25 +1,19 @@
 //! Structs for creating a new zip archive
 
-use compression::CompressionMethod;
+use crate::compression::CompressionMethod;
-use types::{ZipFileData, System, DEFAULT_VERSION, DateTime};
+use crate::types::{ZipFileData, System, DEFAULT_VERSION, DateTime};
-use spec;
+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::*;
 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;
 
@@ -63,6 +57,7 @@ pub struct ZipWriter<W: Write + io::Seek>
     files: Vec<ZipFileData>,
     stats: ZipWriterStats,
     writing_to_file: bool,
+    comment: String,
 }
 
 #[derive(Default)]
@@ -180,9 +175,15 @@ impl<W: Write+io::Seek> ZipWriter<W>
             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<S>(&mut self, comment: S) where S: Into<String> {
+        self.comment = comment.into();
+    }
+
     /// Start a new file for with the requested options.
     fn start_entry<S>(&mut self, name: S, options: FileOptions) -> ZipResult<()>
         where S: Into<String>
@@ -339,7 +340,7 @@ impl<W: Write+io::Seek> ZipWriter<W>
                 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)?;
@@ -395,13 +396,13 @@ impl<W: Write+io::Seek> GenericZipWriter<W>
         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,16 +564,17 @@ 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() {
         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().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, 6, 0, 122, 105, 112, 45, 114, 115]);
+        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]

tests/end_to_end.rs

@@ -1,8 +1,8 @@
-extern crate zip;
-
 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.
@@ -38,6 +38,11 @@ fn write_to_zip_file(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
 fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<String> {
     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::<HashSet<_>>();
+    assert_eq!(file_names, expected_file_names);
+
     let mut file = archive.by_name("test/lorem_ipsum.txt")?;
 
     let mut contents = String::new();

tests/invalid_date.rs

@@ -1,5 +1,3 @@
-extern crate zip;
-
 use zip::read::ZipArchive;
 use std::io::Cursor;
 

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;
@@ -167,16 +164,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];
             },
             _ => {