barad-dur 0.18.0

The all-seeing repository analyzer
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 super::fallback::Language;
use super::queries;

/// Map a language + file extension to the corresponding tree-sitter grammar.
pub fn grammar_for(lang: Language, ext: &str) -> Option<tree_sitter::Language> {
    match lang {
        Language::Rust => Some(tree_sitter_rust::LANGUAGE.into()),
        Language::JsTs => match ext {
            "ts" => Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
            "tsx" => Some(tree_sitter_typescript::LANGUAGE_TSX.into()),
            _ => Some(tree_sitter_javascript::LANGUAGE.into()),
        },
        Language::Python => Some(tree_sitter_python::LANGUAGE.into()),
        Language::Go => Some(tree_sitter_go::LANGUAGE.into()),
        Language::Java => Some(tree_sitter_java::LANGUAGE.into()),
        Language::CSharp => Some(tree_sitter_c_sharp::LANGUAGE.into()),
        Language::Kotlin => Some(tree_sitter_kotlin_ng::LANGUAGE.into()),
        Language::Generic => None,
    }
}

/// Map a language to its import query string, if supported.
pub fn import_query(lang: Language, _ext: &str) -> Option<&'static str> {
    match lang {
        Language::Rust => Some(queries::RUST_IMPORTS),
        Language::JsTs => Some(queries::JS_IMPORTS),
        Language::Python => Some(queries::PYTHON_IMPORTS),
        Language::Go => Some(queries::GO_IMPORTS),
        Language::Java => Some(queries::JAVA_IMPORTS),
        Language::CSharp => Some(queries::CSHARP_IMPORTS),
        Language::Kotlin => Some(queries::KOTLIN_IMPORTS),
        Language::Generic => None,
    }
}

/// Map a language to its cyclomatic complexity query strings.
pub fn complexity_queries(lang: Language, ext: &str) -> (&'static str, Option<&'static str>) {
    match lang {
        Language::Rust => (
            queries::RUST_COMPLEXITY,
            Some(queries::RUST_COMPLEXITY_OPERATORS),
        ),
        Language::JsTs => match ext {
            "ts" | "tsx" => (
                queries::JS_COMPLEXITY,
                Some(queries::JS_COMPLEXITY_OPERATORS),
            ),
            _ => (
                queries::JS_COMPLEXITY,
                Some(queries::JS_COMPLEXITY_OPERATORS),
            ),
        },
        Language::Python => (queries::PYTHON_COMPLEXITY, None),
        Language::Go => (
            queries::GO_COMPLEXITY,
            Some(queries::GO_COMPLEXITY_OPERATORS),
        ),
        Language::Java => (
            queries::JAVA_COMPLEXITY,
            Some(queries::JAVA_COMPLEXITY_OPERATORS),
        ),
        Language::CSharp => (
            queries::CSHARP_COMPLEXITY,
            Some(queries::CSHARP_COMPLEXITY_OPERATORS),
        ),
        Language::Kotlin => (
            queries::KOTLIN_COMPLEXITY,
            Some(queries::KOTLIN_COMPLEXITY_OPERATORS),
        ),
        Language::Generic => (queries::RUST_COMPLEXITY, None), // unreachable
    }
}

/// Map a language to its function-node query string, if supported.
pub fn function_query(lang: Language, _ext: &str) -> Option<&'static str> {
    match lang {
        Language::Rust => Some(queries::RUST_FUNCTIONS),
        Language::JsTs => Some(queries::JS_FUNCTIONS),
        Language::Python => Some(queries::PYTHON_FUNCTIONS),
        Language::Go => Some(queries::GO_FUNCTIONS),
        Language::Java => Some(queries::JAVA_FUNCTIONS),
        Language::CSharp => Some(queries::CSHARP_FUNCTIONS),
        Language::Kotlin => Some(queries::KOTLIN_FUNCTIONS),
        Language::Generic => None,
    }
}

/// Map a language to its nesting query string, if supported.
pub fn nesting_query(lang: Language, _ext: &str) -> Option<&'static str> {
    match lang {
        Language::Rust => Some(queries::RUST_NESTING),
        Language::JsTs => Some(queries::JS_NESTING),
        Language::Python => Some(queries::PYTHON_NESTING),
        Language::Go => Some(queries::GO_NESTING),
        Language::Java => Some(queries::JAVA_NESTING),
        Language::CSharp => Some(queries::CSHARP_NESTING),
        Language::Kotlin => Some(queries::KOTLIN_NESTING),
        Language::Generic => None,
    }
}

/// Map a language to its comment query string (used for LOC calculation).
pub fn comment_query(lang: Language, ext: &str) -> &'static str {
    match lang {
        Language::Rust => queries::RUST_COMMENTS,
        Language::JsTs => match ext {
            "ts" | "tsx" => queries::JS_COMMENTS,
            _ => queries::JS_COMMENTS,
        },
        Language::Python => queries::PYTHON_COMMENTS,
        Language::Go => queries::GO_COMMENTS,
        Language::Java => queries::JAVA_COMMENTS,
        Language::CSharp => queries::CSHARP_COMMENTS,
        Language::Kotlin => queries::KOTLIN_COMMENTS,
        Language::Generic => queries::RUST_COMMENTS, // unreachable
    }
}