qcp 0.8.3

Secure remote file copy utility which uses the QUIC protocol over UDP
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

//! Error output helpers
// (c) 2024 Ross Younger

use figment::error::{Kind, OneOf};
use thiserror::Error;

/// A newtype wrapper implementing `Display` for errors originating from this module
#[derive(Debug, Error, PartialEq)]
pub struct ConfigFileError(Box<figment::Error>);

impl From<figment::Error> for ConfigFileError {
    fn from(e: figment::Error) -> Self {
        Self(Box::new(e))
    }
}
impl std::ops::Deref for ConfigFileError {
    type Target = figment::Error;

    /// Returns a reference to the inner error
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl ConfigFileError {
    fn rewrite_expected_type(s: &str) -> String {
        match s {
            "a boolean" => format!(
                "a boolean ({})",
                OneOf(&["yes", "no", "true", "false", "1", "0"])
            ),
            _ => s.to_owned(),
        }
    }

    fn fmt_kind(kind: &Kind, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match kind {
            Kind::InvalidType(v, exp) => write!(
                f,
                "invalid type: found {v}, expected {exp}",
                exp = Self::rewrite_expected_type(exp)
            ),
            Kind::UnknownVariant(v, exp) => {
                write!(f, "unknown variant: found {v}, expected {}", OneOf(exp))
            }
            _ => std::fmt::Display::fmt(&kind, f),
        }
    }
}

impl std::fmt::Display for ConfigFileError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let e = self;
        Self::fmt_kind(&e.kind, f)?;

        if let (Some(profile), Some(md)) = (&e.profile, &e.metadata)
            && !e.path.is_empty()
        {
            let key = md.interpolate(profile, &e.path);
            write!(f, " for {key}")?;
        }

        if let Some(md) = &e.metadata {
            if let Some(source) = &md.source {
                write!(f, " at {source}")?;
            } else {
                write!(f, " in {}", md.name)?;
            }
        }
        Ok(())
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod test {
    use crate::config::ssh::errors::ConfigFileError;
    use figment::error::{Actual, Kind};
    use pretty_assertions::assert_eq;

    #[test]
    fn error_invalid_type() {
        let err = ConfigFileError::from(figment::Error::from(Kind::InvalidType(
            Actual::Str("string".into()),
            "a boolean".to_string(),
        )));
        assert!(
            err.to_string()
                .contains("invalid type: found string \"string\", expected a boolean")
        );
    }
    #[test]
    fn error_unknown_variant() {
        let knowns = &["a", "b"];
        let err = ConfigFileError::from(figment::Error::from(Kind::UnknownVariant(
            "string".to_string(),
            knowns,
        )));
        assert_eq!(
            err.to_string(),
            "unknown variant: found string, expected `a` or `b`"
        );
    }
    #[test]
    fn error_unsupported() {
        let err = ConfigFileError::from(figment::Error::from(Kind::Unsupported(Actual::Str(
            "abc".into(),
        ))));
        assert_eq!(err.to_string(), "unsupported type `string \"abc\"`");
    }
}