dotpatina 1.5.0

dotpatina is a rust application for managing system dotfiles and configuration
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

//! Miscellaneous utilities used throughout the crate

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

use enum_as_inner::EnumAsInner;

/// An enum representing all possible errors that can occur in this crate
#[allow(dead_code)]
#[derive(Debug, EnumAsInner)]
pub enum Error {
    /// A general error with a message
    Message(String),

    /// An error that occurs when a file cannot be read
    FileRead(PathBuf, std::io::Error),

    /// An error that occurs when a file cannot be written
    FileWrite(PathBuf, std::io::Error),

    /// Failed to get input from the user
    GetUserInput(std::io::Error),

    /// An error that occurs when parsing Toml data
    TomlParse(toml::de::Error),

    /// An error that occurs when rendering a handlebars template
    RenderTemplate(handlebars::RenderError),

    /// A vars object is invalid
    InvalidVars(),

    /// Failed to trash a file
    MoveFileToTrash(trash::Error),
}

/// A Result type that uses the [`Error`] enum
pub type Result<T> = std::result::Result<T, Error>;

/// Given a path, normalize it to an absolute path with cwd (`.`), home (`~`), and environment variables resolved.
pub fn normalize_path<P: AsRef<Path>>(path: P) -> Option<PathBuf> {
    let path = path.as_ref();

    // resolve home dir and environment variables
    let path = path.to_str()?;
    let path = match shellexpand::full(path) {
        Ok(path) => path.into_owned(),
        Err(_) => return None,
    };

    // clean it by resolving `.` and multiple `/`s
    let path = path_clean::clean(path);

    // get the canonical path
    match fs::canonicalize(&path) {
        Ok(path) => Some(path),
        Err(_) => Some(path),
    }
}

#[cfg(test)]
pub mod tests {
    use std::path::PathBuf;

    use super::normalize_path;

    pub fn get_home_dir() -> String {
        let home_dir = dirs::home_dir().unwrap();
        let home_dir = home_dir.to_str().unwrap();
        String::from(home_dir)
    }

    #[test]
    fn test_normalize_path() {
        let path = normalize_path(PathBuf::from("path/to/file.txt"));
        assert_eq!(PathBuf::from("path/to/file.txt"), path.unwrap());
    }

    #[test]
    fn test_normalize_path_with_dotdot() {
        let path = normalize_path(PathBuf::from("path/to/../file.txt"));
        assert_eq!(PathBuf::from("path/file.txt"), path.unwrap());
    }

    #[test]
    fn test_normalize_path_with_multiple_slashes() {
        let path = normalize_path(PathBuf::from("path/to///file.txt"));
        assert_eq!(PathBuf::from("path/to/file.txt"), path.unwrap());
    }

    #[test]
    fn test_normalize_path_home_dir() {
        let path = normalize_path(PathBuf::from("~/path/to/file.txt"));
        assert_eq!(
            PathBuf::from(format!("{}/path/to/file.txt", get_home_dir())),
            path.unwrap()
        );
    }

    #[test]
    fn test_normalize_path_with_hidden_dir() {
        let path = normalize_path(PathBuf::from("~/.dotpatina/file.txt"));
        assert_eq!(
            PathBuf::from(format!("{}/.dotpatina/file.txt", get_home_dir())),
            path.unwrap()
        );
    }
}