artifactize-core 0.13.1

The library behind artifactize: Artifacts, evals, reviews, the monitor and review models, and the shared operations every interface calls.
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

//! Compatibility for optional fields at external JSON boundaries that historically ignored
//! a wrong type. Known values are typed; unrelated JSON is consumed, never inspected or retained.
use serde::{
    Deserialize, Deserializer,
    de::{MapAccess, SeqAccess, Visitor, value::MapAccessDeserializer},
};

/// JSON objects only: derived structs also accept positional arrays, which these wire
/// boundaries never did. Deserialize fields directly without building a generic JSON tree.
pub(crate) struct Object<T>(pub T);
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Object<T> {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        struct ObjectVisitor<T>(std::marker::PhantomData<T>);
        impl<'de, T: Deserialize<'de>> Visitor<'de> for ObjectVisitor<T> {
            type Value = Object<T>;
            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("a JSON object")
            }
            fn visit_map<M: MapAccess<'de>>(self, map: M) -> Result<Self::Value, M::Error> {
                T::deserialize(MapAccessDeserializer::new(map)).map(Object)
            }
        }
        deserializer.deserialize_map(ObjectVisitor(std::marker::PhantomData))
    }
}

/// Discard unrelated JSON without building a tree, but still validate primitives and
/// recurse through the deserializer's normal depth limit. IgnoredAny skips number range
/// validation, unlike the former Value edge; deserialize_any preserves those refusals.
pub(crate) struct Ignored;
impl<'de> Deserialize<'de> for Ignored {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        struct IgnoredVisitor;
        impl<'de> Visitor<'de> for IgnoredVisitor {
            type Value = Ignored;
            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str("a JSON value")
            }
            fn visit_bool<E>(self, _: bool) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_i64<E>(self, _: i64) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_u64<E>(self, _: u64) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_f64<E>(self, _: f64) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_str<E>(self, _: &str) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_string<E>(self, _: String) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_unit<E>(self) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_none<E>(self) -> Result<Ignored, E> {
                Ok(Ignored)
            }
            fn visit_seq<S: SeqAccess<'de>>(self, mut sequence: S) -> Result<Ignored, S::Error> {
                while sequence.next_element::<Ignored>()?.is_some() {}
                Ok(Ignored)
            }
            fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Ignored, M::Error> {
                while map.next_key::<String>()?.is_some() {
                    map.next_value::<Ignored>()?;
                }
                Ok(Ignored)
            }
        }
        deserializer.deserialize_any(IgnoredVisitor)
    }
}

pub(crate) struct Optional<T>(pub Option<T>);
impl<T> Default for Optional<T> {
    fn default() -> Self {
        Self(None)
    }
}
impl<'de, T: Deserialize<'de>> Deserialize<'de> for Optional<T> {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        #[derive(Deserialize)]
        #[serde(untagged)]
        enum Field<T> {
            Known(T),
            Ignored(Ignored),
        }
        Ok(Self(match Field::deserialize(deserializer)? {
            Field::Known(value) => Some(value),
            Field::Ignored(_) => None,
        }))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn typed_discard_rejects_number_overflow_and_excessive_nesting() {
        for input in [
            "1e400",
            "{\"unknown\":[1e400]}",
            "{\"number\":1e400,\"number\":null}",
        ] {
            assert!(serde_json::from_str::<Ignored>(input).is_err());
        }
        for input in [
            "18446744073709551616",
            "-9223372036854775809",
            "{\"unknown\":[null,true,0,1.5,\"s\"]}",
        ] {
            assert!(serde_json::from_str::<Ignored>(input).is_ok());
        }
        let deep = format!("{}null{}", "[".repeat(200), "]".repeat(200));
        assert!(serde_json::from_str::<Ignored>(&deep).is_err());
    }
}