probe-code 0.6.0

AI-friendly, fully local, semantic code search tool for large codebases
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use super::language_trait::LanguageImpl;
use tree_sitter::{Language as TSLanguage, Node};

/// Implementation of LanguageImpl for C#
pub struct CSharpLanguage;

impl Default for CSharpLanguage {
    fn default() -> Self {
        Self::new()
    }
}

impl CSharpLanguage {
    pub fn new() -> Self {
        CSharpLanguage
    }
}

impl LanguageImpl for CSharpLanguage {
    fn get_tree_sitter_language(&self) -> TSLanguage {
        // Create a new instance of the Language type from the current tree-sitter version
        unsafe { std::mem::transmute(tree_sitter_c_sharp::LANGUAGE) }
    }

    fn get_extension(&self) -> &'static str {
        "cs"
    }

    fn is_acceptable_parent(&self, node: &Node) -> bool {
        matches!(
            node.kind(),
            "method_declaration"
                | "class_declaration"
                | "struct_declaration"
                | "interface_declaration"
                | "enum_declaration"
                | "namespace_declaration"
                | "property_declaration"
                | "constructor_declaration"
                | "delegate_declaration"
                | "event_declaration"
        )
    }

    fn is_test_node(&self, node: &Node, source: &[u8]) -> bool {
        let debug_mode = std::env::var("DEBUG").unwrap_or_default() == "1";
        let node_type = node.kind();

        // C#: Check for test methods with attributes
        if node_type == "method_declaration" {
            let mut cursor = node.walk();

            // Check for test attributes (NUnit, MSTest, xUnit)
            let mut has_test_attribute = false;

            for child in node.children(&mut cursor) {
                if child.kind() == "attribute_list" {
                    let attr_text = child.utf8_text(source).unwrap_or("");
                    if attr_text.contains("[Test")
                        || attr_text.contains("[TestMethod")
                        || attr_text.contains("[Fact")
                        || attr_text.contains("[Theory")
                    {
                        has_test_attribute = true;
                        break;
                    }
                }
            }

            if has_test_attribute {
                if debug_mode {
                    println!("DEBUG: Test node detected (C#): test attribute");
                }
                return true;
            }

            // Also check for method name starting with "Test"
            for child in node.children(&mut cursor) {
                if child.kind() == "identifier" {
                    let name = child.utf8_text(source).unwrap_or("");
                    if name.starts_with("Test") {
                        if debug_mode {
                            println!("DEBUG: Test node detected (C#): Test method");
                        }
                        return true;
                    }
                }
            }
        }

        // Check for test classes
        if node_type == "class_declaration" {
            let mut cursor = node.walk();

            // Check for test class attributes
            for child in node.children(&mut cursor) {
                if child.kind() == "attribute_list" {
                    let attr_text = child.utf8_text(source).unwrap_or("");
                    if attr_text.contains("[TestClass") || attr_text.contains("[TestFixture") {
                        if debug_mode {
                            println!("DEBUG: Test node detected (C#): test class attribute");
                        }
                        return true;
                    }
                }
            }

            // Check for class name ending with "Tests" or "Test"
            for child in node.children(&mut cursor) {
                if child.kind() == "identifier" {
                    let name = child.utf8_text(source).unwrap_or("");
                    if name.ends_with("Tests") || name.ends_with("Test") {
                        if debug_mode {
                            println!(
                                "DEBUG: Test node detected (C#): Test class naming convention"
                            );
                        }
                        return true;
                    }
                }
            }
        }

        false
    }

    fn find_parent_function<'a>(&self, node: Node<'a>) -> Option<Node<'a>> {
        let mut current = node;

        while let Some(parent) = current.parent() {
            if parent.kind() == "method_declaration" {
                return Some(parent);
            }
            current = parent;
        }

        None
    }
}