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 ToString) -> Self {
  27         assert!(!formats.is_empty());
  28         Self {
  29             compression_formats: formats,
  30             display_text: text.to_string(),
  31         }
  32     }
  33
  34     /// Checks if the first format in `compression_formats` is an archive
  35     pub fn is_archive(&self) -> bool {
  36         // Safety: we check that `compression_formats` is not empty in `Self::new`
  37         self.compression_formats[0].is_archive_format()
  38     }
  39 }
  40
  41 impl fmt::Display for Extension {
  42     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  43         self.display_text.fmt(f)
  44     }
  45 }
  46
  47 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
  48 /// Accepted extensions for input and output
  49 pub enum CompressionFormat {
  50     /// .gz
  51     Gzip,
  52     /// .bz .bz2
  53     Bzip,
  54     /// .lz4
  55     Lz4,
  56     /// .xz .lzma
  57     Lzma,
  58     /// .sz
  59     Snappy,
  60     /// tar, tgz, tbz, tbz2, txz, tlz4, tlzma, tsz, 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             Snappy => false,
  79             Zstd => false,
  80         }
  81     }
  82 }
  83
  84 impl fmt::Display for CompressionFormat {
  85     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  86         let text = match self {
  87             Gzip => ".gz",
  88             Bzip => ".bz",
  89             Zstd => ".zst",
  90             Lz4 => ".lz4",
  91             Lzma => ".lz",
  92             Snappy => ".sz",
  93             Tar => ".tar",
  94             Zip => ".zip",
  95         };
  96
  97         write!(f, "{text}")
  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" | "tlzma" => &[Tar, Lzma],
 125             "tsz" => &[Tar, Snappy],
 126             "tzst" => &[Tar, Zstd],
 127             "zip" => &[Zip],
 128             "bz" | "bz2" => &[Bzip],
 129             "gz" => &[Gzip],
 130             "lz4" => &[Lz4],
 131             "xz" | "lzma" => &[Lzma],
 132             "sz" => &[Snappy],
 133             "zst" => &[Zstd],
 134             _ => break,
 135         };
 136
 137         let extension = Extension::new(formats, extension);
 138         extensions.push(extension);
 139
 140         // Update for the next iteration
 141         path = if let Some(stem) = path.file_stem() {
 142             Path::new(stem)
 143         } else {
 144             Path::new("")
 145         };
 146     }
 147     // Put the extensions in the correct order: left to right
 148     extensions.reverse();
 149
 150     (path, extensions)
 151 }
 152
 153 /// Extracts extensions from a path, return only the list of extension objects
 154 pub fn extensions_from_path(path: &Path) -> Vec<Extension> {
 155     let (_, extensions) = separate_known_extensions_from_name(path);
 156     extensions
 157 }
 158
 159 #[cfg(test)]
 160 mod tests {
 161     use super::*;
 162
 163     #[test]
 164     fn test_extensions_from_path() {
 165         use CompressionFormat::*;
 166         let path = Path::new("bolovo.tar.gz");
 167
 168         let extensions: Vec<Extension> = extensions_from_path(path);
 169         let formats: Vec<CompressionFormat> = flatten_compression_formats(&extensions);
 170
 171         assert_eq!(formats, vec![Tar, Gzip]);
 172     }
 173 }
 174
 175 // Panics if formats has an empty list of compression formats
 176 pub fn split_first_compression_format(formats: &[Extension]) -> (CompressionFormat, Vec<CompressionFormat>) {
 177     let mut extensions: Vec<CompressionFormat> = flatten_compression_formats(formats);
 178     let first_extension = extensions.remove(0);
 179     (first_extension, extensions)
 180 }
 181
 182 pub fn flatten_compression_formats(extensions: &[Extension]) -> Vec<CompressionFormat> {
 183     extensions
 184         .iter()
 185         .flat_map(|extension| extension.compression_formats.iter())
 186         .copied()
 187         .collect()
 188 }