cmark-writer 0.8.0

A CommonMark writer implementation in Rust for serializing AST nodes to CommonMark format
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Formatting and rendering traits
//!
//! This module provides a unified system for rendering content to different formats.
//! It combines the high-level format abstraction with concrete rendering implementations.

use crate::error::WriteResult;
use crate::writer::{CommonMarkWriter, HtmlWriter};

// ==== Core Rendering Traits ====

/// CommonMark rendering trait - using concrete types for dyn compatibility
pub trait CommonMarkRenderable: super::core::NodeContent {
    /// Render to CommonMark format
    fn render_commonmark(&self, writer: &mut CommonMarkWriter) -> WriteResult<()>;
}

/// HTML rendering trait - using concrete types for dyn compatibility
pub trait HtmlRenderable: super::core::NodeContent {
    /// Render to HTML format
    fn render_html(&self, writer: &mut HtmlWriter) -> WriteResult<()>;
}

// ==== High-Level Format Traits ====

/// Generic format trait - supports multiple output formats
pub trait Format<W> {
    /// Format self to the specified writer
    fn format(&self, writer: &mut W) -> WriteResult<()>;
}

/// Convenience trait for CommonMark format
pub trait ToCommonMark {
    /// Format to CommonMark
    fn to_commonmark(&self, writer: &mut CommonMarkWriter) -> WriteResult<()>;
}

/// Convenience trait for HTML format
pub trait ToHtml {
    /// Format to HTML
    fn to_html(&self, writer: &mut HtmlWriter) -> WriteResult<()>;
}

// ==== Automatic Implementations ====

/// Automatically implement ToCommonMark for types that implement `Format<CommonMarkWriter>`
impl<T> ToCommonMark for T
where
    T: Format<CommonMarkWriter>,
{
    fn to_commonmark(&self, writer: &mut CommonMarkWriter) -> WriteResult<()> {
        self.format(writer)
    }
}

/// Automatically implement ToHtml for types that implement `Format<HtmlWriter>`
impl<T> ToHtml for T
where
    T: Format<HtmlWriter>,
{
    fn to_html(&self, writer: &mut HtmlWriter) -> WriteResult<()> {
        self.format(writer)
    }
}

/// Bridge implementation: Format -> Renderable
impl<T> CommonMarkRenderable for T
where
    T: ToCommonMark + super::core::NodeContent,
{
    fn render_commonmark(&self, writer: &mut CommonMarkWriter) -> WriteResult<()> {
        self.to_commonmark(writer)
    }
}

impl<T> HtmlRenderable for T
where
    T: ToHtml + super::core::NodeContent,
{
    fn render_html(&self, writer: &mut HtmlWriter) -> WriteResult<()> {
        self.to_html(writer)
    }
}

// ==== Multi-Format Support ====

/// Multi-format node trait - unified interface for rendering to multiple formats
///
/// This trait provides a unified multi-format rendering interface for custom nodes.
/// All custom nodes should support at least CommonMark format.
pub trait MultiFormat: ToCommonMark {
    /// Check if HTML format is supported
    ///
    /// Returns false by default. Only types supporting HTML need to override this.
    fn supports_html(&self) -> bool {
        false
    }

    /// HTML rendering implementation
    ///
    /// By default, generates a comment indicating HTML is not supported.
    /// Types that support HTML should override this method.
    fn html_format(&self, writer: &mut HtmlWriter) -> WriteResult<()> {
        writer
            .raw_html(&format!(
                "<!-- HTML rendering not implemented for {} -->",
                std::any::type_name::<Self>()
            ))
            .map_err(Into::into)
    }

    /// Render to the appropriate format based on writer type
    fn render_multi<W>(&self, writer: &mut W) -> WriteResult<()>
    where
        W: std::any::Any + 'static,
    {
        if let Some(cm_writer) =
            (writer as &mut dyn std::any::Any).downcast_mut::<CommonMarkWriter>()
        {
            self.to_commonmark(cm_writer)
        } else if let Some(html_writer) =
            (writer as &mut dyn std::any::Any).downcast_mut::<HtmlWriter>()
        {
            if self.supports_html() {
                self.html_format(html_writer)
            } else {
                Err(crate::error::WriteError::custom(
                    "HTML format not supported for this node type",
                ))
            }
        } else {
            Err(crate::error::WriteError::custom("Unsupported writer type"))
        }
    }
}

/// Automatically implement MultiFormat for types that implement both ToCommonMark and ToHtml
impl<T> MultiFormat for T
where
    T: ToCommonMark + ToHtml,
{
    fn supports_html(&self) -> bool {
        true
    }

    fn html_format(&self, writer: &mut HtmlWriter) -> WriteResult<()> {
        self.to_html(writer)
    }
}