Fix --format parsing extensions with dots

Also improve error reporting for `--format` with malformed or
unsupported extensions

This commit is very messy, as it also does an refac in the project,
which should ideally be in a separated commit

src/archive/rar.rs

@@ -2,7 +2,7 @@
 
 use std::path::Path;
 
-use unrar::{self, Archive};
+use unrar::Archive;
 
 use crate::{error::Error, info, list::FileInArchive};
 

src/archive/zip.rs

@@ -14,7 +14,7 @@ use filetime_creation::{set_file_mtime, FileTime};
 use fs_err as fs;
 use same_file::Handle;
 use time::OffsetDateTime;
-use zip::{self, read::ZipFile, DateTime, ZipArchive};
+use zip::{read::ZipFile, DateTime, ZipArchive};
 
 use crate::{
     error::FinalError,

src/check.rs

@@ -10,7 +10,7 @@ use std::{
 
 use crate::{
     error::FinalError,
-    extension::{build_archive_file_suggestion, Extension, PRETTY_SUPPORTED_ALIASES, PRETTY_SUPPORTED_EXTENSIONS},
+    extension::{build_archive_file_suggestion, Extension},
     info,
     utils::{pretty_format_list_of_paths, try_infer_extension, user_wants_to_continue, EscapedPathDisplay},
     warning, QuestionAction, QuestionPolicy, Result,
@@ -159,10 +159,8 @@ pub fn check_missing_formats_when_decompressing(files: &[PathBuf], formats: &[Ve
         ));
     }
 
-    error = error
-        .detail("Decompression formats are detected automatically from file extension")
-        .hint(format!("Supported extensions are: {}", PRETTY_SUPPORTED_EXTENSIONS))
-        .hint(format!("Supported aliases are: {}", PRETTY_SUPPORTED_ALIASES));
+    error = error.detail("Decompression formats are detected automatically from file extension");
+    error = error.hint_all_supported_formats();
 
     // If there's exactly one file, give a suggestion to use `--format`
     if let &[path] = files_with_broken_extension.as_slice() {

src/cli/mod.rs

@@ -5,7 +5,6 @@ mod args;
 use std::{
     io,
     path::{Path, PathBuf},
-    vec::Vec,
 };
 
 use clap::Parser;

src/commands/mod.rs

@@ -14,10 +14,10 @@ use crate::{
     cli::Subcommand,
     commands::{compress::compress_files, decompress::decompress_file, list::list_archive_contents},
     error::{Error, FinalError},
-    extension::{self, parse_format},
+    extension::{self, parse_format_flag},
     info,
     list::ListOptions,
-    utils::{self, to_utf, EscapedPathDisplay, FileVisibilityPolicy},
+    utils::{self, path_to_str, EscapedPathDisplay, FileVisibilityPolicy},
     warning, CliArgs, QuestionPolicy,
 };
 
@@ -66,7 +66,7 @@ pub fn run(
             // Formats from path extension, like "file.tar.gz.xz" -> vec![Tar, Gzip, Lzma]
             let (formats_from_flag, formats) = match args.format {
                 Some(formats) => {
-                    let parsed_formats = parse_format(&formats)?;
+                    let parsed_formats = parse_format_flag(&formats)?;
                     (Some(formats), parsed_formats)
                 }
                 None => (None, extension::extensions_from_path(&output_path)),
@@ -109,7 +109,7 @@ pub fn run(
                 // having a final status message is important especially in an accessibility context
                 // as screen readers may not read a commands exit code, making it hard to reason
                 // about whether the command succeeded without such a message
-                info!(accessible, "Successfully compressed '{}'.", to_utf(&output_path));
+                info!(accessible, "Successfully compressed '{}'.", path_to_str(&output_path));
             } else {
                 // If Ok(false) or Err() occurred, delete incomplete file at `output_path`
                 //
@@ -137,7 +137,7 @@ pub fn run(
             let mut formats = vec![];
 
             if let Some(format) = args.format {
-                let format = parse_format(&format)?;
+                let format = parse_format_flag(&format)?;
                 for path in files.iter() {
                     let file_name = path.file_name().ok_or_else(|| Error::NotFound {
                         error_title: format!("{} does not have a file name", EscapedPathDisplay::new(path)),
@@ -189,7 +189,7 @@ pub fn run(
             let mut formats = vec![];
 
             if let Some(format) = args.format {
-                let format = parse_format(&format)?;
+                let format = parse_format_flag(&format)?;
                 for _ in 0..files.len() {
                     formats.push(format.clone());
                 }

src/error.rs

@@ -4,15 +4,21 @@
 
 use std::{
     borrow::Cow,
+    ffi::OsString,
     fmt::{self, Display},
+    io,
 };
 
-use crate::{accessible::is_running_in_accessible_mode, utils::colors::*};
+use crate::{
+    accessible::is_running_in_accessible_mode,
+    extension::{PRETTY_SUPPORTED_ALIASES, PRETTY_SUPPORTED_EXTENSIONS},
+    utils::os_str_to_str,
+};
 
 /// All errors that can be generated by `ouch`
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Error {
-    /// Not every IoError, some of them get filtered by `From<io::Error>` into other variants
+    /// An IoError that doesn't have a dedicated error variant
     IoError { reason: String },
     /// From lzzzz::lz4f::Error
     Lz4Error { reason: String },
@@ -33,9 +39,9 @@ pub enum Error {
     /// Custom and unique errors are reported in this variant
     Custom { reason: FinalError },
     /// Invalid format passed to `--format`
-    InvalidFormat { reason: String },
+    InvalidFormatFlag { text: OsString, reason: String },
     /// From sevenz_rust::Error
-    SevenzipError(sevenz_rust::Error),
+    SevenzipError { reason: String },
     /// Recognised but unsupported format
     // currently only RAR when built without the `unrar` feature
     UnsupportedFormat { reason: String },
@@ -60,6 +66,8 @@ pub struct FinalError {
 
 impl Display for FinalError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use crate::utils::colors::*;
+
         // Title
         //
         // When in ACCESSIBLE mode, the square brackets are suppressed
@@ -120,55 +128,71 @@ impl FinalError {
         self.hints.push(hint.into());
         self
     }
+
+    /// Adds all supported formats as hints.
+    ///
+    /// This is what it looks like:
+    /// ```
+    /// hint: Supported extensions are: tar, zip, bz, bz2, gz, lz4, xz, lzma, sz, zst
+    /// hint: Supported aliases are: tgz, tbz, tlz4, txz, tzlma, tsz, tzst
+    /// ```
+    pub fn hint_all_supported_formats(self) -> Self {
+        self.hint(format!("Supported extensions are: {}", PRETTY_SUPPORTED_EXTENSIONS))
+            .hint(format!("Supported aliases are: {}", PRETTY_SUPPORTED_ALIASES))
+    }
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let err = match self {
-            Error::WalkdirError { reason } => FinalError::with_title(reason.to_string()),
-            Error::NotFound { error_title } => FinalError::with_title(error_title.to_string()).detail("File not found"),
+impl From<Error> for FinalError {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::WalkdirError { reason } => FinalError::with_title(reason),
+            Error::NotFound { error_title } => FinalError::with_title(error_title).detail("File not found"),
             Error::CompressingRootFolder => {
                 FinalError::with_title("It seems you're trying to compress the root folder.")
                     .detail("This is unadvisable since ouch does compressions in-memory.")
                     .hint("Use a more appropriate tool for this, such as rsync.")
             }
-            Error::IoError { reason } => FinalError::with_title(reason.to_string()),
-            Error::Lz4Error { reason } => FinalError::with_title(reason.to_string()),
-            Error::AlreadyExists { error_title } => {
-                FinalError::with_title(error_title.to_string()).detail("File already exists")
-            }
-            Error::InvalidZipArchive(reason) => FinalError::with_title("Invalid zip archive").detail(*reason),
-            Error::PermissionDenied { error_title } => {
-                FinalError::with_title(error_title.to_string()).detail("Permission denied")
+            Error::IoError { reason } => FinalError::with_title(reason),
+            Error::Lz4Error { reason } => FinalError::with_title(reason),
+            Error::AlreadyExists { error_title } => FinalError::with_title(error_title).detail("File already exists"),
+            Error::InvalidZipArchive(reason) => FinalError::with_title("Invalid zip archive").detail(reason),
+            Error::PermissionDenied { error_title } => FinalError::with_title(error_title).detail("Permission denied"),
+            Error::UnsupportedZipArchive(reason) => FinalError::with_title("Unsupported zip archive").detail(reason),
+            Error::InvalidFormatFlag { reason, text } => {
+                FinalError::with_title(format!("Failed to parse `--format {}`", os_str_to_str(&text)))
+                    .detail(reason)
+                    .hint_all_supported_formats()
+                    .hint("")
+                    .hint("Examples:")
+                    .hint("  --format tar")
+                    .hint("  --format gz")
+                    .hint("  --format tar.gz")
             }
-            Error::UnsupportedZipArchive(reason) => FinalError::with_title("Unsupported zip archive").detail(*reason),
-            Error::InvalidFormat { reason } => FinalError::with_title("Invalid archive format").detail(reason.clone()),
             Error::Custom { reason } => reason.clone(),
-            Error::SevenzipError(reason) => FinalError::with_title("7z error").detail(reason.to_string()),
+            Error::SevenzipError { reason } => FinalError::with_title("7z error").detail(reason),
             Error::UnsupportedFormat { reason } => {
                 FinalError::with_title("Recognised but unsupported format").detail(reason.clone())
             }
-        };
+        }
+    }
+}
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let err = FinalError::from(self.clone());
         write!(f, "{err}")
     }
 }
 
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Self {
+        let error_title = err.to_string();
+
         match err.kind() {
-            std::io::ErrorKind::NotFound => Self::NotFound {
-                error_title: err.to_string(),
-            },
-            std::io::ErrorKind::PermissionDenied => Self::PermissionDenied {
-                error_title: err.to_string(),
-            },
-            std::io::ErrorKind::AlreadyExists => Self::AlreadyExists {
-                error_title: err.to_string(),
-            },
-            _other => Self::IoError {
-                reason: err.to_string(),
-            },
+            io::ErrorKind::NotFound => Self::NotFound { error_title },
+            io::ErrorKind::PermissionDenied => Self::PermissionDenied { error_title },
+            io::ErrorKind::AlreadyExists => Self::AlreadyExists { error_title },
+            _other => Self::IoError { reason: error_title },
         }
     }
 }
@@ -198,7 +222,9 @@ impl From<unrar::error::UnrarError> for Error {
 
 impl From<sevenz_rust::Error> for Error {
     fn from(err: sevenz_rust::Error) -> Self {
-        Self::SevenzipError(err)
+        Self::SevenzipError {
+            reason: err.to_string(),
+        }
     }
 }
 

src/extension.rs

@@ -3,8 +3,8 @@
 use std::{ffi::OsStr, fmt, path::Path};
 
 use bstr::ByteSlice;
+use CompressionFormat::*;
 
-use self::CompressionFormat::*;
 use crate::{error::Error, warning};
 
 pub const SUPPORTED_EXTENSIONS: &[&str] = &[
@@ -34,7 +34,10 @@ pub const PRETTY_SUPPORTED_ALIASES: &str = "tgz, tbz, tlz4, txz, tzlma, tsz, tzs
 
 /// A wrapper around `CompressionFormat` that allows combinations like `tgz`
 #[derive(Debug, Clone)]
+// Keep `PartialEq` only for testing because two formats are the same even if
+// their `display_text` does not match (beware of aliases)
 #[cfg_attr(test, derive(PartialEq))]
+// Should only be built with constructors
 #[non_exhaustive]
 pub struct Extension {
     /// One extension like "tgz" can be made of multiple CompressionFormats ([Tar, Gz])
@@ -144,17 +147,30 @@ fn split_extension(name: &mut &[u8]) -> Option<Extension> {
     Some(ext)
 }
 
-pub fn parse_format(fmt: &OsStr) -> crate::Result<Vec<Extension>> {
-    let fmt = <[u8] as ByteSlice>::from_os_str(fmt).ok_or_else(|| Error::InvalidFormat {
-        reason: "Invalid UTF-8".into(),
+pub fn parse_format_flag(input: &OsStr) -> crate::Result<Vec<Extension>> {
+    let format = input.as_encoded_bytes();
+
+    let format = std::str::from_utf8(format).map_err(|_| Error::InvalidFormatFlag {
+        text: input.to_owned(),
+        reason: "Invalid UTF-8.".to_string(),
     })?;
 
-    let mut extensions = Vec::new();
-    for extension in fmt.split_str(b".") {
-        let extension = to_extension(extension).ok_or_else(|| Error::InvalidFormat {
-            reason: format!("Unsupported extension: {}", extension.to_str_lossy()),
-        })?;
-        extensions.push(extension);
+    let extensions: Vec<Extension> = format
+        .split('.')
+        .filter(|extension| !extension.is_empty())
+        .map(|extension| {
+            to_extension(extension.as_bytes()).ok_or_else(|| Error::InvalidFormatFlag {
+                text: input.to_owned(),
+                reason: format!("Unsupported extension '{}'", extension),
+            })
+        })
+        .collect::<crate::Result<_>>()?;
+
+    if extensions.is_empty() {
+        return Err(Error::InvalidFormatFlag {
+            text: input.to_owned(),
+            reason: "Parsing got an empty list of extensions.".to_string(),
+        });
     }
 
     Ok(extensions)
@@ -242,8 +258,6 @@ pub fn build_archive_file_suggestion(path: &Path, suggested_extension: &str) ->
 
 #[cfg(test)]
 mod tests {
-    use std::path::Path;
-
     use super::*;
 
     #[test]
@@ -257,6 +271,7 @@ mod tests {
     }
 
     #[test]
+    /// Test extension parsing for input/output files
     fn test_separate_known_extensions_from_name() {
         assert_eq!(
             separate_known_extensions_from_name("file".as_ref()),
@@ -287,6 +302,37 @@ mod tests {
         );
     }
 
+    #[test]
+    /// Test extension parsing of `--format FORMAT`
+    fn test_parse_of_format_flag() {
+        assert_eq!(
+            parse_format_flag(OsStr::new("tar")).unwrap(),
+            vec![Extension::new(&[Tar], "tar")]
+        );
+        assert_eq!(
+            parse_format_flag(OsStr::new(".tar")).unwrap(),
+            vec![Extension::new(&[Tar], "tar")]
+        );
+        assert_eq!(
+            parse_format_flag(OsStr::new("tar.gz")).unwrap(),
+            vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
+        );
+        assert_eq!(
+            parse_format_flag(OsStr::new(".tar.gz")).unwrap(),
+            vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
+        );
+        assert_eq!(
+            parse_format_flag(OsStr::new("..tar..gz.....")).unwrap(),
+            vec![Extension::new(&[Tar], "tar"), Extension::new(&[Gzip], "gz")]
+        );
+
+        assert!(parse_format_flag(OsStr::new("../tar.gz")).is_err());
+        assert!(parse_format_flag(OsStr::new("targz")).is_err());
+        assert!(parse_format_flag(OsStr::new("tar.gz.unknown")).is_err());
+        assert!(parse_format_flag(OsStr::new(".tar.gz.unknown")).is_err());
+        assert!(parse_format_flag(OsStr::new(".tar.!@#.gz")).is_err());
+    }
+
     #[test]
     fn builds_suggestion_correctly() {
         assert_eq!(build_archive_file_suggestion(Path::new("linux.png"), ".tar"), None);

src/list.rs

@@ -78,7 +78,6 @@ mod tree {
     use std::{
         ffi::{OsStr, OsString},
         io::Write,
-        iter::FromIterator,
         path,
     };