Implement serde traits for ego-tree

Cargo.toml

@@ -11,3 +11,13 @@ authors = [
 license = "ISC"
 repository = "https://github.com/rust-scraper/ego-tree"
 readme = "README.md"
+
+[features]
+serde = ["dep:serde"]
+
+[dependencies]
+serde = { version = "1.0.209", optional = true }
+
+[dev-dependencies]
+serde = "1.0.209"
+serde_json = "1.0.127"

src/lib.rs

@@ -38,6 +38,10 @@
 use std::fmt::{self, Debug, Display, Formatter};
 use std::num::NonZeroUsize;
 
+#[cfg(feature = "serde")]
+/// Implement serde traits for Tree
+pub mod serde;
+
 /// Vec-backed ID-tree.
 ///
 /// Always contains at least a root node.

src/serde.rs

@@ -0,0 +1,158 @@
+use std::{fmt, marker::PhantomData};
+
+use serde::{
+    de::{self, MapAccess, Visitor},
+    ser::{Serialize, SerializeStruct},
+    Deserialize, Deserializer,
+};
+
+use crate::{NodeId, NodeRef, Tree};
+
+#[derive(Debug)]
+struct SerNode<'a, T> {
+    value: &'a T,
+    children: Vec<SerNode<'a, T>>,
+}
+
+impl<'a, T> From<NodeRef<'a, T>> for SerNode<'a, T> {
+    fn from(node: NodeRef<'a, T>) -> Self {
+        let value: &T = node.value();
+        let children: Vec<SerNode<'a, T>> = node.children().map(SerNode::<'a, T>::from).collect();
+        SerNode { value, children }
+    }
+}
+
+impl<'a, T: Serialize> Serialize for SerNode<'a, T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("SerNode", 2)?;
+        state.serialize_field("value", &self.value)?;
+        state.serialize_field("children", &self.children)?;
+        state.end()
+    }
+}
+
+impl<T: Serialize> Serialize for Tree<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        SerNode::from(self.root()).serialize(serializer)
+    }
+}
+
+#[derive(Debug)]
+struct DeserNode<T> {
+    value: T,
+    children: Vec<DeserNode<T>>,
+}
+
+impl<T> DeserNode<T> {
+    fn into_tree_node(self, tree: &mut Tree<T>, parent: NodeId) -> NodeId {
+        let mut parent = tree.get_mut(parent).unwrap();
+        let node = parent.append(self.value).id();
+
+        for child in self.children {
+            child.into_tree_node(tree, node);
+        }
+
+        node
+    }
+}
+
+impl<T> From<DeserNode<T>> for Tree<T> {
+    fn from(root: DeserNode<T>) -> Self {
+        let mut tree: Tree<T> = Tree::new(root.value);
+        let root_id = tree.root().id;
+
+        for child in root.children {
+            child.into_tree_node(&mut tree, root_id);
+        }
+
+        tree
+    }
+}
+
+struct DeserNodeVisitor<T> {
+    marker: PhantomData<fn() -> DeserNode<T>>,
+}
+
+impl<T> DeserNodeVisitor<T> {
+    fn new() -> Self {
+        DeserNodeVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, T> Visitor<'de> for DeserNodeVisitor<T>
+where
+    T: Deserialize<'de>,
+{
+    type Value = DeserNode<T>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("struct DeserNode")
+    }
+
+    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
+    {
+        let mut value = None;
+        let mut children = None;
+
+        while let Some(key) = map.next_key()? {
+            match key {
+                "value" => {
+                    if value.is_some() {
+                        return Err(de::Error::duplicate_field("value"));
+                    }
+                    value = Some(map.next_value()?);
+                }
+                "children" => {
+                    if children.is_some() {
+                        return Err(de::Error::duplicate_field("children"));
+                    }
+                    children = Some(map.next_value()?);
+                }
+                _ => {
+                    return Err(de::Error::unknown_field(key, &["value", "children"]));
+                }
+            }
+        }
+
+        let value = value.ok_or_else(|| de::Error::missing_field("value"))?;
+        let children = children.ok_or_else(|| de::Error::missing_field("children"))?;
+
+        Ok(DeserNode { value, children })
+    }
+}
+
+impl<'de, T> Deserialize<'de> for DeserNode<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_struct(
+            "DeserNode",
+            &["value", "children"],
+            DeserNodeVisitor::new(),
+        )
+    }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for Tree<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let deser = DeserNode::<T>::deserialize(deserializer)?;
+        Ok(deser.into())
+    }
+}

tests/iter.rs

@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate ego_tree;
+use ego_tree::tree;
 
 #[test]
 fn into_iter() {

tests/macro.rs

@@ -1,7 +1,4 @@
-#[macro_use]
-extern crate ego_tree;
-
-use ego_tree::Tree;
+use ego_tree::{tree, Tree};
 
 #[test]
 fn root() {

tests/node_mut.rs

@@ -1,7 +1,4 @@
-#[macro_use]
-extern crate ego_tree;
-
-use ego_tree::NodeRef;
+use ego_tree::{tree, NodeRef};
 
 #[test]
 fn value() {

tests/node_ref.rs

@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate ego_tree;
+use ego_tree::tree;
 
 #[test]
 fn value() {

tests/serde.rs

@@ -0,0 +1,13 @@
+#![cfg(feature = "serde")]
+
+use ego_tree::{tree, Tree};
+
+#[test]
+fn test_serde_round_trip() {
+    let tree = tree!("a" => {"b", "c" => {"d", "e"}, "f"});
+    let repr = serde_json::to_string(&tree).unwrap();
+    println!("{repr}");
+    let re_tree: Tree<&str> = serde_json::from_str(&repr).unwrap();
+    println!("{re_tree}");
+    assert_eq!(tree, re_tree);
+}

tests/subtree.rs

@@ -1,39 +1,35 @@
-#[macro_use]
-extern crate ego_tree;
+use ego_tree::tree;
 
-#[cfg(test)]
-mod test {
-    #[test]
-    fn prepend_subtree() {
-        let mut tree = tree!('a' => { 'b', 'c' => { 'd', 'e' } });
-        let node_id = tree.root().first_child().unwrap().id();
-        let mut node = tree.get_mut(node_id).unwrap();
-        assert_eq!(node.value(), &'b');
+#[test]
+fn prepend_subtree() {
+    let mut tree = tree!('a' => { 'b', 'c' => { 'd', 'e' } });
+    let node_id = tree.root().first_child().unwrap().id();
+    let mut node = tree.get_mut(node_id).unwrap();
+    assert_eq!(node.value(), &'b');
 
-        let subtree = tree!('f' => { 'g', 'h' => { 'i', 'j' } });
-        let mut root_subtree = node.prepend_subtree(subtree);
-        assert_eq!(root_subtree.parent().unwrap().value(), &'b');
-        assert_eq!(
-            root_subtree.parent().unwrap().parent().unwrap().value(),
-            &'a'
-        );
+    let subtree = tree!('f' => { 'g', 'h' => { 'i', 'j' } });
+    let mut root_subtree = node.prepend_subtree(subtree);
+    assert_eq!(root_subtree.parent().unwrap().value(), &'b');
+    assert_eq!(
+        root_subtree.parent().unwrap().parent().unwrap().value(),
+        &'a'
+    );
 
-        let new_tree =
-            tree!('a' => { 'b' => { 'f' => { 'g', 'h' => { 'i', 'j' } } }, 'c' => { 'd', 'e' } });
-        assert_eq!(format!("{:#?}", tree), format!("{:#?}", new_tree));
-    }
+    let new_tree =
+        tree!('a' => { 'b' => { 'f' => { 'g', 'h' => { 'i', 'j' } } }, 'c' => { 'd', 'e' } });
+    assert_eq!(format!("{:#?}", tree), format!("{:#?}", new_tree));
+}
 
-    #[test]
-    fn append_subtree() {
-        let mut tree = tree!('a' => { 'b', 'c' });
-        let mut node = tree.root_mut();
-        assert_eq!(node.value(), &'a');
+#[test]
+fn append_subtree() {
+    let mut tree = tree!('a' => { 'b', 'c' });
+    let mut node = tree.root_mut();
+    assert_eq!(node.value(), &'a');
 
-        let subtree = tree!('d' => { 'e', 'f' });
-        let mut root_subtree = node.append_subtree(subtree);
-        assert_eq!(root_subtree.parent().unwrap().value(), &'a');
+    let subtree = tree!('d' => { 'e', 'f' });
+    let mut root_subtree = node.append_subtree(subtree);
+    assert_eq!(root_subtree.parent().unwrap().value(), &'a');
 
-        let new_tree = tree!('a' => { 'b', 'c', 'd' => { 'e', 'f' } });
-        assert_eq!(format!("{:#?}", tree), format!("{:#?}", new_tree));
-    }
+    let new_tree = tree!('a' => { 'b', 'c', 'd' => { 'e', 'f' } });
+    assert_eq!(format!("{:#?}", tree), format!("{:#?}", new_tree));
 }

tests/tree.rs

@@ -1,5 +1,3 @@
-extern crate ego_tree;
-
 use ego_tree::{tree, Tree};
 
 #[test]