rsql_formatters 0.19.3

rsql formatters to output rsql results in various formats
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

pub type Result<T, E = Error> = core::result::Result<T, E>;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// IO error
    #[error(transparent)]
    IoError(anyhow::Error),
    /// Error when parsing an integer
    #[error(transparent)]
    TryFromIntError(#[from] std::num::TryFromIntError),
    /// Error an unknown format is specified
    #[error("unknown format [{format}]")]
    UnknownFormat { format: String },
}

#[cfg(any(
    feature = "ascii",
    feature = "markdown",
    feature = "plain",
    feature = "psql",
    feature = "unicode"
))]
/// Converts a [`csv::Error`] into an [`IoError`](Error::IoError)
impl From<csv::Error> for Error {
    fn from(error: csv::Error) -> Self {
        Error::IoError(error.into())
    }
}

#[cfg(any(feature = "html", feature = "xml"))]
/// Converts a [`quick_xml::Error`] into an [`IoError`](Error::IoError)
impl From<quick_xml::Error> for Error {
    fn from(error: quick_xml::Error) -> Self {
        Error::IoError(error.into())
    }
}

#[cfg(any(feature = "json", feature = "jsonl"))]
/// Converts a [`serde_json::Error`] into an [`IoError`](Error::IoError)
impl From<serde_json::Error> for Error {
    fn from(error: serde_json::Error) -> Self {
        Error::IoError(error.into())
    }
}

#[cfg(feature = "yaml")]
/// Converts a [`serde_yaml::Error`] into an [`IoError`](Error::IoError)
impl From<serde_yaml::Error> for Error {
    fn from(error: serde_yaml::Error) -> Self {
        Error::IoError(error.into())
    }
}

/// Converts a [`std::io::Error`] into an [`IoError`](Error::IoError)
impl From<std::io::Error> for Error {
    fn from(error: std::io::Error) -> Self {
        Error::IoError(error.into())
    }
}

/// Convert [`utf8 errors`](std::string::FromUtf8Error) to [`IoError`](Error::IoError)
impl From<std::string::FromUtf8Error> for Error {
    fn from(error: std::string::FromUtf8Error) -> Self {
        Error::IoError(error.into())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use quick_xml::Error::IllFormed;
    use quick_xml::errors::IllFormedError::UnmatchedEndTag;
    use test_log::test;

    #[cfg(any(
        feature = "ascii",
        feature = "markdown",
        feature = "plain",
        feature = "psql",
        feature = "unicode"
    ))]
    #[test]
    fn test_csv_error() {
        let std_io_error = std::io::Error::other("test");
        let csv_error = csv::Error::from(std_io_error);
        let io_error = Error::from(csv_error);
        assert_eq!(io_error.to_string(), "test");
    }

    #[cfg(any(feature = "html", feature = "xml"))]
    #[test]
    fn test_quick_xml_error() {
        let error = IllFormed(UnmatchedEndTag("test".to_string()));
        let io_error = Error::from(error);
        assert_eq!(
            io_error.to_string(),
            "ill-formed document: close tag `</test>` does not match any open tag"
        );
    }

    #[cfg(any(feature = "json", feature = "jsonl"))]
    #[test]
    fn test_serde_json_error() {
        let serde_json_error = serde_json::from_str::<String>(">").unwrap_err();
        let io_error = Error::from(serde_json_error);
        assert_eq!(io_error.to_string(), "expected value at line 1 column 1");
    }

    #[cfg(feature = "yaml")]
    #[test]
    fn test_serde_yaml_error() {
        let serde_yaml_error = serde_yaml::from_str::<String>(">\n@").unwrap_err();
        let io_error = Error::from(serde_yaml_error);
        assert_eq!(
            io_error.to_string(),
            "found character that cannot start any token at line 2 column 1, while scanning for the next token"
        );
    }

    #[test]
    fn test_std_io_error() {
        let error = std::io::Error::other("test");
        let io_error = Error::from(error);
        assert_eq!(io_error.to_string(), "test");
    }

    #[test]
    fn test_from_utf8_error() {
        let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
        let utf8_error = String::from_utf8(invalid_utf8).unwrap_err();
        let error = Error::from(utf8_error);
        assert_eq!(
            error.to_string(),
            "invalid utf-8 sequence of 1 bytes from index 1"
        );
    }
}