Skip to main content

alpha2_compose/
de.rs

1//! Spec parsing that reports where in the spec an error lies.
2//!
3//! `serde_path_to_error` does not follow paths into the buffered content of tagged or
4//! untagged enums, which is where a spec's nodes are. Those enums parse by hand here: each
5//! picks its variant by tag or JSON type, parses it with its own path, and passes that path
6//! up in the error message for the level above to join.
7
8use serde::de::{DeserializeOwned, Error as _};
9use serde::{Deserialize, Deserializer};
10use serde_json::Value;
11
12use crate::spec::{
13    Canvas, EasingChoice, FrameRateChoice, Inset, Loudness, MediaItem, Node, ThemeChoice,
14    TransitionChoice,
15};
16
17/// Marks a message that carries the path below the value that failed.
18const MARK: char = '\u{0}';
19
20/// A problem and where it lies, below some value.
21pub(crate) struct Located {
22    /// `serde_path_to_error`'s form: `children[2].text`, or `.` for the value itself.
23    pub path: String,
24    pub message: String,
25}
26
27/// `inner` (a path below `outer`) joined to `outer`.
28pub(crate) fn join(outer: &str, inner: &str) -> String {
29    match (outer, inner) {
30        (".", inner) => inner.to_owned(),
31        (outer, ".") => outer.to_owned(),
32        (outer, inner) if inner.starts_with('[') => format!("{outer}{inner}"),
33        (outer, inner) => format!("{outer}.{inner}"),
34    }
35}
36
37/// Parses `value` as `T`, the path through any enum included.
38pub(crate) fn from_value<T: DeserializeOwned>(value: Value) -> Result<T, Located> {
39    serde_path_to_error::deserialize(value).map_err(|error| {
40        let outer = error.path().to_string();
41        let message = error.into_inner().to_string();
42        match message
43            .strip_prefix(MARK)
44            .and_then(|rest| rest.split_once(MARK))
45        {
46            Some((inner, message)) => Located {
47                path: join(&outer, inner),
48                message: message.to_owned(),
49            },
50            None => Located {
51                path: outer,
52                message,
53            },
54        }
55    })
56}
57
58/// A serde error carrying `located`'s path up.
59#[allow(clippy::needless_pass_by_value)]
60fn carry<E: serde::de::Error>(located: Located) -> E {
61    E::custom(format!("{MARK}{}{MARK}{}", located.path, located.message))
62}
63
64fn kind_of(value: &Value) -> &'static str {
65    match value {
66        Value::Null => "null",
67        Value::Bool(_) => "a boolean",
68        Value::Number(_) => "a number",
69        Value::String(_) => "a string",
70        Value::Array(_) => "a list",
71        Value::Object(_) => "an object",
72    }
73}
74
75fn node(mut value: Value) -> Result<Node, Located> {
76    let here = |message: String| Located {
77        path: ".".to_owned(),
78        message,
79    };
80    let Value::Object(map) = &mut value else {
81        return Err(here(format!(
82            "a node is an object with a `type`, not {}",
83            kind_of(&value)
84        )));
85    };
86    let tag = match map.remove("type") {
87        Some(Value::String(tag)) => tag,
88        Some(other) => {
89            return Err(Located {
90                path: "type".to_owned(),
91                message: format!("a node's type is a string, not {}", kind_of(&other)),
92            });
93        }
94        None => return Err(here("a node has a `type`".to_owned())),
95    };
96    match tag.as_str() {
97        "sequence" => from_value(value).map(Node::Sequence),
98        "stack" => from_value(value).map(Node::Stack),
99        "grid" => from_value(value).map(Node::Grid),
100        "media" => from_value(value).map(Node::Media),
101        "text" => from_value(value).map(Node::Text),
102        "color" => from_value(value).map(Node::Color),
103        "captions" => from_value(value).map(Node::Captions),
104        "layout" => from_value(value).map(Node::Layout),
105        "audio" => from_value(value).map(Node::Audio),
106        "raw" => from_value(value).map(Node::Raw),
107        "slideshow" => from_value(value).map(Node::Slideshow),
108        "captioned_video" => from_value(value).map(Node::CaptionedVideo),
109        "music_bed" => from_value(value).map(Node::MusicBed),
110        "counter" => from_value(value).map(Node::Counter),
111        "group" => from_value(value).map(Node::Group),
112        "shape" => from_value(value).map(Node::Shape),
113        "matte" => from_value(value).map(Node::Matte),
114        "mask" => from_value(value).map(Node::Mask),
115        "box" => from_value(value).map(Node::Box),
116        other => Err(Located {
117            path: "type".to_owned(),
118            message: format!(
119                "unknown node type \"{other}\"; the types are {}",
120                NODE_TYPES.join(", ")
121            ),
122        }),
123    }
124}
125
126/// Every node type, as specs write them.
127pub(crate) const NODE_TYPES: [&str; 26] = [
128    "sequence",
129    "stack",
130    "grid",
131    "media",
132    "text",
133    "color",
134    "captions",
135    "layout",
136    "audio",
137    "raw",
138    "slideshow",
139    "captioned_video",
140    "title",
141    "title_card",
142    "lower_third",
143    "end_card",
144    "comparison_grid",
145    "reframe",
146    "logo",
147    "music_bed",
148    "counter",
149    "group",
150    "shape",
151    "matte",
152    "mask",
153    "box",
154];
155
156impl<'de> Deserialize<'de> for Node {
157    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
158        node(Value::deserialize(deserializer)?).map_err(carry)
159    }
160}
161
162/// Parses `value` by its JSON type: a string with `string`, anything else with `other`.
163fn by_type<T, E: serde::de::Error>(
164    value: Value,
165    string: impl FnOnce(String) -> T,
166    other: impl FnOnce(Value) -> Result<T, Located>,
167) -> Result<T, E> {
168    match value {
169        Value::String(text) => Ok(string(text)),
170        value => other(value).map_err(carry),
171    }
172}
173
174fn object<T: DeserializeOwned>(value: Value, expected: &str) -> Result<T, Located> {
175    if value.is_object() {
176        from_value(value)
177    } else {
178        Err(Located {
179            path: ".".to_owned(),
180            message: format!("expected {expected}, not {}", kind_of(&value)),
181        })
182    }
183}
184
185impl<'de> Deserialize<'de> for MediaItem {
186    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
187        by_type(Value::deserialize(deserializer)?, Self::Path, |value| {
188            node(value).map(|node| Self::Node(Box::new(node)))
189        })
190    }
191}
192
193impl<'de> Deserialize<'de> for Canvas {
194    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
195        by_type(Value::deserialize(deserializer)?, Self::Preset, |value| {
196            object(value, "a preset name or a canvas object").map(Self::Custom)
197        })
198    }
199}
200
201impl<'de> Deserialize<'de> for ThemeChoice {
202    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
203        by_type(Value::deserialize(deserializer)?, Self::Named, |value| {
204            object(value, "a theme name or a theme object")
205                .map(|theme| Self::Custom(Box::new(theme)))
206        })
207    }
208}
209
210impl<'de> Deserialize<'de> for TransitionChoice {
211    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
212        by_type(Value::deserialize(deserializer)?, Self::Named, |value| {
213            object(value, "a transition name or a transition object").map(Self::Given)
214        })
215    }
216}
217
218impl<'de> Deserialize<'de> for EasingChoice {
219    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
220        by_type(Value::deserialize(deserializer)?, Self::Named, |value| {
221            object(value, "an easing name or an easing object").map(Self::Curve)
222        })
223    }
224}
225
226impl<'de> Deserialize<'de> for Loudness {
227    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
228        match Value::deserialize(deserializer)? {
229            Value::Number(number) => number
230                .as_f64()
231                .map(Self::Lufs)
232                .ok_or_else(|| D::Error::custom("the loudness is a number of LUFS")),
233            value => object(
234                value,
235                "a number of LUFS or {target_lufs, true_peak_ceiling_dbtp}",
236            )
237            .map(Self::Target)
238            .map_err(carry),
239        }
240    }
241}
242
243impl<'de> Deserialize<'de> for Inset {
244    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
245        let value = Value::deserialize(deserializer)?;
246        match &value {
247            #[allow(clippy::cast_possible_truncation)]
248            Value::Number(number) => number
249                .as_f64()
250                .map(|pixels| Self::Uniform(pixels as f32))
251                .ok_or_else(|| D::Error::custom("an inset is pixels")),
252            Value::Array(_) => from_value(value).map(Self::Sides).map_err(carry),
253            other => Err(D::Error::custom(format!(
254                "an inset is pixels, or [top, right, bottom, left] pixels, not {}",
255                kind_of(other)
256            ))),
257        }
258    }
259}
260
261impl<'de> Deserialize<'de> for FrameRateChoice {
262    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
263        match Value::deserialize(deserializer)? {
264            Value::Number(number) => number
265                .as_f64()
266                .map(Self::Number)
267                .ok_or_else(|| D::Error::custom("a frame rate is a number")),
268            value => object(value, "frames per second, or {num, den}")
269                .map(Self::Exact)
270                .map_err(carry),
271        }
272    }
273}