Merge pull request #338 from aquacash5/fix-clippy-issues

Fix clippy issues

benches/read_metadata.rs

@@ -17,10 +17,7 @@ fn generate_random_archive(count_files: usize, file_size: usize) -> Vec<u8> {
     let bytes = vec![0u8; file_size];
 
     for i in 0..count_files {
-        let name = format!(
+        let name = format!("file_deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef_{i}.dat");
-            "file_deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef_{}.dat",
-            i
-        );
         writer.start_file(name, options).unwrap();
         writer.write_all(&bytes).unwrap();
     }

examples/extract.rs

@@ -12,7 +12,7 @@ fn real_main() -> i32 {
         return 1;
     }
     let fname = std::path::Path::new(&*args[1]);
-    let file = fs::File::open(&fname).unwrap();
+    let file = fs::File::open(fname).unwrap();
 
     let mut archive = zip::ZipArchive::new(file).unwrap();
 
@@ -26,7 +26,7 @@ fn real_main() -> i32 {
         {
             let comment = file.comment();
             if !comment.is_empty() {
-                println!("File {} comment: {}", i, comment);
+                println!("File {i} comment: {comment}");
             }
         }
 

examples/extract_lorem.rs

@@ -25,7 +25,7 @@ fn real_main() -> i32 {
 
     let mut contents = String::new();
     file.read_to_string(&mut contents).unwrap();
-    println!("{}", contents);
+    println!("{contents}");
 
     0
 }

examples/file_info.rs

@@ -30,7 +30,7 @@ fn real_main() -> i32 {
         {
             let comment = file.comment();
             if !comment.is_empty() {
-                println!("Entry {} comment: {}", i, comment);
+                println!("Entry {i} comment: {comment}");
             }
         }
 

examples/stdin_info.rs

@@ -20,12 +20,12 @@ fn real_main() -> i32 {
                 );
                 match file.read(&mut buf) {
                     Ok(n) => println!("The first {} bytes are: {:?}", n, &buf[0..n]),
-                    Err(e) => println!("Could not read the file: {:?}", e),
+                    Err(e) => println!("Could not read the file: {e:?}"),
                 };
             }
             Ok(None) => break,
             Err(e) => {
-                println!("Error encountered while reading zip: {:?}", e);
+                println!("Error encountered while reading zip: {e:?}");
                 return 1;
             }
         }

examples/write_dir.rs

@@ -54,8 +54,8 @@ fn real_main() -> i32 {
             continue;
         }
         match doit(src_dir, dst_file, method.unwrap()) {
-            Ok(_) => println!("done: {} written to {}", src_dir, dst_file),
+            Ok(_) => println!("done: {src_dir} written to {dst_file}"),
-            Err(e) => println!("Error: {:?}", e),
+            Err(e) => println!("Error: {e:?}"),
         }
     }
 
@@ -84,18 +84,18 @@ where
         // Write file or directory explicitly
         // Some unzip tools unzip files with directory paths correctly, some do not!
         if path.is_file() {
-            println!("adding file {:?} as {:?} ...", path, name);
+            println!("adding file {path:?} as {name:?} ...");
             #[allow(deprecated)]
             zip.start_file_from_path(name, options)?;
             let mut f = File::open(path)?;
 
             f.read_to_end(&mut buffer)?;
-            zip.write_all(&*buffer)?;
+            zip.write_all(&buffer)?;
             buffer.clear();
         } 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);
+            println!("adding dir {path:?} as {name:?} ...");
             #[allow(deprecated)]
             zip.add_directory_from_path(name, options)?;
         }

examples/write_sample.rs

@@ -14,8 +14,8 @@ fn real_main() -> i32 {
 
     let filename = &*args[1];
     match doit(filename) {
-        Ok(_) => println!("File written to {}", filename),
+        Ok(_) => println!("File written to {filename}"),
-        Err(e) => println!("Error: {:?}", e),
+        Err(e) => println!("Error: {e:?}"),
     }
 
     0

src/compression.rs

@@ -141,7 +141,7 @@ impl CompressionMethod {
 impl fmt::Display for CompressionMethod {
     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)
+        write!(f, "{self:?}")
     }
 }
 
@@ -195,8 +195,8 @@ mod test {
     #[test]
     fn to_display_fmt() {
         fn check_match(method: CompressionMethod) {
-            let debug_str = format!("{:?}", method);
+            let debug_str = format!("{method:?}");
-            let display_str = format!("{}", method);
+            let display_str = format!("{method}");
             assert_eq!(debug_str, display_str);
         }
 

src/result.rs

@@ -44,9 +44,9 @@ impl From<io::Error> for ZipError {
 impl fmt::Display for ZipError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            ZipError::Io(err) => write!(fmt, "{}", err),
+            ZipError::Io(err) => write!(fmt, "{err}"),
-            ZipError::InvalidArchive(err) => write!(fmt, "invalid Zip archive: {}", err),
+            ZipError::InvalidArchive(err) => write!(fmt, "invalid Zip archive: {err}"),
-            ZipError::UnsupportedArchive(err) => write!(fmt, "unsupported Zip archive: {}", err),
+            ZipError::UnsupportedArchive(err) => write!(fmt, "unsupported Zip archive: {err}"),
             ZipError::FileNotFound => write!(fmt, "specified file not found in archive"),
         }
     }

src/write.rs

@@ -110,31 +110,6 @@ pub struct FileOptions {
 }
 
 impl FileOptions {
-    /// Construct a new FileOptions object
-    pub fn default() -> FileOptions {
-        FileOptions {
-            #[cfg(any(
-                feature = "deflate",
-                feature = "deflate-miniz",
-                feature = "deflate-zlib"
-            ))]
-            compression_method: CompressionMethod::Deflated,
-            #[cfg(not(any(
-                feature = "deflate",
-                feature = "deflate-miniz",
-                feature = "deflate-zlib"
-            )))]
-            compression_method: CompressionMethod::Stored,
-            compression_level: None,
-            #[cfg(feature = "time")]
-            last_modified_time: DateTime::from_time(OffsetDateTime::now_utc()).unwrap_or_default(),
-            #[cfg(not(feature = "time"))]
-            last_modified_time: DateTime::default(),
-            permissions: None,
-            large_file: false,
-        }
-    }
-
     /// Set the compression method for the new file
     ///
     /// The default is `CompressionMethod::Deflated`. If the deflate compression feature is
@@ -198,8 +173,29 @@ impl FileOptions {
 }
 
 impl Default for FileOptions {
+    /// Construct a new FileOptions object
     fn default() -> Self {
-        Self::default()
+        Self {
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
+            compression_method: CompressionMethod::Deflated,
+            #[cfg(not(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            )))]
+            compression_method: CompressionMethod::Stored,
+            compression_level: None,
+            #[cfg(feature = "time")]
+            last_modified_time: DateTime::from_time(OffsetDateTime::now_utc()).unwrap_or_default(),
+            #[cfg(not(feature = "time"))]
+            last_modified_time: DateTime::default(),
+            permissions: None,
+            large_file: false,
+        }
     }
 }
 
@@ -848,7 +844,7 @@ impl<W: Write + io::Seek> Drop for ZipWriter<W> {
     fn drop(&mut self) {
         if !self.inner.is_closed() {
             if let Err(e) = self.finalize() {
-                let _ = write!(io::stderr(), "ZipWriter drop failed: {:?}", e);
+                let _ = write!(io::stderr(), "ZipWriter drop failed: {e:?}");
             }
         }
     }
@@ -1211,8 +1207,7 @@ fn validate_extra_data(file: &ZipFileData) -> ZipResult<()> {
                 return Err(ZipError::Io(io::Error::new(
                     io::ErrorKind::Other,
                     format!(
-                        "Extra data header ID {:#06} requires crate feature \"unreserved\"",
+                        "Extra data header ID {kind:#06} requires crate feature \"unreserved\"",
-                        kind,
                     ),
                 )));
             }

tests/end_to_end.rs

@@ -13,7 +13,7 @@ fn end_to_end() {
     for &method in SUPPORTED_COMPRESSION_METHODS {
         let file = &mut Cursor::new(Vec::new());
 
-        println!("Writing file with {} compression", method);
+        println!("Writing file with {method} compression");
         write_test_archive(file, method).expect("Couldn't write test zip archive");
 
         println!("Checking file contents");

tests/zip64_large.rs

@@ -205,7 +205,7 @@ fn zip64_large() {
 
         match file.read_exact(&mut buf) {
             Ok(()) => println!("The first {} bytes are: {:?}", buf.len(), buf),
-            Err(e) => println!("Could not read the file: {:?}", e),
+            Err(e) => println!("Could not read the file: {e:?}"),
         };
     }
 }