use std::collections::HashMap;
use serde::de::DeserializeSeed;
use serde_json::Value;
use serde_json::de::SliceRead;
use serde_json::value::RawValue;
use crate::row_batches::_helpers::json_seed::{ArraySeed, ObjectSeed, RowSink};
use crate::row_batches::models::RowColumns;
type JsonDeserializer<'a> = serde_json::Deserializer<SliceRead<'a>>;
impl<F: FnMut(RowColumns) -> Result<(), String>> RowSink<F> {
pub(crate) fn read_lines(&mut self, bytes: &[u8]) -> Result<(), String> {
for (index, line) in bytes.split(|byte| *byte == b'\n').enumerate() {
if line.trim_ascii().is_empty() {
continue;
}
let mut deserializer: JsonDeserializer<'_> = serde_json::Deserializer::from_slice(line);
ObjectSeed(&mut *self)
.deserialize(&mut deserializer)
.and_then(|()| deserializer.end())
.map_err(|error| located(&error, index as u64 + 1))?;
}
Ok(())
}
pub(crate) fn read_document(&mut self, bytes: &[u8]) -> Result<(), String> {
let start = bytes.iter().position(|byte| !byte.is_ascii_whitespace());
match start.map(|position| bytes[position]) {
None => Ok(()),
Some(b'[') => {
let mut deserializer: JsonDeserializer<'_> =
serde_json::Deserializer::from_slice(bytes);
ArraySeed(&mut *self)
.deserialize(&mut deserializer)
.and_then(|()| deserializer.end())
.map_err(|error| located(&error, 1))
}
Some(b'{') => self.read_objects(bytes),
Some(_) => match serde_json::from_slice::<Value>(bytes) {
Ok(Value::Null) => Ok(()),
Ok(_) => Err(
"expected a JSON array of objects, or JSON objects one after another"
.to_owned(),
),
Err(error) => Err(located(&error, 1)),
},
}
}
fn read_objects(&mut self, bytes: &[u8]) -> Result<(), String> {
let mut deserializer: JsonDeserializer<'_> = serde_json::Deserializer::from_slice(bytes);
loop {
ObjectSeed(&mut *self)
.deserialize(&mut deserializer)
.map_err(|error| located(&error, 1))?;
if let Ok(()) = deserializer.end() {
return Ok(());
}
}
}
}
pub(crate) fn select_path<'a>(bytes: &'a [u8], path: &str) -> Result<&'a [u8], String> {
let mut current: &RawValue =
serde_json::from_slice(bytes).map_err(|error| located(&error, 1))?;
let mut walked: Vec<&str> = Vec::new();
for segment in path.split('.') {
let listed = current.get().trim_start().starts_with('[');
let index = segment
.strip_prefix('[')
.and_then(|rest| rest.strip_suffix(']'))
.filter(|_| listed)
.map(str::parse::<usize>);
current = match index {
Some(Err(_)) | None => {
let object: HashMap<String, &RawValue> = serde_json::from_str(current.get())
.map_err(|_| format!("path {path}: {} is not a JSON object", shown(&walked)))?;
object.get(segment).copied().ok_or_else(|| {
format!("path {path}: {} has no key {segment:?}", shown(&walked))
})?
}
Some(Ok(index)) => {
let items: Vec<&RawValue> = serde_json::from_str(current.get())
.map_err(|_| format!("path {path}: {} is not a JSON list", shown(&walked)))?;
items.get(index).copied().ok_or_else(|| {
format!("path {path}: {} has no item {segment}", shown(&walked))
})?
}
};
walked.push(segment);
}
Ok(current.get().as_bytes())
}
fn shown(walked: &[&str]) -> String {
match walked.is_empty() {
true => "the document".to_owned(),
false => walked.join("."),
}
}
fn located(error: &serde_json::Error, first_line: u64) -> String {
let at = first_line + (error.line() as u64).saturating_sub(1);
let text = error.to_string();
let reason = text
.rsplit_once(" at line ")
.map_or(text.as_str(), |(reason, _)| reason);
format!("line {at}: {reason}")
}