cargo-trim 0.7.0

Binary application to cleanup $CARGO_HOME cache
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

use std::{
    fs,
    path::{Path, PathBuf},
};

// Struct for storing Directory path
pub(crate) struct DirPath {
    bin_dir: PathBuf,
    config_file: PathBuf,
    git_dir: PathBuf,
    checkout_dir: PathBuf,
    db_dir: PathBuf,
    registry_dir: PathBuf,
    cache_dir: PathBuf,
    index_dir: PathBuf,
    src_dir: PathBuf,
}

impl DirPath {
    // set directory path
    pub(crate) fn set_dir_path() -> Self {
        // set config file directory path
        let config_dir = dirs::config_dir().expect("Cannot get config directory location");
        // if config dir not exists create
        if !config_dir.exists() {
            fs::create_dir_all(&config_dir).expect("Failed to create config dir");
        }
        let config_file = config_dir.join("cargo_trim_config.toml");

        // If config file does not exists create config file
        if !config_file.exists() {
            fs::File::create(config_file.to_str().unwrap()).expect("Failed to create config file");
        }

        let home_dir = Path::new(env!("CARGO_HOME")).to_path_buf();

        // set bin directory path
        let bin_dir = home_dir.join("bin");

        // set git directory path
        let git_dir = home_dir.join("git");

        // set git dir sub folder path
        let checkout_dir = git_dir.join("checkouts");
        let db_dir = git_dir.join("db");

        // set registry dir path
        let registry_dir = home_dir.join("registry");

        // set registry dir sub folder path
        let cache_dir = registry_dir.join("cache");
        let src_dir = registry_dir.join("src");
        let index_dir = registry_dir.join("index");

        Self {
            bin_dir,
            config_file,
            git_dir,
            checkout_dir,
            db_dir,
            registry_dir,
            cache_dir,
            index_dir,
            src_dir,
        }
    }

    // return path of bin dir
    pub(crate) fn bin_dir(&self) -> &PathBuf {
        &self.bin_dir
    }

    // return path of config file
    pub(crate) fn config_file(&self) -> &PathBuf {
        &self.config_file
    }

    // return path of git dir
    pub(crate) fn git_dir(&self) -> &PathBuf {
        &self.git_dir
    }

    // return path of checkout dir
    pub(crate) fn checkout_dir(&self) -> &PathBuf {
        &self.checkout_dir
    }

    // return path of db dir
    pub(crate) fn db_dir(&self) -> &PathBuf {
        &self.db_dir
    }

    // return path of registry dir
    pub(crate) fn registry_dir(&self) -> &PathBuf {
        &self.registry_dir
    }

    // return path of cache dir
    pub(crate) fn cache_dir(&self) -> &PathBuf {
        &self.cache_dir
    }

    // return path of index dir
    pub(crate) fn index_dir(&self) -> &PathBuf {
        &self.index_dir
    }

    // return path of src dir
    pub(crate) fn src_dir(&self) -> &PathBuf {
        &self.src_dir
    }
}