refactor(general_renderer): rename to structural_renderer

5 files changed, 88 insertions, 88 deletions

diff --git a/mingling_core/src/program/collection.rs b/mingling_core/src/program/collection.rs
index 36a0c94..044379c 100644
--- a/mingling_core/src/program/collection.rs
+++ b/mingling_core/src/program/collection.rs
@@ -6,8 +6,8 @@ use crate::Dispatcher;
 
 use crate::{AnyOutput, ChainProcess, Groupped, RenderResult};
 
-#[cfg(feature = "general_renderer")]
-use crate::{GeneralRendererSetting, error::GeneralRendererSerializeError};
+#[cfg(feature = "structural_renderer")]
+use crate::{StructuralRendererSetting, error::StructuralRendererSerializeError};
 
 #[cfg(feature = "comp")]
 use crate::{ShellContext, Suggest};
@@ -78,15 +78,15 @@ pub trait ProgramCollect {
     /// Whether the program has a chain that can handle the current [`AnyOutput`](./struct.AnyOutput.html)
     fn has_chain(any: &AnyOutput<Self::Enum>) -> bool;
 
-    /// Perform general rendering and presentation of any type
+    /// Perform structural rendering and presentation of any type
     ///
     /// # Errors
     ///
-    /// Returns `Err(GeneralRendererSerializeError)` if serialization of the
+    /// Returns `Err(StructuralRendererSerializeError)` if serialization of the
     /// output value fails.
-    #[cfg(feature = "general_renderer")]
-    fn general_render(
+    #[cfg(feature = "structural_renderer")]
+    fn structural_render(
         any: AnyOutput<Self::Enum>,
-        setting: &GeneralRendererSetting,
-    ) -> Result<RenderResult, GeneralRendererSerializeError>;
+        setting: &StructuralRendererSetting,
+    ) -> Result<RenderResult, StructuralRendererSerializeError>;
 }
diff --git a/mingling_core/src/program/collection/mock.rs b/mingling_core/src/program/collection/mock.rs
index caef804..b37a709 100644
--- a/mingling_core/src/program/collection/mock.rs
+++ b/mingling_core/src/program/collection/mock.rs
@@ -6,16 +6,16 @@ use crate::Dispatcher;
 
 use crate::{AnyOutput, ChainProcess, Groupped, ProgramCollect, RenderResult};
 
-#[cfg(feature = "general_renderer")]
-use crate::{GeneralRendererSetting, error::GeneralRendererSerializeError};
+#[cfg(feature = "structural_renderer")]
+use crate::{StructuralRendererSetting, error::StructuralRendererSerializeError};
 
 #[cfg(feature = "comp")]
 use crate::{ShellContext, Suggest};
 
-#[cfg(feature = "general_renderer")]
+#[cfg(feature = "structural_renderer")]
 use serde::Serialize;
 
-#[cfg_attr(feature = "general_renderer", derive(Serialize))]
+#[cfg_attr(feature = "structural_renderer", derive(Serialize))]
 #[allow(unused)]
 pub enum MockProgramCollect {
     Foo,
@@ -91,11 +91,11 @@ impl ProgramCollect for MockProgramCollect {
         unreachable!()
     }
 
-    #[cfg(feature = "general_renderer")]
-    fn general_render(
+    #[cfg(feature = "structural_renderer")]
+    fn structural_render(
         _any: AnyOutput<Self::Enum>,
-        _setting: &GeneralRendererSetting,
-    ) -> Result<RenderResult, GeneralRendererSerializeError> {
+        _setting: &StructuralRendererSetting,
+    ) -> Result<RenderResult, StructuralRendererSerializeError> {
         unreachable!()
     }
 }
diff --git a/mingling_core/src/program/config.rs b/mingling_core/src/program/config.rs
index 4e193f2..6d54a4e 100644
--- a/mingling_core/src/program/config.rs
+++ b/mingling_core/src/program/config.rs
@@ -119,12 +119,12 @@ impl Default for ProgramUserContext {
     }
 }
 
-#[cfg(feature = "general_renderer")]
+#[cfg(feature = "structural_renderer")]
 #[derive(Debug, Clone, Default)]
-/// Settings for the general renderer output format.
+/// Settings for the structural renderer output format.
 ///
 /// Controls how structured data (e.g., JSON, YAML, TOML) is rendered to stdout.
-pub enum GeneralRendererSetting {
+pub enum StructuralRendererSetting {
     /// Do not render structured output (use default formatting).
     #[default]
     Disable,
@@ -148,61 +148,61 @@ pub enum GeneralRendererSetting {
     RonPretty,
 }
 
-#[cfg(feature = "general_renderer")]
-impl std::str::FromStr for GeneralRendererSetting {
+#[cfg(feature = "structural_renderer")]
+impl std::str::FromStr for StructuralRendererSetting {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match just_fmt::kebab_case!(s).as_str() {
-            "disable" => Ok(GeneralRendererSetting::Disable),
+            "disable" => Ok(StructuralRendererSetting::Disable),
             #[cfg(feature = "json_serde_fmt")]
-            "json" => Ok(GeneralRendererSetting::Json),
+            "json" => Ok(StructuralRendererSetting::Json),
             #[cfg(feature = "json_serde_fmt")]
-            "json-pretty" => Ok(GeneralRendererSetting::JsonPretty),
+            "json-pretty" => Ok(StructuralRendererSetting::JsonPretty),
             #[cfg(feature = "yaml_serde_fmt")]
-            "yaml" => Ok(GeneralRendererSetting::Yaml),
+            "yaml" => Ok(StructuralRendererSetting::Yaml),
             #[cfg(feature = "toml_serde_fmt")]
-            "toml" => Ok(GeneralRendererSetting::Toml),
+            "toml" => Ok(StructuralRendererSetting::Toml),
             #[cfg(feature = "ron_serde_fmt")]
-            "ron" => Ok(GeneralRendererSetting::Ron),
+            "ron" => Ok(StructuralRendererSetting::Ron),
             #[cfg(feature = "ron_serde_fmt")]
-            "ron-pretty" => Ok(GeneralRendererSetting::RonPretty),
+            "ron-pretty" => Ok(StructuralRendererSetting::RonPretty),
             _ => Err(format!("Invalid renderer: '{s}'")),
         }
     }
 }
 
-#[cfg(feature = "general_renderer")]
-impl From<&str> for GeneralRendererSetting {
+#[cfg(feature = "structural_renderer")]
+impl From<&str> for StructuralRendererSetting {
     fn from(s: &str) -> Self {
-        s.parse().unwrap_or(GeneralRendererSetting::Disable)
+        s.parse().unwrap_or(StructuralRendererSetting::Disable)
     }
 }
 
-#[cfg(feature = "general_renderer")]
-impl From<String> for GeneralRendererSetting {
+#[cfg(feature = "structural_renderer")]
+impl From<String> for StructuralRendererSetting {
     fn from(s: String) -> Self {
         s.as_str().into()
     }
 }
 
-#[cfg(feature = "general_renderer")]
-impl std::fmt::Display for GeneralRendererSetting {
+#[cfg(feature = "structural_renderer")]
+impl std::fmt::Display for StructuralRendererSetting {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            GeneralRendererSetting::Disable => write!(f, "disable"),
+            StructuralRendererSetting::Disable => write!(f, "disable"),
             #[cfg(feature = "json_serde_fmt")]
-            GeneralRendererSetting::Json => write!(f, "json"),
+            StructuralRendererSetting::Json => write!(f, "json"),
             #[cfg(feature = "json_serde_fmt")]
-            GeneralRendererSetting::JsonPretty => write!(f, "json-pretty"),
+            StructuralRendererSetting::JsonPretty => write!(f, "json-pretty"),
             #[cfg(feature = "yaml_serde_fmt")]
-            GeneralRendererSetting::Yaml => write!(f, "yaml"),
+            StructuralRendererSetting::Yaml => write!(f, "yaml"),
             #[cfg(feature = "toml_serde_fmt")]
-            GeneralRendererSetting::Toml => write!(f, "toml"),
+            StructuralRendererSetting::Toml => write!(f, "toml"),
             #[cfg(feature = "ron_serde_fmt")]
-            GeneralRendererSetting::Ron => write!(f, "ron"),
+            StructuralRendererSetting::Ron => write!(f, "ron"),
             #[cfg(feature = "ron_serde_fmt")]
-            GeneralRendererSetting::RonPretty => write!(f, "ron-pretty"),
+            StructuralRendererSetting::RonPretty => write!(f, "ron-pretty"),
         }
     }
 }
@@ -236,113 +236,113 @@ mod tests {
         assert!(!ctx.assume_yes);
     }
 
-    #[cfg(feature = "general_renderer")]
-    mod general_renderer_tests {
+    #[cfg(feature = "structural_renderer")]
+    mod structural_renderer_tests {
         use super::*;
 
         #[test]
         fn from_str_disable() {
-            let val: GeneralRendererSetting = "disable".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Disable));
+            let val: StructuralRendererSetting = "disable".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Disable));
         }
 
         #[cfg(feature = "json_serde_fmt")]
         #[test]
         fn from_str_json() {
-            let val: GeneralRendererSetting = "json".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Json));
+            let val: StructuralRendererSetting = "json".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Json));
         }
 
         #[cfg(feature = "json_serde_fmt")]
         #[test]
         fn from_str_json_pretty() {
-            let val: GeneralRendererSetting = "json-pretty".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::JsonPretty));
+            let val: StructuralRendererSetting = "json-pretty".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::JsonPretty));
         }
 
         #[cfg(feature = "yaml_serde_fmt")]
         #[test]
         fn from_str_yaml() {
-            let val: GeneralRendererSetting = "yaml".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Yaml));
+            let val: StructuralRendererSetting = "yaml".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Yaml));
         }
 
         #[cfg(feature = "toml_serde_fmt")]
         #[test]
         fn from_str_toml() {
-            let val: GeneralRendererSetting = "toml".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Toml));
+            let val: StructuralRendererSetting = "toml".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Toml));
         }
 
         #[cfg(feature = "ron_serde_fmt")]
         #[test]
         fn from_str_ron() {
-            let val: GeneralRendererSetting = "ron".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Ron));
+            let val: StructuralRendererSetting = "ron".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Ron));
         }
 
         #[cfg(feature = "ron_serde_fmt")]
         #[test]
         fn from_str_ron_pretty() {
-            let val: GeneralRendererSetting = "ron-pretty".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::RonPretty));
+            let val: StructuralRendererSetting = "ron-pretty".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::RonPretty));
         }
 
         #[test]
         fn from_str_invalid() {
-            let res: Result<GeneralRendererSetting, String> = "invalid".parse();
+            let res: Result<StructuralRendererSetting, String> = "invalid".parse();
             assert!(res.is_err());
         }
 
         #[test]
         fn from_str_kebab_case() {
-            let val: GeneralRendererSetting = "JsonPretty".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::JsonPretty));
+            let val: StructuralRendererSetting = "JsonPretty".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::JsonPretty));
         }
 
         #[test]
         fn from_str_case_insensitive() {
-            let val: GeneralRendererSetting = "JSON".parse().unwrap();
-            assert!(matches!(val, GeneralRendererSetting::Json));
+            let val: StructuralRendererSetting = "JSON".parse().unwrap();
+            assert!(matches!(val, StructuralRendererSetting::Json));
         }
 
         #[test]
         fn from_and_str() {
-            let val = <GeneralRendererSetting as From<&str>>::from("json");
+            let val = <StructuralRendererSetting as From<&str>>::from("json");
             assert!(
-                matches!(val, GeneralRendererSetting::Disable)
-                    || matches!(val, GeneralRendererSetting::Json)
+                matches!(val, StructuralRendererSetting::Disable)
+                    || matches!(val, StructuralRendererSetting::Json)
             );
 
-            let val = <GeneralRendererSetting as From<&str>>::from("invalid");
-            assert!(matches!(val, GeneralRendererSetting::Disable));
+            let val = <StructuralRendererSetting as From<&str>>::from("invalid");
+            assert!(matches!(val, StructuralRendererSetting::Disable));
         }
 
         #[test]
         fn from_string() {
-            let val = <GeneralRendererSetting as From<String>>::from("json-pretty".to_string());
+            let val = <StructuralRendererSetting as From<String>>::from("json-pretty".to_string());
             assert!(
-                matches!(val, GeneralRendererSetting::Disable)
-                    || matches!(val, GeneralRendererSetting::JsonPretty)
+                matches!(val, StructuralRendererSetting::Disable)
+                    || matches!(val, StructuralRendererSetting::JsonPretty)
             );
         }
 
         #[test]
         fn display_disable() {
-            assert_eq!(GeneralRendererSetting::Disable.to_string(), "disable");
+            assert_eq!(StructuralRendererSetting::Disable.to_string(), "disable");
         }
 
         #[cfg(feature = "json_serde_fmt")]
         #[test]
         fn display_json() {
-            assert_eq!(GeneralRendererSetting::Json.to_string(), "json");
+            assert_eq!(StructuralRendererSetting::Json.to_string(), "json");
         }
 
         #[cfg(feature = "json_serde_fmt")]
         #[test]
         fn display_json_pretty() {
             assert_eq!(
-                GeneralRendererSetting::JsonPretty.to_string(),
+                StructuralRendererSetting::JsonPretty.to_string(),
                 "json-pretty"
             );
         }
diff --git a/mingling_core/src/program/exec.rs b/mingling_core/src/program/exec.rs
index 1832430..d1983ed 100644
--- a/mingling_core/src/program/exec.rs
+++ b/mingling_core/src/program/exec.rs
@@ -459,22 +459,22 @@ pub(crate) fn handle_program_control<C: ProgramCollect<Enum = C>>(
 #[inline]
 #[allow(unused_variables)]
 fn render<C: ProgramCollect<Enum = C>>(program: &Program<C>, any: AnyOutput<C>) -> RenderResult {
-    #[cfg(not(feature = "general_renderer"))]
+    #[cfg(not(feature = "structural_renderer"))]
     {
         let mut render_result = RenderResult::default();
         C::render(any, &mut render_result);
         render_result
     }
-    #[cfg(feature = "general_renderer")]
+    #[cfg(feature = "structural_renderer")]
     {
         #[allow(unreachable_patterns)]
-        match program.general_renderer_name {
-            super::GeneralRendererSetting::Disable => {
+        match program.structural_renderer_name {
+            super::StructuralRendererSetting::Disable => {
                 let mut render_result = RenderResult::default();
                 C::render(any, &mut render_result);
                 render_result
             }
-            _ => C::general_render(any, &program.general_renderer_name).unwrap(),
+            _ => C::structural_render(any, &program.structural_renderer_name).unwrap(),
         }
     }
 }
@@ -485,17 +485,17 @@ fn render_help<C: ProgramCollect<Enum = C>>(
     program: &Program<C>,
     entry: AnyOutput<C>,
 ) -> RenderResult {
-    #[cfg(not(feature = "general_renderer"))]
+    #[cfg(not(feature = "structural_renderer"))]
     {
         let mut render_result = RenderResult::default();
         C::render_help(entry, &mut render_result);
         render_result
     }
-    #[cfg(feature = "general_renderer")]
+    #[cfg(feature = "structural_renderer")]
     {
         #[allow(unreachable_patterns)]
-        match program.general_renderer_name {
-            super::GeneralRendererSetting::Disable => {
+        match program.structural_renderer_name {
+            super::StructuralRendererSetting::Disable => {
                 let mut render_result = RenderResult::default();
                 C::render_help(entry, &mut render_result);
                 render_result
diff --git a/mingling_core/src/program/hook.rs b/mingling_core/src/program/hook.rs
index 7b07d90..cd758ca 100644
--- a/mingling_core/src/program/hook.rs
+++ b/mingling_core/src/program/hook.rs
@@ -637,7 +637,7 @@ mod tests {
     use std::sync::atomic::{AtomicBool, Ordering};
 
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-    #[cfg_attr(feature = "general_renderer", derive(serde::Serialize))]
+    #[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))]
     enum MockHookEnum {
         A,
         B,
@@ -701,11 +701,11 @@ mod tests {
             unreachable!()
         }
 
-        #[cfg(feature = "general_renderer")]
-        fn general_render(
+        #[cfg(feature = "structural_renderer")]
+        fn structural_render(
             _any: crate::AnyOutput<MockHookEnum>,
-            _setting: &crate::GeneralRendererSetting,
-        ) -> Result<crate::RenderResult, crate::error::GeneralRendererSerializeError> {
+            _setting: &crate::StructuralRendererSetting,
+        ) -> Result<crate::RenderResult, crate::error::StructuralRendererSerializeError> {
             unreachable!()
         }
     }