panache 2.43.0

An LSP, formatter, and linter for Markdown, Quarto, and R Markdown
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

pub use panache_parser::syntax::*;
use panache_parser::syntax::{
    SyntaxElement as ParserSyntaxElement, SyntaxNode as ParserSyntaxNode,
    SyntaxToken as ParserSyntaxToken,
};

#[derive(Debug, serde::Serialize)]
struct JsonRange {
    start: u32,
    end: u32,
}

#[derive(Debug, serde::Serialize)]
pub struct JsonToken {
    kind: String,
    range: JsonRange,
    text: String,
}

#[derive(Debug, serde::Serialize)]
pub struct JsonNode {
    kind: String,
    range: JsonRange,
    children: Vec<JsonElement>,
}

#[derive(Debug, serde::Serialize)]
#[serde(untagged)]
pub enum JsonElement {
    Node(JsonNode),
    Token(JsonToken),
}

fn range_to_json(range: rowan::TextRange) -> JsonRange {
    JsonRange {
        start: u32::from(range.start()),
        end: u32::from(range.end()),
    }
}

fn token_to_json(token: ParserSyntaxToken) -> JsonToken {
    JsonToken {
        kind: format!("{:?}", token.kind()),
        range: range_to_json(token.text_range()),
        text: token.text().to_string(),
    }
}

fn element_to_json(element: ParserSyntaxElement) -> JsonElement {
    match element {
        rowan::NodeOrToken::Node(node) => JsonElement::Node(cst_to_json(&node)),
        rowan::NodeOrToken::Token(token) => JsonElement::Token(token_to_json(token)),
    }
}

pub fn cst_to_json(node: &ParserSyntaxNode) -> JsonNode {
    let children: Vec<JsonElement> = node.children_with_tokens().map(element_to_json).collect();
    JsonNode {
        kind: format!("{:?}", node.kind()),
        range: range_to_json(node.text_range()),
        children,
    }
}