2020-09-22 21:24:55 +12:00
|
|
|
use std::collections::BTreeMap;
|
2022-01-04 06:13:07 +13:00
|
|
|
use std::fs;
|
2023-10-11 07:54:41 +13:00
|
|
|
use std::io::Write;
|
2022-01-04 06:13:07 +13:00
|
|
|
use std::path::PathBuf;
|
2020-12-02 22:25:27 +13:00
|
|
|
|
2023-12-04 00:06:42 +13:00
|
|
|
use crossbeam_channel::{Receiver, Sender};
|
2023-10-11 07:54:41 +13:00
|
|
|
use fun_time::fun_time;
|
|
|
|
use log::debug;
|
2023-10-14 07:33:17 +13:00
|
|
|
use rayon::prelude::*;
|
2021-11-28 08:49:20 +13:00
|
|
|
|
2023-05-11 07:27:41 +12:00
|
|
|
use crate::common_dir_traversal::{Collect, DirTraversalBuilder, DirTraversalResult, FolderEmptiness, FolderEntry, ProgressData, ToolType};
|
2023-10-14 07:33:17 +13:00
|
|
|
use crate::common_tool::{CommonData, CommonToolData, DeleteMethod};
|
2023-10-11 07:54:41 +13:00
|
|
|
use crate::common_traits::{DebugPrint, PrintResults};
|
2020-09-01 05:37:30 +12:00
|
|
|
|
|
|
|
pub struct EmptyFolder {
|
2023-10-05 19:06:47 +13:00
|
|
|
common_data: CommonToolData,
|
2020-09-18 20:23:49 +12:00
|
|
|
information: Info,
|
2020-10-15 05:41:37 +13:00
|
|
|
empty_folder_list: BTreeMap<PathBuf, FolderEntry>, // Path, FolderEntry
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
|
|
|
|
2020-10-10 09:32:08 +13:00
|
|
|
#[derive(Default)]
|
2020-09-18 17:32:37 +12:00
|
|
|
pub struct Info {
|
2020-09-22 21:24:55 +12:00
|
|
|
pub number_of_empty_folders: usize,
|
2020-09-18 17:32:37 +12:00
|
|
|
}
|
2021-11-28 08:57:10 +13:00
|
|
|
|
2020-09-01 05:37:30 +12:00
|
|
|
impl EmptyFolder {
|
2020-10-10 09:32:08 +13:00
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
2023-10-05 19:06:47 +13:00
|
|
|
common_data: CommonToolData::new(ToolType::EmptyFolders),
|
2020-09-18 20:23:49 +12:00
|
|
|
information: Default::default(),
|
2020-09-02 03:10:54 +12:00
|
|
|
empty_folder_list: Default::default(),
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-15 05:41:37 +13:00
|
|
|
pub const fn get_empty_folder_list(&self) -> &BTreeMap<PathBuf, FolderEntry> {
|
2020-09-22 21:24:55 +12:00
|
|
|
&self.empty_folder_list
|
|
|
|
}
|
|
|
|
|
2020-10-10 09:32:08 +13:00
|
|
|
pub const fn get_information(&self) -> &Info {
|
2020-09-22 21:24:55 +12:00
|
|
|
&self.information
|
|
|
|
}
|
2020-09-18 17:32:37 +12:00
|
|
|
|
2023-10-15 04:48:57 +13:00
|
|
|
#[fun_time(message = "find_empty_folders", level = "info")]
|
2023-12-04 00:06:42 +13:00
|
|
|
pub fn find_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&Sender<ProgressData>>) {
|
2023-10-05 19:06:47 +13:00
|
|
|
self.optimize_dirs_before_start();
|
2020-12-02 22:25:27 +13:00
|
|
|
if !self.check_for_empty_folders(stop_receiver, progress_sender) {
|
2023-10-05 19:06:47 +13:00
|
|
|
self.common_data.stopped_search = true;
|
2020-10-10 22:15:20 +13:00
|
|
|
return;
|
|
|
|
}
|
2020-09-02 03:10:54 +12:00
|
|
|
self.optimize_folders();
|
2023-10-14 07:33:17 +13:00
|
|
|
|
|
|
|
self.delete_files();
|
2020-09-18 17:32:37 +12:00
|
|
|
self.debug_print();
|
|
|
|
}
|
|
|
|
|
2020-09-02 03:10:54 +12:00
|
|
|
fn optimize_folders(&mut self) {
|
2020-10-15 05:41:37 +13:00
|
|
|
let mut new_directory_folders: BTreeMap<PathBuf, FolderEntry> = Default::default();
|
2020-09-02 03:10:54 +12:00
|
|
|
|
2020-09-27 07:46:35 +13:00
|
|
|
for (name, folder_entry) in &self.empty_folder_list {
|
2020-09-27 06:51:28 +13:00
|
|
|
match &folder_entry.parent_path {
|
2020-09-02 03:10:54 +12:00
|
|
|
Some(t) => {
|
|
|
|
if !self.empty_folder_list.contains_key(t) {
|
2020-09-27 06:51:28 +13:00
|
|
|
new_directory_folders.insert(name.clone(), folder_entry.clone());
|
2020-09-02 03:10:54 +12:00
|
|
|
}
|
|
|
|
}
|
|
|
|
None => {
|
2020-09-27 06:51:28 +13:00
|
|
|
new_directory_folders.insert(name.clone(), folder_entry.clone());
|
2020-09-02 03:10:54 +12:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.empty_folder_list = new_directory_folders;
|
2020-09-18 21:11:08 +12:00
|
|
|
self.information.number_of_empty_folders = self.empty_folder_list.len();
|
2020-09-02 03:10:54 +12:00
|
|
|
}
|
|
|
|
|
2023-10-15 04:48:57 +13:00
|
|
|
#[fun_time(message = "check_for_empty_folders", level = "debug")]
|
2023-12-04 00:06:42 +13:00
|
|
|
fn check_for_empty_folders(&mut self, stop_receiver: Option<&Receiver<()>>, progress_sender: Option<&Sender<ProgressData>>) -> bool {
|
2022-01-04 06:13:07 +13:00
|
|
|
let result = DirTraversalBuilder::new()
|
2023-10-05 19:06:47 +13:00
|
|
|
.root_dirs(self.common_data.directories.included_directories.clone())
|
2022-01-04 06:13:07 +13:00
|
|
|
.group_by(|_fe| ())
|
|
|
|
.stop_receiver(stop_receiver)
|
|
|
|
.progress_sender(progress_sender)
|
2023-10-05 19:06:47 +13:00
|
|
|
.directories(self.common_data.directories.clone())
|
|
|
|
.excluded_items(self.common_data.excluded_items.clone())
|
2022-01-04 06:13:07 +13:00
|
|
|
.collect(Collect::EmptyFolders)
|
|
|
|
.max_stage(0)
|
2023-12-04 00:06:42 +13:00
|
|
|
.tool_type(self.common_data.tool_type)
|
2022-01-04 06:13:07 +13:00
|
|
|
.build()
|
|
|
|
.run();
|
2023-10-11 07:54:41 +13:00
|
|
|
|
|
|
|
match result {
|
2022-01-04 06:13:07 +13:00
|
|
|
DirTraversalResult::SuccessFiles { .. } => {
|
|
|
|
unreachable!()
|
2020-10-10 22:15:20 +13:00
|
|
|
}
|
2023-05-08 06:54:05 +12:00
|
|
|
DirTraversalResult::SuccessFolders { folder_entries, warnings } => {
|
2023-10-11 07:54:41 +13:00
|
|
|
for (name, folder_entry) in folder_entries {
|
2022-01-04 06:13:07 +13:00
|
|
|
if folder_entry.is_empty != FolderEmptiness::No {
|
|
|
|
self.empty_folder_list.insert(name, folder_entry);
|
2021-12-18 07:29:37 +13:00
|
|
|
}
|
2020-09-01 09:03:10 +12:00
|
|
|
}
|
2020-09-27 06:51:28 +13:00
|
|
|
|
2023-10-05 19:06:47 +13:00
|
|
|
self.common_data.text_messages.warnings.extend(warnings);
|
2023-10-11 07:54:41 +13:00
|
|
|
debug!("Found {} empty folders.", self.empty_folder_list.len());
|
2022-01-04 06:13:07 +13:00
|
|
|
true
|
2020-09-02 03:10:54 +12:00
|
|
|
}
|
2022-01-04 06:13:07 +13:00
|
|
|
DirTraversalResult::Stopped => false,
|
2023-10-11 07:54:41 +13:00
|
|
|
}
|
2020-09-01 09:03:10 +12:00
|
|
|
}
|
2020-09-02 03:10:54 +12:00
|
|
|
|
2023-10-15 04:48:57 +13:00
|
|
|
#[fun_time(message = "delete_files", level = "debug")]
|
2023-10-14 07:33:17 +13:00
|
|
|
fn delete_files(&mut self) {
|
|
|
|
if self.get_delete_method() == DeleteMethod::None {
|
|
|
|
return;
|
2020-09-02 03:10:54 +12:00
|
|
|
}
|
2023-10-14 07:33:17 +13:00
|
|
|
let folders_to_remove = self.empty_folder_list.keys().collect::<Vec<_>>();
|
|
|
|
|
|
|
|
let errors: Vec<_> = folders_to_remove
|
|
|
|
.into_par_iter()
|
|
|
|
.filter_map(|name| {
|
|
|
|
if let Err(e) = fs::remove_dir_all(name) {
|
|
|
|
Some(format!("Failed to remove folder {name:?}, reason {e}"))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
self.get_text_messages_mut().errors.extend(errors);
|
2020-09-01 09:03:10 +12:00
|
|
|
}
|
2020-09-27 03:52:13 +13:00
|
|
|
}
|
2020-11-01 07:19:33 +13:00
|
|
|
|
2020-09-27 03:52:13 +13:00
|
|
|
impl Default for EmptyFolder {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self::new()
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
2020-09-27 03:52:13 +13:00
|
|
|
}
|
2020-09-01 05:37:30 +12:00
|
|
|
|
2020-09-27 03:52:13 +13:00
|
|
|
impl DebugPrint for EmptyFolder {
|
2020-09-01 05:37:30 +12:00
|
|
|
fn debug_print(&self) {
|
2023-10-11 07:54:41 +13:00
|
|
|
if !cfg!(debug_assertions) {
|
2020-09-18 21:31:44 +12:00
|
|
|
return;
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
2020-09-18 21:31:44 +12:00
|
|
|
|
|
|
|
println!("---------------DEBUG PRINT---------------");
|
|
|
|
println!("Number of empty folders - {}", self.information.number_of_empty_folders);
|
2023-10-05 19:06:47 +13:00
|
|
|
self.debug_print_common();
|
2020-09-18 21:31:44 +12:00
|
|
|
println!("-----------------------------------------");
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
2020-09-27 03:52:13 +13:00
|
|
|
}
|
2021-11-28 08:57:10 +13:00
|
|
|
|
2023-10-11 07:54:41 +13:00
|
|
|
impl PrintResults for EmptyFolder {
|
|
|
|
fn write_results<T: Write>(&self, writer: &mut T) -> std::io::Result<()> {
|
2020-09-27 03:52:13 +13:00
|
|
|
if !self.empty_folder_list.is_empty() {
|
2023-10-11 07:54:41 +13:00
|
|
|
writeln!(writer, "--------------------------Empty folder list--------------------------")?;
|
|
|
|
writeln!(writer, "Found {} empty folders", self.information.number_of_empty_folders)?;
|
2020-09-27 03:52:13 +13:00
|
|
|
for name in self.empty_folder_list.keys() {
|
2023-10-11 07:54:41 +13:00
|
|
|
writeln!(writer, "{}", name.display())?;
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
2020-09-27 03:52:13 +13:00
|
|
|
} else {
|
2023-10-11 07:54:41 +13:00
|
|
|
write!(writer, "Not found any empty folders.")?;
|
2020-09-01 05:37:30 +12:00
|
|
|
}
|
2023-05-08 06:54:05 +12:00
|
|
|
|
2023-10-11 07:54:41 +13:00
|
|
|
Ok(())
|
2020-09-07 19:06:12 +12:00
|
|
|
}
|
2023-10-13 05:48:46 +13:00
|
|
|
|
|
|
|
fn save_results_to_file_as_json(&self, file_name: &str, pretty_print: bool) -> std::io::Result<()> {
|
|
|
|
self.save_results_to_file_as_json_internal(file_name, &self.empty_folder_list.keys().collect::<Vec<_>>(), pretty_print)
|
|
|
|
}
|
2020-09-07 19:06:12 +12:00
|
|
|
}
|
2023-10-05 19:06:47 +13:00
|
|
|
|
|
|
|
impl CommonData for EmptyFolder {
|
|
|
|
fn get_cd(&self) -> &CommonToolData {
|
|
|
|
&self.common_data
|
|
|
|
}
|
|
|
|
fn get_cd_mut(&mut self) -> &mut CommonToolData {
|
|
|
|
&mut self.common_data
|
|
|
|
}
|
|
|
|
}
|