implement ZipFile::options + refactor options normalization (#305)

Co-authored-by: Chris Hennick <[email protected]>

Author: WilliamVenner

src/read.rs

@@ -13,7 +13,9 @@ use crate::types::{
     AesMode, AesVendorVersion, DateTime, System, ZipCentralEntryBlock, ZipFileData,
     ZipLocalEntryBlock,
 };
+use crate::write::SimpleFileOptions;
 use crate::zipcrypto::{ZipCryptoReader, ZipCryptoReaderValid, ZipCryptoValidator};
+use crate::ZIP64_BYTES_THR;
 use indexmap::IndexMap;
 use std::borrow::Cow;
 use std::ffi::OsStr;
@@ -115,7 +117,7 @@ use crate::aes::PWD_VERIFY_LENGTH;
 use crate::extra_fields::UnicodeExtraField;
 use crate::result::ZipError::{InvalidArchive, InvalidPassword};
 use crate::spec::is_dir;
-use crate::types::ffi::S_IFLNK;
+use crate::types::ffi::{S_IFLNK, S_IFREG};
 use crate::unstable::{path_to_string, LittleEndianReadExt};
 pub use zip_archive::ZipArchive;
 
@@ -1578,6 +1580,23 @@ impl<'a> ZipFile<'a> {
     pub fn central_header_start(&self) -> u64 {
         self.get_metadata().central_header_start
     }
+
+    /// Get the [`SimpleFileOptions`] that would be used to write this file to
+    /// a new zip archive.
+    pub fn options(&self) -> SimpleFileOptions {
+        let mut options = SimpleFileOptions::default()
+            .large_file(self.compressed_size().max(self.size()) > ZIP64_BYTES_THR)
+            .compression_method(self.compression())
+            .unix_permissions(self.unix_mode().unwrap_or(0o644) | S_IFREG)
+            .last_modified_time(
+                self.last_modified()
+                    .filter(|m| m.is_valid())
+                    .unwrap_or_else(DateTime::default_for_write),
+            );
+
+        options.normalize();
+        options
+    }
 }
 
 /// Methods for retrieving information on zip files

src/write.rs

@@ -417,6 +417,14 @@ impl<'a> arbitrary::Arbitrary<'a> for FileOptions<'a, ExtendedFileOptions> {
 }
 
 impl<T: FileOptionExtension> FileOptions<'_, T> {
+    pub(crate) fn normalize(&mut self) {
+        if !self.last_modified_time.is_valid() {
+            self.last_modified_time = FileOptions::<T>::default().last_modified_time;
+        }
+
+        *self.permissions.get_or_insert(0o644) |= ffi::S_IFREG;
+    }
+
     /// Set the compression method for the new file
     ///
     /// The default is `CompressionMethod::Deflated` if it is enabled. If not,
@@ -1168,7 +1176,7 @@ impl<W: Write + Seek> ZipWriter<W> {
         name: S,
         mut options: FileOptions<T>,
     ) -> ZipResult<()> {
-        Self::normalize_options(&mut options);
+        options.normalize();
         let make_new_self = self.inner.prepare_next_writer(
             options.compression_method,
             options.compression_level,
@@ -1244,16 +1252,6 @@ impl<W: Write + Seek> ZipWriter<W> {
         Ok(())
     }
 
-    fn normalize_options<T: FileOptionExtension>(options: &mut FileOptions<T>) {
-        if options.permissions.is_none() {
-            options.permissions = Some(0o644);
-        }
-        if !options.last_modified_time.is_valid() {
-            options.last_modified_time = FileOptions::<T>::default().last_modified_time;
-        }
-        *options.permissions.as_mut().unwrap() |= ffi::S_IFREG;
-    }
-
     /// Starts a file, taking a Path as argument.
     ///
     /// This function ensures that the '/' path separator is used and normalizes `.` and `..`. It
@@ -1294,17 +1292,7 @@ impl<W: Write + Seek> ZipWriter<W> {
     /// }
     /// ```
     pub fn raw_copy_file_rename<S: ToString>(&mut self, file: ZipFile, name: S) -> ZipResult<()> {
-        let mut options = SimpleFileOptions::default()
-            .large_file(file.compressed_size().max(file.size()) > spec::ZIP64_BYTES_THR)
-            .last_modified_time(
-                file.last_modified()
-                    .unwrap_or_else(DateTime::default_for_write),
-            )
-            .compression_method(file.compression());
-        if let Some(perms) = file.unix_mode() {
-            options = options.unix_permissions(perms);
-        }
-        Self::normalize_options(&mut options);
+        let options = file.options();
         self.raw_copy_file_rename_internal(file, name, options)
     }
 
@@ -1399,14 +1387,17 @@ impl<W: Write + Seek> ZipWriter<W> {
         unix_mode: Option<u32>,
     ) -> ZipResult<()> {
         let name = file.name().to_owned();
-        let mut options = SimpleFileOptions::default()
-            .large_file(file.compressed_size().max(file.size()) > spec::ZIP64_BYTES_THR)
-            .last_modified_time(last_modified_time)
-            .compression_method(file.compression());
+
+        let mut options = file.options();
+
+        options = options.last_modified_time(last_modified_time);
+
         if let Some(perms) = unix_mode {
             options = options.unix_permissions(perms);
         }
-        Self::normalize_options(&mut options);
+
+        options.normalize();
+
         self.raw_copy_file_rename_internal(file, name, options)
     }