1 files changed, 207 insertions, 0 deletions
diff --git a/vendor/zip/src/compression.rs b/vendor/zip/src/compression.rs
new file mode 100644
index 000000000..abd8b5300
--- /dev/null
+++ b/vendor/zip/src/compression.rs
@@ -0,0 +1,207 @@
+//! Possible ZIP compression methods.
+
+use std::fmt;
+
+#[allow(deprecated)]
+/// Identifies the storage format used to compress a file within a ZIP archive.
+///
+/// Each file's compression method is stored alongside it, allowing the
+/// contents to be read without context.
+///
+/// When creating ZIP files, you may choose the method to use with
+/// [`crate::write::FileOptions::compression_method`]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[non_exhaustive]
+pub enum CompressionMethod {
+    /// Store the file as is
+    Stored,
+    /// Compress the file using Deflate
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
+    Deflated,
+    /// Compress the file using BZIP2
+    #[cfg(feature = "bzip2")]
+    Bzip2,
+    /// Encrypted using AES.
+    ///
+    /// The actual compression method has to be taken from the AES extra data field
+    /// or from `ZipFileData`.
+    #[cfg(feature = "aes-crypto")]
+    Aes,
+    /// Compress the file using ZStandard
+    #[cfg(feature = "zstd")]
+    Zstd,
+    /// Unsupported compression method
+    #[deprecated(since = "0.5.7", note = "use the constants instead")]
+    Unsupported(u16),
+}
+#[allow(deprecated, missing_docs)]
+/// All compression methods defined for the ZIP format
+impl CompressionMethod {
+    pub const STORE: Self = CompressionMethod::Stored;
+    pub const SHRINK: Self = CompressionMethod::Unsupported(1);
+    pub const REDUCE_1: Self = CompressionMethod::Unsupported(2);
+    pub const REDUCE_2: Self = CompressionMethod::Unsupported(3);
+    pub const REDUCE_3: Self = CompressionMethod::Unsupported(4);
+    pub const REDUCE_4: Self = CompressionMethod::Unsupported(5);
+    pub const IMPLODE: Self = CompressionMethod::Unsupported(6);
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
+    pub const DEFLATE: Self = CompressionMethod::Deflated;
+    #[cfg(not(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    )))]
+    pub const DEFLATE: Self = CompressionMethod::Unsupported(8);
+    pub const DEFLATE64: Self = CompressionMethod::Unsupported(9);
+    pub const PKWARE_IMPLODE: Self = CompressionMethod::Unsupported(10);
+    #[cfg(feature = "bzip2")]
+    pub const BZIP2: Self = CompressionMethod::Bzip2;
+    #[cfg(not(feature = "bzip2"))]
+    pub const BZIP2: Self = CompressionMethod::Unsupported(12);
+    pub const LZMA: Self = CompressionMethod::Unsupported(14);
+    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);
+    pub const JPEG: Self = CompressionMethod::Unsupported(96);
+    pub const WAVPACK: Self = CompressionMethod::Unsupported(97);
+    pub const PPMD: Self = CompressionMethod::Unsupported(98);
+    #[cfg(feature = "aes-crypto")]
+    pub const AES: Self = CompressionMethod::Aes;
+    #[cfg(not(feature = "aes-crypto"))]
+    pub const AES: Self = CompressionMethod::Unsupported(99);
+}
+impl CompressionMethod {
+    /// Converts an u16 to its corresponding CompressionMethod
+    #[deprecated(
+        since = "0.5.7",
+        note = "use a constant to construct a compression method"
+    )]
+    pub fn from_u16(val: u16) -> CompressionMethod {
+        #[allow(deprecated)]
+        match val {
+            0 => CompressionMethod::Stored,
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
+            8 => CompressionMethod::Deflated,
+            #[cfg(feature = "bzip2")]
+            12 => CompressionMethod::Bzip2,
+            #[cfg(feature = "zstd")]
+            93 => CompressionMethod::Zstd,
+            #[cfg(feature = "aes-crypto")]
+            99 => CompressionMethod::Aes,
+
+            v => CompressionMethod::Unsupported(v),
+        }
+    }
+
+    /// Converts a CompressionMethod to a u16
+    #[deprecated(
+        since = "0.5.7",
+        note = "to match on other compression methods, use a constant"
+    )]
+    pub fn to_u16(self) -> u16 {
+        #[allow(deprecated)]
+        match self {
+            CompressionMethod::Stored => 0,
+            #[cfg(any(
+                feature = "deflate",
+                feature = "deflate-miniz",
+                feature = "deflate-zlib"
+            ))]
+            CompressionMethod::Deflated => 8,
+            #[cfg(feature = "bzip2")]
+            CompressionMethod::Bzip2 => 12,
+            #[cfg(feature = "aes-crypto")]
+            CompressionMethod::Aes => 99,
+            #[cfg(feature = "zstd")]
+            CompressionMethod::Zstd => 93,
+
+            CompressionMethod::Unsupported(v) => v,
+        }
+    }
+}
+
+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)
+    }
+}
+
+/// 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,
+];
+
+#[cfg(test)]
+mod test {
+    use super::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS};
+
+    #[test]
+    fn from_eq_to() {
+        for v in 0..(u16::MAX as u32 + 1) {
+            #[allow(deprecated)]
+            let from = CompressionMethod::from_u16(v as u16);
+            #[allow(deprecated)]
+            let to = from.to_u16() as u32;
+            assert_eq!(v, to);
+        }
+    }
+
+    #[test]
+    fn to_eq_from() {
+        fn check_match(method: CompressionMethod) {
+            #[allow(deprecated)]
+            let to = method.to_u16();
+            #[allow(deprecated)]
+            let from = CompressionMethod::from_u16(to);
+            #[allow(deprecated)]
+            let back = from.to_u16();
+            assert_eq!(to, back);
+        }
+
+        for &method in SUPPORTED_COMPRESSION_METHODS {
+            check_match(method);
+        }
+    }
+
+    #[test]
+    fn to_display_fmt() {
+        fn check_match(method: CompressionMethod) {
+            let debug_str = format!("{:?}", method);
+            let display_str = format!("{}", method);
+            assert_eq!(debug_str, display_str);
+        }
+
+        for &method in SUPPORTED_COMPRESSION_METHODS {
+            check_match(method);
+        }
+    }
+}