src/extension.rs

   1 //! Our representation of all the supported compression formats.
   2
   3 use std::{fmt, path::Path};
   4
   5 use bstr::ByteSlice;
   6
   7 use self::CompressionFormat::*;
   8 use crate::warning;
   9
  10 /// A wrapper around `CompressionFormat` that allows combinations like `tgz`
  11 #[derive(Debug, Clone, Eq)]
  12 #[non_exhaustive]
  13 pub struct Extension {
  14     /// One extension like "tgz" can be made of multiple CompressionFormats ([Tar, Gz])
  15     pub compression_formats: &'static [CompressionFormat],
  16     /// The input text for this extension, like "tgz", "tar" or "xz"
  17     pub display_text: String,
  18 }
  19 // The display_text should be ignored when comparing extensions
  20 impl PartialEq for Extension {
  21     fn eq(&self, other: &Self) -> bool {
  22         self.compression_formats == other.compression_formats
  23     }
  24 }
  25
  26 impl Extension {
  27     /// # Panics:
  28     ///   Will panic if `formats` is empty
  29     pub fn new(formats: &'static [CompressionFormat], text: impl ToString) -> Self {
  30         assert!(!formats.is_empty());
  31         Self {
  32             compression_formats: formats,
  33             display_text: text.to_string(),
  34         }
  35     }
  36
  37     /// Checks if the first format in `compression_formats` is an archive
  38     pub fn is_archive(&self) -> bool {
  39         // Safety: we check that `compression_formats` is not empty in `Self::new`
  40         self.compression_formats[0].is_archive_format()
  41     }
  42 }
  43
  44 impl fmt::Display for Extension {
  45     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  46         self.display_text.fmt(f)
  47     }
  48 }
  49
  50 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
  51 /// Accepted extensions for input and output
  52 pub enum CompressionFormat {
  53     /// .gz
  54     Gzip,
  55     /// .bz .bz2
  56     Bzip,
  57     /// .lz4
  58     Lz4,
  59     /// .xz .lzma
  60     Lzma,
  61     /// .sz
  62     Snappy,
  63     /// tar, tgz, tbz, tbz2, txz, tlz4, tlzma, tsz, tzst
  64     Tar,
  65     /// .zst
  66     Zstd,
  67     /// .zip
  68     Zip,
  69 }
  70
  71 impl CompressionFormat {
  72     /// Currently supported archive formats are .tar (and aliases to it) and .zip
  73     pub fn is_archive_format(&self) -> bool {
  74         // Keep this match like that without a wildcard `_` so we don't forget to update it
  75         match self {
  76             Tar | Zip => true,
  77             Gzip => false,
  78             Bzip => false,
  79             Lz4 => false,
  80             Lzma => false,
  81             Snappy => false,
  82             Zstd => false,
  83         }
  84     }
  85 }
  86
  87 impl fmt::Display for CompressionFormat {
  88     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  89         let text = match self {
  90             Gzip => ".gz",
  91             Bzip => ".bz",
  92             Zstd => ".zst",
  93             Lz4 => ".lz4",
  94             Lzma => ".lz",
  95             Snappy => ".sz",
  96             Tar => ".tar",
  97             Zip => ".zip",
  98         };
  99
 100         write!(f, "{text}")
 101     }
 102 }
 103
 104 pub const SUPPORTED_EXTENSIONS: &[&str] = &[
 105     "tar", "tgz", "tbz", "tlz4", "txz", "tzlma", "tsz", "tzst", "zip", "bz", "bz2", "gz", "lz4", "xz", "lzma", "sz",
 106     "zst",
 107 ];
 108
 109 pub fn to_extension(ext: &[u8]) -> Option<Extension> {
 110     Some(Extension::new(
 111         match ext {
 112             b"tar" => &[Tar],
 113             b"tgz" => &[Tar, Gzip],
 114             b"tbz" | b"tbz2" => &[Tar, Bzip],
 115             b"tlz4" => &[Tar, Lz4],
 116             b"txz" | b"tlzma" => &[Tar, Lzma],
 117             b"tsz" => &[Tar, Snappy],
 118             b"tzst" => &[Tar, Zstd],
 119             b"zip" => &[Zip],
 120             b"bz" | b"bz2" => &[Bzip],
 121             b"gz" => &[Gzip],
 122             b"lz4" => &[Lz4],
 123             b"xz" | b"lzma" => &[Lzma],
 124             b"sz" => &[Snappy],
 125             b"zst" => &[Zstd],
 126             _ => return None,
 127         },
 128         ext.to_str_lossy(),
 129     ))
 130 }
 131
 132 pub fn split_extension<'a>(name: &mut &'a [u8]) -> Option<&'a [u8]> {
 133     let (new_name, ext) = name.rsplit_once_str(b".")?;
 134     if matches!(new_name, b"" | b"." | b"..") {
 135         return None;
 136     }
 137     *name = new_name;
 138     Some(ext)
 139 }
 140
 141 /// Extracts extensions from a path.
 142 ///
 143 /// Returns both the remaining path and the list of extension objects
 144 pub fn separate_known_extensions_from_name(path: &Path) -> (&Path, Vec<Extension>) {
 145     let mut extensions = vec![];
 146
 147     let Some(mut name) = path.file_name().and_then(<[u8] as ByteSlice>::from_os_str) else {
 148         return (path, extensions);
 149     };
 150
 151     // While there is known extensions at the tail, grab them
 152     while let Some(extension) = split_extension(&mut name).and_then(to_extension) {
 153         extensions.insert(0, extension);
 154     }
 155
 156     if let Ok(name) = name.to_str() {
 157         let file_stem = name.trim_matches('.');
 158         if SUPPORTED_EXTENSIONS.contains(&file_stem) {
 159             warning!("Received a file with name '{file_stem}', but {file_stem} was expected as the extension.");
 160         }
 161     }
 162
 163     (name.to_path().unwrap(), extensions)
 164 }
 165
 166 /// Extracts extensions from a path, return only the list of extension objects
 167 pub fn extensions_from_path(path: &Path) -> Vec<Extension> {
 168     let (_, extensions) = separate_known_extensions_from_name(path);
 169     extensions
 170 }
 171
 172 #[cfg(test)]
 173 mod tests {
 174     use super::*;
 175
 176     #[test]
 177     fn test_extensions_from_path() {
 178         use CompressionFormat::*;
 179         let path = Path::new("bolovo.tar.gz");
 180
 181         let extensions: Vec<Extension> = extensions_from_path(path);
 182         let formats: Vec<CompressionFormat> = flatten_compression_formats(&extensions);
 183
 184         assert_eq!(formats, vec![Tar, Gzip]);
 185     }
 186 }
 187
 188 // Panics if formats has an empty list of compression formats
 189 pub fn split_first_compression_format(formats: &[Extension]) -> (CompressionFormat, Vec<CompressionFormat>) {
 190     let mut extensions: Vec<CompressionFormat> = flatten_compression_formats(formats);
 191     let first_extension = extensions.remove(0);
 192     (first_extension, extensions)
 193 }
 194
 195 pub fn flatten_compression_formats(extensions: &[Extension]) -> Vec<CompressionFormat> {
 196     extensions
 197         .iter()
 198         .flat_map(|extension| extension.compression_formats.iter())
 199         .copied()
 200         .collect()
 201 }