notedown_ast 0.14.13

Notedown Abstract Syntax Tree
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

use super::*;
use crate::{NoteError, Result};

///
#[repr(u8)]
#[derive(Clone, Eq, PartialEq, Hash)]
pub enum TextSpan {
    ///
    Empty,
    ///
    Normal(String),
    ///
    Raw(String),
    ///
    HTMLRawInline(String),
    /// The Unicode codepoint sequence of this emoji.
    /// The actual/rendered emoji.
    Emoji(&'static str),
    ///
    Escaped(char),
    ///
    SoftNewline,
    ///
    HardNewline,
    ///
    CheckBox(bool),
}

impl Default for TextSpan {
    fn default() -> Self {
        Self::Empty
    }
}

impl ASTKind {
    /// Aka. `<br>`
    #[inline]
    pub fn hard_break(range: MaybeRanged) -> ASTNode {
        TextSpan::HardNewline.into_node(range)
    }
    /// Aka. `\n`
    #[inline]
    pub fn soft_break(range: MaybeRanged) -> ASTNode {
        TextSpan::SoftNewline.into_node(range)
    }
    ///
    #[inline]
    pub fn text(s: impl Into<String>, range: MaybeRanged) -> ASTNode {
        TextSpan::Normal(s.into()).into_node(range)
    }
    ///
    #[inline]
    pub fn text_raw(s: impl Into<String>, range: MaybeRanged) -> ASTNode {
        TextSpan::Raw(s.into()).into_node(range)
    }
    /// Constructor of [`TextSpan::Escaped`]
    #[inline]
    pub fn escaped(text: &str, range: MaybeRanged) -> Result<ASTNode> {
        let c = match text.chars().next() {
            None => '\\',
            Some(s) => s,
        };
        Ok(TextSpan::Escaped(c).into_node(range))
    }
    /// Constructor of [`TextSpan::Escaped`]
    #[inline]
    pub fn escaped_char(c: char, range: MaybeRanged) -> ASTNode {
        TextSpan::Escaped(c).into_node(range)
    }
    /// Constructor of [`TextSpan::Normal`]
    #[inline]
    pub fn escaped_html(_: char, _: MaybeRanged) -> Result<ASTNode> {
        todo!()
    }
    /// Constructor of [`TextSpan::Emoji`]
    #[inline]
    pub fn emoji(text: &str, range: MaybeRanged) -> Result<ASTNode> {
        match text_utils::parse_emoji(text) {
            None => {
                let msg = format!("{} can not be parsed as emoji", text);
                let mut error = NoteError::syntax_error(msg);
                error.range = range;
                Err(error)
            }
            Some(s) => Ok(TextSpan::Emoji(s.grapheme).into_node(range)),
        }
    }
}