standard_paths 2.1.0

A port of QStandardPaths class which provides methods for accessing standard paths on the local filesystem (config, cache, user directories and etc.).
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

use argparse::{ArgumentParser, Store, StoreTrue};
use std::process;

use standard_paths::*;

fn main() {
    let mut app_name = String::new();
    let mut org_name = String::new();
    let mut file = String::new();
    let mut location = String::new();
    let mut option = String::from("LocateFile");
    let mut locate_all = false;
    {
        let mut ap = ArgumentParser::new();
        ap.set_description("Example of usage of the standard_paths locate methods.");
        ap.refer(&mut app_name)
            .add_argument("app_name", Store, "name of the application")
            .required();
        ap.refer(&mut org_name)
            .add_argument("org_name", Store, "name of the organization")
            .required();
        ap.refer(&mut file)
            .add_argument("file", Store, "file name to search")
            .required();
        ap.refer(&mut location)
            .add_argument("location", Store, "type of location")
            .required();
        ap.refer(&mut option).add_option(
            &["-o", "--option"],
            Store,
            "locate option, default is 'LocateFile'",
        );
        ap.refer(&mut locate_all).add_option(
            &["-a", "--all"],
            StoreTrue,
            "locate all, default is false",
        );
        ap.parse_args_or_exit();
    }

    let location = match location.as_str() {
        "HomeLocation" => LocationType::HomeLocation,
        "DesktopLocation" => LocationType::DesktopLocation,
        "DocumentsLocation" => LocationType::DocumentsLocation,
        "DownloadLocation" => LocationType::DownloadLocation,
        "MoviesLocation" => LocationType::MoviesLocation,
        "MusicLocation" => LocationType::MusicLocation,
        "PicturesLocation" => LocationType::PicturesLocation,
        "ApplicationsLocation" => LocationType::ApplicationsLocation,
        "FontsLocation" => LocationType::FontsLocation,
        "RuntimeLocation" => LocationType::RuntimeLocation,
        "TempLocation" => LocationType::TempLocation,
        "GenericDataLocation" => LocationType::GenericDataLocation,
        "AppDataLocation" => LocationType::AppDataLocation,
        "AppLocalDataLocation" => LocationType::AppLocalDataLocation,
        "GenericCacheLocation" => LocationType::GenericCacheLocation,
        "AppCacheLocation" => LocationType::AppCacheLocation,
        "ConfigLocation" => LocationType::ConfigLocation,
        "GenericConfigLocation" => LocationType::GenericConfigLocation,
        "AppConfigLocation" => LocationType::AppConfigLocation,
        _ => {
            eprintln!("Bad location type '{location}', see the documentation for valid values");
            process::exit(1)
        }
    };

    let option = match option.as_str() {
        "LocateBoth" => LocateOption::LocateBoth,
        "LocateFile" => LocateOption::LocateFile,
        "LocateDirectory" => LocateOption::LocateDirectory,
        _ => {
            eprintln!("Bad locate option '{option}', see the documentation for valid values");
            process::exit(1)
        }
    };

    let sp = StandardPaths::new(app_name, org_name);
    if locate_all {
        match sp.locate_all(location, &file, option) {
            Ok(paths) => {
                if let Some(paths) = paths {
                    let paths = paths
                        .iter()
                        .map(|p| p.to_str().unwrap())
                        .collect::<Vec<_>>()
                        .join(r#"", ""#);
                    println!(r#""{paths}""#);
                    process::exit(0)
                }
            }
            Err(err) => {
                eprintln!("{err}");
                process::exit(2)
            }
        }
    } else {
        match sp.locate(location, &file, option) {
            Ok(path) => {
                if path.is_some() {
                    println!(r#""{}""#, path.unwrap().to_str().unwrap());
                    process::exit(0)
                }
            }
            Err(err) => {
                eprintln!("{err}");
                process::exit(2)
            }
        }
    }

    println!("No entries found for '{file}'");
}