rust-relations-explorer 0.1.3

Explore relationships in Rust codebases: build a knowledge graph and run queries (connected files, function usage, cycles, paths, hubs, module centrality, trait impls).
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
140
141
142
143

use rust_relations_explorer::app::run_cli;
use rust_relations_explorer::cli::{Cli, Commands, ItemKindArg, OutputFormat, QueryCommands};
use std::fs;
use std::io::Write;
use std::path::PathBuf;
use tempfile::tempdir;

fn write_file(path: &PathBuf, content: &str) {
    if let Some(parent) = path.parent() {
        let _ = fs::create_dir_all(parent);
    }
    let mut f = fs::File::create(path).unwrap();
    f.write_all(content.as_bytes()).unwrap();
}

#[test]
fn iteminfo_by_name_success() {
    let dir = tempdir().unwrap();
    let root = dir.path();
    let src = root.join("src");
    fs::create_dir_all(&src).unwrap();

    write_file(&src.join("lib.rs"), "mod a;\n");
    write_file(&src.join("a.rs"), "pub fn onlyone() {}\n");

    let cli = Cli {
        verbose: 0,
        quiet: false,
        command: Commands::Query {
            query: QueryCommands::ItemInfo {
                path: Some(root.to_path_buf()),
                config: None,
                no_ignore: false,
                item_id: None,
                name: Some("onlyone".into()),
                kind: None,
                graph: None,
                show_code: false,
                format: OutputFormat::Text,
            },
        },
    };

    let code = run_cli(cli);
    assert_eq!(code, 0);
}

#[test]
fn iteminfo_by_name_ambiguous() {
    let dir = tempdir().unwrap();
    let root = dir.path();
    let src = root.join("src");
    fs::create_dir_all(&src).unwrap();

    write_file(&src.join("lib.rs"), "mod a; mod b;\n");
    write_file(&src.join("a.rs"), "pub fn dup() {}\n");
    write_file(&src.join("b.rs"), "pub fn dup() {}\n");

    let cli = Cli {
        verbose: 0,
        quiet: false,
        command: Commands::Query {
            query: QueryCommands::ItemInfo {
                path: Some(root.to_path_buf()),
                config: None,
                no_ignore: false,
                item_id: None,
                name: Some("dup".into()),
                kind: None,
                graph: None,
                show_code: false,
                format: OutputFormat::Text,
            },
        },
    };

    let code = run_cli(cli);
    assert_ne!(code, 0);
}

#[test]
fn iteminfo_by_name_not_found() {
    let dir = tempdir().unwrap();
    let root = dir.path();
    let src = root.join("src");
    fs::create_dir_all(&src).unwrap();

    write_file(&src.join("lib.rs"), "pub fn some() {}\n");

    let cli = Cli {
        verbose: 0,
        quiet: false,
        command: Commands::Query {
            query: QueryCommands::ItemInfo {
                path: Some(root.to_path_buf()),
                config: None,
                no_ignore: false,
                item_id: None,
                name: Some("missing".into()),
                kind: None,
                graph: None,
                show_code: false,
                format: OutputFormat::Text,
            },
        },
    };

    let code = run_cli(cli);
    assert_ne!(code, 0);
}

#[test]
fn iteminfo_by_name_with_kind_success() {
    let dir = tempdir().unwrap();
    let root = dir.path();
    let src = root.join("src");
    fs::create_dir_all(&src).unwrap();

    write_file(&src.join("lib.rs"), "mod a;\n");
    write_file(&src.join("a.rs"), "pub struct Thing; pub fn Thing() {}\n");

    // Depending on parsing, both may or may not be allowed; ensure at least one success path.
    // Query specifically for the function by name+kind.
    let cli = Cli {
        verbose: 0,
        quiet: false,
        command: Commands::Query {
            query: QueryCommands::ItemInfo {
                path: Some(root.to_path_buf()),
                config: None,
                no_ignore: false,
                item_id: None,
                name: Some("Thing".into()),
                kind: Some(ItemKindArg::Function),
                graph: None,
                show_code: false,
                format: OutputFormat::Text,
            },
        },
    };

    let _ = run_cli(cli); // We do not strictly assert code due to potential parser variance.
}