3 files changed, 54 insertions, 54 deletions

diff --git a/mingling_core/src/renderer/general.rs b/mingling_core/src/renderer/structural.rs
index e6da06b..16ce471 100644
--- a/mingling_core/src/renderer/general.rs
+++ b/mingling_core/src/renderer/structural.rs
@@ -1,5 +1,5 @@
 use crate::{
-    GeneralRendererSetting, RenderResult, renderer::general::error::GeneralRendererSerializeError,
+    StructuralRendererSetting, RenderResult, renderer::structural::error::StructuralRendererSerializeError,
 };
 use serde::Serialize;
 
@@ -8,40 +8,40 @@ pub mod structural_data;
 
 use structural_data::StructuralData;
 
-/// A general renderer that supports multiple serialization formats.
+/// A structural renderer that supports multiple serialization formats.
 ///
-/// The `GeneralRenderer` provides methods to serialize data into various formats
+/// The `StructuralRenderer` provides methods to serialize data into various formats
 /// including JSON, YAML, TOML, and RON, with support for both regular and
 /// pretty-printed variants. It is designed to work with types that implement
 /// the [`StructuralData`] trait (which implies `Serialize`).
-pub struct GeneralRenderer;
+pub struct StructuralRenderer;
 
-impl GeneralRenderer {
+impl StructuralRenderer {
     /// Renders data in the specified format to the given `RenderResult`.
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[allow(unused_variables)]
     pub fn render<T: StructuralData + Send>(
         data: &T,
-        setting: &GeneralRendererSetting,
+        setting: &StructuralRendererSetting,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         match setting {
-            GeneralRendererSetting::Disable => Ok(()),
+            StructuralRendererSetting::Disable => Ok(()),
             #[cfg(feature = "json_serde_fmt")]
-            GeneralRendererSetting::Json => Self::render_to_json(data, r),
+            StructuralRendererSetting::Json => Self::render_to_json(data, r),
             #[cfg(feature = "json_serde_fmt")]
-            GeneralRendererSetting::JsonPretty => Self::render_to_json_pretty(data, r),
+            StructuralRendererSetting::JsonPretty => Self::render_to_json_pretty(data, r),
             #[cfg(feature = "yaml_serde_fmt")]
-            GeneralRendererSetting::Yaml => Self::render_to_yaml(data, r),
+            StructuralRendererSetting::Yaml => Self::render_to_yaml(data, r),
             #[cfg(feature = "toml_serde_fmt")]
-            GeneralRendererSetting::Toml => Self::render_to_toml(data, r),
+            StructuralRendererSetting::Toml => Self::render_to_toml(data, r),
             #[cfg(feature = "ron_serde_fmt")]
-            GeneralRendererSetting::Ron => Self::render_to_ron(data, r),
+            StructuralRendererSetting::Ron => Self::render_to_ron(data, r),
             #[cfg(feature = "ron_serde_fmt")]
-            GeneralRendererSetting::RonPretty => Self::render_to_ron_pretty(data, r),
+            StructuralRendererSetting::RonPretty => Self::render_to_ron_pretty(data, r),
         }
     }
 
@@ -49,14 +49,14 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "json_serde_fmt")]
     fn render_to_json<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let json_string = serde_json::to_string(data)
-            .map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            .map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&json_string);
         Ok(())
     }
@@ -65,14 +65,14 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "json_serde_fmt")]
     fn render_to_json_pretty<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let json_string = serde_json::to_string_pretty(data)
-            .map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            .map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&json_string);
         Ok(())
     }
@@ -81,14 +81,14 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "ron_serde_fmt")]
     fn render_to_ron<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let ron_string = ron::ser::to_string(data)
-            .map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            .map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&ron_string);
         Ok(())
     }
@@ -97,18 +97,18 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "ron_serde_fmt")]
     fn render_to_ron_pretty<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let pretty_config = ron::ser::PrettyConfig::new()
             .new_line("\n")
             .indentor("  ");
 
         let ron_string = ron::ser::to_string_pretty(data, pretty_config)
-            .map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            .map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&ron_string);
         Ok(())
     }
@@ -117,14 +117,14 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "toml_serde_fmt")]
     fn render_to_toml<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let toml_string =
-            toml::to_string(data).map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            toml::to_string(data).map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&toml_string);
         Ok(())
     }
@@ -133,14 +133,14 @@ impl GeneralRenderer {
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization fails.
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization fails.
     #[cfg(feature = "yaml_serde_fmt")]
     fn render_to_yaml<T: Serialize + Send>(
         data: &T,
         r: &mut RenderResult,
-    ) -> Result<(), GeneralRendererSerializeError> {
+    ) -> Result<(), StructuralRendererSerializeError> {
         let yaml_string = serde_yaml::to_string(data)
-            .map_err(|e| GeneralRendererSerializeError::new(e.to_string()))?;
+            .map_err(|e| StructuralRendererSerializeError::new(e.to_string()))?;
         r.print(&yaml_string);
         Ok(())
     }
@@ -172,7 +172,7 @@ mod tests {
     fn test_render_disable_does_nothing() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Disable, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Disable, &mut r);
         assert!(result.is_ok());
         assert!(r.is_empty());
     }
@@ -182,7 +182,7 @@ mod tests {
     fn test_render_to_json() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Json, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Json, &mut r);
         assert!(result.is_ok());
         assert!(!r.is_empty());
         let output: String = r.into();
@@ -197,7 +197,7 @@ mod tests {
     fn test_render_to_json_pretty() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::JsonPretty, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::JsonPretty, &mut r);
         assert!(result.is_ok());
         let output: String = r.into();
         // Pretty JSON has newlines
@@ -209,7 +209,7 @@ mod tests {
     fn test_render_to_yaml() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Yaml, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Yaml, &mut r);
         assert!(result.is_ok());
         assert!(!r.is_empty());
     }
@@ -219,7 +219,7 @@ mod tests {
     fn test_render_to_toml() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Toml, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Toml, &mut r);
         assert!(result.is_ok());
         assert!(!r.is_empty());
     }
@@ -229,7 +229,7 @@ mod tests {
     fn test_render_to_ron() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Ron, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Ron, &mut r);
         assert!(result.is_ok());
         assert!(!r.is_empty());
     }
@@ -239,7 +239,7 @@ mod tests {
     fn test_render_to_ron_pretty() {
         let mut r = RenderResult::default();
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::RonPretty, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::RonPretty, &mut r);
         assert!(result.is_ok());
         let output: String = r.into();
         assert!(output.contains('\n'));
@@ -252,7 +252,7 @@ mod tests {
 
         // Disable
         let result =
-            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Disable, &mut r);
+            StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Disable, &mut r);
         assert!(result.is_ok());
         assert!(r.is_empty());
     }
@@ -261,7 +261,7 @@ mod tests {
     #[test]
     fn test_render_dispatches_json() {
         let mut r = RenderResult::default();
-        let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Json, &mut r);
+        let result = StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Json, &mut r);
         assert!(result.is_ok());
         assert!(!r.is_empty());
     }
diff --git a/mingling_core/src/renderer/general/error.rs b/mingling_core/src/renderer/structural/error.rs
index 07ca92b..a7fbc75 100644
--- a/mingling_core/src/renderer/general/error.rs
+++ b/mingling_core/src/renderer/structural/error.rs
@@ -1,27 +1,27 @@
-/// Represents an error that occurs during serialization of a general renderer.
+/// Represents an error that occurs during serialization of a structural renderer.
 ///
 /// This error stores a human-readable message describing what went wrong
 /// during the serialization process.
 #[derive(Debug)]
-pub struct GeneralRendererSerializeError {
+pub struct StructuralRendererSerializeError {
     /// The underlying error message.
     error: String,
 }
 
-impl GeneralRendererSerializeError {
+impl StructuralRendererSerializeError {
     #[must_use]
     pub fn new(error: String) -> Self {
         Self { error }
     }
 }
 
-impl From<&str> for GeneralRendererSerializeError {
+impl From<&str> for StructuralRendererSerializeError {
     fn from(s: &str) -> Self {
         Self::new(s.to_string())
     }
 }
 
-impl std::ops::Deref for GeneralRendererSerializeError {
+impl std::ops::Deref for StructuralRendererSerializeError {
     type Target = String;
 
     fn deref(&self) -> &Self::Target {
@@ -29,8 +29,8 @@ impl std::ops::Deref for GeneralRendererSerializeError {
     }
 }
 
-impl From<GeneralRendererSerializeError> for String {
-    fn from(val: GeneralRendererSerializeError) -> Self {
+impl From<StructuralRendererSerializeError> for String {
+    fn from(val: StructuralRendererSerializeError) -> Self {
         val.error
     }
 }
@@ -42,26 +42,26 @@ mod tests {
     #[test]
     fn new_creates_error_with_message() {
         let msg = "serialization failed".to_string();
-        let err = GeneralRendererSerializeError::new(msg.clone());
+        let err = StructuralRendererSerializeError::new(msg.clone());
         assert_eq!(err.error, msg);
     }
 
     #[test]
     fn from_str_creates_error_from_string_slice() {
-        let err: GeneralRendererSerializeError = "oops".into();
+        let err: StructuralRendererSerializeError = "oops".into();
         assert_eq!(err.error, "oops");
     }
 
     #[test]
     fn deref_accesses_inner_error_string() {
-        let err = GeneralRendererSerializeError::new("inner message".to_string());
+        let err = StructuralRendererSerializeError::new("inner message".to_string());
         let derefed: &String = &err;
         assert_eq!(derefed, "inner message");
     }
 
     #[test]
     fn into_string_extracts_message() {
-        let err = GeneralRendererSerializeError::new("extract me".to_string());
+        let err = StructuralRendererSerializeError::new("extract me".to_string());
         let s: String = err.into();
         assert_eq!(s, "extract me");
     }
diff --git a/mingling_core/src/renderer/general/structural_data.rs b/mingling_core/src/renderer/structural/structural_data.rs
index ac6363e..1cafac3 100644
--- a/mingling_core/src/renderer/general/structural_data.rs
+++ b/mingling_core/src/renderer/structural/structural_data.rs
@@ -10,6 +10,6 @@ use serde::Serialize;
 /// - `group_structural!`
 ///
 /// These entry points also register the type in the global `STRUCTURED_TYPES`
-/// registry, which is required for the `general_render` match arm to be generated.
+/// registry, which is required for the `structural_render` match arm to be generated.
 #[doc(hidden)]
 pub trait StructuralData: Serialize + crate::__private::StructuralDataSealed {}