224 lines
9.4 KiB
Rust
224 lines
9.4 KiB
Rust
use std::{env, process};
|
|
|
|
mod common;
|
|
mod duplicate;
|
|
mod empty_folder;
|
|
|
|
fn main() {
|
|
// Parse argument
|
|
let mut all_arguments: Vec<String> = env::args().collect();
|
|
let mut commands_arguments: Vec<String> = Vec::new();
|
|
|
|
all_arguments.remove(0); // Removing program name from arguments
|
|
|
|
// No arguments, so we print help to allow user to learn more about program
|
|
if all_arguments.is_empty() {
|
|
print_help();
|
|
process::exit(0);
|
|
}
|
|
|
|
// Assigning commands with arguments
|
|
let mut arguments: Vec<ArgumentsPair> = Vec::new();
|
|
|
|
for argument in all_arguments {
|
|
if argument.starts_with("--") {
|
|
commands_arguments.push(argument);
|
|
} else if argument.starts_with('-') {
|
|
let a: ArgumentsPair = ArgumentsPair {
|
|
command: argument,
|
|
argument: Option::None,
|
|
};
|
|
arguments.push(a);
|
|
} else {
|
|
if arguments.is_empty() {
|
|
println!("FATAL ERROR: Trying to use {} without any arguments(like -i -e -delete)", argument);
|
|
process::exit(1);
|
|
}
|
|
if arguments[arguments.len() - 1].argument != Option::None {
|
|
println!("FATAL ERROR: Trying set second parameter {}, but only one is supported", argument); // This may be changed in future to support 2 or more attributes with space
|
|
process::exit(1);
|
|
}
|
|
let last_element = arguments.len() - 1;
|
|
arguments[last_element].argument = Option::from(argument);
|
|
}
|
|
}
|
|
|
|
for a in &arguments {
|
|
println!(
|
|
"Argument number {} - {}",
|
|
a.command,
|
|
match &a.argument {
|
|
Some(t) => t.clone(),
|
|
None => "MISSING_ARGUMENT".to_string(),
|
|
}
|
|
);
|
|
}
|
|
|
|
if commands_arguments.is_empty() {
|
|
println! {"FATAL ERROR: Missing type of app which you want to run, please read help for more info."};
|
|
process::exit(0);
|
|
}
|
|
match commands_arguments[0].as_ref() {
|
|
"--d" => {
|
|
let mut df = duplicate::DuplicateFinder::new();
|
|
let mut check_method: duplicate::CheckingMethod = duplicate::CheckingMethod::HASH;
|
|
|
|
if ArgumentsPair::has_command(&arguments, "-i") {
|
|
df.set_include_directory(ArgumentsPair::get_argument(&arguments, "-i", false));
|
|
} else {
|
|
println!("FATAL ERROR: Parameter -i with set of included files is required.");
|
|
process::exit(1);
|
|
}
|
|
if ArgumentsPair::has_command(&arguments, "-e") {
|
|
df.set_exclude_directory(ArgumentsPair::get_argument(&arguments, "-e", false));
|
|
}
|
|
|
|
if ArgumentsPair::has_command(&arguments, "-s") {
|
|
let min_size = match ArgumentsPair::get_argument(&arguments, "-s", false).parse::<u64>() {
|
|
Ok(t) => t,
|
|
Err(_) => {
|
|
println!(
|
|
"FATAL ERROR: \"{}\" is not valid file size(allowed range <0,u64::max>)",
|
|
ArgumentsPair::get_argument(&arguments, "-s", false)
|
|
);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
df.set_min_file_size(min_size);
|
|
}
|
|
|
|
if ArgumentsPair::has_command(&arguments, "-x") {
|
|
df.set_allowed_extensions(ArgumentsPair::get_argument(&arguments, "-x", false));
|
|
}
|
|
if ArgumentsPair::has_command(&arguments, "-k") {
|
|
df.set_excluded_items(ArgumentsPair::get_argument(&arguments, "-k", false));
|
|
}
|
|
if ArgumentsPair::has_command(&arguments, "-l") {
|
|
let argument_name = ArgumentsPair::get_argument(&arguments, "-l", false).to_lowercase();
|
|
if argument_name == "size" {
|
|
check_method = duplicate::CheckingMethod::SIZE;
|
|
} else if argument_name == "hash" {
|
|
check_method = duplicate::CheckingMethod::HASH;
|
|
} else {
|
|
println!("-l can only have values hash or size");
|
|
process::exit(1);
|
|
}
|
|
}
|
|
|
|
let mut delete_method: duplicate::DeleteMethod = duplicate::DeleteMethod::None;
|
|
if ArgumentsPair::has_command(&arguments, "-delete") {
|
|
delete_method = duplicate::DeleteMethod::AllExceptOldest;
|
|
let argument_name = ArgumentsPair::get_argument(&arguments, "-delete", true).to_lowercase();
|
|
if argument_name == "aen" {
|
|
delete_method = duplicate::DeleteMethod::AllExceptNewest;
|
|
} else if argument_name == "aeo" {
|
|
delete_method = duplicate::DeleteMethod::AllExceptOldest;
|
|
} else if argument_name == "on" {
|
|
delete_method = duplicate::DeleteMethod::OneNewest;
|
|
} else if argument_name == "oo" {
|
|
delete_method = duplicate::DeleteMethod::OneOldest;
|
|
} else if argument_name == "" {
|
|
// Nothing to do choosing default one
|
|
} else {
|
|
println!(
|
|
"Invalid argument {} for command -delete, available arguments - aen(All except newest one), aeo(All except oldest one), on(Only one newest), oo(Only one oldest)",
|
|
argument_name
|
|
);
|
|
process::exit(1);
|
|
}
|
|
}
|
|
|
|
df.find_duplicates(&check_method, &delete_method);
|
|
}
|
|
"--h" | "--help" => {
|
|
print_help();
|
|
}
|
|
"--e" => {
|
|
let mut ef = empty_folder::EmptyFolder::new();
|
|
let mut delete_folders: bool = false;
|
|
|
|
if ArgumentsPair::has_command(&arguments, "-i") {
|
|
ef.set_include_directory(ArgumentsPair::get_argument(&arguments, "-i", false));
|
|
} else {
|
|
println!("FATAL ERROR: Parameter -i with set of included files is required.");
|
|
process::exit(1);
|
|
}
|
|
if ArgumentsPair::has_command(&arguments, "-e") {
|
|
ef.set_exclude_directory(ArgumentsPair::get_argument(&arguments, "-e", false));
|
|
}
|
|
|
|
if ArgumentsPair::has_command(&arguments, "-delete") {
|
|
delete_folders = true;
|
|
}
|
|
|
|
ef.find_empty_folders(delete_folders);
|
|
}
|
|
argum => {
|
|
println!("FATAL ERROR: \"{}\" argument is not supported, check help for more info.", argum);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
}
|
|
|
|
fn print_help() {
|
|
println!(
|
|
r###"
|
|
Usage of Czkawka:
|
|
|
|
## Main arguments:
|
|
--h / --help - prints help, also works without any arguments
|
|
Usage example:
|
|
czkawka --help
|
|
czkawka
|
|
|
|
--d <-i directory_to_search> [-e exclude_directories = ""] [-s min_size = 1024] [-x allowed_extension = ""] [-l type_of_search = "hash"] [-delete = "aeo"] - search for duplicates files
|
|
-i directory_to_search - list of directories which should will be searched like /home/rafal
|
|
-e exclude_directories - list of directories which will be excluded from search.
|
|
-s min_size - minimum size of checked files in bytes, assigning bigger value may speed up searching.
|
|
-x allowed_extension - list of checked extension, e.g. "jpg,mp4" will allow to check "book.jpg" and "car.mp4" but not roman.png.There are also helpful macros which allow to easy use a typcal extension like IMAGE("jpg,kra,gif,png,bmp,tiff,webp,hdr,svg") or TEXT("txt,doc,docx,odt,rtf")
|
|
-l type_of_search - allows to use fastest which takes into account only size, and more accurate which check if file contnet is same(hashes).
|
|
-delete - delete found files, by default remove all except the most oldest one, it can take arguments: aen(All except newest one), aeo(All except oldest one), on(Only one newest), oo(Only one oldest)
|
|
Usage example:
|
|
czkawka --d -i "/home/rafal/,/home/szczekacz" -e "/home/rafal/Pulpit,/home/rafal/Obrazy" -s 25 -x "7z,rar,IMAGE" -l "size" -delete
|
|
czkawka --d -i "/etc/,/mnt/Miecz" -s 1000 -x "VIDEO" -l "hash"
|
|
czkawka --d -i "/etc/" -delete "aeo"
|
|
--e <-i directory_to_search> [-e exclude_directories = ""] [-delete] - option to find and delete empty folders
|
|
-i directory_to_search - list of directories which should will be searched like /home/rafal
|
|
-e exclude_directories - list of directories which will be excluded from search.
|
|
-delete - delete found empty folders
|
|
czkawka --e -i "/home/rafal/rr, /home/gateway" -e "/home/rafal/rr/2" -delete
|
|
"###
|
|
);
|
|
}
|
|
|
|
struct ArgumentsPair {
|
|
command: String,
|
|
argument: Option<String>,
|
|
}
|
|
|
|
impl ArgumentsPair {
|
|
pub fn has_command(ar: &[ArgumentsPair], command: &str) -> bool {
|
|
for a in ar {
|
|
if a.command == command {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
pub fn get_argument(ar: &[ArgumentsPair], command: &str, can_be_empty: bool) -> String {
|
|
for a in ar {
|
|
if a.command == command {
|
|
if !can_be_empty && a.argument == Option::None {
|
|
println!("FATAL ERROR: {} commands should have argument passed", command);
|
|
process::exit(1);
|
|
}
|
|
return match &a.argument {
|
|
Some(t) => t.clone(),
|
|
None => "".to_string(),
|
|
};
|
|
}
|
|
}
|
|
panic!("FATAL ERROR: Get argument should always return value");
|
|
}
|
|
}
|