nedots 0.1.3

A tool to manage configuration files/(ne)dots.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::errors::Error;
use anyhow::Context;
use std::path::{Path, PathBuf};

pub(crate) trait ResolvePath {
    fn resolve_path(&self) -> anyhow::Result<PathBuf>;
}

impl ResolvePath for Path {
    fn resolve_path(&self) -> anyhow::Result<PathBuf> {
        self.to_path_buf().resolve_path()
    }
}

impl ResolvePath for PathBuf {
    fn resolve_path(&self) -> anyhow::Result<PathBuf> {
        if !&self.exists() {
            let path = Path::new(env!("HOME")).join(self);
            return path
                .canonicalize()
                .with_context(|| format!("Failed to canonicalize {}", path.display()));
        }

        Ok(self.to_path_buf())
    }
}

pub(crate) trait StripPrefix {
    fn strip_prefix(&self, prefix: &str) -> anyhow::Result<PathBuf>;
}

impl StripPrefix for PathBuf {
    fn strip_prefix(&self, prefix: &str) -> anyhow::Result<PathBuf> {
        match Path::strip_prefix(self, prefix) {
            Ok(path) => Ok(path.to_path_buf()),
            Err(err) => {
                let err = Error::StripPrefix {
                    prefix: String::from("/"),
                    path: self.display().to_string(),
                    err,
                };
                Err(err.into())
            }
        }
    }
}

impl StripPrefix for Path {
    fn strip_prefix(&self, prefix: &str) -> anyhow::Result<PathBuf> {
        self.to_path_buf().strip_prefix(prefix)
    }
}

pub(crate) trait MakeDirs {
    fn make_all_dirs(&self) -> anyhow::Result<()>;
}

impl MakeDirs for Path {
    fn make_all_dirs(&self) -> anyhow::Result<()> {
        match std::fs::create_dir_all(self) {
            Ok(_) => Ok(()),
            Err(err) => {
                let err = Error::MakeDir {
                    path: self.display().to_string(),
                    err,
                };
                Err(err.into())
            }
        }
    }
}

impl MakeDirs for PathBuf {
    fn make_all_dirs(&self) -> anyhow::Result<()> {
        self.as_path().make_all_dirs()
    }
}

pub(crate) trait RemoveDirs {
    fn remove_all_dirs(&self) -> anyhow::Result<()>;
}

impl RemoveDirs for Path {
    fn remove_all_dirs(&self) -> anyhow::Result<()> {
        match std::fs::remove_dir_all(self) {
            Ok(_) => Ok(()),
            Err(err) => {
                let err = Error::RemoveDir {
                    path: self.display().to_string(),
                    err,
                };
                Err(err.into())
            }
        }
    }
}

impl RemoveDirs for PathBuf {
    fn remove_all_dirs(&self) -> anyhow::Result<()> {
        self.as_path().remove_all_dirs()
    }
}

pub(crate) trait Metadata {
    fn get_metadata(&self) -> anyhow::Result<std::fs::Metadata>;
    fn get_modified(&self) -> anyhow::Result<std::time::SystemTime>;
}

impl Metadata for Path {
    fn get_metadata(&self) -> anyhow::Result<std::fs::Metadata> {
        match self.metadata() {
            Ok(metadata) => Ok(metadata),
            Err(_) => {
                let err = Error::Metadata(self.display().to_string());
                Err(err.into())
            }
        }
    }

    fn get_modified(&self) -> anyhow::Result<std::time::SystemTime> {
        match self.get_metadata()?.modified() {
            Ok(modified) => Ok(modified),
            Err(_) => {
                let err = Error::ModifiedTime(self.display().to_string());
                Err(err.into())
            }
        }
    }
}

impl Metadata for PathBuf {
    fn get_metadata(&self) -> anyhow::Result<std::fs::Metadata> {
        self.as_path().get_metadata()
    }

    fn get_modified(&self) -> anyhow::Result<std::time::SystemTime> {
        self.as_path().get_modified()
    }
}

#[cfg(test)]
mod tests {}