repo-mapper 0.0.1

Token-budget-respecting repository map generator — ranked structural summary of a codebase
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

//! Query registry with bundled .scm files (SPEC §4.1).

/// A pair of queries: main tags query and optional idents fallback.
#[derive(Debug, Clone, Copy)]
pub struct QueryPair {
    /// Main tags query content
    pub tags: &'static str,
    /// Optional fallback idents query (for languages without name.reference.call)
    pub idents: Option<&'static str>,
}

// Bundled query files (compile-time inclusion)
mod bundled {
    pub const RUST_TAGS: &str = include_str!("../queries/tree-sitter-language-pack/rust-tags.scm");

    pub const PYTHON_TAGS: &str =
        include_str!("../queries/tree-sitter-language-pack/python-tags.scm");

    pub const JAVASCRIPT_TAGS: &str =
        include_str!("../queries/tree-sitter-language-pack/javascript-tags.scm");

    pub const TYPESCRIPT_TAGS: &str =
        include_str!("../queries/tree-sitter-language-pack/typescript-tags.scm");
    pub const TYPESCRIPT_IDENTS: &str =
        include_str!("../queries/tree-sitter-language-pack/typescript-idents.scm");

    pub const GO_TAGS: &str = include_str!("../queries/tree-sitter-language-pack/go-tags.scm");
}

/// Get the query pair for a language.
///
/// Returns `None` if the language has no bundled queries (SPEC §4.1).
pub fn get_queries(lang: &str) -> Option<QueryPair> {
    match lang {
        "rust" => Some(QueryPair {
            tags: bundled::RUST_TAGS,
            idents: None,
        }),
        "python" => Some(QueryPair {
            tags: bundled::PYTHON_TAGS,
            idents: None,
        }),
        "javascript" => Some(QueryPair {
            tags: bundled::JAVASCRIPT_TAGS,
            idents: None,
        }),
        "typescript" => Some(QueryPair {
            tags: bundled::TYPESCRIPT_TAGS,
            idents: Some(bundled::TYPESCRIPT_IDENTS),
        }),
        "go" => Some(QueryPair {
            tags: bundled::GO_TAGS,
            idents: None,
        }),
        _ => None,
    }
}

/// Check if a language has an idents fallback query.
pub fn has_idents_fallback(lang: &str) -> bool {
    get_queries(lang)
        .map(|q| q.idents.is_some())
        .unwrap_or(false)
}

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

    #[test]
    fn get_queries_rust() {
        let q = get_queries("rust").expect("rust should have queries");
        assert!(q.tags.contains("name.definition.function"));
        assert!(q.tags.contains("name.reference.call"));
        assert!(q.idents.is_none());
    }

    #[test]
    fn get_queries_typescript_has_idents() {
        let q = get_queries("typescript").expect("typescript should have queries");
        assert!(q.idents.is_some());
        let idents = q.idents.unwrap();
        assert!(idents.contains("name.reference.identifier"));
    }

    #[test]
    fn get_queries_unknown() {
        assert!(get_queries("unknown_lang").is_none());
    }

    #[test]
    fn has_idents_fallback_check() {
        assert!(!has_idents_fallback("rust"));
        assert!(!has_idents_fallback("python"));
        assert!(has_idents_fallback("typescript"));
    }
}