zenops 0.11.0

Declarative system configuration management for shell config and dotfiles.
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

use std::fmt;

use serde::de;

use zenops_safe_relative_path::{SafeRelativePath, SafeRelativePathBuf};

/// Represents a relative path that cannot leave its parent directory,
/// unless there is filesystem shenanigans (e.g. symlinks).
#[derive(Clone, Debug)]
pub(super) struct StoredRelativePath {
    /// The original path, as written in the config, for display and serialization purposes
    org: String,
    /// The normalized path
    normal: SafeRelativePathBuf,
}

impl StoredRelativePath {
    /// Returns the unique part to use when implementing traits
    /// NOTE: self.normal is generated from self.org and can't be otherwise modified, so no need to include it
    const fn unique_part(&self) -> &String {
        &self.org
    }
}

impl PartialEq for StoredRelativePath {
    fn eq(&self, other: &Self) -> bool {
        self.unique_part() == other.unique_part()
    }
}

impl Eq for StoredRelativePath {}

impl std::hash::Hash for StoredRelativePath {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.unique_part().hash(state);
    }
}

impl fmt::Display for StoredRelativePath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.org, f)
    }
}

impl std::ops::Deref for StoredRelativePath {
    type Target = SafeRelativePath;

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

impl AsRef<SafeRelativePath> for StoredRelativePath {
    fn as_ref(&self) -> &SafeRelativePath {
        self.normal.as_ref()
    }
}

impl schemars::JsonSchema for StoredRelativePath {
    fn schema_name() -> std::borrow::Cow<'static, str> {
        "StoredRelativePath".into()
    }

    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
        schemars::json_schema!({
            "type": "string",
            "description": "Relative path under the zenops config repo; normalized after parse, `..` traversal rejected.",
        })
    }
}

impl<'de> de::Deserialize<'de> for StoredRelativePath {
    fn deserialize<D: de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        struct Visitor;

        impl<'de> de::Visitor<'de> for Visitor {
            type Value = StoredRelativePath;

            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(f, "version string")
            }

            fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
                Ok(StoredRelativePath {
                    org: v.to_string(),
                    normal: SafeRelativePath::from_relative_path(v)
                        .map_err(de::Error::custom)?
                        .normalize_safe(),
                })
            }
        }

        d.deserialize_any(Visitor)
    }
}