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