html-languageservice 0.12.0

The basics of an HTML language server.
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
113
114
115
116
117

use lsp_textdocument::FullTextDocument;
use lsp_types::{DocumentSymbol, Location, Range, SymbolInformation, SymbolKind, Uri};

use crate::parser::html_document::{HTMLDocument, Node};

pub fn find_document_symbols(
    uri: &Uri,
    document: &FullTextDocument,
    html_document: &HTMLDocument,
) -> Vec<SymbolInformation> {
    let mut symbols = vec![];
    let symbols2 = find_document_symbols2(document, html_document);

    for symbol in &symbols2 {
        walk(uri, symbol, None, &mut symbols);
    }

    symbols
}

pub fn find_document_symbols2(
    document: &FullTextDocument,
    html_document: &HTMLDocument,
) -> Vec<DocumentSymbol> {
    let mut symbols = vec![];

    for root in &html_document.roots {
        provide_file_symbols_internal(document, root, &mut symbols);
    }

    symbols
}

fn provide_file_symbols_internal(
    document: &FullTextDocument,
    node: &Node,
    symbols: &mut Vec<DocumentSymbol>,
) {
    let name = node_to_name(node);
    let range = Range::new(
        document.position_at(node.start as u32),
        document.position_at(node.end as u32),
    );

    let mut children = vec![];

    for child in &node.children {
        provide_file_symbols_internal(document, &child, &mut children);
    }

    #[allow(deprecated)]
    let symbol = DocumentSymbol {
        name,
        detail: None,
        kind: SymbolKind::FIELD,
        range: range.clone(),
        selection_range: range,
        tags: None,
        children: Some(children),
        deprecated: None,
    };

    symbols.push(symbol);
}

fn walk(
    uri: &Uri,
    node: &DocumentSymbol,
    parent: Option<&DocumentSymbol>,
    symbols: &mut Vec<SymbolInformation>,
) {
    #[allow(deprecated)]
    let symbol = SymbolInformation {
        name: node.name.clone(),
        kind: node.kind.clone(),
        tags: None,
        location: Location::new(uri.clone(), node.range),
        deprecated: None,
        container_name: parent.map(|v| v.name.clone()),
    };

    symbols.push(symbol);

    if let Some(children) = &node.children {
        for child in children {
            walk(uri, child, Some(&node), symbols)
        }
    }
}

fn node_to_name(node: &Node) -> String {
    if let Some(mut name) = node.tag.clone() {
        if !node.attributes.is_empty() {
            let id = node.attributes.get("id").map(|v| v.value.clone()).flatten();
            let class = node
                .attributes
                .get("class")
                .map(|v| v.value.clone())
                .flatten();
            if let Some(id) = id {
                name += &format!("#{}", id.replace("\"", "").replace("'", ""));
            }
            if let Some(class) = class {
                name += &class
                    .replace("\"", "")
                    .replace("'", "")
                    .split_ascii_whitespace()
                    .map(|class_name| format!(".{}", class_name))
                    .collect::<Vec<_>>()
                    .join("");
            }
        }
        name
    } else {
        "?".to_string()
    }
}