rustcodegraph 1.2.10

Local-first code intelligence graph and CLI for AI agents
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

mod describe_0846_rust_extraction {
    use super::*;
    const TS_DESCRIBE_TITLE: &str = "Rust Extraction";
    const TS_DESCRIBE_LINE: usize = 846;
    #[test]
    fn describes_010_is_represented() {
        assert!(!TS_DESCRIBE_TITLE.is_empty());
        assert_eq!(TS_DESCRIBE_LINE, 846);
    }
    #[test]
    fn case_0847_should_extract_function_declarations() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(57, 57);
        let code = r#"
pub fn process_data(input: &str) -> Result<Output, Error> {
    Ok(Output::new())
}
"#;
        let result = extract("lib.rs", code);
        let func_node = find_node(&result, NodeKind::Function, "process_data")
            .expect("process_data function should be extracted");
        assert_eq!(func_node.visibility, Some(Visibility::Public));
    }
    #[test]
    fn case_0862_should_extract_struct_declarations() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(58, 58);
        let code = r#"
pub struct User {
    pub id: String,
    pub name: String,
    email: String,
}
"#;
        let result = extract("models.rs", code);
        let struct_node =
            find_node(&result, NodeKind::Struct, "User").expect("User struct should be extracted");
        assert_eq!(struct_node.language, Language::Rust);
    }
    #[test]
    fn case_0877_should_extract_trait_declarations() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(59, 59);
        let code = r#"
pub trait Repository {
    fn find(&self, id: &str) -> Option<Entity>;
    fn save(&mut self, entity: Entity) -> Result<(), Error>;
}
"#;
        let result = extract("traits.rs", code);
        let trait_node = find_node(&result, NodeKind::Trait, "Repository")
            .expect("Repository trait should be extracted");
        assert_eq!(trait_node.language, Language::Rust);
    }
    #[test]
    fn case_0891_should_extract_impl_trait_for_type_as_implements_edges() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(60, 60);
        let code = r#"
pub struct MyCache {}

pub trait Cache {
    fn get(&self, key: &str) -> Option<String>;
}

impl Cache for MyCache {
    fn get(&self, key: &str) -> Option<String> {
        None
    }
}
"#;
        let result = extract("cache.rs", code);
        let my_cache = find_node(&result, NodeKind::Struct, "MyCache")
            .expect("MyCache struct should be extracted");
        assert!(result.unresolved_references.iter().any(|reference| {
            reference.reference_kind == ReferenceKind::Implements
                && reference.reference_name == "Cache"
                && reference.from_node_id == my_cache.id
        }));
    }
    #[test]
    fn case_0919_should_extract_trait_supertraits_as_extends_references() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(61, 61);
        let code = r#"
pub trait Display {}

pub trait Error: Display {
    fn description(&self) -> &str;
}
"#;
        let result = extract("error.rs", code);
        let error_trait =
            find_node(&result, NodeKind::Trait, "Error").expect("Error trait should be extracted");
        assert!(result.unresolved_references.iter().any(|reference| {
            reference.reference_kind == ReferenceKind::Extends
                && reference.reference_name == "Display"
                && reference.from_node_id == error_trait.id
        }));
    }
    #[test]
    fn case_0939_should_not_create_implements_edges_for_plain_impl_blocks() {
        let suite = ["Rust Extraction"];
        assert_eq!(suite.len(), 1);
        assert_eq!(62, 62);
        let code = r#"
pub struct Counter {
    count: u32,
}

impl Counter {
    pub fn new() -> Counter {
        Counter { count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
}
"#;
        let result = extract("counter.rs", code);
        assert!(
            result
                .unresolved_references
                .iter()
                .all(|reference| reference.reference_kind != ReferenceKind::Implements),
            "references: {:?}",
            result.unresolved_references
        );
    }
}