Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use std::{cell::RefCell, fmt::Display};
use serde::Deserialize;
use crate::ParseStatus;
thread_local! {
static ERRORS: RefCell<Option<Vec<anyhow::Error>>> = const { RefCell::new(None) };
}
pub fn parse_json<'de, T>(json: &'de str) -> (Option<T>, ParseStatus)
where
T: Deserialize<'de>,
{
ERRORS.with_borrow_mut(|errors| {
errors.replace(Vec::default());
});
let mut deserializer = serde_json_lenient::Deserializer::from_str(json);
let value = serde_path_to_error::deserialize::<_, T>(&mut deserializer);
let value = match value {
Ok(value) => value,
Err(error) => {
return (
None,
ParseStatus::Failed {
error: error.into_inner().to_string(),
},
);
}
};
if let Some(errors) = ERRORS.with_borrow_mut(|errors| errors.take().filter(|e| !e.is_empty())) {
let error = errors
.into_iter()
.map(|e| e.to_string())
.flat_map(|e| ["\n".to_owned(), e])
.skip(1)
.collect::<String>();
return (Some(value), ParseStatus::Failed { error });
}
(Some(value), ParseStatus::Success)
}
pub(crate) fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
D: serde::Deserializer<'de>,
T: serde::Deserialize<'de> + FallibleOption,
{
match T::deserialize(deserializer) {
Ok(value) => Ok(value),
Err(error) => {
let mut error = Some(error);
let mut fallback = None;
recover_deserialization_error(&mut |record_error| {
if let Some(error) = error.take() {
record_error(&error);
let value = T::default();
drop(error);
fallback = Some(value);
}
});
match error {
Some(error) => Err(error),
None => Ok(fallback.expect("recovery creates a fallback")),
}
}
}
}
pub trait FallibleOption: Default {}
impl<T> FallibleOption for Option<T> {}
macro_rules! flattened_deserialize {
($type_name:ty {
sections: { $($section:ident),* $(,)? },
options: { $($option_field:ident),* $(,)? },
defaults: { $($default_field:ident),* $(,)? } $(,)?
}) => {
impl $type_name {
#[doc(hidden)]
pub const NAMED_DESERIALIZE_KEYS: &'static [&'static str] = &[
$(stringify!($option_field),)*
$(stringify!($default_field),)*
];
}
impl<'de> serde::Deserialize<'de> for $type_name {
fn deserialize<D: serde::Deserializer<'de>>(
deserializer: D,
) -> Result<Self, D::Error> {
let mut object =
serde_json::Map::<String, serde_json::Value>::deserialize(deserializer)?;
(|| -> Result<Self, serde_json::Error> {
$(
let $option_field =
$crate::fallible_options::take_option_field(
&mut object,
stringify!($option_field),
)?;
)*
$(
let $default_field =
$crate::fallible_options::take_default_field(
&mut object,
stringify!($default_field),
)?;
)*
let rest = serde_json::Value::Object(object);
Ok(Self {
$($section: $crate::fallible_options::section(&rest)?,)*
$($option_field,)*
$($default_field,)*
})
})()
.map_err(serde::de::Error::custom)
}
}
};
}
pub(crate) use flattened_deserialize;
pub(crate) fn take_option_field<T>(
object: &mut serde_json::Map<String, serde_json::Value>,
key: &str,
) -> Result<T, serde_json::Error>
where
T: serde::de::DeserializeOwned + FallibleOption,
{
match object.remove(key) {
None => Ok(T::default()),
Some(value) => deserialize(&value),
}
}
pub(crate) fn take_default_field<T>(
object: &mut serde_json::Map<String, serde_json::Value>,
key: &str,
) -> Result<T, serde_json::Error>
where
T: serde::de::DeserializeOwned + Default,
{
match object.remove(key) {
None => Ok(T::default()),
Some(value) => T::deserialize(&value),
}
}
pub(crate) fn section<T>(rest: &serde_json::Value) -> Result<T, serde_json::Error>
where
T: serde::de::DeserializeOwned,
{
T::deserialize(rest)
}
#[inline(never)]
fn recover_deserialization_error(recover: &mut dyn FnMut(&mut dyn FnMut(&dyn Display))) {
ERRORS.with_borrow_mut(|errors| {
if let Some(errors) = errors {
recover(&mut |error| errors.push(anyhow::anyhow!("{error}")));
}
});
}
#[cfg(test)]
mod tests {
use serde::Deserialize;
use settings_macros::with_fallible_options;
use crate::ParseStatus;
#[with_fallible_options]
#[derive(Deserialize, Debug, PartialEq)]
struct Foo {
foo: Option<String>,
bar: Option<usize>,
baz: Option<bool>,
}
#[test]
fn test_fallible() {
let input = r#"
{"foo": "bar",
"bar": "foo",
"baz": 3,
}
"#;
let (settings, result) = crate::fallible_options::parse_json::<Foo>(&input);
assert_eq!(
settings.unwrap(),
Foo {
foo: Some("bar".into()),
bar: None,
baz: None,
}
);
assert!(settings_json::parse_json_with_comments::<Foo>(&input).is_err());
let ParseStatus::Failed { error } = result else {
panic!("Expected parse to fail")
};
assert_eq!(
error,
"invalid type: string \"foo\", expected usize at line 3 column 24\ninvalid type: integer `3`, expected a boolean at line 4 column 20".to_string()
)
}
}