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,82 @@
+use std::num::NonZeroUsize;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{Node, NodeId, Tree};
+
+impl<T: Serialize> Serialize for Tree<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.vec.serialize(serializer)
+    }
+}
+
+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 vec = Vec::deserialize(deserializer)?;
+        Ok(Tree { vec })
+    }
+}
+
+impl<T: Serialize> Serialize for Node<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (
+            &self.parent,
+            &self.prev_sibling,
+            &self.next_sibling,
+            &self.children,
+            &self.value,
+        )
+            .serialize(serializer)
+    }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for Node<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let (parent, prev_sibling, next_sibling, children, value) =
+            <(
+                Option<NodeId>,
+                Option<NodeId>,
+                Option<NodeId>,
+                Option<(NodeId, NodeId)>,
+                T,
+            )>::deserialize(deserializer)?;
+        Ok(Node {
+            parent,
+            prev_sibling,
+            next_sibling,
+            children,
+            value,
+        })
+    }
+}
+
+impl Serialize for NodeId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for NodeId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let index = <NonZeroUsize>::deserialize(deserializer)?;
+        Ok(NodeId(index))
+    }
+}

tests/serde.rs

@@ -0,0 +1,16 @@
+#![cfg(feature = "serde")]
+#[macro_use]
+extern crate ego_tree;
+use std::assert_eq;
+
+use ego_tree::Tree;
+
+#[test]
+fn test_serialize() {
+    let tree = tree!("r" => {"a", "b" => { "d", "e" }, "c"});
+
+    let serialized = serde_json::to_string(&tree).unwrap();
+    let deserialized: Tree<&str> = serde_json::from_str(&serialized).unwrap();
+
+    assert_eq!(tree, deserialized);
+}