use std::collections::BTreeMap;
use std::path::PathBuf;
use crate::Value;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SourceRef {
File(PathBuf),
String(usize),
Value(usize),
}
#[derive(Debug, Clone, PartialEq)]
pub enum TracedValue {
Leaf { value: Value, source: SourceRef },
Object(BTreeMap<String, TracedValue>),
}
#[derive(Debug, Clone, PartialEq)]
pub struct Trace {
pub value: TracedValue,
pub warnings: Vec<Warning>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Warning {
pub source: SourceRef,
pub message: String,
}
impl std::fmt::Display for Warning {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}: {}", self.source.label(), self.message)
}
}
impl serde::Serialize for Warning {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(Some(2))?;
map.serialize_entry("source", &self.source.label())?;
map.serialize_entry("message", &self.message)?;
map.end()
}
}
impl serde::Serialize for Trace {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(Some(2))?;
map.serialize_entry("value", &self.value)?;
map.serialize_entry("warnings", &self.warnings)?;
map.end()
}
}
impl From<TracedValue> for Value {
fn from(traced: TracedValue) -> Value {
match traced {
TracedValue::Leaf { value, .. } => value,
TracedValue::Object(entries) => {
Value::Object(entries.into_iter().map(|(k, v)| (k, v.into())).collect())
}
}
}
}
impl SourceRef {
fn label(&self) -> String {
match self {
SourceRef::File(path) => path.to_string_lossy().into_owned(),
SourceRef::String(index) => format!("string:{index}"),
SourceRef::Value(index) => format!("value:{index}"),
}
}
}
impl serde::Serialize for TracedValue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeMap;
match self {
TracedValue::Leaf { value, source } => {
let mut map = serializer.serialize_map(Some(4))?;
map.serialize_entry("$id", "Leaf")?;
map.serialize_entry("value", value)?;
map.serialize_entry("source", &source.label())?;
map.serialize_entry("format", &value.format_id())?;
map.end()
}
TracedValue::Object(entries) => serializer.collect_map(entries),
}
}
}