From 19081caa7047c3d6b11bd48dac140e8844a01c8c Mon Sep 17 00:00:00 2001 From: Nbiba Bedis Date: Thu, 9 Dec 2021 09:37:23 +0100 Subject: [PATCH] Rebase --- src/commands.rs.orig | 763 ------------------------------------------- 1 file changed, 763 deletions(-) delete mode 100644 src/commands.rs.orig diff --git a/src/commands.rs.orig b/src/commands.rs.orig deleted file mode 100644 index 3a3d35a24..000000000 --- a/src/commands.rs.orig +++ /dev/null @@ -1,763 +0,0 @@ -//! Core of the crate, where the `compress_files` and `decompress_file` functions are implemented -//! -//! Also, where correctly call functions based on the detected `Command`. - -use std::{ - io::{self, BufReader, BufWriter, Read, Write}, - ops::ControlFlow, - path::{Path, PathBuf}, -}; - -use fs_err as fs; -use utils::colors; - -use crate::{ - archive, - error::FinalError, - extension::{ - self, - CompressionFormat::{self, *}, - Extension, - }, - info, - list::{self, FileInArchive, ListOptions}, - progress::Progress, - utils::{ - self, concatenate_os_str_list, dir_is_empty, nice_directory_display, to_utf, try_infer_extension, - user_wants_to_continue_compressing, user_wants_to_continue_decompressing, - }, - warning, Opts, QuestionPolicy, Subcommand, -}; - -// Used in BufReader and BufWriter to perform less syscalls -const BUFFER_CAPACITY: usize = 1024 * 64; - -fn represents_several_files(files: &[PathBuf]) -> bool { - let is_non_empty_dir = |path: &PathBuf| { - let is_non_empty = || !dir_is_empty(path); - - path.is_dir().then(is_non_empty).unwrap_or_default() - }; - - files.iter().any(is_non_empty_dir) || files.len() > 1 -} - -/// Entrypoint of ouch, receives cli options and matches Subcommand to decide what to do -pub fn run(args: Opts, question_policy: QuestionPolicy) -> crate::Result<()> { - match args.cmd { - Subcommand::Compress { mut files, output: output_path } => { - // If the output_path file exists and is the same as some of the input files, warn the user and skip those inputs (in order to avoid compression recursion) - if output_path.exists() { - clean_input_files_if_needed(&mut files, &fs::canonicalize(&output_path)?); - } - // After cleaning, if there are no input files left, exit - if files.is_empty() { - return Err(FinalError::with_title("No files to compress").into()); - } - - // Formats from path extension, like "file.tar.gz.xz" -> vec![Tar, Gzip, Lzma] - let mut formats = extension::extensions_from_path(&output_path); - - if formats.is_empty() { - let error = FinalError::with_title(format!("Cannot compress to '{}'.", to_utf(&output_path))) - .detail("You shall supply the compression format") - .hint("Try adding supported extensions (see --help):") - .hint(format!(" ouch compress ... {}.tar.gz", to_utf(&output_path))) - .hint(format!(" ouch compress ... {}.zip", to_utf(&output_path))) - .hint("") - .hint("Alternatively, you can overwrite this option by using the '--format' flag:") - .hint(format!(" ouch compress ... {} --format tar.gz", to_utf(&output_path))); - - return Err(error.into()); - } - - if !formats.get(0).map(Extension::is_archive).unwrap_or(false) && represents_several_files(&files) { - // This piece of code creates a suggestion for compressing multiple files - // It says: - // Change from file.bz.xz - // To file.tar.bz.xz - let extensions_text: String = formats.iter().map(|format| format.to_string()).collect(); - - let output_path = to_utf(output_path); - - // Breaks if Lzma is .lz or .lzma and not .xz - // Or if Bzip is .bz2 and not .bz - let extensions_start_position = output_path.rfind(&extensions_text).unwrap(); - let pos = extensions_start_position - 1; - let mut suggested_output_path = output_path.clone(); - suggested_output_path.insert_str(pos, ".tar"); - - let error = FinalError::with_title(format!("Cannot compress to '{}'.", to_utf(&output_path))) - .detail("You are trying to compress multiple files.") - .detail(format!("The compression format '{}' cannot receive multiple files.", &formats[0])) - .detail("The only supported formats that archive files into an archive are .tar and .zip.") - .hint(format!("Try inserting '.tar' or '.zip' before '{}'.", &formats[0])) - .hint(format!("From: {}", output_path)) - .hint(format!("To: {}", suggested_output_path)); - - return Err(error.into()); - } - - if let Some(format) = formats.iter().skip(1).find(|format| format.is_archive()) { - let error = FinalError::with_title(format!("Cannot compress to '{}'.", to_utf(&output_path))) - .detail(format!("Found the format '{}' in an incorrect position.", format)) - .detail(format!("'{}' can only be used at the start of the file extension.", format)) - .hint(format!("If you wish to compress multiple files, start the extension with '{}'.", format)) - .hint(format!("Otherwise, remove the last '{}' from '{}'.", format, to_utf(&output_path))); - - return Err(error.into()); - } - - if output_path.exists() && !utils::user_wants_to_overwrite(&output_path, question_policy)? { - // User does not want to overwrite this file, skip and return without any errors - return Ok(()); - } - - let output_file = fs::File::create(&output_path)?; - - if !represents_several_files(&files) { - // It's possible the file is already partially compressed so we don't want to compress it again - // `ouch compress file.tar.gz file.tar.gz.xz` should produce `file.tar.gz.xz` and not `file.tar.gz.tar.gz.xz` - let input_extensions = extension::extensions_from_path(&files[0]); - - // We calculate the formats that are left if we filter out a sublist at the start of what we have that's the same as the input formats - let mut new_formats = Vec::with_capacity(formats.len()); - for (inp_ext, out_ext) in input_extensions.iter().zip(&formats) { - if inp_ext.compression_formats == out_ext.compression_formats { - new_formats.push(out_ext.clone()); - } else if inp_ext - .compression_formats - .iter() - .zip(out_ext.compression_formats.iter()) - .all(|(inp, out)| inp == out) - { - let new_ext = Extension::new( - &out_ext.compression_formats[..inp_ext.compression_formats.len()], - &out_ext.display_text, - ); - new_formats.push(new_ext); - break; - } - } - // If the input is a sublist at the start of `formats` then remove the extensions - // Note: If input_extensions is empty then it will make `formats` empty too, which we don't want - if !input_extensions.is_empty() && new_formats != formats { - // Safety: - // We checked above that input_extensions isn't empty, so files[0] has an extension. - // - // Path::extension says: "if there is no file_name, then there is no extension". - // Contrapositive statement: "if there is extension, then there is file_name". - info!( - accessible, // important information - "Partial compression detected. Compressing {} into {}", - to_utf(files[0].as_path().file_name().unwrap()), - to_utf(&output_path) - ); - formats = new_formats; - } - } - let compress_result = compress_files(files, formats, output_file, &output_path, question_policy); - - // If any error occurred, delete incomplete file - if compress_result.is_err() { - // Print an extra alert message pointing out that we left a possibly - // CORRUPTED FILE at `output_path` - if let Err(err) = fs::remove_file(&output_path) { - eprintln!("{red}FATAL ERROR:\n", red = *colors::RED); - eprintln!(" Please manually delete '{}'.", to_utf(&output_path)); - eprintln!(" Compression failed and we could not delete '{}'.", to_utf(&output_path),); - eprintln!(" Error:{reset} {}{red}.{reset}\n", err, reset = *colors::RESET, red = *colors::RED); - } - } else { - // this is only printed once, so it doesn't result in much text. On the other hand, - // 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)); - } - - compress_result?; - } - Subcommand::Decompress { files, output_dir } => { - let mut output_paths = vec![]; - let mut formats = vec![]; - - for path in files.iter() { - let (file_output_path, file_formats) = extension::separate_known_extensions_from_name(path); - output_paths.push(file_output_path); - formats.push(file_formats); - } - - if let ControlFlow::Break(_) = check_mime_type(&files, &mut formats, question_policy)? { - return Ok(()); - } - - let files_missing_format: Vec = files - .iter() - .zip(&formats) - .filter(|(_, formats)| formats.is_empty()) - .map(|(input_path, _)| PathBuf::from(input_path)) - .collect(); - - if !files_missing_format.is_empty() { - let error = FinalError::with_title("Cannot decompress files without extensions") - .detail(format!( - "Files without supported extensions: {}", - concatenate_os_str_list(&files_missing_format) - )) - .detail("Decompression formats are detected automatically by the file extension") - .hint("Provide a file with a supported extension:") - .hint(" ouch decompress example.tar.gz") - .hint("") - .hint("Or overwrite this option with the '--format' flag:") - .hint(format!(" ouch decompress {} --format tar.gz", to_utf(&files_missing_format[0]))); - - return Err(error.into()); - } - - // The directory that will contain the output files - // We default to the current directory if the user didn't specify an output directory with --dir - let output_dir = if let Some(dir) = output_dir { - if !utils::clear_path(&dir, question_policy)? { - // User doesn't want to overwrite - return Ok(()); - } - utils::create_dir_if_non_existent(&dir)?; - dir - } else { - PathBuf::from(".") - }; - - for ((input_path, formats), file_name) in files.iter().zip(formats).zip(output_paths) { - let output_file_path = output_dir.join(file_name); // Path used by single file format archives - decompress_file(input_path, formats, &output_dir, output_file_path, question_policy)?; - } - } - Subcommand::List { archives: files, tree } => { - let mut formats = vec![]; - - for path in files.iter() { - let (_, file_formats) = extension::separate_known_extensions_from_name(path); - formats.push(file_formats); - } - - if let ControlFlow::Break(_) = check_mime_type(&files, &mut formats, question_policy)? { - return Ok(()); - } - - let not_archives: Vec = files - .iter() - .zip(&formats) - .filter(|(_, formats)| !formats.get(0).map(Extension::is_archive).unwrap_or(false)) - .map(|(path, _)| path.clone()) - .collect(); - - if !not_archives.is_empty() { - let error = FinalError::with_title("Cannot list archive contents") - .detail("Only archives can have their contents listed") - .detail(format!("Files are not archives: {}", concatenate_os_str_list(¬_archives))); - - return Err(error.into()); - } - - let list_options = ListOptions { tree }; - - for (i, (archive_path, formats)) in files.iter().zip(formats).enumerate() { - if i > 0 { - println!(); - } - let formats = formats.iter().flat_map(Extension::iter).map(Clone::clone).collect(); - list_archive_contents(archive_path, formats, list_options, question_policy)?; - } - } - } - Ok(()) -} - -// Compress files into an `output_file` -// -// files are the list of paths to be compressed: ["dir/file1.txt", "dir/file2.txt"] -// formats contains each format necessary for compression, example: [Tar, Gz] (in compression order) -// output_file is the resulting compressed file name, example: "compressed.tar.gz" -fn compress_files( - files: Vec, - formats: Vec, - output_file: fs::File, - output_dir: &Path, - question_policy: QuestionPolicy, -) -> crate::Result<()> { - // The next lines are for displaying the progress bar - // If the input files contain a directory, then the total size will be underestimated - let (total_input_size, precise) = files - .iter() - .map(|f| (f.metadata().expect("file exists").len(), f.is_file())) - .fold((0, true), |(total_size, and_precise), (size, precise)| (total_size + size, and_precise & precise)); - //NOTE: canonicalize is here to avoid a weird bug: - // > If output_file_path is a nested path and it exists and the user overwrite it - // >> output_file_path.exists() will always return false (somehow) - // - canonicalize seems to fix this - let output_file_path = output_file.path().canonicalize()?; - - let file_writer = BufWriter::with_capacity(BUFFER_CAPACITY, output_file); - - let mut writer: Box = Box::new(file_writer); - - // Grab previous encoder and wrap it inside of a new one - let chain_writer_encoder = |format: &CompressionFormat, encoder: Box| -> crate::Result> { - let encoder: Box = match format { - Gzip => Box::new(flate2::write::GzEncoder::new(encoder, Default::default())), - Bzip => Box::new(bzip2::write::BzEncoder::new(encoder, Default::default())), - Lz4 => Box::new(lzzzz::lz4f::WriteCompressor::new(encoder, Default::default())?), - Lzma => Box::new(xz2::write::XzEncoder::new(encoder, 6)), - Snappy => Box::new(snap::write::FrameEncoder::new(encoder)), - Zstd => { - let zstd_encoder = zstd::stream::write::Encoder::new(encoder, Default::default()); - // Safety: - // Encoder::new() can only fail if `level` is invalid, but Default::default() - // is guaranteed to be valid - Box::new(zstd_encoder.unwrap().auto_finish()) - } - Tar | Zip => unreachable!(), - }; - Ok(encoder) - }; - - for format in formats.iter().flat_map(Extension::iter).skip(1).collect::>().iter().rev() { - writer = chain_writer_encoder(format, writer)?; - } - - match formats[0].compression_formats[0] { - Gzip | Bzip | Lz4 | Lzma | Snappy | Zstd => { - let _progress = Progress::new_accessible_aware( - total_input_size, - precise, - Some(Box::new(move || output_file_path.metadata().expect("file exists").len())), - ); - - writer = chain_writer_encoder(&formats[0].compression_formats[0], writer)?; - let mut reader = fs::File::open(&files[0]).unwrap(); - io::copy(&mut reader, &mut writer)?; - } - Tar => { - let mut progress = Progress::new_accessible_aware( - total_input_size, - precise, - Some(Box::new(move || output_file_path.metadata().expect("file exists").len())), - ); - - archive::tar::build_archive_from_paths( - &files, - &mut writer, - progress.as_mut().map(Progress::display_handle).unwrap_or(&mut io::stdout()), - )?; - writer.flush()?; - } - Zip => { - eprintln!("{orange}[WARNING]{reset}", orange = *colors::ORANGE, reset = *colors::RESET); - eprintln!( - "\tThere is a limitation for .zip archives with extra extensions. (e.g. .zip.gz)\ - \n\tThe design of .zip makes it impossible to compress via stream, so it must be done entirely in memory.\ - \n\tBy compressing .zip with extra compression formats, you can run out of RAM if the file is too large!" - ); - - // give user the option to continue compressing after warning is shown - if !user_wants_to_continue_compressing(output_dir, question_policy)? { - return Ok(()); - } - - let mut vec_buffer = io::Cursor::new(vec![]); - - let current_position_fn = { - let vec_buffer_ptr = { - struct FlyPtr(*const io::Cursor>); - unsafe impl Send for FlyPtr {} - FlyPtr(&vec_buffer as *const _) - }; - Box::new(move || { - let vec_buffer_ptr = &vec_buffer_ptr; - // Safety: ptr is valid and vec_buffer is still alive - unsafe { &*vec_buffer_ptr.0 }.position() - }) - }; - - let mut progress = Progress::new_accessible_aware(total_input_size, precise, Some(current_position_fn)); - - archive::zip::build_archive_from_paths( - &files, - &mut vec_buffer, - progress.as_mut().map(Progress::display_handle).unwrap_or(&mut io::stdout()), - )?; - let vec_buffer = vec_buffer.into_inner(); - io::copy(&mut vec_buffer.as_slice(), &mut writer)?; - } - } - - Ok(()) -} - -// Decompress a file -// -// File at input_file_path is opened for reading, example: "archive.tar.gz" -// formats contains each format necessary for decompression, example: [Gz, Tar] (in decompression order) -// output_dir it's where the file will be decompressed to, this function assumes that the directory exists -// output_file_path is only used when extracting single file formats, not archive formats like .tar or .zip -fn decompress_file( - input_file_path: &Path, - formats: Vec, - output_dir: &Path, - output_file_path: PathBuf, - question_policy: QuestionPolicy, -) -> crate::Result<()> { - assert!(output_dir.exists()); - let total_input_size = input_file_path.metadata().expect("file exists").len(); - let reader = fs::File::open(&input_file_path)?; - // Zip archives are special, because they require io::Seek, so it requires it's logic separated - // from decoder chaining. - // - // This is the only case where we can read and unpack it directly, without having to do - // in-memory decompression/copying first. - // - // Any other Zip decompression done can take up the whole RAM and freeze ouch. - if formats.len() == 1 && *formats[0].compression_formats == [Zip] { - let zip_archive = zip::ZipArchive::new(reader)?; - let files = if let ControlFlow::Continue(files) = smart_unpack( - Box::new(move |output_dir| { - let mut progress = Progress::new_accessible_aware(total_input_size, true, None); - crate::archive::zip::unpack_archive( - zip_archive, - output_dir, - progress.as_mut().map(Progress::display_handle).unwrap_or(&mut io::stdout()), - ) - }), - output_dir, - &output_file_path, - question_policy, - )? { - files - } else { - return Ok(()); - }; - - // this is only printed once, so it doesn't result in much text. On the other hand, - // 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 decompressed archive in {} ({} files).", - nice_directory_display(output_dir), - files.len() - ); - - return Ok(()); - } - - // Will be used in decoder chaining - let reader = BufReader::with_capacity(BUFFER_CAPACITY, reader); - let mut reader: Box = Box::new(reader); - - // Grab previous decoder and wrap it inside of a new one - let chain_reader_decoder = |format: &CompressionFormat, decoder: Box| -> crate::Result> { - let decoder: Box = match format { - Gzip => Box::new(flate2::read::GzDecoder::new(decoder)), - Bzip => Box::new(bzip2::read::BzDecoder::new(decoder)), - Lz4 => Box::new(lzzzz::lz4f::ReadDecompressor::new(decoder)?), - Lzma => Box::new(xz2::read::XzDecoder::new(decoder)), - Snappy => Box::new(snap::read::FrameDecoder::new(decoder)), - Zstd => Box::new(zstd::stream::Decoder::new(decoder)?), - Tar | Zip => unreachable!(), - }; - Ok(decoder) - }; - - for format in formats.iter().flat_map(Extension::iter).skip(1).collect::>().iter().rev() { - reader = chain_reader_decoder(format, reader)?; - } - - let files_unpacked; - match formats[0].compression_formats[0] { - Gzip | Bzip | Lz4 | Lzma | Snappy | Zstd => { - reader = chain_reader_decoder(&formats[0].compression_formats[0], reader)?; - - let writer = utils::create_or_ask_overwrite(&output_file_path, question_policy)?; - if writer.is_none() { - // Means that the user doesn't want to overwrite - return Ok(()); - } - let mut writer = writer.unwrap(); - - let current_position_fn = Box::new({ - let output_file_path = output_file_path.clone(); - move || output_file_path.clone().metadata().expect("file exists").len() - }); - let _progress = Progress::new_accessible_aware(total_input_size, true, Some(current_position_fn)); - - io::copy(&mut reader, &mut writer)?; - files_unpacked = vec![output_file_path]; - } - Tar => { - files_unpacked = if let ControlFlow::Continue(files) = smart_unpack( - Box::new(move |output_dir| { - let mut progress = Progress::new_accessible_aware(total_input_size, true, None); - crate::archive::tar::unpack_archive( - reader, - output_dir, - progress.as_mut().map(Progress::display_handle).unwrap_or(&mut io::stdout()), - ) - }), - output_dir, - &output_file_path, - question_policy, - )? { - files - } else { - return Ok(()); - }; - } - Zip => { - eprintln!("{orange}[WARNING]{reset}", orange = *colors::ORANGE, reset = *colors::RESET); - eprintln!( - "\tThere is a limitation for .zip archives with extra extensions. (e.g. .zip.gz)\ - \n\tThe design of .zip makes it impossible to compress via stream, so it must be done entirely in memory.\ - \n\tBy compressing .zip with extra compression formats, you can run out of RAM if the file is too large!" - ); - - // give user the option to continue decompressing after warning is shown - if !user_wants_to_continue_decompressing(input_file_path, question_policy)? { - return Ok(()); - } - - let mut vec = vec![]; - io::copy(&mut reader, &mut vec)?; - let zip_archive = zip::ZipArchive::new(io::Cursor::new(vec))?; - - files_unpacked = if let ControlFlow::Continue(files) = smart_unpack( - Box::new(move |output_dir| { - let mut progress = Progress::new_accessible_aware(total_input_size, true, None); - crate::archive::zip::unpack_archive( - zip_archive, - output_dir, - progress.as_mut().map(Progress::display_handle).unwrap_or(&mut io::stdout()), - ) - }), - output_dir, - &output_file_path, - question_policy, - )? { - files - } else { - return Ok(()); - }; - } - } - - // this is only printed once, so it doesn't result in much text. On the other hand, - // 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 decompressed archive in {}.", nice_directory_display(output_dir)); - info!(accessible, "Files unpacked: {}", files_unpacked.len()); - - Ok(()) -} - -// File at input_file_path is opened for reading, example: "archive.tar.gz" -// formats contains each format necessary for decompression, example: [Gz, Tar] (in decompression order) -fn list_archive_contents( - archive_path: &Path, - formats: Vec, - list_options: ListOptions, - question_policy: QuestionPolicy, -) -> crate::Result<()> { - let reader = fs::File::open(&archive_path)?; - - // Zip archives are special, because they require io::Seek, so it requires it's logic separated - // from decoder chaining. - // - // This is the only case where we can read and unpack it directly, without having to do - // in-memory decompression/copying first. - // - // Any other Zip decompression done can take up the whole RAM and freeze ouch. - if let [Zip] = *formats.as_slice() { - let zip_archive = zip::ZipArchive::new(reader)?; - let files = crate::archive::zip::list_archive(zip_archive); - list::list_files(archive_path, files, list_options)?; - - return Ok(()); - } - - // Will be used in decoder chaining - let reader = BufReader::with_capacity(BUFFER_CAPACITY, reader); - let mut reader: Box = Box::new(reader); - - // Grab previous decoder and wrap it inside of a new one -<<<<<<< HEAD - let chain_reader_decoder = |format: &CompressionFormat, decoder: Box| -> crate::Result> { - let decoder: Box = match format { - Gzip => Box::new(flate2::read::GzDecoder::new(decoder)), - Bzip => Box::new(bzip2::read::BzDecoder::new(decoder)), - Lz4 => Box::new(lzzzz::lz4f::ReadDecompressor::new(decoder)?), - Lzma => Box::new(xz2::read::XzDecoder::new(decoder)), - Snappy => Box::new(snap::read::FrameDecoder::new(decoder)), - Zstd => Box::new(zstd::stream::Decoder::new(decoder)?), - Tar | Zip => unreachable!(), -======= - let chain_reader_decoder = - |format: &CompressionFormat, decoder: Box| -> crate::Result> { - let decoder: Box = match format { - Gzip => Box::new(flate2::read::GzDecoder::new(decoder)), - Bzip => Box::new(bzip2::read::BzDecoder::new(decoder)), - Lz4 => Box::new(lzzzz::lz4f::ReadDecompressor::new(decoder)?), - Lzma => Box::new(xz2::read::XzDecoder::new(decoder)), - Zstd => Box::new(zstd::stream::Decoder::new(decoder)?), - Tar | Zip => unreachable!(), - }; - Ok(decoder) ->>>>>>> 84526db (Use a new thread for listing) - }; - - for format in formats.iter().skip(1).rev() { - reader = chain_reader_decoder(format, reader)?; - } - - let files: Box>> = match formats[0] { - Tar => Box::new(crate::archive::tar::list_archive(tar::Archive::new(reader))), - Zip => { - eprintln!("{orange}[WARNING]{reset}", orange = *colors::ORANGE, reset = *colors::RESET); - eprintln!( - "\tThere is a limitation for .zip archives with extra extensions. (e.g. .zip.gz)\ - \n\tThe design of .zip makes it impossible to compress via stream, so it must be done entirely in memory.\ - \n\tBy compressing .zip with extra compression formats, you can run out of RAM if the file is too large!" - ); - - // give user the option to continue decompressing after warning is shown - if !user_wants_to_continue_decompressing(archive_path, question_policy)? { - return Ok(()); - } - - let mut vec = vec![]; - io::copy(&mut reader, &mut vec)?; - let zip_archive = zip::ZipArchive::new(io::Cursor::new(vec))?; - - Box::new(crate::archive::zip::list_archive(zip_archive)) - } - Gzip | Bzip | Lz4 | Lzma | Snappy | Zstd => { - panic!("Not an archive! This should never happen, if it does, something is wrong with `CompressionFormat::is_archive()`. Please report this error!"); - } - }; - list::list_files(archive_path, files, list_options)?; - Ok(()) -} - -/// Unpacks an archive with some heuristics -/// - If the archive contains only one file, it will be extracted to the `output_dir` -/// - If the archive contains multiple files, it will be extracted to a subdirectory of the output_dir named after the archive (given by `output_file_path`) -/// Note: This functions assumes that `output_dir` exists -fn smart_unpack( - unpack_fn: Box crate::Result>>, - output_dir: &Path, - output_file_path: &Path, - question_policy: QuestionPolicy, -) -> crate::Result>> { - assert!(output_dir.exists()); - let temp_dir = tempfile::tempdir_in(output_dir)?; - let temp_dir_path = temp_dir.path(); - info!( - accessible, - "Created temporary directory {} to hold decompressed elements.", - nice_directory_display(temp_dir_path) - ); - - // unpack the files - let files = unpack_fn(temp_dir_path)?; - - let root_contains_only_one_element = fs::read_dir(&temp_dir_path)?.count() == 1; - if root_contains_only_one_element { - // Only one file in the root directory, so we can just move it to the output directory - let file = fs::read_dir(&temp_dir_path)?.next().expect("item exists")?; - let file_path = file.path(); - let file_name = - file_path.file_name().expect("Should be safe because paths in archives should not end with '..'"); - let correct_path = output_dir.join(file_name); - // One case to handle tough is we need to check if a file with the same name already exists - if !utils::clear_path(&correct_path, question_policy)? { - return Ok(ControlFlow::Break(())); - } - fs::rename(&file_path, &correct_path)?; - info!( - accessible, - "Successfully moved {} to {}.", - nice_directory_display(&file_path), - nice_directory_display(&correct_path) - ); - } else { - // Multiple files in the root directory, so: - // Rename the temporary directory to the archive name, which is output_file_path - // One case to handle tough is we need to check if a file with the same name already exists - if !utils::clear_path(output_file_path, question_policy)? { - return Ok(ControlFlow::Break(())); - } - fs::rename(&temp_dir_path, &output_file_path)?; - info!( - accessible, - "Successfully moved {} to {}.", - nice_directory_display(&temp_dir_path), - nice_directory_display(&output_file_path) - ); - } - Ok(ControlFlow::Continue(files)) -} - -fn check_mime_type( - files: &[PathBuf], - formats: &mut Vec>, - question_policy: QuestionPolicy, -) -> crate::Result> { - for (path, format) in files.iter().zip(formats.iter_mut()) { - if format.is_empty() { - // File with no extension - // Try to detect it automatically and prompt the user about it - if let Some(detected_format) = try_infer_extension(path) { - // Infering the file extension can have unpredicted consequences (e.g. the user just - // mistyped, ...) which we should always inform the user about. - info!(accessible, "Detected file: `{}` extension as `{}`", path.display(), detected_format); - if user_wants_to_continue_decompressing(path, question_policy)? { - format.push(detected_format); - } else { - return Ok(ControlFlow::Break(())); - } - } - } else if let Some(detected_format) = try_infer_extension(path) { - // File ending with extension - // Try to detect the extension and warn the user if it differs from the written one - let outer_ext = format.iter().next_back().unwrap(); - if outer_ext != &detected_format { - warning!( - "The file extension: `{}` differ from the detected extension: `{}`", - outer_ext, - detected_format - ); - if !user_wants_to_continue_decompressing(path, question_policy)? { - return Ok(ControlFlow::Break(())); - } - } - } else { - // NOTE: If this actually produces no false positives, we can upgrade it in the future - // to a warning and ask the user if he wants to continue decompressing. - info!(accessible, "Could not detect the extension of `{}`", path.display()); - } - } - Ok(ControlFlow::Continue(())) -} - -fn clean_input_files_if_needed(files: &mut Vec, output_path: &Path) { - let mut idx = 0; - while idx < files.len() { - if files[idx] == output_path { - warning!("The output file and the input file are the same: `{}`, skipping...", output_path.display()); - files.remove(idx); - } else { - idx += 1; - } - } -}