marco-core 1.0.2

nom-based Markdown parser, HTML renderer, and intelligence features (highlights, diagnostics, completions) for the Marco editor.
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

//! Inline-level markdown grammar/parsing namespace for intelligence.
//!
//! Current implementation reuses parser/grammar inlines from `crate::parser`.

use super::ast::{is_inline_kind, Node, NodeKind};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum InlineCategory {
    Text,
    TaskCheckboxInline,
    Emphasis,
    Strong,
    StrongEmphasis,
    Strikethrough,
    Mark,
    Superscript,
    Subscript,
    Link,
    LinkReference,
    FootnoteReference,
    Image,
    CodeSpan,
    InlineHtml,
    HardBreak,
    SoftBreak,
    PlatformMention,
    InlineMath,
    DisplayMath,
}

pub fn classify_inline_kind(kind: &NodeKind) -> Option<InlineCategory> {
    match kind {
        NodeKind::Text(_) => Some(InlineCategory::Text),
        NodeKind::TaskCheckboxInline { .. } => Some(InlineCategory::TaskCheckboxInline),
        NodeKind::Emphasis => Some(InlineCategory::Emphasis),
        NodeKind::Strong => Some(InlineCategory::Strong),
        NodeKind::StrongEmphasis => Some(InlineCategory::StrongEmphasis),
        NodeKind::Strikethrough => Some(InlineCategory::Strikethrough),
        NodeKind::Mark => Some(InlineCategory::Mark),
        NodeKind::Superscript => Some(InlineCategory::Superscript),
        NodeKind::Subscript => Some(InlineCategory::Subscript),
        NodeKind::Link { .. } => Some(InlineCategory::Link),
        NodeKind::LinkReference { .. } => Some(InlineCategory::LinkReference),
        NodeKind::FootnoteReference { .. } => Some(InlineCategory::FootnoteReference),
        NodeKind::Image { .. } => Some(InlineCategory::Image),
        NodeKind::CodeSpan(_) => Some(InlineCategory::CodeSpan),
        NodeKind::InlineHtml(_) => Some(InlineCategory::InlineHtml),
        NodeKind::HardBreak => Some(InlineCategory::HardBreak),
        NodeKind::SoftBreak => Some(InlineCategory::SoftBreak),
        NodeKind::PlatformMention { .. } => Some(InlineCategory::PlatformMention),
        NodeKind::InlineMath { .. } => Some(InlineCategory::InlineMath),
        NodeKind::DisplayMath { .. } => Some(InlineCategory::DisplayMath),
        _ => None,
    }
}

pub fn is_inline_node(node: &Node) -> bool {
    is_inline_kind(&node.kind)
}

/// Collect inline nodes recursively in pre-order.
pub fn collect_inline_nodes<'a>(nodes: &'a [Node], out: &mut Vec<&'a Node>) {
    for node in nodes {
        if is_inline_node(node) {
            out.push(node);
        }
        if !node.children.is_empty() {
            collect_inline_nodes(&node.children, out);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn smoke_test_classify_inline_kind_basic() {
        assert_eq!(
            classify_inline_kind(&NodeKind::Text("x".to_string())),
            Some(InlineCategory::Text)
        );
        assert_eq!(classify_inline_kind(&NodeKind::Paragraph), None);
    }

    #[test]
    fn smoke_test_collect_inline_nodes_recursive() {
        let nodes = vec![Node {
            kind: NodeKind::Paragraph,
            span: None,
            children: vec![Node {
                kind: NodeKind::Link {
                    url: "https://example.com".to_string(),
                    title: None,
                },
                span: None,
                children: vec![Node {
                    kind: NodeKind::Text("example".to_string()),
                    span: None,
                    children: vec![],
                }],
            }],
        }];

        let mut inlines = Vec::new();
        collect_inline_nodes(&nodes, &mut inlines);

        assert_eq!(inlines.len(), 2);
        assert!(matches!(inlines[0].kind, NodeKind::Link { .. }));
        assert!(matches!(inlines[1].kind, NodeKind::Text(_)));
    }
}