securefmt 0.1.5

Drop-in replacement for the Debug derive macro that hides fields marked as sensitive.
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#[cfg(not(feature = "debug_mode"))]
use quote::format_ident;
use syn::Field;

use crate::formatting_data::FieldFormattingData;

impl From<&Field> for FieldFormattingData {
    #[cfg(not(feature = "debug_mode"))]
    fn from(field: &Field) -> Self {
        FieldFormattingData {
            ident: field.ident.as_ref().map(|it| it.to_string()),
            sensitive: field
                .attrs
                .iter()
                .any(|it| it.path().get_ident() == Some(&format_ident!("sensitive"))),
        }
    }

    #[cfg(feature = "debug_mode")]
    fn from(field: &Field) -> Self {
        FieldFormattingData {
            ident: field.ident.as_ref().map(std::string::ToString::to_string),
            sensitive: false,
        }
    }
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;
    use quote::format_ident;
    use syn::{
        parse_str,
        token::{Bracket, Not, Pound},
        AttrStyle, Attribute, Field, FieldMutability, Meta, Path, Type, TypePath, Visibility,
    };

    use crate::formatting_data::FieldFormattingData;

    #[test]
    fn should_contain_ident_for_named_field() {
        let field_type: TypePath = parse_str("u8").expect("String is not tokens");
        let field = Field {
            attrs: vec![],
            vis: Visibility::Inherited,
            ident: Some(format_ident!("TestField")),
            colon_token: None,
            ty: Type::Path(field_type),
            mutability: FieldMutability::None,
        };

        assert_eq!(
            FieldFormattingData::from(&field),
            FieldFormattingData {
                ident: Some("TestField".to_string()),
                sensitive: false
            }
        );
    }

    #[test]
    fn should_not_contain_ident_for_unnamed_field() {
        let field_type: TypePath = parse_str("u8").expect("String is not tokens");
        let field = Field {
            attrs: vec![],
            vis: Visibility::Inherited,
            ident: None,
            colon_token: None,
            ty: Type::Path(field_type),
            mutability: FieldMutability::None,
        };

        assert_eq!(
            FieldFormattingData::from(&field),
            FieldFormattingData {
                ident: None,
                sensitive: false
            }
        );
    }

    #[test]
    fn should_be_sensitive_when_field_has_sensitive_attribute() {
        let field_type: TypePath = parse_str("u8").expect("String is not tokens");
        let sensitive = Attribute {
            pound_token: Pound::default(),
            style: AttrStyle::Inner(Not::default()),
            bracket_token: Bracket::default(),
            meta: Meta::Path(Path::from(format_ident!("sensitive"))),
        };
        let field = Field {
            attrs: vec![sensitive],
            vis: Visibility::Inherited,
            ident: None,
            colon_token: None,
            ty: Type::Path(field_type),
            mutability: FieldMutability::None,
        };

        if cfg!(feature = "debug_mode") {
            assert_eq!(
                FieldFormattingData::from(&field),
                FieldFormattingData {
                    ident: None,
                    sensitive: false
                }
            );
        } else {
            assert_eq!(
                FieldFormattingData::from(&field),
                FieldFormattingData {
                    ident: None,
                    sensitive: true
                }
            );
        }
    }
}