1use 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
17const MARK: char = '\u{0}';
19
20pub(crate) struct Located {
22 pub path: String,
24 pub message: String,
25}
26
27pub(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
37pub(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#[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
126pub(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
162fn 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}