refactored formats

Author: Jonas Bertossa

Cargo.lock

@@ -47,6 +47,11 @@ zip = { version = "0.6.6", default-features = false, features = [
     "aes-crypto",
 ] }
 zstd = { version = "0.13.2", default-features = false, features = ["zstdmt"] }
+phf = { version = "0.13", features = ["macros"] }
+comfy-table = { version = "7.1", features = ["tty", "custom_styling"] }
+terminal_size = "0.4"
+unicode-width = "0.2"
+strip-ansi-escapes = "0.2"
 
 [target.'cfg(not(unix))'.dependencies]
 is_executable = "1.0.1"

Cargo.toml

@@ -159,7 +159,7 @@ pub fn check_missing_formats_when_decompressing(files: &[PathBuf], formats: &[Ve
     }
 
     error = error.detail("Decompression formats are detected automatically from file extension");
-    error = error.hint_all_supported_formats();
+    error = error.hint_supported_formats_for_decompress();
 
     // If there's exactly one file, give a suggestion to use `--format`
     if let &[path] = files_with_broken_extension.as_slice() {
@@ -187,6 +187,7 @@ pub fn check_first_format_when_compressing<'a>(formats: &'a [Extension], output_
             .hint("")
             .hint("Alternatively, you can overwrite this option by using the '--format' flag:")
             .hint(format!("  ouch compress <FILES>... {output_path} --format tar.gz"))
+            .hint_supported_formats_for_compress()
             .into()
     })
 }
@@ -246,7 +247,8 @@ pub fn check_invalid_compression_with_non_archive_format(
         .detail("Formats that bundle files into an archive are tar and zip.")
         .hint(format!("Try inserting 'tar.' or 'zip.' before '{first_format}'."))
         .hint(from_hint)
-        .hint(to_hint);
+        .hint(to_hint)
+        .hint_supported_formats_for_compress();
 
     Err(error.into())
 }

src/check.rs

@@ -116,6 +116,9 @@ pub enum Subcommand {
         #[arg(short, long)]
         tree: bool,
     },
+    /// List supported formats and their capabilities
+    #[command(name = "list-formats", visible_aliases = ["formats", "support"])]
+    ListFormats,
 }
 
 #[cfg(test)]

src/cli/args.rs

@@ -28,10 +28,19 @@ impl CliArgs {
 
         set_accessible(args.accessible);
 
-        let (Subcommand::Compress { files, .. }
-        | Subcommand::Decompress { files, .. }
-        | Subcommand::List { archives: files, .. }) = &mut args.cmd;
-        *files = canonicalize_files(files)?;
+        match &mut args.cmd {
+            // These subcommands receive file paths and must be canonicalized
+            Subcommand::Compress { files, .. } | Subcommand::Decompress { files, .. } => {
+                *files = canonicalize_files(files)?;
+            }
+            Subcommand::List { archives: files, .. } => {
+                *files = canonicalize_files(files)?;
+            }
+            // New subcommand: no paths to canonicalize
+            Subcommand::ListFormats => {
+                // No-op
+            }
+        }
 
         let skip_questions_positively = match (args.yes, args.no) {
             (false, false) => QuestionPolicy::Ask,

src/cli/mod.rs

@@ -106,7 +106,9 @@ pub fn compress_files(
                 let win_size = 22; // default to 2^22 = 4 MiB window size
                 Box::new(brotli::CompressorWriter::new(encoder, BUFFER_CAPACITY, level, win_size))
             }
-            Tar | Zip | Rar | SevenZip => unreachable!(),
+            Tar | Zip | SevenZip => unreachable!(),
+            #[cfg(feature = "unrar")]
+            Rar => unreachable!(),
         };
         Ok(encoder)
     };

src/commands/compress.rs

@@ -140,7 +140,9 @@ pub fn decompress_file(options: DecompressOptions) -> crate::Result<()> {
             Snappy => Box::new(snap::read::FrameDecoder::new(decoder)),
             Zstd => Box::new(zstd::stream::Decoder::new(decoder)?),
             Brotli => Box::new(brotli::Decompressor::new(decoder, BUFFER_CAPACITY)),
-            Tar | Zip | Rar | SevenZip => decoder,
+            Tar | Zip | SevenZip => decoder,
+            #[cfg(feature = "unrar")]
+            Rar => decoder,
         };
         Ok(decoder)
     };
@@ -250,10 +252,7 @@ pub fn decompress_file(options: DecompressOptions) -> crate::Result<()> {
                 return Ok(());
             }
         }
-        #[cfg(not(feature = "unrar"))]
-        Rar => {
-            return Err(crate::archive::rar_stub::no_support());
-        }
+
         SevenZip => {
             if options.formats.len() > 1 {
                 // Locking necessary to guarantee that warning and question

src/commands/decompress.rs

@@ -69,14 +69,16 @@ pub fn list_archive_contents(
                 Snappy => Box::new(snap::read::FrameDecoder::new(decoder)),
                 Zstd => Box::new(zstd::stream::Decoder::new(decoder)?),
                 Brotli => Box::new(brotli::Decompressor::new(decoder, BUFFER_CAPACITY)),
-                Tar | Zip | Rar | SevenZip => unreachable!("should be treated by caller"),
+                Tar | Zip | SevenZip => unreachable!("should be treated by caller"),
+                #[cfg(feature = "unrar")]
+                Rar => unreachable!("should be treated by caller"),
             };
             Ok(decoder)
         };
 
     let mut misplaced_archive_format = None;
     for &format in formats.iter().skip(1).rev() {
-        if format.archive_format() {
+        if format.is_archive() {
             misplaced_archive_format = Some(format);
             break;
         }
@@ -114,10 +116,7 @@ pub fn list_archive_contents(
                 Box::new(crate::archive::rar::list_archive(archive_path, password)?)
             }
         }
-        #[cfg(not(feature = "unrar"))]
-        Rar => {
-            return Err(crate::archive::rar_stub::no_support());
-        }
+
         SevenZip => {
             if formats.len() > 1 {
                 // Locking necessary to guarantee that warning and question

src/commands/list.rs

@@ -262,5 +262,10 @@ pub fn run(
 
             Ok(())
         }
+        Subcommand::ListFormats => {
+            // Print a concise explanation + the capability table + the shorthand table.
+            println!("{}", crate::formats::render_capabilities_and_shorthands(crate::formats::SupportedOp::Any));
+            Ok(())
+        }
     }
 }

src/commands/mod.rs

@@ -2,19 +2,16 @@
 //!
 //! All usage errors will pass through the Error enum, a lot of them in the Error::Custom.
 
+use crate::formats::{self, SupportedOp};
+use crate::utils::colors::{BLUE, GREEN, RESET, YELLOW};
+use crate::{accessible::is_running_in_accessible_mode, utils::os_str_to_str};
 use std::{
     borrow::Cow,
     ffi::OsString,
     fmt::{self, Display},
     io,
 };
 
-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, Clone)]
 pub enum Error {
@@ -43,7 +40,7 @@ pub enum Error {
     /// From sevenz_rust::Error
     SevenzipError { reason: String },
     /// Recognised but unsupported format
-    // currently only RAR when built without the `unrar` feature
+    /// (currently only RAR when built without the `unrar` feature)
     UnsupportedFormat { reason: String },
     /// Invalid password provided
     InvalidPassword { reason: String },
@@ -58,11 +55,11 @@ pub type CowStr = Cow<'static, str>;
 /// Pretty final error message for end users, crashing the program after display.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct FinalError {
-    /// Should be made of just one line, appears after the "\[ERROR\]" part
+    /// Single line shown after `[ERROR]`
     title: CowStr,
-    /// Shown as a unnumbered list in yellow
+    /// Bullet list in yellow
     details: Vec<CowStr>,
-    /// Shown as green at the end to give hints on how to work around this error, if it's fixable
+    /// Hints in green at the end
     hints: Vec<CowStr>,
 }
 
@@ -71,8 +68,6 @@ impl Display for FinalError {
         use crate::utils::colors::*;
 
         // Title
-        //
-        // When in ACCESSIBLE mode, the square brackets are suppressed
         if is_running_in_accessible_mode() {
             write!(f, "{}ERROR{}: {}", *RED, *RESET, self.title)?;
         } else {
@@ -88,9 +83,8 @@ impl Display for FinalError {
         if !self.hints.is_empty() {
             // Separate by one blank line.
             writeln!(f)?;
-            // to reduce redundant output for text-to-speech systems, braille
-            // displays and so on, only print "hints" once in ACCESSIBLE mode
             if is_running_in_accessible_mode() {
+                // In ACCESSIBLE mode, print the "hints" header once.
                 write!(f, "\n{}hints:{}", *GREEN, *RESET)?;
                 for hint in &self.hints {
                     write!(f, "\n{hint}")?;
@@ -107,7 +101,7 @@ impl Display for FinalError {
 }
 
 impl FinalError {
-    /// Only constructor
+    /// Constructor with title only.
     #[must_use]
     pub fn with_title(title: impl Into<CowStr>) -> Self {
         Self {
@@ -117,30 +111,88 @@ impl FinalError {
         }
     }
 
-    /// Add one detail line, can have multiple
+    /// Adds one detail line (can be called multiple times).
     #[must_use]
     pub fn detail(mut self, detail: impl Into<CowStr>) -> Self {
         self.details.push(detail.into());
         self
     }
 
-    /// Add one hint line, can have multiple
+    /// Adds one hint line (can be called multiple times).
     #[must_use]
     pub fn hint(mut self, hint: impl Into<CowStr>) -> Self {
         self.hints.push(hint.into());
         self
     }
 
-    /// Adds all supported formats as hints.
+    // ---------------------------------------------------------------------
+    // Compact, colored lists of supported formats (DRY helper + 3 public APIs)
+    // ---------------------------------------------------------------------
+
+    /// Internal helper to add compact, colored supported-lists.
     ///
-    /// This is what it looks like:
-    /// ```
-    /// hint: Supported extensions are: tar, zip, bz, bz2, gz, lz4, xz, lzma, lz, sz, zst
-    /// hint: Supported aliases are: tgz, tbz, tlz4, txz, tlzma, tsz, tzst, tlz
-    /// ```
+    /// - If `show_compress` is true, prints the compress-only list.
+    /// - If `show_decompress` is true, prints the decompress-only list.
+    /// - Always appends a colored hint for `ouch list-formats`.
+    fn hint_supported_lists(mut self, show_compress: bool, show_decompress: bool) -> Self {
+        // Color each token in a comma-separated list.
+        let color_csv = |csv: String| -> String {
+            csv.split(", ")
+                .map(|t| format!("{}{}{}", *GREEN, t, *RESET))
+                .collect::<Vec<_>>()
+                .join(", ")
+        };
+
+        if show_compress {
+            let compress = formats::compact_extensions(SupportedOp::Compress);
+            let compress_colored = color_csv(compress);
+            self = self.hint(format!(
+                "Supported extensions for {}compression{} are: {}",
+                *YELLOW, *RESET, compress_colored
+            ));
+        }
+
+        if show_decompress {
+            let decompress = formats::compact_extensions(SupportedOp::Decompress);
+            let decompress_colored = color_csv(decompress);
+            self = self.hint(format!(
+                "Supported extensions for {}decompression{} are: {}",
+                *YELLOW, *RESET, decompress_colored
+            ));
+        }
+
+        let aliases = formats::compact_shorthands();
+        if !aliases.is_empty() {
+            let aliases_colored = aliases
+                .split(", ")
+                .map(|t| format!("{}{}{}", *GREEN, t, *RESET))
+                .collect::<Vec<_>>()
+                .join(", ");
+            self = self.hint(format!(
+                "Supported {}aliases{} are: {}",
+                *YELLOW, *RESET, aliases_colored
+            ));
+        }
+
+        self.hint(format!(
+            "For detailed capabilities and notes, run: {}ouch list-formats{}",
+            *BLUE, *RESET
+        ))
+    }
+
+    /// Adds a single, multi-line hint with the compact lists (compress + decompress).
     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}"))
+        self.hint_supported_lists(true, true)
+    }
+
+    /// Adds a compact list filtered to compression only.
+    pub fn hint_supported_formats_for_compress(self) -> Self {
+        self.hint_supported_lists(true, false)
+    }
+
+    /// Adds a compact list filtered to decompression only.
+    pub fn hint_supported_formats_for_decompress(self) -> Self {
+        self.hint_supported_lists(false, true)
     }
 }