feat(serde): Enable serialization & deserialization for Template*

Cargo.toml

@@ -17,14 +17,17 @@ edition = "2021"
 # Implement `VariableMap` for `indexmap::IndexMap`.
 indexmap = ["dep:indexmap"]
 
+# Enable serde Deserialize and Serialize implementations for templates.
+serde = ["dep:serde"]
+
 # Enable support for performing substitution in all string values of a JSON document.
-json = ["dep:serde", "dep:serde_json"]
+json = ["serde", "dep:serde_json"]
 
 # Enable support for performing substitution in all string values of a TOML document.
-toml = ["dep:serde", "dep:toml"]
+toml = ["serde", "dep:toml"]
 
 # Enable support for performing substitution in all string values of a YAML document.
-yaml = ["dep:serde", "dep:serde_yaml"]
+yaml = ["serde", "dep:serde_yaml"]
 
 # Preserve the order of fields in JSON objects and TOML tables (YAML always preserves the order).
 preserve-order = ["toml?/preserve_order", "serde_json?/preserve_order"]
@@ -45,6 +48,7 @@ unicode-width = "0.1.9"
 assert2 = "0.3.6"
 subst = { path = ".", features = ["json", "toml", "yaml"] }
 serde = { version = "1.0.0", features = ["derive"] }
+serde_test = "1.0.177"
 
 [package.metadata.docs.rs]
 all-features = true

src/features/mod.rs

@@ -13,3 +13,8 @@ pub mod yaml;
 #[cfg(feature = "toml")]
 #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "toml")))]
 pub mod toml;
+
+// This module isn't expected, since it only defines trait implementations.
+#[cfg(feature = "serde")]
+#[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "serde")))]
+mod serde;

src/features/serde.rs

@@ -0,0 +1,130 @@
+use serde::Deserialize;
+use serde::Deserializer;
+use serde::Serialize;
+use serde::Serializer;
+use serde::de::Error;
+
+use crate::{ByteTemplate, ByteTemplateBuf, Template, TemplateBuf};
+
+impl Serialize for Template<'_> {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(self.source())
+	}
+}
+
+impl Serialize for TemplateBuf {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(self.as_template().source())
+	}
+}
+
+impl Serialize for ByteTemplate<'_> {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_bytes(self.source())
+	}
+}
+
+impl Serialize for ByteTemplateBuf {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_bytes(self.as_template().source())
+	}
+}
+
+impl<'de> Deserialize<'de> for Template<'de> {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let source: &'de str = Deserialize::deserialize(deserializer)?;
+		Self::from_str(source).map_err(D::Error::custom)
+	}
+}
+
+impl<'de> Deserialize<'de> for TemplateBuf {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let source: String = Deserialize::deserialize(deserializer)?;
+		Self::from_string(source).map_err(D::Error::custom)
+	}
+}
+
+impl<'de> Deserialize<'de> for ByteTemplate<'de> {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let source: &'de [u8] = Deserialize::deserialize(deserializer)?;
+		Self::from_slice(source).map_err(D::Error::custom)
+	}
+}
+
+impl<'de> Deserialize<'de> for ByteTemplateBuf {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		struct ByteBufVisitor;
+		impl<'de> serde::de::Visitor<'de> for ByteBufVisitor {
+			type Value = Vec<u8>;
+			fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+				write!(formatter, "bytes")
+			}
+			fn visit_bytes<E: Error>(self, v: &[u8]) -> Result<Self::Value, E> {
+				Ok(v.to_vec())
+			}
+			fn visit_byte_buf<E: Error>(self, v: Vec<u8>) -> Result<Self::Value, E> {
+				Ok(v)
+			}
+		}
+
+		let source = deserializer.deserialize_byte_buf(ByteBufVisitor)?;
+		Self::from_vec(source).map_err(D::Error::custom)
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use crate::{ByteTemplate, ByteTemplateBuf, Template, TemplateBuf};
+	use assert2::let_assert;
+	use serde_test::{assert_tokens, Token};
+
+	const SOURCE: &str = "Hello $name";
+
+	#[test]
+	fn template_ser_de() {
+		let_assert!(Ok(template) = Template::from_str(SOURCE));
+		assert_tokens(&template, &[Token::BorrowedStr(SOURCE)]);
+	}
+
+	#[test]
+	fn template_buf_ser_de() {
+		let_assert!(Ok(template) = TemplateBuf::from_string(SOURCE.into()));
+		assert_tokens(&template, &[Token::String(SOURCE)]);
+	}
+
+	#[test]
+	fn byte_template_ser_de() {
+		let_assert!(Ok(template) = ByteTemplate::from_slice(SOURCE.as_bytes()));
+		assert_tokens(&template, &[Token::BorrowedBytes(SOURCE.as_bytes())]);
+	}
+
+	#[test]
+	fn byte_template_buf_ser_de() {
+		let_assert!(Ok(template) = ByteTemplateBuf::from_vec(SOURCE.as_bytes().to_vec()));
+		serde_test::assert_tokens(&template, &[Token::ByteBuf(SOURCE.as_bytes())]);
+	}
+}

src/non_aliasing.rs

@@ -2,8 +2,7 @@ use core::mem::MaybeUninit;
 
 /// Simple wrapper around [`MaybeUninit`] that guarantees the type is initialized.
 ///
-/// This may sound odd, but the compiler can not assume that `MaybeUninit` is initialized,
-/// but as far is the compiler is concerned, `MaybeUninit<T>` is not keeping any references around, even if `T` would.
+/// This may sound odd, but as far is the compiler is concerned, `MaybeUninit<T>` is not keeping any references around, even if `T` would.
 /// So `NonAliasing<T>` is not aliassing anything untill you call `inner()` to get your `&T` back.
 ///
 /// We use this to create a (hopefully) sound self referential struct in `TemplateBuf` and `ByteTemplateBuf`.
@@ -35,3 +34,19 @@ impl<T> Drop for NonAliasing<T> {
 		}
 	}
 }
+
+impl<T: core::cmp::Eq> core::cmp::Eq for NonAliasing<T> {}
+
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for NonAliasing<T> {
+	fn eq(&self, other: &Self) -> bool {
+		self.inner() == other.inner()
+	}
+
+	#[allow(
+		clippy::partialeq_ne_impl,
+		reason = "we don't know how T implements eq/ne, we just forward behavior"
+	)]
+	fn ne(&self, other: &Self) -> bool {
+		self.inner() != other.inner()
+	}
+}