shiplog-redact 0.6.0

Deterministic profile-based redaction engine for shiplog events and workstreams.
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
96
97
98
99
100
101
102
103

//! Redaction profile parsing for shiplog projections.

use core::convert::Infallible;
use core::fmt;
use core::str::FromStr;
use serde::{Deserialize, Serialize};

/// Rendering profiles.
///
/// The tool produces multiple projections from the same ledger.
/// Think of them as lenses, not forks.
#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum RedactionProfile {
    Internal,
    Manager,
    #[default]
    Public,
}

impl RedactionProfile {
    pub fn as_str(&self) -> &'static str {
        match self {
            RedactionProfile::Internal => "internal",
            RedactionProfile::Manager => "manager",
            RedactionProfile::Public => "public",
        }
    }

    /// Parse profile string, defaulting unknown values to `Public`.
    pub fn from_profile_str(profile: &str) -> Self {
        match profile {
            "internal" => RedactionProfile::Internal,
            "manager" => RedactionProfile::Manager,
            _ => RedactionProfile::Public,
        }
    }
}

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

impl FromStr for RedactionProfile {
    type Err = Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Self::from_profile_str(s))
    }
}

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

    #[test]
    fn as_str_returns_expected_values() {
        assert_eq!(RedactionProfile::Internal.as_str(), "internal");
        assert_eq!(RedactionProfile::Manager.as_str(), "manager");
        assert_eq!(RedactionProfile::Public.as_str(), "public");
    }

    #[test]
    fn parser_handles_known_values() {
        assert_eq!(
            RedactionProfile::from_profile_str("internal"),
            RedactionProfile::Internal
        );
        assert_eq!(
            RedactionProfile::from_profile_str("manager"),
            RedactionProfile::Manager
        );
        assert_eq!(
            RedactionProfile::from_profile_str("public"),
            RedactionProfile::Public
        );
    }

    #[test]
    fn parser_defaults_unknown_to_public() {
        assert_eq!(
            RedactionProfile::from_profile_str("unexpected"),
            RedactionProfile::Public
        );
        assert_eq!(
            RedactionProfile::from_profile_str(""),
            RedactionProfile::Public
        );
    }

    #[test]
    fn default_is_public() {
        assert_eq!(RedactionProfile::default(), RedactionProfile::Public);
    }

    #[test]
    fn from_str_and_display_are_canonical() {
        let parsed: RedactionProfile = "manager".parse().expect("infallible parser");
        assert_eq!(parsed, RedactionProfile::Manager);
        assert_eq!(parsed.to_string(), "manager");
    }
}