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

// -a or -all this should show or search all dir even hidden files this should
// be tht pretty version so breath first display 
use std::fs::{metadata,read_dir};
use std::path;


pub struct Pretty {
    pub found: Vec<String>,
    pub folders: u32,
    pub files:u32,
}

pub fn print_dirs(name: String, path:String, depth:u32) -> Pretty{
  let mut file_count:u32 = 0;
  let mut folder_count:u32 = 0;
  let mut res:Vec<String> = Vec::new();
  let directory = match read_dir(path.clone()){
      Ok(directory) => directory,
      Err(_) =>  {
      let fail = Pretty {
                  found:res,
                  folders:0,
                  files:0,
              };   
      return fail    
      } , 
   };
  // queue of folders that need printed while there is a queue of fodler
  for item in directory{ 
    // each current folder and file 
      let dir = item.unwrap();
      let meta = metadata(dir.path());
      match meta {
          Ok(place) => {
            if dir.file_name().to_str().unwrap().starts_with(".") == false{
                  let mut dash_string = String::from("  ");
                  let mut dash_file = String::from("  ");
                  for _i in 0..depth{
                    dash_string.push('|');
                    dash_string.push(' ');
                    dash_string.push(' ');
                    dash_file.push('|');
                    dash_file.push(' ');
                    dash_file.push(' ');
                    
                  } 
              if place.is_dir() {
            // print folder
            // now print each folder and file
                  folder_count = folder_count + 1;
                  println!("{}|-{}",dash_string, dir.file_name().to_str().unwrap());
                  let path_to_dir: path::PathBuf = path::PathBuf::from(dir.path().file_name().unwrap());
                  let query: path::PathBuf = path::PathBuf::from(&name);
                  if path_to_dir == query {
                      let item:String = String::from(dir.path().to_str().unwrap());
                      res.push(item)
                      }
                  }

                    //if its not a file then it pass that path to the function again
                  let buff_path = dir.path();
                  let str_path = buff_path.to_str().unwrap();
                  let string_path:String = String::from(str_path); 
                  let new_name = String::from(&name);
                  let res2 = print_dirs(new_name,string_path, depth+1);
                      for file in res2.found {
                          res.push(file)
                      }

                  folder_count = folder_count + res2.folders;
                  file_count = file_count + res2.files;
          }
        },
          Err(e) => println!("{},{} was not sure what to do here with this one" ,e, dir.path().to_str().unwrap())
      }
  }
  let res_pretty = Pretty {
      found: res,
      folders: folder_count,
      files:file_count,
  };
  res_pretty
}