src/extension.rs

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