dotune 0.1.0

A cross-platform dotfile manager configured with Lua
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use core::borrow::Borrow;
use core::ops::Deref;
use std::ffi::OsStr;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
use std::{fs, io};

/// An absolute normalized path. Gives guarantee only about the string -
/// symlinks and existence is checked elsewhere
#[repr(transparent)]
#[derive(Debug)]
pub struct AbsolutePath(Path);

impl AbsolutePath {
    pub fn new(path: &Path) -> Option<&Self> {
        (path.is_absolute()
            && path.components().all(|component| {
                matches!(
                    component,
                    Component::Prefix(_) | Component::RootDir | Component::Normal(_)
                )
            }))
        .then(|| Self::from_path(path))
    }

    pub fn parent(&self) -> Option<&Self> {
        self.0.parent().map(Self::from_path)
    }

    pub fn join(&self, path: impl AsRef<Path>) -> AbsolutePathBuf {
        let mut buf = self.to_owned();
        buf.push(path);
        buf
    }

    pub fn with_file_name(&self, file_name: impl AsRef<OsStr>) -> AbsolutePathBuf {
        AbsolutePathBuf(self.0.with_file_name(file_name))
    }

    pub fn with_extension(&self, extension: impl AsRef<OsStr>) -> AbsolutePathBuf {
        AbsolutePathBuf(self.0.with_extension(extension))
    }

    fn from_path(path: &Path) -> &Self {
        // SAFETY: same as for Path in PathBuf in std, valid as long as layout of Self
        // and Path are same. Keep repr(transparent) for that to be true
        unsafe { &*(path as *const Path as *const Self) }
    }
}

impl Deref for AbsolutePath {
    type Target = Path;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl ToOwned for AbsolutePath {
    type Owned = AbsolutePathBuf;

    fn to_owned(&self) -> Self::Owned {
        AbsolutePathBuf(self.0.to_owned())
    }
}

impl AsRef<Path> for AbsolutePath {
    fn as_ref(&self) -> &Path {
        &self.0
    }
}

impl AsRef<AbsolutePath> for AbsolutePath {
    fn as_ref(&self) -> &AbsolutePath {
        self
    }
}

impl From<&AbsolutePath> for Arc<AbsolutePath> {
    fn from(path: &AbsolutePath) -> Self {
        let path: Arc<Path> = Arc::from(&path.0);
        let ptr = Arc::into_raw(path) as *const AbsolutePath;
        unsafe { Arc::from_raw(ptr) }
    }
}

/// Owned version of [`AbsolutePath`]
#[derive(Clone, Debug)]
pub struct AbsolutePathBuf(PathBuf);

impl AbsolutePathBuf {
    pub fn new(path: PathBuf) -> Option<Self> {
        AbsolutePath::new(&path)?;
        Some(Self(path))
    }

    pub fn canonicalize(path: impl AsRef<Path>) -> io::Result<Self> {
        let canonical_path = fs::canonicalize(path)?;
        Ok(Self::new(canonical_path)
            .expect("canonicalize always returns an absolute path without indirection"))
    }

    pub fn push(&mut self, path: impl AsRef<Path>) {
        for component in path.as_ref().components() {
            match component {
                Component::Prefix(_) | Component::RootDir | Component::Normal(_) => {
                    self.0.push(component);
                }
                Component::CurDir => {}
                Component::ParentDir => {
                    self.0.pop();
                }
            }
        }
    }
}

impl Deref for AbsolutePathBuf {
    type Target = AbsolutePath;

    fn deref(&self) -> &Self::Target {
        AbsolutePath::from_path(&self.0)
    }
}

impl Borrow<AbsolutePath> for AbsolutePathBuf {
    fn borrow(&self) -> &AbsolutePath {
        self.deref()
    }
}

impl<T> AsRef<T> for AbsolutePathBuf
where
    T: ?Sized,
    <AbsolutePathBuf as Deref>::Target: AsRef<T>,
{
    fn as_ref(&self) -> &T {
        self.deref().as_ref()
    }
}

impl From<AbsolutePathBuf> for PathBuf {
    fn from(path: AbsolutePathBuf) -> Self {
        path.0
    }
}

impl From<AbsolutePathBuf> for Arc<AbsolutePath> {
    fn from(path: AbsolutePathBuf) -> Self {
        Self::from(path.deref())
    }
}

impl mlua::FromLua for AbsolutePathBuf {
    fn from_lua(value: mlua::Value, lua: &mlua::Lua) -> mlua::Result<Self> {
        let path = PathBuf::from_lua(value, lua)?;
        AbsolutePathBuf::new(path).ok_or_else(|| mlua::Error::external("lua path is not absolute"))
    }
}

impl mlua::IntoLua for AbsolutePathBuf {
    fn into_lua(self, lua: &mlua::Lua) -> mlua::Result<mlua::Value> {
        self.0.into_lua(lua)
    }
}