go-brrr 0.1.0

Token-efficient code analysis for LLMs - Rust implementation
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

//! Test Java language support.

use go_brrr::lang::java::Java;
use go_brrr::lang::traits::Language;

fn main() {
    let java = Java;

    // Test parsing
    let mut parser = java.parser().expect("Failed to create parser");

    let code = r#"
import java.util.List;
import static java.lang.Math.PI;

/**
 * User class with documentation.
 */
@Entity
public class User extends BaseEntity implements Serializable {
    private String name;

    /**
     * Constructor.
     */
    public User(String name) {
        this.name = name;
    }

    /**
     * Get name.
     */
    @Override
    public String getName() {
        return name;
    }

    public static <T> List<T> process(List<T> items, int count) {
        return items;
    }
}
"#;

    let tree = parser.parse(code, None).expect("Failed to parse");
    let root = tree.root_node();

    println!("=== Java Language Support Test ===\n");

    // Test import extraction
    let imports = java.extract_imports(&tree, code.as_bytes());
    println!("Imports found: {}", imports.len());
    for imp in &imports {
        println!(
            "  - {}{}",
            imp.module,
            if imp.is_from { " (static)" } else { "" }
        );
    }

    // Test class and method extraction
    for child in root.children(&mut root.walk()) {
        if child.kind() == "class_declaration" {
            if let Some(class) = java.extract_class(child, code.as_bytes()) {
                println!("\nClass: {}", class.name);
                println!("  Bases: {:?}", class.bases);
                println!("  Decorators: {:?}", class.decorators);
                if let Some(doc) = &class.docstring {
                    println!("  Doc: {}", doc.lines().next().unwrap_or(""));
                }
                println!("  Methods:");
                for method in &class.methods {
                    println!("    - {} ({})", method.name, method.signature());
                    println!("      Decorators: {:?}", method.decorators);
                }
            }
        }
    }

    println!("\n=== Test Passed ===");
}