riptree 0.3.8

Displays and searches through directories
Documentation 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

use std::{env, usize};


mod flag;
mod print_tree_all;
mod print_tree;
mod print_dirs;
mod print_full_path;
mod print_ignore_pattern;
mod print_prune;
mod print_file_n_limit;
pub struct Config {
    pub path:String,
    pub query:String, 
    pub flag:Vec<String>,
}


impl Config {
    // handle all command line interface in build pass a to recursice func type config
    pub fn build(mut args: impl Iterator<Item = String> ) -> Result<Config, &'static str> {
        args.next();
       // gets the local directory path in case the user does not give a path
        let local_dir = match env::current_dir(){
            Ok(l_path) => l_path,
            Err(_e) => return Err("problem getting current directory {e}" ),
       };
       let mut user_path:String = String::from(local_dir.to_str().unwrap());
       // next arg is either a path or a flag could be nothing if nothing return local path
       let arg_one = match args.next(){
            Some(path)=>path,
            None => String::from(local_dir.to_str().unwrap()),
       };
       
       if arg_one.starts_with("--help"){
            // ref &str is better to pass here
            let msg = flag::help(arg_one.clone());
            println!("{}", msg);
            std::process::exit(1); 
       }
       let mut flags:Vec<String> = Vec::new();
       // check to see if a path wnew_dir);iven and if not was it a query?? 
       let mut query:String = String::new();
       //string_path_id should me more thourogh. Most likely a fn that returns a bool.
       let string_path_id = "/";
           if arg_one.contains(string_path_id){
                user_path = arg_one.clone();
           }else if arg_one.len() > 0 && arg_one.starts_with("-") == false {
                query = arg_one.clone();
           }else {
                flags.push(arg_one);
           }
       
       // check for a string that doesnt start with a '-' that will be out query
       let args_after_two:Vec<String> = args.collect();
          for arg in args_after_two {
              if arg.starts_with("--help"){
                  let msg = flag::help(String::from(&arg));
                  println!("{}", msg);
              }else if arg.starts_with("-"){
                    let msg = flag::help(String::from(&arg));
                    println!("{}",msg);
                    flags.push(arg)
              }else {
                 query = String::from(&arg);
              }
       } 
       Ok(Config{
           path:user_path,
           query:query,
           flag:flags,
       })
    }
}


// handle arg length and finalize funcionality
pub fn run(config:Result<Config, &'static str>){ 
    let config = match config {
        Ok(config) => config,
        _ =>  Config{
                    path:String::from("/"),
                    query:String::from(""),
                    flag:Vec::new(),
                    } 
    };
    if config.flag.len() > 1 {
        // logic for multiple flags
        if config.flag[0] == String::from("-v") && config.flag[1] == String::from("-f"){
                println!("can not fast search and be verbose, flag combo is not supporeted, remove -f flag");
        } else if config.flag[0] == String::from("-f") && config.flag[1] == String::from("-v"){
                println!("can not fast search and be verbose, flag combo is not supporeted, remove -f flag");
        } else if config.flag[0] == String::from("-v") && config.flag[1] == String::from("-l") {
                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_tree::print_tree(config.query,config.path,0);
                            println!(" folders {}, files {} ", res.folders, res.files);
                        if res.found.len() > 0 {
                            println!("  '{}' was found in the following paths:", user_query);
                            for item in res.found {
                                println!("       {}", item);
                                }
                        }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query) 
                                }
        } else if config.flag[0] == String::from("-l") && config.flag[1] == String::from("-v") {
                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_tree::print_tree(config.query,config.path,0);
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query)
                            }
        } else if config.flag[0] == String::from("-l") && config.flag[1] == String::from("-f") && config.query != String::from(""){

                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_tree::print_tree(config.query, config.path,0);      
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query)
                            }
        } else if config.flag[0] == String::from("-f") && config.flag[1] == String::from("-l") && config.query != String::from(""){
                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_tree::print_tree(config.query, config.path,0);      
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query)
                            }
        }else{
            println!("did not recognize flag options {}, {}", config.flag[0], config.flag[1]);        
            }
     }else if config.flag.len() == 1 {
        // logic a singal flag passed. Also if statement hell what idiot wrote this... 
         if config.flag[0] == String::from("-a") {
                        let user_query:String = String::from(&config.query); 
                            println!("{} ", &config.path);
                        let res: print_tree_all::Pretty = print_tree_all::recursive_print_all(config.query, config.path,0);      
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query)
                            }
         } else if config.flag[0] == String::from("-d"){ 
                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_dirs::print_dirs(config.query, config.path,0);      
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!(" No file or Directory with the name » '{}'", user_query)
                            }
         } else if config.flag[0] == String::from("-f") { 
            let user_query:String = String::from(&config.query); 
            let res = print_full_path::print_full_path(config.query,config.path,0);
                println!(" folders {}, files {} ", res.folders, res.files);
            if res.found.len() > 0 {
                println!("  '{}' was found in the following paths:", user_query);
                    for item in res.found {
                        println!("       {}", item);
                    }
                }else if user_query != ""{
                    println!(" No file or Directory with the name » '{}'", user_query) 
                }
         }  else if config.flag[0] == String::from("-l") { 
            let user_query:String = String::from(&config.query); 
            let res = print_ignore_pattern::print_ignore_pattern(config.query,config.path,0);
                println!(" folders {}, files {} ", res.folders, res.files);
            if res.found.len() > 0 {
                println!("  '{}' was found in the following paths:", user_query);
                    for item in res.found {
                        println!("       {}", item);
                    }
                }else if user_query != "" && config.flag[0] != "-l"{
                    println!(" No file or Directory with the name » '{}'", user_query) 
                }
         }  else if config.flag[0] == String::from("-p") {
                        let user_query:String = String::from(&config.query); 
                            println!("{}", &config.path);
                        let res = print_prune::print_prune(config.query, config.path,0);      
                            println!(" folders {}, files {} ", res.folders, res.files);
                            if res.found.len() > 0 {
                                println!("  '{}' was found in the following paths:", user_query);
                                for item in res.found {
                                    println!("       {}", item);
                                    }
                            }else if user_query != ""{
                                println!("pruned » '{}'", user_query)
                            }else if user_query == "" {
                                println!("...you didn't give me anything to prune...")
                            }
         }  else if config.flag[0] == String::from("--filelimit") || config.flag[0] == String::from("-filelimit") {
                        println!("{}", config.path);
                       let mut n:usize= 0;
                       let parsed: Result<usize, _> = config.query.parse();
                       match parsed {
                        Ok(num)=> {n = num;}
                        Err(e)=> {
                            println!(" You did not specify a limit so I got this error:\n '{}'",e);
                            println!("  `riptree --filelimit 3`");
                       }}
                        let res = print_file_n_limit::print_file_n_limit(config.query, config.path,0,n);
                            println!(" folders {}, files {} ", res.folders, res.files);
         }
     }else
     if config.flag.len() == 0 {
        let user_query:String = String::from(&config.query); 
        let res = print_tree::print_tree(config.query,config.path,0);
            println!(" folders {}, files {} ", res.folders, res.files);
        if res.found.len() > 0 {
            println!("  '{}' was found in the following paths:", user_query);
            for item in res.found {
                println!("       {}", item);
            }
        }else if user_query != ""{
            println!(" No file or Directory with the name » '{}'", user_query) 
        }
     }
}