uninode 0.4.2

Universal object type
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

//
// Copyright (c) 2022 Oleg Lelenkov <o.lelenkov@gmail.com>
// Distributed under terms of the BSD 3-Clause license.
//

use std::{fmt, result, error::Error};
use crate::value::UniNode;
use serde::{ser, de};
use serde::de::Unexpected;

#[derive(Debug)]
pub enum UniNodeSerError {
    KeyMustBeAString,
    Custom(String),
    MissingField(String),
    UnknownVariant(String, Vec<String>),
}

pub type Result<T> = result::Result<T, UniNodeSerError>;

struct OneOf<'a>(&'a [String]);

impl<'a> fmt::Display for OneOf<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.0.len() {
            0 => panic!(),
            1 => write!(f, "'{}'", self.0[0]),
            2 => write!(f, "'{}' or '{}'", self.0[0], self.0[1]),
            _ => {
                write!(f, "one of ")?;
                for (i, v) in self.0.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "'{}'", v)?;
                }
                Ok(())
            },
        }
    }
}

impl fmt::Display for UniNodeSerError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            UniNodeSerError::KeyMustBeAString => {
                f.write_str("key must be a string")
            },
            UniNodeSerError::Custom(msg) => f.write_str(msg),
            UniNodeSerError::MissingField(fld) => {
                write!(f, "Missing field '{}'", fld)
            },
            UniNodeSerError::UnknownVariant(v, exp) => {
                if exp.is_empty() {
                    write!(f, "Unknown variant '{}'", v)
                } else {
                    let one = OneOf(exp.as_slice());
                    write!(f, "Unknown variant '{}', expected {}", v, one)
                }
            },
        }
    }
}

impl Error for UniNodeSerError {}

impl ser::Error for UniNodeSerError {
    fn custom<T: fmt::Display>(msg: T) -> Self {
        UniNodeSerError::Custom(msg.to_string())
    }
}

impl de::Error for UniNodeSerError {
    fn custom<T: fmt::Display>(msg: T) -> Self {
        UniNodeSerError::Custom(msg.to_string())
    }

    fn missing_field(field: &'static str) -> Self {
        UniNodeSerError::MissingField(String::from(field))
    }

    fn unknown_variant(
        variant: &str, expected: &'static [&'static str],
    ) -> Self {
        let expected = expected.iter().map(|&v| String::from(v)).collect();
        UniNodeSerError::UnknownVariant(String::from(variant), expected)
    }
}

impl UniNode {
    pub fn invalid_type(&self, exp: &dyn de::Expected) -> UniNodeSerError {
        <UniNodeSerError as serde::de::Error>::invalid_type(self.into(), exp)
    }
}

impl<'a> From<&'a UniNode> for Unexpected<'a> {
    fn from(val: &'a UniNode) -> Unexpected<'a> {
        match val {
            UniNode::Null => Unexpected::Unit,
            UniNode::Boolean(val) => Unexpected::Bool(*val),
            UniNode::Integer(val) => Unexpected::Signed(*val),
            UniNode::UInteger(val) => Unexpected::Unsigned(*val),
            UniNode::Float(val) => Unexpected::Float(*val),
            UniNode::String(val) => Unexpected::Str(val),
            UniNode::Bytes(val) => {
                Unexpected::Bytes(&val[0..val.len().min(10)])
            },
            UniNode::Array(_) => Unexpected::Seq,
            UniNode::Object(_) => Unexpected::Map,
        }
    }
}