refactor(general_renderer): rename to structural_renderer

1 files changed, 58 insertions, 58 deletions

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"
             );
         }