cosy 0.1.0

A parser for Cosense/Scrapbox markup syntax that produces a typed AST
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

use super::bracket_content::take_bracket_content;
use crate::CosyParserExtension;
use crate::ast::Node;
use crate::tokens::{ICON_SUFFIX, LBRACKET, RBRACKET};
use crate::url::{UrlKind, infer_url};
use winnow::combinator::delimited;
use winnow::error::ContextError;
use winnow::prelude::*;

use super::node::parse_nodes_no_deco;

/// Parses `[[...]]` Strong notation.
///
/// Returns `Node::Strong` containing the recursively parsed inner nodes.
/// Fails immediately if the input does not start with `[[`, so that
/// `alt()` can fall through to the standard bracket parser.
pub fn parse_strong<'s, 'i, E>(
    extension: &'s E,
) -> impl Parser<&'i str, Node<E::Output>, ContextError> + 's
where
    E: CosyParserExtension,
{
    move |input: &mut &'i str| {
        if !input.starts_with("[[") {
            return Err(ContextError::new());
        }

        // Outer delimited([, ..., ]) wraps the inner delimited([, content, ])
        // For [[text]]:
        //   outer [ consumed → remaining [text]]
        //   inner delimited extracts "text" and consumes [text] → remaining ]
        //   outer ] consumed → done
        let mut content: &str = delimited(
            LBRACKET,
            delimited(LBRACKET, take_bracket_content, RBRACKET),
            RBRACKET,
        )
        .parse_next(input)?;

        let nodes = match content.strip_suffix(ICON_SUFFIX) {
            Some("") => return Err(ContextError::new()),
            Some(name) => vec![Node::Icon {
                name: name.to_string(),
                count: 1,
            }],
            None => match infer_url(content) {
                Some((url, UrlKind::Image)) => vec![Node::Image(url)],
                Some((url, UrlKind::Other)) => vec![Node::Link(crate::ast::Link::Url(url))],
                None => parse_nodes_no_deco(&mut content, extension)?,
            },
        };
        Ok(Node::Strong(nodes))
    }
}

#[cfg(test)]
mod tests {
    use super::parse_strong;
    use crate::ast::{Link, Node};
    use winnow::prelude::*;

    #[test]
    fn test_parse_strong_basic() {
        let mut input = "[[Bold text]]";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![Node::Text("Bold text".to_string())])
        );
        assert_eq!(input, "");
    }

    #[test]
    fn test_parse_strong_multiple_words() {
        let mut input = "[[Multiple words here]] rest";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![Node::Text("Multiple words here".to_string())])
        );
        assert_eq!(input, " rest");
    }

    #[test]
    fn test_parse_strong_with_nested_link() {
        let mut input = "[[Link inside [Page] here]]";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![
                Node::Text("Link inside ".to_string()),
                Node::Link(Link::Page("Page".to_string())),
                Node::Text(" here".to_string()),
            ])
        );
        assert_eq!(input, "");
    }

    #[test]
    fn test_parse_strong_image() {
        let mut input = "[[https://example.com/photo.png]]";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![Node::Image(
                ::url::Url::parse("https://example.com/photo.png").unwrap()
            )])
        );
        assert_eq!(input, "");
    }

    #[test]
    fn test_parse_strong_non_image_url_is_link() {
        let mut input = "[[https://example.com/page]]";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![Node::Link(crate::ast::Link::Url(
                ::url::Url::parse("https://example.com/page").unwrap()
            ))])
        );
        assert_eq!(input, "");
    }

    #[test]
    fn test_parse_strong_icon() {
        let mut input = "[[user.icon]]";
        let result: Node<()> = parse_strong(&()).parse_next(&mut input).unwrap();
        assert_eq!(
            result,
            Node::Strong(vec![Node::Icon {
                name: "user".to_string(),
                count: 1,
            }])
        );
        assert_eq!(input, "");
    }

    #[test]
    fn test_single_bracket_not_strong() {
        let mut input = "[text]";
        let result = parse_strong::<()>(&()).parse_next(&mut input);
        assert!(result.is_err());
        // Input must be unchanged
        assert_eq!(input, "[text]");
    }
}