cadir 0.1.1

This is a tool to create one or many directories. It provides recursive and multithreading modes.
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

//! # Cadir
//!
//! `cadir` is a tool to create one or many directories.
//! It provides recursive and multithreading modes.

use std::fs;
use std::path::PathBuf;
use std::thread::{self, JoinHandle};

/// # Creates directories
///
/// If you have a directory path "/a/b/c" and "b"
/// doesn't exist, use `recursively = true`
/// 
/// If you need to create a lof of dirs, set `mthread = true`
///
/// # Examples
/// ```
/// use std::path::PathBuf;
///
/// let path:PathBuf = PathBuf::from("e");
/// let path2:PathBuf = PathBuf::from("b");
/// let vec = vec![path, path2];
///
/// cadir::run(vec, false, false);
/// ```
pub fn run(directories: Vec<PathBuf>, recursively: bool, mthread: bool) {
    if mthread {
        let handles = multi_create(directories, recursively);
        for handle in handles {
            handle.join().unwrap();
        }
    } else {
        sync_create(directories, recursively);
    }
}

/// Create directories one by one in the main thread
/// 
/// If you have dir path "/a/b/c" and "b"
/// doesn't exist, use `recursively = true`
/// 
/// # Examples
/// ```
/// use std::path::PathBuf;
///
/// let path:PathBuf = PathBuf::from("e");
/// let path2:PathBuf = PathBuf::from("b");
/// let vec = vec![path, path2];
///
/// cadir::sync_create(vec, false);
/// ```
pub fn sync_create(directories: Vec<PathBuf>, recursively: bool) {
    validate(&directories, recursively);
    for dir in directories {
        create(&dir, recursively);
    }
}

/// Create directories in the multithreading mode
/// 
/// If you have dir path "/a/b/c" and "b"
/// doesn't exist, use `recursively = true`
/// 
/// # Examples
/// ```
/// use std::path::PathBuf;
///
/// let path:PathBuf = PathBuf::from("e");
/// let path2:PathBuf = PathBuf::from("b");
/// let vec = vec![path, path2];
///
/// cadir::sync_create(vec, false);
/// ```
pub fn multi_create(directories: Vec<PathBuf>, recursively: bool) -> Vec<JoinHandle<()>> {
    validate(&directories, recursively);
    let mut handles = vec![];
    for dir in directories {
        let handle = thread::spawn(move || {
            create(&dir, recursively);
        });
        handles.push(handle);
    }
    handles
}

fn validate(opt_dirs: &Vec<PathBuf>, recursively: bool) {
    let directories = opt_dirs.clone();
    let mut valid: bool = true;
    for mut dir in directories {
        if !dir.exists() {
            dir.pop();
            if !recursively && !dir.exists() && dir.iter().count() > 1 {
                println!("Use -r flag for the create dir recurvively.");
                valid = false;
                break;
            }
        } else {
            println!("This directory is already exists.");
            valid = false;
            break;
        }
    }
    if !valid {
        std::process::exit(0);
    }
}

fn create(dir: &PathBuf, recursively: bool) {
    if recursively {
        fs::create_dir_all(&dir).unwrap();
    } else {
        fs::create_dir(&dir).unwrap();
    }
}