use-zip 0.1.0

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

//! ZIP compression method labels for `RustUse`.

use core::fmt;

/// Common ZIP file extension.
pub const ZIP_EXTENSION: &str = "zip";

/// ZIP compression methods.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ZipCompressionMethod {
    /// Stored without compression.
    #[default]
    Stored,
    /// Deflate compression.
    Deflated,
    /// Bzip2 compression.
    Bzip2,
    /// Zstandard compression.
    Zstd,
    /// LZMA compression.
    Lzma,
    /// Unknown method code.
    Unknown(u16),
}

impl ZipCompressionMethod {
    /// Returns the ZIP method code.
    #[must_use]
    pub const fn code(self) -> u16 {
        match self {
            Self::Stored => 0,
            Self::Deflated => 8,
            Self::Bzip2 => 12,
            Self::Lzma => 14,
            Self::Zstd => 93,
            Self::Unknown(code) => code,
        }
    }

    /// Returns a stable lowercase label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Stored => "stored",
            Self::Deflated => "deflated",
            Self::Bzip2 => "bzip2",
            Self::Zstd => "zstd",
            Self::Lzma => "lzma",
            Self::Unknown(_) => "unknown",
        }
    }

    /// Maps a ZIP method code to a known label or preserves the unknown code.
    #[must_use]
    pub const fn from_code(code: u16) -> Self {
        match code {
            0 => Self::Stored,
            8 => Self::Deflated,
            12 => Self::Bzip2,
            14 => Self::Lzma,
            93 => Self::Zstd,
            other => Self::Unknown(other),
        }
    }
}

impl fmt::Display for ZipCompressionMethod {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

#[cfg(test)]
mod tests {
    use super::{ZIP_EXTENSION, ZipCompressionMethod};

    #[test]
    fn maps_zip_method_codes() {
        assert_eq!(
            ZipCompressionMethod::from_code(0),
            ZipCompressionMethod::Stored
        );
        assert_eq!(
            ZipCompressionMethod::from_code(8),
            ZipCompressionMethod::Deflated
        );
        assert_eq!(
            ZipCompressionMethod::from_code(93),
            ZipCompressionMethod::Zstd
        );
        assert_eq!(
            ZipCompressionMethod::from_code(65000),
            ZipCompressionMethod::Unknown(65000)
        );
    }

    #[test]
    fn exposes_zip_extension_label() {
        assert_eq!(ZIP_EXTENSION, "zip");
    }
}