mermaid-builder 0.1.2

A Rust library for generating Mermaid diagrams using the builder pattern.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Submodule providing a builder struct for the configuration of class diagrams
//! in Mermaid syntax.

use alloc::string::ToString;

use crate::{
    diagrams::class_diagram::configuration::ClassDiagramConfiguration, errors::ConfigError,
    shared::generic_configuration::GenericConfigurationBuilder, traits::ConfigurationBuilder,
};

#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClassDiagramConfigurationBuilder {
    /// Generic configuration options which apply to all Mermaid diagrams.
    generic: GenericConfigurationBuilder,
    /// Whether to hide empty members in the class diagram.
    hide_empty_members_box: bool,
}

impl ClassDiagramConfigurationBuilder {
    /// Sets whether to hide empty members in the class diagram.
    pub fn hide_empty_members_box(mut self, hide: bool) -> Self {
        self.hide_empty_members_box = hide;
        self
    }

    /// Sets the theme to use for the diagram.
    pub fn theme(mut self, theme: crate::shared::generic_configuration::Theme) -> Self {
        self.generic = self.generic.theme(theme);
        self
    }

    /// Sets the look to use for the diagram.
    pub fn look(mut self, look: crate::shared::generic_configuration::Look) -> Self {
        self.generic = self.generic.look(look);
        self
    }
}

impl TryFrom<ClassDiagramConfigurationBuilder> for ClassDiagramConfiguration {
    type Error = ConfigError;

    fn try_from(builder: ClassDiagramConfigurationBuilder) -> Result<Self, Self::Error> {
        Ok(ClassDiagramConfiguration {
            generic: builder.generic.try_into()?,
            hide_empty_members_box: builder.hide_empty_members_box,
        })
    }
}

impl ConfigurationBuilder for ClassDiagramConfigurationBuilder {
    type Configuration = ClassDiagramConfiguration;
    type Error = ConfigError;

    fn build(self) -> Result<Self::Configuration, Self::Error> {
        self.try_into()
    }

    fn title<S: ToString>(mut self, title: S) -> Result<Self, Self::Error> {
        self.generic = self.generic.title(title)?;
        Ok(self)
    }

    fn direction(mut self, direction: crate::shared::generic_configuration::Direction) -> Self {
        self.generic = self.generic.direction(direction);
        self
    }

    fn renderer(mut self, renderer: crate::shared::generic_configuration::Renderer) -> Self {
        self.generic = self.generic.renderer(renderer);
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        shared::generic_configuration::{Direction, Look, Renderer, Theme},
        traits::Configuration,
    };

    #[test]
    fn test_class_diagram_configuration_builder()
    -> Result<(), alloc::boxed::Box<dyn core::error::Error>> {
        let config = ClassDiagramConfigurationBuilder::default()
            .title("My Class Diagram")?
            .direction(Direction::LeftToRight)
            .renderer(Renderer::Dagre)
            .theme(Theme::Forest)
            .look(Look::HandDrawn)
            .hide_empty_members_box(true)
            .build()?;

        assert!(config.hide_empty_members_box);
        assert_eq!(config.title(), Some("My Class Diagram"));
        assert_eq!(config.direction(), Direction::LeftToRight);
        assert_eq!(config.renderer(), Renderer::Dagre);
        assert_eq!(config.theme(), Theme::Forest);
        assert_eq!(config.look(), Look::HandDrawn);
        Ok(())
    }
}