#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]
use std::collections::BTreeMap;
use std::fmt;
use serde::de::{self, SeqAccess, Visitor};
use serde::ser::{self, SerializeSeq};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{Map, Value};
#[derive(Debug, Clone, PartialEq)]
pub enum Node {
Element(Element),
Text(String),
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Element {
pub name: String,
pub attrs: BTreeMap<String, Value>,
pub children: Vec<Node>,
}
impl Element {
pub fn new(name: impl Into<String>) -> Self {
Element {
name: name.into(),
attrs: BTreeMap::new(),
children: Vec::new(),
}
}
pub fn attr(mut self, name: impl Into<String>, value: impl Into<Value>) -> Self {
self.attrs.insert(name.into(), value.into());
self
}
pub fn child(mut self, node: impl Into<Node>) -> Self {
self.children.push(node.into());
self
}
}
impl From<Element> for Node {
fn from(element: Element) -> Self {
Node::Element(element)
}
}
impl From<String> for Node {
fn from(text: String) -> Self {
Node::Text(text)
}
}
impl From<&str> for Node {
fn from(text: &str) -> Self {
Node::Text(text.to_string())
}
}
impl Node {
pub fn as_element(&self) -> Option<&Element> {
match self {
Node::Element(element) => Some(element),
_ => None,
}
}
pub fn as_text(&self) -> Option<&str> {
match self {
Node::Text(text) => Some(text),
_ => None,
}
}
pub fn walk(&self, visit: &mut impl FnMut(&Node, Path<'_>) -> Walk) {
let mut trail = Vec::new();
self.walk_from(&mut trail, visit);
}
fn walk_from(
&self,
trail: &mut Vec<usize>,
visit: &mut impl FnMut(&Node, Path<'_>) -> Walk,
) -> Walk {
match visit(self, Path(trail.as_slice())) {
Walk::Stop => return Walk::Stop,
Walk::SkipChildren => return Walk::Continue,
Walk::Continue => {}
}
if let Node::Element(element) = self {
for (index, child) in element.children.iter().enumerate() {
trail.push(index);
let outcome = child.walk_from(trail, visit);
trail.pop();
if outcome == Walk::Stop {
return Walk::Stop;
}
}
}
Walk::Continue
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Walk {
Continue,
SkipChildren,
Stop,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Path<'a>(&'a [usize]);
impl Path<'_> {
pub fn indices(&self) -> &[usize] {
self.0
}
pub fn depth(&self) -> usize {
self.0.len()
}
pub fn is_root(&self) -> bool {
self.0.is_empty()
}
}
impl fmt::Display for Path<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for index in self.0 {
write!(f, "/{index}")?;
}
Ok(())
}
}
pub fn from_str(source: &str) -> Result<Node, Error> {
json5::from_str(source).map_err(|e| Error(ErrorKind::Parse(e.to_string())))
}
pub fn from_json_str(source: &str) -> Result<Node, Error> {
serde_json::from_str(source).map_err(|e| Error(ErrorKind::Parse(e.to_string())))
}
pub fn to_string(node: &Node) -> Result<String, Error> {
serde_json::to_string(node).map_err(|e| Error(ErrorKind::Serialize(e.to_string())))
}
#[derive(Debug)]
enum ErrorKind {
Parse(String),
Serialize(String),
}
#[derive(Debug)]
pub struct Error(ErrorKind);
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.0 {
ErrorKind::Parse(message) => write!(f, "J5ML parse failed: {message}"),
ErrorKind::Serialize(message) => write!(f, "J5ML serialization failed: {message}"),
}
}
}
impl std::error::Error for Error {}
impl Serialize for Node {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Node::Text(text) => serializer.serialize_str(text),
Node::Element(element) => {
if element.name.is_empty() {
return Err(ser::Error::custom(NAME_REQUIRED));
}
let has_attrs = !element.attrs.is_empty();
let len = 1 + usize::from(has_attrs) + element.children.len();
let mut seq = serializer.serialize_seq(Some(len))?;
seq.serialize_element(&element.name)?;
if has_attrs {
seq.serialize_element(&element.attrs)?;
}
for child in &element.children {
seq.serialize_element(child)?;
}
seq.end()
}
}
}
}
struct NodeVisitor;
impl<'de> Visitor<'de> for NodeVisitor {
type Value = Node;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("a J5ML element array or a text string")
}
fn visit_str<E: de::Error>(self, value: &str) -> Result<Node, E> {
Ok(Node::Text(value.to_string()))
}
fn visit_seq<A>(self, mut seq: A) -> Result<Node, A::Error>
where
A: SeqAccess<'de>,
{
let mut members = Vec::new();
while let Some(member) = seq.next_element::<Value>()? {
members.push(member);
}
element_from_members::<A::Error>(members).map(Node::Element)
}
}
const NAME_REQUIRED: &str = "an element's first member must be a non-empty name";
fn into_attrs(map: Map<String, Value>) -> BTreeMap<String, Value> {
map.into_iter().collect()
}
fn element_from_members<E: de::Error>(members: Vec<Value>) -> Result<Element, E> {
let mut members = members.into_iter();
let name = match members.next() {
Some(Value::String(name)) if !name.is_empty() => name,
_ => return Err(E::custom(NAME_REQUIRED)),
};
let mut attrs = BTreeMap::new();
let mut children = Vec::new();
if let Some(second) = members.next() {
match second {
Value::Object(map) => attrs = into_attrs(map),
other => children.push(value_to_node::<E>(other)?),
}
}
for member in members {
children.push(value_to_node::<E>(member)?);
}
Ok(Element {
name,
attrs,
children,
})
}
fn value_to_node<E: de::Error>(value: Value) -> Result<Node, E> {
match value {
Value::String(text) => Ok(Node::Text(text)),
Value::Array(members) => element_from_members::<E>(members).map(Node::Element),
_ => Err(E::custom("a child member must be a string or an array")),
}
}
impl<'de> Deserialize<'de> for Node {
fn deserialize<D>(deserializer: D) -> Result<Node, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_any(NodeVisitor)
}
}