|
14 | 14 | //! `serde_json::from_slice`, so unused fields are skipped instead of being |
15 | 15 | //! materialized into an intermediate `Value` tree. |
16 | 16 |
|
17 | | -use serde::{Deserialize, Deserializer, de::DeserializeOwned}; |
| 17 | +use std::{fmt, marker::PhantomData}; |
| 18 | + |
| 19 | +use serde::{ |
| 20 | + Deserialize, Deserializer, |
| 21 | + de::{ |
| 22 | + self, DeserializeOwned, IgnoredAny, MapAccess, SeqAccess, Visitor, |
| 23 | + value::MapAccessDeserializer, |
| 24 | + }, |
| 25 | +}; |
18 | 26 |
|
19 | 27 | use ccusage_core::fast::{LinePrefilter, byte_lines}; |
20 | 28 |
|
@@ -201,13 +209,159 @@ where |
201 | 209 | Ok(ccusage_core::non_empty_json_string(value.as_ref())) |
202 | 210 | } |
203 | 211 |
|
| 212 | +macro_rules! skip_scalars { |
| 213 | + ($empty:expr) => { |
| 214 | + fn visit_bool<E: de::Error>(self, _: bool) -> Result<Self::Value, E> { |
| 215 | + Ok($empty) |
| 216 | + } |
| 217 | + fn visit_i64<E: de::Error>(self, _: i64) -> Result<Self::Value, E> { |
| 218 | + Ok($empty) |
| 219 | + } |
| 220 | + fn visit_u64<E: de::Error>(self, _: u64) -> Result<Self::Value, E> { |
| 221 | + Ok($empty) |
| 222 | + } |
| 223 | + fn visit_f64<E: de::Error>(self, _: f64) -> Result<Self::Value, E> { |
| 224 | + Ok($empty) |
| 225 | + } |
| 226 | + fn visit_unit<E: de::Error>(self) -> Result<Self::Value, E> { |
| 227 | + Ok($empty) |
| 228 | + } |
| 229 | + }; |
| 230 | +} |
| 231 | + |
| 232 | +/// A JSON object read as `T`, or `None` for any other value, which is skipped |
| 233 | +/// without being built, unlike [`lenient_object`]. A failure inside the object |
| 234 | +/// cannot be recovered, so every field of `T` must be lenient too, such as |
| 235 | +/// [`LenientObject`], [`LenientString`], or [`LenientSeq`] with |
| 236 | +/// `#[serde(default)]`. |
| 237 | +pub struct LenientObject<T>(pub Option<T>); |
| 238 | + |
| 239 | +impl<T> Default for LenientObject<T> { |
| 240 | + fn default() -> Self { |
| 241 | + Self(None) |
| 242 | + } |
| 243 | +} |
| 244 | + |
| 245 | +impl<'de, T: Deserialize<'de>> Deserialize<'de> for LenientObject<T> { |
| 246 | + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| 247 | + struct ObjectVisitor<T>(PhantomData<T>); |
| 248 | + |
| 249 | + impl<'de, T: Deserialize<'de>> Visitor<'de> for ObjectVisitor<T> { |
| 250 | + type Value = LenientObject<T>; |
| 251 | + |
| 252 | + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 253 | + formatter.write_str("any JSON value") |
| 254 | + } |
| 255 | + |
| 256 | + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { |
| 257 | + T::deserialize(MapAccessDeserializer::new(map)) |
| 258 | + .map(|value| LenientObject(Some(value))) |
| 259 | + } |
| 260 | + |
| 261 | + fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> { |
| 262 | + IgnoredAny.visit_seq(seq).map(|_| LenientObject(None)) |
| 263 | + } |
| 264 | + |
| 265 | + fn visit_str<E: de::Error>(self, _: &str) -> Result<Self::Value, E> { |
| 266 | + Ok(LenientObject(None)) |
| 267 | + } |
| 268 | + |
| 269 | + skip_scalars!(LenientObject(None)); |
| 270 | + } |
| 271 | + |
| 272 | + deserializer.deserialize_any(ObjectVisitor(PhantomData)) |
| 273 | + } |
| 274 | +} |
| 275 | + |
| 276 | +/// A JSON string, or `None` for any other value, which is skipped without |
| 277 | +/// being built. Never fails, so it is safe inside a [`LenientObject`]. |
| 278 | +#[derive(Default)] |
| 279 | +pub struct LenientString(pub Option<String>); |
| 280 | + |
| 281 | +impl<'de> Deserialize<'de> for LenientString { |
| 282 | + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| 283 | + struct StringVisitor; |
| 284 | + |
| 285 | + impl<'de> Visitor<'de> for StringVisitor { |
| 286 | + type Value = LenientString; |
| 287 | + |
| 288 | + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 289 | + formatter.write_str("any JSON value") |
| 290 | + } |
| 291 | + |
| 292 | + fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> { |
| 293 | + Ok(LenientString(Some(value.to_owned()))) |
| 294 | + } |
| 295 | + |
| 296 | + fn visit_string<E: de::Error>(self, value: String) -> Result<Self::Value, E> { |
| 297 | + Ok(LenientString(Some(value))) |
| 298 | + } |
| 299 | + |
| 300 | + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { |
| 301 | + IgnoredAny.visit_map(map).map(|_| LenientString(None)) |
| 302 | + } |
| 303 | + |
| 304 | + fn visit_seq<A: SeqAccess<'de>>(self, seq: A) -> Result<Self::Value, A::Error> { |
| 305 | + IgnoredAny.visit_seq(seq).map(|_| LenientString(None)) |
| 306 | + } |
| 307 | + |
| 308 | + skip_scalars!(LenientString(None)); |
| 309 | + } |
| 310 | + |
| 311 | + deserializer.deserialize_any(StringVisitor) |
| 312 | + } |
| 313 | +} |
| 314 | + |
| 315 | +/// A JSON array read as `T` elements, or empty for any other value, which is |
| 316 | +/// skipped without being built. Elements must be lenient for one malformed |
| 317 | +/// element not to fail the whole array. |
| 318 | +pub struct LenientSeq<T>(pub Vec<T>); |
| 319 | + |
| 320 | +impl<T> Default for LenientSeq<T> { |
| 321 | + fn default() -> Self { |
| 322 | + Self(Vec::new()) |
| 323 | + } |
| 324 | +} |
| 325 | + |
| 326 | +impl<'de, T: Deserialize<'de>> Deserialize<'de> for LenientSeq<T> { |
| 327 | + fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| 328 | + struct SeqVisitor<T>(PhantomData<T>); |
| 329 | + |
| 330 | + impl<'de, T: Deserialize<'de>> Visitor<'de> for SeqVisitor<T> { |
| 331 | + type Value = LenientSeq<T>; |
| 332 | + |
| 333 | + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 334 | + formatter.write_str("any JSON value") |
| 335 | + } |
| 336 | + |
| 337 | + fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> { |
| 338 | + std::iter::from_fn(|| seq.next_element().transpose()) |
| 339 | + .collect::<Result<_, _>>() |
| 340 | + .map(LenientSeq) |
| 341 | + } |
| 342 | + |
| 343 | + fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> { |
| 344 | + IgnoredAny.visit_map(map).map(|_| LenientSeq(Vec::new())) |
| 345 | + } |
| 346 | + |
| 347 | + fn visit_str<E: de::Error>(self, _: &str) -> Result<Self::Value, E> { |
| 348 | + Ok(LenientSeq(Vec::new())) |
| 349 | + } |
| 350 | + |
| 351 | + skip_scalars!(LenientSeq(Vec::new())); |
| 352 | + } |
| 353 | + |
| 354 | + deserializer.deserialize_any(SeqVisitor(PhantomData)) |
| 355 | + } |
| 356 | +} |
| 357 | + |
204 | 358 | #[cfg(test)] |
205 | 359 | mod tests { |
206 | 360 | use serde::Deserialize; |
207 | 361 |
|
208 | 362 | use super::{ |
209 | | - lenient_array, lenient_f64, lenient_i64, lenient_object, lenient_u64, lenient_vec, |
210 | | - non_empty_string, records, |
| 363 | + LenientObject, LenientSeq, LenientString, lenient_array, lenient_f64, lenient_i64, |
| 364 | + lenient_object, lenient_u64, lenient_vec, non_empty_string, records, |
211 | 365 | }; |
212 | 366 | use ccusage_core::fast::LinePrefilter; |
213 | 367 |
|
@@ -255,6 +409,58 @@ mod tests { |
255 | 409 | ); |
256 | 410 | } |
257 | 411 |
|
| 412 | + #[test] |
| 413 | + fn lenient_wrappers_skip_values_of_another_shape() { |
| 414 | + #[derive(Deserialize)] |
| 415 | + struct Part { |
| 416 | + #[serde(default)] |
| 417 | + name: LenientString, |
| 418 | + #[serde(default)] |
| 419 | + child: LenientObject<Child>, |
| 420 | + } |
| 421 | + |
| 422 | + #[derive(Deserialize)] |
| 423 | + struct Child { |
| 424 | + #[serde(default)] |
| 425 | + id: LenientString, |
| 426 | + } |
| 427 | + |
| 428 | + #[derive(Deserialize)] |
| 429 | + struct Parts { |
| 430 | + #[serde(default)] |
| 431 | + parts: LenientSeq<LenientObject<Part>>, |
| 432 | + } |
| 433 | + |
| 434 | + let parse = |raw: &str| { |
| 435 | + serde_json::from_str::<Parts>(raw) |
| 436 | + .unwrap() |
| 437 | + .parts |
| 438 | + .0 |
| 439 | + .into_iter() |
| 440 | + .map(|part| { |
| 441 | + part.0 |
| 442 | + .map(|part| (part.name.0, part.child.0.and_then(|child| child.id.0))) |
| 443 | + }) |
| 444 | + .collect::<Vec<_>>() |
| 445 | + }; |
| 446 | + |
| 447 | + assert_eq!( |
| 448 | + parse( |
| 449 | + r#"{"parts":[{"name":"a","child":{"id":"x"}},"junk",{"name":{"o":1},"child":[1]},{"name":["n"],"child":{"id":{"o":[2]}}},7,null]}"# |
| 450 | + ), |
| 451 | + [ |
| 452 | + Some((Some("a".to_string()), Some("x".to_string()))), |
| 453 | + None, |
| 454 | + Some((None, None)), |
| 455 | + Some((None, None)), |
| 456 | + None, |
| 457 | + None, |
| 458 | + ] |
| 459 | + ); |
| 460 | + assert!(parse(r#"{"parts":{"a":[1]}}"#).is_empty()); |
| 461 | + assert!(parse(r#"{"parts":"x"}"#).is_empty()); |
| 462 | + } |
| 463 | + |
258 | 464 | #[test] |
259 | 465 | fn lenient_u64_matches_value_as_u64() { |
260 | 466 | let coerce = |raw: &str| { |
|
0 commit comments