separate function `check_first_format_when_compressing`
[ouch.git] / src / check.rs
blobdd5b6a0b051aebef47589804c46c32880e715a0c
1 //! Checks for errors.
3 #![warn(missing_docs)]
5 use std::{
6     ops::ControlFlow,
7     path::{Path, PathBuf},
8 };
10 use crate::{
11     error::FinalError,
12     extension::Extension,
13     info,
14     utils::{pretty_format_list_of_paths, try_infer_extension, user_wants_to_continue, EscapedPathDisplay},
15     warning, QuestionAction, QuestionPolicy, Result,
18 /// Check, for each file, if the mime type matches the detected extensions.
19 ///
20 /// In case the file doesn't has any extensions, try to infer the format.
21 ///
22 /// TODO: maybe the name of this should be "magic numbers" or "file signature",
23 /// and not MIME.
24 pub fn check_mime_type(
25     files: &[PathBuf],
26     formats: &mut [Vec<Extension>],
27     question_policy: QuestionPolicy,
28 ) -> Result<ControlFlow<()>> {
29     for (path, format) in files.iter().zip(formats.iter_mut()) {
30         if format.is_empty() {
31             // File with no extension
32             // Try to detect it automatically and prompt the user about it
33             if let Some(detected_format) = try_infer_extension(path) {
34                 // Inferring the file extension can have unpredicted consequences (e.g. the user just
35                 // mistyped, ...) which we should always inform the user about.
36                 info!(
37                     accessible,
38                     "Detected file: `{}` extension as `{}`",
39                     path.display(),
40                     detected_format
41                 );
42                 if user_wants_to_continue(path, question_policy, QuestionAction::Decompression)? {
43                     format.push(detected_format);
44                 } else {
45                     return Ok(ControlFlow::Break(()));
46                 }
47             }
48         } else if let Some(detected_format) = try_infer_extension(path) {
49             // File ending with extension
50             // Try to detect the extension and warn the user if it differs from the written one
51             let outer_ext = format.iter().next_back().unwrap();
52             if !outer_ext
53                 .compression_formats
54                 .ends_with(detected_format.compression_formats)
55             {
56                 warning!(
57                     "The file extension: `{}` differ from the detected extension: `{}`",
58                     outer_ext,
59                     detected_format
60                 );
61                 if !user_wants_to_continue(path, question_policy, QuestionAction::Decompression)? {
62                     return Ok(ControlFlow::Break(()));
63                 }
64             }
65         } else {
66             // NOTE: If this actually produces no false positives, we can upgrade it in the future
67             // to a warning and ask the user if he wants to continue decompressing.
68             info!(accessible, "Could not detect the extension of `{}`", path.display());
69         }
70     }
71     Ok(ControlFlow::Continue(()))
74 /// In the context of listing archives, this function checks if `ouch` was told to list
75 /// the contents of a compressed file that is not an archive
76 pub fn check_for_non_archive_formats(files: &[PathBuf], formats: &[Vec<Extension>]) -> Result<()> {
77     let mut not_archives = files
78         .iter()
79         .zip(formats)
80         .filter(|(_, formats)| !formats.first().map(Extension::is_archive).unwrap_or(false))
81         .map(|(path, _)| path)
82         .peekable();
84     if not_archives.peek().is_some() {
85         let not_archives: Vec<_> = not_archives.collect();
86         let error = FinalError::with_title("Cannot list archive contents")
87             .detail("Only archives can have their contents listed")
88             .detail(format!(
89                 "Files are not archives: {}",
90                 pretty_format_list_of_paths(&not_archives)
91             ));
93         return Err(error.into());
94     }
96     Ok(())
99 /// Show error if archive format is not the first format in the chain.
100 pub fn check_archive_formats_position(formats: &[Extension], output_path: &Path) -> Result<()> {
101     if let Some(format) = formats.iter().skip(1).find(|format| format.is_archive()) {
102         let error = FinalError::with_title(format!(
103             "Cannot compress to '{}'.",
104             EscapedPathDisplay::new(output_path)
105         ))
106         .detail(format!("Found the format '{format}' in an incorrect position."))
107         .detail(format!(
108             "'{format}' can only be used at the start of the file extension."
109         ))
110         .hint(format!(
111             "If you wish to compress multiple files, start the extension with '{format}'."
112         ))
113         .hint(format!(
114             "Otherwise, remove the last '{}' from '{}'.",
115             format,
116             EscapedPathDisplay::new(output_path)
117         ));
119         return Err(error.into());
120     }
121     Ok(())
124 /// Check if all provided files have formats to decompress.
125 pub fn check_missing_formats_when_decompressing(files: &[PathBuf], formats: &[Vec<Extension>]) -> Result<()> {
126     let files_missing_format: Vec<PathBuf> = files
127         .iter()
128         .zip(formats)
129         .filter(|(_, format)| format.is_empty())
130         .map(|(input_path, _)| PathBuf::from(input_path))
131         .collect();
133     if let Some(path) = files_missing_format.first() {
134         let error = FinalError::with_title("Cannot decompress files without extensions")
135             .detail(format!(
136                 "Files without supported extensions: {}",
137                 pretty_format_list_of_paths(&files_missing_format)
138             ))
139             .detail("Decompression formats are detected automatically by the file extension")
140             .hint("Provide a file with a supported extension:")
141             .hint("  ouch decompress example.tar.gz")
142             .hint("")
143             .hint("Or overwrite this option with the '--format' flag:")
144             .hint(format!(
145                 "  ouch decompress {} --format tar.gz",
146                 EscapedPathDisplay::new(path),
147             ));
149         return Err(error.into());
150     }
151     Ok(())
154 /// Check if there is a first format when compressing, and returns it.
155 pub fn check_first_format_when_compressing<'a>(formats: &'a [Extension], output_path: &Path) -> Result<&'a Extension> {
156     formats.first().ok_or_else(|| {
157         let output_path = EscapedPathDisplay::new(output_path);
158         FinalError::with_title(format!("Cannot compress to '{output_path}'."))
159             .detail("You shall supply the compression format")
160             .hint("Try adding supported extensions (see --help):")
161             .hint(format!("  ouch compress <FILES>... {output_path}.tar.gz"))
162             .hint(format!("  ouch compress <FILES>... {output_path}.zip"))
163             .hint("")
164             .hint("Alternatively, you can overwrite this option by using the '--format' flag:")
165             .hint(format!("  ouch compress <FILES>... {output_path} --format tar.gz"))
166             .into()
167     })