locket 0.17.3

Helper tool for secret injection as a process dependency
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

//! Defines the Bitwarden Secrets (BWS) reference type and its parsing logic.
use super::{Extract, ReferenceParseError, ReferenceSyntax, SecretReference};
use std::str::FromStr;
use uuid::Uuid;

/// Represents a syntactically valid Bitwarden Secrets Manager secret reference.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct BwsReference(Uuid);

impl From<BwsReference> for SecretReference {
    fn from(r: BwsReference) -> Self {
        Self::Bws(r)
    }
}

impl ReferenceSyntax for BwsReference {
    fn try_parse(raw: &str) -> Option<Self> {
        Self::from_str(raw).ok()
    }
}

impl Extract for BwsReference {
    fn extract(r: &SecretReference) -> Option<&Self> {
        #[allow(unreachable_patterns)]
        match r {
            SecretReference::Bws(inner) => Some(inner),
            _ => None,
        }
    }
}

impl FromStr for BwsReference {
    type Err = ReferenceParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let uuid = Uuid::parse_str(s)?;
        Ok(BwsReference(uuid))
    }
}

impl std::fmt::Display for BwsReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl From<Uuid> for BwsReference {
    fn from(u: Uuid) -> Self {
        BwsReference(u)
    }
}

impl From<BwsReference> for Uuid {
    fn from(bws: BwsReference) -> Self {
        bws.0
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_bws() {
        let raw = "3832b656-a93b-45ad-bdfa-b267016802c3";
        let r = SecretReference::from_str(raw).unwrap();
        match r {
            SecretReference::Bws(u) => assert_eq!(u.to_string(), raw),
            _ => panic!("wrong type"),
        }
    }
}