cmark-writer 0.7.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

//! Custom node definitions for the CommonMark AST.

use crate::error::WriteResult;
use crate::writer::{HtmlRenderOptions, HtmlWriteResult};
use std::any::Any;

/// Trait for implementing custom node behavior
pub trait CustomNode: std::fmt::Debug + Send + Sync {
    /// Write the custom node content to the provided writer (for CommonMark output)
    fn write(&self, writer: &mut dyn CustomNodeWriter) -> WriteResult<()>;

    /// Returns the HTML representation of the custom node as a string, using specified options.
    ///
    /// By default, this returns an HTML comment indicating that HTML rendering is not implemented
    /// for this custom node type.
    fn to_html_string(&self, options: &HtmlRenderOptions) -> HtmlWriteResult<String> {
        let _ = options;
        Ok(format!(
            "<!-- HTML rendering not implemented for Custom Node: {} -->",
            self.type_name()
        ))
    }

    /// Clone the custom node
    fn clone_box(&self) -> Box<dyn CustomNode>;

    /// Check if two custom nodes are equal
    fn eq_box(&self, other: &dyn CustomNode) -> bool;

    /// Whether the custom node is a block element
    fn is_block(&self) -> bool;

    /// Convert to Any for type casting
    fn as_any(&self) -> &dyn Any;

    /// Convert to mutable Any for type casting
    fn as_any_mut(&mut self) -> &mut dyn Any;

    /// Get the type name of the custom node for pattern matching
    fn type_name(&self) -> &'static str {
        std::any::type_name::<Self>()
    }
}

/// Trait for custom node writer implementation
pub trait CustomNodeWriter {
    /// Write a string to the output
    fn write_str(&mut self, s: &str) -> std::fmt::Result;

    /// Write a character to the output
    fn write_char(&mut self, c: char) -> std::fmt::Result;
}

// Implement Clone for Box<dyn CustomNode>
impl Clone for Box<dyn CustomNode> {
    fn clone(&self) -> Self {
        self.clone_box()
    }
}

// Implement PartialEq for Box<dyn CustomNode>
impl PartialEq for Box<dyn CustomNode> {
    fn eq(&self, other: &Self) -> bool {
        self.eq_box(&**other)
    }
}