src/extension.rs

   1 //! Our representation of all the supported compression formats.
   2
   3 use std::{ffi::OsStr, fmt, path::Path};
   4
   5 use bstr::ByteSlice;
   6 use CompressionFormat::*;
   7
   8 use crate::{error::Error, utils::logger::warning};
   9
  10 pub const SUPPORTED_EXTENSIONS: &[&str] = &[
  11     "tar",
  12     "zip",
  13     "bz",
  14     "bz2",
  15     "gz",
  16     "lz4",
  17     "xz",
  18     "lzma",
  19     "sz",
  20     "zst",
  21     #[cfg(feature = "unrar")]
  22     "rar",
  23     "7z",
  24 ];
  25
  26 pub const SUPPORTED_ALIASES: &[&str] = &["tgz", "tbz", "tlz4", "txz", "tzlma", "tsz", "tzst"];
  27
  28 #[cfg(not(feature = "unrar"))]
  29 pub const PRETTY_SUPPORTED_EXTENSIONS: &str = "tar, zip, bz, bz2, gz, lz4, xz, lzma, sz, zst, 7z";
  30 #[cfg(feature = "unrar")]
  31 pub const PRETTY_SUPPORTED_EXTENSIONS: &str = "tar, zip, bz, bz2, gz, lz4, xz, lzma, sz, zst, rar, 7z";
  32
  33 pub const PRETTY_SUPPORTED_ALIASES: &str = "tgz, tbz, tlz4, txz, tzlma, tsz, tzst";
  34
  35 /// A wrapper around `CompressionFormat` that allows combinations like `tgz`
  36 #[derive(Debug, Clone)]
  37 // Keep `PartialEq` only for testing because two formats are the same even if
  38 // their `display_text` does not match (beware of aliases)
  39 #[cfg_attr(test, derive(PartialEq))]
  40 // Should only be built with constructors
  41 #[non_exhaustive]
  42 pub struct Extension {
  43     /// One extension like "tgz" can be made of multiple CompressionFormats ([Tar, Gz])
  44     pub compression_formats: &'static [CompressionFormat],
  45     /// The input text for this extension, like "tgz", "tar" or "xz"
  46     display_text: String,
  47 }
  48
  49 impl Extension {
  50     /// # Panics:
  51     ///   Will panic if `formats` is empty
  52     pub fn new(formats: &'static [CompressionFormat], text: impl ToString) -> Self {
  53         assert!(!formats.is_empty());
  54         Self {
  55             compression_formats: formats,
  56             display_text: text.to_string(),
  57         }
  58     }
  59
  60     /// Checks if the first format in `compression_formats` is an archive
  61     pub fn is_archive(&self) -> bool {
  62         // Safety: we check that `compression_formats` is not empty in `Self::new`
  63         self.compression_formats[0].is_archive_format()
  64     }
  65 }
  66
  67 impl fmt::Display for Extension {
  68     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  69         self.display_text.fmt(f)
  70     }
  71 }
  72
  73 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
  74 /// Accepted extensions for input and output
  75 pub enum CompressionFormat {
  76     /// .gz
  77     Gzip,
  78     /// .bz .bz2
  79     Bzip,
  80     /// .lz4
  81     Lz4,
  82     /// .xz .lzma
  83     Lzma,
  84     /// .sz
  85     Snappy,
  86     /// tar, tgz, tbz, tbz2, txz, tlz4, tlzma, tsz, tzst
  87     Tar,
  88     /// .zst
  89     Zstd,
  90     /// .zip
  91     Zip,
  92     // even if built without RAR support, we still want to recognise the format
  93     /// .rar
  94     Rar,
  95     /// .7z
  96     SevenZip,
  97 }
  98
  99 impl CompressionFormat {
 100     /// Currently supported archive formats are .tar (and aliases to it) and .zip
 101     fn is_archive_format(&self) -> bool {
 102         // Keep this match like that without a wildcard `_` so we don't forget to update it
 103         match self {
 104             Tar | Zip | Rar | SevenZip => true,
 105             Gzip => false,
 106             Bzip => false,
 107             Lz4 => false,
 108             Lzma => false,
 109             Snappy => false,
 110             Zstd => false,
 111         }
 112     }
 113 }
 114
 115 fn to_extension(ext: &[u8]) -> Option<Extension> {
 116     Some(Extension::new(
 117         match ext {
 118             b"tar" => &[Tar],
 119             b"tgz" => &[Tar, Gzip],
 120             b"tbz" | b"tbz2" => &[Tar, Bzip],
 121             b"tlz4" => &[Tar, Lz4],
 122             b"txz" | b"tlzma" => &[Tar, Lzma],
 123             b"tsz" => &[Tar, Snappy],
 124             b"tzst" => &[Tar, Zstd],
 125             b"zip" => &[Zip],
 126             b"bz" | b"bz2" => &[Bzip],
 127             b"gz" => &[Gzip],
 128             b"lz4" => &[Lz4],
 129             b"xz" | b"lzma" => &[Lzma],
 130             b"sz" => &[Snappy],
 131             b"zst" => &[Zstd],
 132             b"rar" => &[Rar],
 133             b"7z" => &[SevenZip],
 134             _ => return None,
 135         },
 136         ext.to_str_lossy(),
 137     ))
 138 }
 139
 140 fn split_extension(name: &mut &[u8]) -> Option<Extension> {
 141     let (new_name, ext) = name.rsplit_once_str(b".")?;
 142     if matches!(new_name, b"" | b"." | b"..") {
 143         return None;
 144     }
 145     let ext = to_extension(ext)?;
 146     *name = new_name;
 147     Some(ext)
 148 }
 149
 150 pub fn parse_format_flag(input: &OsStr) -> crate::Result<Vec<Extension>> {
 151     let format = input.as_encoded_bytes();
 152
 153     let format = std::str::from_utf8(format).map_err(|_| Error::InvalidFormatFlag {
 154         text: input.to_owned(),
 155         reason: "Invalid UTF-8.".to_string(),
 156     })?;
 157
 158     let extensions: Vec<Extension> = format
 159         .split('.')
 160         .filter(|extension| !extension.is_empty())
 161         .map(|extension| {
 162             to_extension(extension.as_bytes()).ok_or_else(|| Error::InvalidFormatFlag {
 163                 text: input.to_owned(),
 164                 reason: format!("Unsupported extension '{}'", extension),
 165             })
 166         })
 167         .collect::<crate::Result<_>>()?;
 168
 169     if extensions.is_empty() {
 170         return Err(Error::InvalidFormatFlag {
 171             text: input.to_owned(),
 172             reason: "Parsing got an empty list of extensions.".to_string(),
 173         });
 174     }
 175
 176     Ok(extensions)
 177 }
 178
 179 /// Extracts extensions from a path.
 180 ///
 181 /// Returns both the remaining path and the list of extension objects
 182 pub fn separate_known_extensions_from_name(path: &Path) -> (&Path, Vec<Extension>) {
 183     let mut extensions = vec![];
 184
 185     let Some(mut name) = path.file_name().and_then(<[u8] as ByteSlice>::from_os_str) else {
 186         return (path, extensions);
 187     };
 188
 189     // While there is known extensions at the tail, grab them
 190     while let Some(extension) = split_extension(&mut name) {
 191         extensions.insert(0, extension);
 192     }
 193
 194     if let Ok(name) = name.to_str() {
 195         let file_stem = name.trim_matches('.');
 196         if SUPPORTED_EXTENSIONS.contains(&file_stem) || SUPPORTED_ALIASES.contains(&file_stem) {
 197             warning(format!(
 198                 "Received a file with name '{file_stem}', but {file_stem} was expected as the extension."
 199             ));
 200         }
 201     }
 202
 203     (name.to_path().unwrap(), extensions)
 204 }
 205
 206 /// Extracts extensions from a path, return only the list of extension objects
 207 pub fn extensions_from_path(path: &Path) -> Vec<Extension> {
 208     let (_, extensions) = separate_known_extensions_from_name(path);
 209     extensions
 210 }
 211
 212 /// Panics if formats has an empty list of compression formats
 213 pub fn split_first_compression_format(formats: &[Extension]) -> (CompressionFormat, Vec<CompressionFormat>) {
 214     let mut extensions: Vec<CompressionFormat> = flatten_compression_formats(formats);
 215     let first_extension = extensions.remove(0);
 216     (first_extension, extensions)
 217 }
 218
 219 pub fn flatten_compression_formats(extensions: &[Extension]) -> Vec<CompressionFormat> {
 220     extensions
 221         .iter()
 222         .flat_map(|extension| extension.compression_formats.iter())
 223         .copied()
 224         .collect()
 225 }
 226
 227 /// Builds a suggested output file in scenarios where the user tried to compress
 228 /// a folder into a non-archive compression format, for error message purposes
 229 ///
 230 /// E.g.: `build_suggestion("file.bz.xz", ".tar")` results in `Some("file.tar.bz.xz")`
 231 pub fn build_archive_file_suggestion(path: &Path, suggested_extension: &str) -> Option<String> {
 232     let path = path.to_string_lossy();
 233     let mut rest = &*path;
 234     let mut position_to_insert = 0;
 235
 236     // Walk through the path to find the first supported compression extension
 237     while let Some(pos) = rest.find('.') {
 238         // Use just the text located after the dot we found
 239         rest = &rest[pos + 1..];
 240         position_to_insert += pos + 1;
 241
 242         // If the string contains more chained extensions, clip to the immediate one
 243         let maybe_extension = {
 244             let idx = rest.find('.').unwrap_or(rest.len());
 245             &rest[..idx]
 246         };
 247
 248         // If the extension we got is a supported extension, generate the suggestion
 249         // at the position we found
 250         if SUPPORTED_EXTENSIONS.contains(&maybe_extension) || SUPPORTED_ALIASES.contains(&maybe_extension) {
 251             let mut path = path.to_string();
 252             path.insert_str(position_to_insert - 1, suggested_extension);
 253
 254             return Some(path);
 255         }
 256     }
 257
 258     None
 259 }
 260
 261 #[cfg(test)]
 262 mod tests {
 263     use super::*;
 264     use crate::utils::logger::spawn_logger_thread;
 265
 266     #[test]
 267     fn test_extensions_from_path() {
 268         let path = Path::new("bolovo.tar.gz");
 269
 270         let extensions: Vec<Extension> = extensions_from_path(path);
 271         let formats: Vec<CompressionFormat> = flatten_compression_formats(&extensions);
 272
 273         assert_eq!(formats, vec![Tar, Gzip]);
 274     }
 275
 276     #[test]
 277     /// Test extension parsing for input/output files
 278     fn test_separate_known_extensions_from_name() {
 279         let _handler = spawn_logger_thread();
 280         assert_eq!(
 281             separate_known_extensions_from_name("file".as_ref()),
 282             ("file".as_ref(), vec![])
 283         );
 284         assert_eq!(
 285             separate_known_extensions_from_name("tar".as_ref()),
 286             ("tar".as_ref(), vec![])
 287         );
 288         assert_eq!(
 289             separate_known_extensions_from_name(".tar".as_ref()),
 290             (".tar".as_ref(), vec![])
 291         );
 292         assert_eq!(
 293             separate_known_extensions_from_name("file.tar".as_ref()),
 294             ("file".as_ref(), vec![Extension::new(&[Tar], "tar")])
 295         );
 296         assert_eq!(
 297             separate_known_extensions_from_name("file.tar.gz".as_ref()),
 298             (
 299                 "file".as_ref(),
 300                 vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
 301             )
 302         );
 303         assert_eq!(
 304             separate_known_extensions_from_name(".tar.gz".as_ref()),
 305             (".tar".as_ref(), vec![Extension::new(&[Gzip], "gz")])
 306         );
 307     }
 308
 309     #[test]
 310     /// Test extension parsing of `--format FORMAT`
 311     fn test_parse_of_format_flag() {
 312         assert_eq!(
 313             parse_format_flag(OsStr::new("tar")).unwrap(),
 314             vec![Extension::new(&[Tar], "tar")]
 315         );
 316         assert_eq!(
 317             parse_format_flag(OsStr::new(".tar")).unwrap(),
 318             vec![Extension::new(&[Tar], "tar")]
 319         );
 320         assert_eq!(
 321             parse_format_flag(OsStr::new("tar.gz")).unwrap(),
 322             vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
 323         );
 324         assert_eq!(
 325             parse_format_flag(OsStr::new(".tar.gz")).unwrap(),
 326             vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
 327         );
 328         assert_eq!(
 329             parse_format_flag(OsStr::new("..tar..gz.....")).unwrap(),
 330             vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
 331         );
 332
 333         assert!(parse_format_flag(OsStr::new("../tar.gz")).is_err());
 334         assert!(parse_format_flag(OsStr::new("targz")).is_err());
 335         assert!(parse_format_flag(OsStr::new("tar.gz.unknown")).is_err());
 336         assert!(parse_format_flag(OsStr::new(".tar.gz.unknown")).is_err());
 337         assert!(parse_format_flag(OsStr::new(".tar.!@#.gz")).is_err());
 338     }
 339
 340     #[test]
 341     fn builds_suggestion_correctly() {
 342         assert_eq!(build_archive_file_suggestion(Path::new("linux.png"), ".tar"), None);
 343         assert_eq!(
 344             build_archive_file_suggestion(Path::new("linux.xz.gz.zst"), ".tar").unwrap(),
 345             "linux.tar.xz.gz.zst"
 346         );
 347         assert_eq!(
 348             build_archive_file_suggestion(Path::new("linux.pkg.xz.gz.zst"), ".tar").unwrap(),
 349             "linux.pkg.tar.xz.gz.zst"
 350         );
 351         assert_eq!(
 352             build_archive_file_suggestion(Path::new("linux.pkg.zst"), ".tar").unwrap(),
 353             "linux.pkg.tar.zst"
 354         );
 355         assert_eq!(
 356             build_archive_file_suggestion(Path::new("linux.pkg.info.zst"), ".tar").unwrap(),
 357             "linux.pkg.info.tar.zst"
 358         );
 359     }
 360 }