diff options
Diffstat (limited to 'mingling_core')
22 files changed, 185 insertions, 185 deletions
diff --git a/mingling_core/Cargo.toml b/mingling_core/Cargo.toml index 4ce9ecd..b22a630 100644 --- a/mingling_core/Cargo.toml +++ b/mingling_core/Cargo.toml @@ -17,7 +17,7 @@ async = [] builds = [] dispatch_tree = [] -general_renderer = ["dep:serde"] +structural_renderer = ["dep:serde"] ron_serde_fmt = ["dep:ron"] json_serde_fmt = ["dep:serde_json"] yaml_serde_fmt = ["dep:serde_yaml"] @@ -35,7 +35,7 @@ just_fmt.workspace = true # comp just_template = { workspace = true, optional = true } -# general_renderer +# structural_renderer serde = { workspace = true, optional = true } ron = { workspace = true, optional = true } serde_json = { workspace = true, optional = true } diff --git a/mingling_core/src/any.rs b/mingling_core/src/any.rs index ef9f912..ad02b0c 100644 --- a/mingling_core/src/any.rs +++ b/mingling_core/src/any.rs @@ -161,7 +161,7 @@ mod tests { } #[derive(Debug, Clone, PartialEq)] - #[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] + #[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] struct AlphaData { value: i32, } @@ -173,7 +173,7 @@ mod tests { } #[derive(Debug, Clone, PartialEq)] - #[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] + #[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] struct BetaData { name: String, } @@ -186,7 +186,7 @@ mod tests { #[derive(Debug, Clone, PartialEq)] #[allow(dead_code)] - #[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] + #[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] struct GammaData; impl Groupped<MockGroup> for GammaData { @@ -333,9 +333,9 @@ mod tests { assert_eq!(format!("{}", NextProcess::Renderer), "Renderer"); } - // AnyOutput::restore general_renderer feature only + // AnyOutput::restore structural_renderer feature only - #[cfg(feature = "general_renderer")] + #[cfg(feature = "structural_renderer")] #[test] fn test_any_output_restore_success() { use serde::Serialize; @@ -357,7 +357,7 @@ mod tests { assert_eq!(restored, Some(SerData { x: 42 })); } - #[cfg(feature = "general_renderer")] + #[cfg(feature = "structural_renderer")] #[test] fn test_any_output_restore_type_mismatch() { use serde::Serialize; diff --git a/mingling_core/src/any/group.rs b/mingling_core/src/any/group.rs index 07f8400..afe5e3a 100644 --- a/mingling_core/src/any/group.rs +++ b/mingling_core/src/any/group.rs @@ -3,7 +3,7 @@ use crate::{AnyOutput, ChainProcess}; /// Used to mark a type with a unique enum ID, assisting dynamic dispatch /// /// **Note:** Unlike earlier versions, `Groupped` no longer requires `Serialize` -/// even when the `general_renderer` feature is enabled. Structured output is +/// even when the `structural_renderer` feature is enabled. Structured output is /// controlled separately via the [`StructalData`] trait. pub trait Groupped<Group> where diff --git a/mingling_core/src/comp/flags.rs b/mingling_core/src/comp/flags.rs index 424fe8b..9a88d2e 100644 --- a/mingling_core/src/comp/flags.rs +++ b/mingling_core/src/comp/flags.rs @@ -5,7 +5,7 @@ use just_fmt::snake_case; /// This enum defines the supported shell types that can be used for /// generating shell-specific command syntax, scripts, or completions. #[derive(Default, Debug, Clone)] -#[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] +#[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] pub enum ShellFlag { /// Represents the Bash shell. #[default] diff --git a/mingling_core/src/comp/shell_ctx.rs b/mingling_core/src/comp/shell_ctx.rs index 616eade..cfa4700 100644 --- a/mingling_core/src/comp/shell_ctx.rs +++ b/mingling_core/src/comp/shell_ctx.rs @@ -6,7 +6,7 @@ use crate::{Flag, ShellFlag, Suggest}; /// providing information about the current command line state /// to guide how completions should be generated. #[derive(Default, Debug)] -#[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] +#[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] pub struct ShellContext { /// The full command line (-f / --command-line) pub command_line: String, diff --git a/mingling_core/src/comp/suggest.rs b/mingling_core/src/comp/suggest.rs index bd5dea6..a81de64 100644 --- a/mingling_core/src/comp/suggest.rs +++ b/mingling_core/src/comp/suggest.rs @@ -5,7 +5,7 @@ use crate::ShellContext; /// A completion suggestion that tells the shell how to perform completion. /// This can be either a set of specific suggestion items or a request for file completion. #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] +#[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] pub enum Suggest { /// A set of specific suggestion items for the shell to display. Suggest(BTreeSet<SuggestItem>), @@ -78,7 +78,7 @@ impl std::ops::DerefMut for Suggest { /// The first `String` always holds the suggestion text, and the second `String` (if present) /// holds an optional description providing additional context. #[derive(Debug, Clone, PartialEq, Eq, Hash)] -#[cfg_attr(feature = "general_renderer", derive(serde::Serialize))] +#[cfg_attr(feature = "structural_renderer", derive(serde::Serialize))] pub enum SuggestItem { /// A simple suggestion with only the suggestion text. Simple(String), diff --git a/mingling_core/src/lib.rs b/mingling_core/src/lib.rs index 9d0ac2a..ef7d192 100644 --- a/mingling_core/src/lib.rs +++ b/mingling_core/src/lib.rs @@ -19,12 +19,12 @@ pub mod test { pub use crate::tester::*; } -#[cfg(feature = "general_renderer")] -pub use crate::renderer::general::GeneralRenderer; +#[cfg(feature = "structural_renderer")] +pub use crate::renderer::structural::StructuralRenderer; // NOT re-exported at top level: the `StructuralData` trait is sealed and only // accessible through the derive macro. Users who need the trait can access it -// via `mingling::renderer::general::StructuralData` (through the inner alias). +// via `mingling::renderer::structural::StructuralData` (through the inner alias). pub use crate::any::group::*; pub use crate::any::*; @@ -42,8 +42,8 @@ pub mod error { pub use crate::asset::chain::error::*; pub use crate::exec::error::*; pub use crate::program::error::*; - #[cfg(feature = "general_renderer")] - pub use crate::renderer::general::error::*; + #[cfg(feature = "structural_renderer")] + pub use crate::renderer::structural::error::*; } pub use crate::program::*; @@ -83,8 +83,8 @@ pub mod __private { /// Re-export so the derive macro can reference the trait without /// conflicting with the derive macro name at `::mingling::StructuralData`. - #[cfg(feature = "general_renderer")] - pub use crate::renderer::general::structural_data::StructuralData; + #[cfg(feature = "structural_renderer")] + pub use crate::renderer::structural::structural_data::StructuralData; } #[doc(hidden)] diff --git a/mingling_core/src/program.rs b/mingling_core/src/program.rs index e791d86..71d5290 100644 --- a/mingling_core/src/program.rs +++ b/mingling_core/src/program.rs @@ -56,8 +56,8 @@ where pub stdout_setting: ProgramStdoutSetting, pub user_context: ProgramUserContext, - #[cfg(feature = "general_renderer")] - pub general_renderer_name: GeneralRendererSetting, + #[cfg(feature = "structural_renderer")] + pub structural_renderer_name: StructuralRendererSetting, pub(crate) hooks: Vec<ProgramHook<C>>, @@ -99,8 +99,8 @@ where stdout_setting: ProgramStdoutSetting::default(), user_context: ProgramUserContext::default(), - #[cfg(feature = "general_renderer")] - general_renderer_name: GeneralRendererSetting::Disable, + #[cfg(feature = "structural_renderer")] + structural_renderer_name: StructuralRendererSetting::Disable, hooks: Vec::new(), 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!() } } diff --git a/mingling_core/src/renderer.rs b/mingling_core/src/renderer.rs index 33dd08d..435518d 100644 --- a/mingling_core/src/renderer.rs +++ b/mingling_core/src/renderer.rs @@ -1,3 +1,3 @@ -#[cfg(feature = "general_renderer")] -pub mod general; +#[cfg(feature = "structural_renderer")] +pub mod structural; pub mod render_result; 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 {} diff --git a/mingling_core/tests/test-all/Cargo.toml b/mingling_core/tests/test-all/Cargo.toml index 9eea2de..a63b6e6 100644 --- a/mingling_core/tests/test-all/Cargo.toml +++ b/mingling_core/tests/test-all/Cargo.toml @@ -8,7 +8,7 @@ publish = false [dependencies] mingling = { path = "../../../mingling", features = [ - "general_renderer_full", + "structural_renderer_full", "comp", "builds", "repl", diff --git a/mingling_core/tests/test-all/tests/integration.rs b/mingling_core/tests/test-all/tests/integration.rs index 99910a9..3581702 100644 --- a/mingling_core/tests/test-all/tests/integration.rs +++ b/mingling_core/tests/test-all/tests/integration.rs @@ -1,6 +1,6 @@ use mingling::Flag; -use mingling::GeneralRenderer; -use mingling::GeneralRendererSetting; +use mingling::StructuralRenderer; +use mingling::StructuralRendererSetting; use mingling::MockProgramCollect; use mingling::NextProcess; use mingling::StructuralData; @@ -89,7 +89,7 @@ fn test_render_result_print() { assert_eq!(&*r, "hello"); } -// GeneralRenderer +// StructuralRenderer #[derive(Debug, Clone, PartialEq, Serialize, StructuralData)] struct TestData { @@ -98,25 +98,25 @@ struct TestData { } #[test] -fn test_general_renderer_disable() { +fn test_structural_renderer_disable() { let data = TestData { name: "test".into(), value: 42, }; let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&data, &GeneralRendererSetting::Disable, &mut r); + let result = StructuralRenderer::render(&data, &StructuralRendererSetting::Disable, &mut r); assert!(result.is_ok()); assert!(r.is_empty()); } #[test] -fn test_general_renderer_json() { +fn test_structural_renderer_json() { let data = TestData { name: "test".into(), value: 42, }; let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&data, &GeneralRendererSetting::Json, &mut r); + let result = StructuralRenderer::render(&data, &StructuralRendererSetting::Json, &mut r); assert!(result.is_ok()); assert!(!r.is_empty()); } diff --git a/mingling_core/tests/test-general-renderer/Cargo.lock b/mingling_core/tests/test-structural-renderer/Cargo.lock index 7c4b628..a0f7088 100644 --- a/mingling_core/tests/test-general-renderer/Cargo.lock +++ b/mingling_core/tests/test-structural-renderer/Cargo.lock @@ -210,7 +210,7 @@ dependencies = [ ] [[package]] -name = "test-general-renderer" +name = "test-structural-renderer" version = "0.1.0" dependencies = [ "mingling", diff --git a/mingling_core/tests/test-general-renderer/Cargo.toml b/mingling_core/tests/test-structural-renderer/Cargo.toml index 3d038aa..6ae8fce 100644 --- a/mingling_core/tests/test-general-renderer/Cargo.toml +++ b/mingling_core/tests/test-structural-renderer/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "test-general-renderer" +name = "test-structural-renderer" version = "0.1.0" edition = "2024" publish = false @@ -7,5 +7,5 @@ publish = false [workspace] [dependencies] -mingling = { path = "../../../mingling", features = ["general_renderer_full", "parser"] } +mingling = { path = "../../../mingling", features = ["structural_renderer_full", "parser"] } serde = { version = "1", features = ["derive"] } diff --git a/mingling_core/tests/test-general-renderer/tests/integration.rs b/mingling_core/tests/test-structural-renderer/tests/integration.rs index 2e2472e..3c3c6db 100644 --- a/mingling_core/tests/test-general-renderer/tests/integration.rs +++ b/mingling_core/tests/test-structural-renderer/tests/integration.rs @@ -1,4 +1,4 @@ -use mingling::{GeneralRenderer, GeneralRendererSetting, RenderResult, StructuralData}; +use mingling::{StructuralRenderer, StructuralRendererSetting, RenderResult, StructuralData}; use serde::Serialize; #[derive(Debug, Clone, PartialEq, Serialize, StructuralData)] @@ -17,7 +17,7 @@ fn test_data() -> TestData { #[test] fn test_render_disable() { let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Disable, &mut r); + let result = StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Disable, &mut r); assert!(result.is_ok()); assert!(r.is_empty()); } @@ -25,7 +25,7 @@ fn test_render_disable() { #[test] fn test_render_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()); let output: String = r.into(); @@ -38,7 +38,7 @@ fn test_render_json() { #[test] fn test_render_yaml() { let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Yaml, &mut r); + let result = StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Yaml, &mut r); assert!(result.is_ok()); assert!(!r.is_empty()); let output: String = r.into(); @@ -51,7 +51,7 @@ fn test_render_yaml() { #[test] fn test_render_toml() { let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Toml, &mut r); + let result = StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Toml, &mut r); assert!(result.is_ok()); assert!(!r.is_empty()); let output: String = r.into(); @@ -64,7 +64,7 @@ fn test_render_toml() { #[test] fn test_render_ron() { let mut r = RenderResult::default(); - let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Ron, &mut r); + let result = StructuralRenderer::render(&test_data(), &StructuralRendererSetting::Ron, &mut r); assert!(result.is_ok()); assert!(!r.is_empty()); let output: String = r.into(); |