use std::borrow::Cow;
use std::collections::HashMap;
use std::ops::Range;
use jsonvet::{Event, EventKind, key_text};
use serde_json::{Map, Value};
use super::fold::number;
use crate::messages;
pub(super) struct Document {
pub(super) value: Value,
pub(super) events: Range<usize>,
pub(super) unchecked: Option<(usize, &'static str)>,
}
enum Open<'e> {
Array(Vec<Value>),
Object(
Map<String, Value>,
(String, usize, Cow<'e, [u8]>),
HashMap<String, Cow<'e, [u8]>>,
),
}
#[derive(Default)]
pub(super) struct Fold<'e> {
stack: Vec<Open<'e>>,
seen: usize,
first: (usize, usize),
unchecked: Option<(usize, &'static str)>,
}
impl<'e> Fold<'e> {
pub(super) fn event(&mut self, event: &Event<'e>) -> Option<Document> {
let i = self.seen;
self.seen += 1;
if self.stack.is_empty() {
self.first = (i, event.offset);
}
let value = match &event.kind {
EventKind::Key(key) => {
if let Some(Open::Object(_, current, _)) = self.stack.last_mut() {
let text = key_text(key).into_owned();
let raw = if text.contains('\u{FFFD}') {
key.clone()
} else {
Cow::Borrowed(&[][..])
};
*current = (text, event.offset, raw);
}
return None;
}
EventKind::ObjectStart => {
self.stack.push(Open::Object(
Map::new(),
(String::new(), 0, Cow::Borrowed(&[])),
HashMap::new(),
));
return None;
}
EventKind::ArrayStart => {
self.stack.push(Open::Array(Vec::new()));
return None;
}
EventKind::End => match self.stack.pop() {
Some(Open::Array(items)) => Value::Array(items),
Some(Open::Object(members, ..)) => Value::Object(members),
None => return None,
},
EventKind::Null => Value::Null,
EventKind::Bool(b) => Value::Bool(*b),
EventKind::String(s) => Value::String(s.to_string()),
EventKind::Number(text) => number(text).unwrap_or_else(|| {
self.unchecked
.get_or_insert((event.offset, messages::text("schema.not-a-number")));
Value::Null
}),
_ => return None,
};
match self.stack.last_mut() {
None => {
return Some(Document {
value,
events: self.first.0..i + 1,
unchecked: self.unchecked.take(),
});
}
Some(Open::Array(items)) => items.push(value),
Some(Open::Object(members, (key, offset, raw), seen)) => {
let key = std::mem::take(key);
if key.contains('\u{FFFD}') {
match seen.get(&key) {
Some(earlier) if earlier != raw => {
self.unchecked
.get_or_insert((*offset, messages::text("schema.same-keys")));
}
Some(_) => {}
None => {
seen.insert(key.clone(), std::mem::take(raw));
}
}
}
members.insert(key, value);
}
}
None
}
}
pub(super) fn documents(events: &[Event<'_>]) -> impl Iterator<Item = Document> {
let mut fold = Fold::default();
events.iter().filter_map(move |event| fold.event(event))
}
#[cfg(test)]
mod tests {
use super::super::fold::{self, tests::any_json};
use super::documents;
use jsonvet::{Config, Dialect};
use proptest::prelude::*;
#[test]
fn keys_that_only_read_the_same_after_lone_surrogates_are_not_checked() {
let unchecked = |text: &str| {
let (_, events) = jsonvet::parse(text, &Config::new(Dialect::Json5));
let events = events.unwrap_or_default();
documents(&events).next().map(|d| d.unchecked.is_some())
};
assert_eq!(unchecked(r#"{"\ud800": 1, "\ud801": 2}"#), Some(true));
assert_eq!(unchecked(r#"{"\ud800": 1, "\ud800": 2}"#), Some(false));
}
fn same(text: &str) {
let (_, events) = jsonvet::parse(text, &Config::new(Dialect::Json5));
let events = events.unwrap_or_default();
let direct: Vec<_> = documents(&events).map(|d| d.value).collect();
let tree: Vec<_> = fold::documents(&events).map(|d| d.tree.value()).collect();
assert_eq!(direct, tree, "{text}");
}
#[test]
fn the_schema_fold_reads_what_the_tree_does() {
for text in [
r#"{"a": [1, {"b": 2}], "bé/~": "x", "a": "last"}"#,
r#"{"\ud800": 1, "a": [0x10, +1, .5, 5.], 'q': null}"#,
"[1, [2, {}], true]",
] {
same(text);
}
}
proptest! {
#[test]
fn the_schema_fold_reads_any_json_as_the_tree_does(value in any_json()) {
same(&serde_json::to_string(&value).unwrap_or_default());
}
}
}