search 1.1.0

A recursive search tool to locate files or find certain strings in files
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use clap::{
    Args,
    Parser,
    Subcommand,
};

use crate::model::config::{Config, SearchType};
use crate::util::cli_feedback::setup_progress_indication;
use crate::util::letter::get_drive_letter;

#[derive(Debug, Parser)]
#[clap(author, version, about)]
pub struct SearchArgs {
    #[clap(subcommand)]
    pub entity_type: EntityType
}

impl SearchArgs {
    pub fn convert_to_config(&self) -> Config {
        let mut config = Config::default();
        let d_letters = get_drive_letter();

        match &self.entity_type {
            EntityType::Locate(locate_command) => {
                config.search_type = SearchType::LocateFile;
                config.query = locate_command.filename.clone();

                match &locate_command.command {
                    None => config.dirs = d_letters,
                    Some(val) => match val {
                        LocateSubcommand::Dir(dir_command) => config.dirs = vec![dir_command.dir.clone()],
                        LocateSubcommand::All => config.dirs = d_letters
                    }
                }
            }
            EntityType::Find(find_command) => {
                config.search_type = SearchType::FindString;
                config.query = find_command.search_query.clone();

                match &find_command.command {
                    None => config.dirs = d_letters,
                    Some(val) => match val {
                        FindSubcommand::Dir(dir_command) => config.dirs = vec![dir_command.dir.clone()],
                        FindSubcommand::All => config.dirs = d_letters
                    }
                }
            }
        }

        config.progress_bar = Some(setup_progress_indication(format!("Searching for {}", config.query)));

        config
    }
}

#[derive(Debug, Subcommand)]
pub enum EntityType {
    /// Locate a file on your computer
    Locate(LocateCommand),
    /// Find a string in a file
    Find(FindCommand),
}

#[derive(Debug, Args)]
pub struct LocateCommand {
    /// Enter the file name that should be located
    pub filename: String,
    #[clap(subcommand)]
    /// The default search range is your whole computer. Use this arg to specify a directory if required
    pub command: Option<LocateSubcommand>
}

#[derive(Debug, Subcommand)]
pub enum LocateSubcommand {
    /// Search in a specified directory
    Dir(SelectDirCommand),
    /// Search your whole computer (it takes long)
    All
}

#[derive(Debug, Args)]
pub struct SelectDirCommand {
    pub dir: String,
}

#[derive(Debug, Args)]
pub struct FindCommand {
    /// Enter the string that should be searched
    pub search_query: String,
    #[clap(subcommand)]
    /// The default search range is your whole computer. Use this arg to specify a directory if required
    pub command: Option<FindSubcommand>,
}

#[derive(Debug, Subcommand)]
pub enum FindSubcommand {
    /// Search in a specified directory
    Dir(SelectDirCommand),
    /// Search your whole computer (it takes very (very) long)
    All,
}