normalize-languages 0.3.2

Tree-sitter language support and dynamic grammar loading
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

//! JSON language support.

use crate::{Language, LanguageSymbols};
use tree_sitter::Node;

/// JSON language support.
pub struct Json;

impl Language for Json {
    fn name(&self) -> &'static str {
        "JSON"
    }
    fn extensions(&self) -> &'static [&'static str] {
        &["json", "jsonc"]
    }
    fn grammar_name(&self) -> &'static str {
        "json"
    }

    fn as_symbols(&self) -> Option<&dyn LanguageSymbols> {
        Some(self)
    }

    fn refine_kind(
        &self,
        node: &Node,
        _content: &str,
        tag_kind: crate::SymbolKind,
    ) -> crate::SymbolKind {
        // Pairs with object values act as containers (sections/namespaces)
        if node.kind() == "pair"
            && let Some(value) = node.child_by_field_name("value")
            && value.kind() == "object"
        {
            return crate::SymbolKind::Module;
        }
        tag_kind
    }

    fn node_name<'a>(&self, node: &Node, content: &'a str) -> Option<&'a str> {
        // For pair nodes, extract the key string content
        if node.kind() == "pair"
            && let Some(key) = node.child_by_field_name("key")
        {
            let mut cursor = key.walk();
            for child in key.children(&mut cursor) {
                if child.kind() == "string_content" {
                    return Some(&content[child.byte_range()]);
                }
            }
        }
        None
    }

    fn container_body<'a>(&self, node: &'a Node<'a>) -> Option<Node<'a>> {
        if node.kind() == "pair"
            && let Some(value) = node.child_by_field_name("value")
            && value.kind() == "object"
        {
            return Some(value);
        }
        None
    }

    fn build_signature(&self, node: &Node, content: &str) -> String {
        if node.kind() == "pair"
            && let Some(key) = self.node_name(node, content)
        {
            if let Some(value) = node.child_by_field_name("value") {
                return match value.kind() {
                    "object" => format!("{}: {{}}", key),
                    "array" => format!("{}: []", key),
                    _ => {
                        let val_text = &content[value.byte_range()];
                        if val_text.len() > 40 {
                            format!("{}: {}…", key, &val_text[..37])
                        } else {
                            format!("{}: {}", key, val_text)
                        }
                    }
                };
            }
            return key.to_string();
        }
        content[node.byte_range()]
            .lines()
            .next()
            .unwrap_or("")
            .trim()
            .to_string()
    }
}

impl LanguageSymbols for Json {}

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

    #[test]
    fn unused_node_kinds_audit() {
        // JSON has no "interesting" unused kinds matching our patterns
        let documented_unused: &[&str] = &[];
        validate_unused_kinds_audit(&Json, documented_unused)
            .expect("JSON unused node kinds audit failed");
    }
}