raz-core 0.2.4

Universal command generator for Rust projects - Core library with stateless file analysis and cursor-aware execution
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

//! Integration tests for the universal command generator

use raz_core::{FileDetector, Position, UniversalCommandGenerator};
use std::fs;
use tempfile::TempDir;

#[tokio::test]
async fn test_single_file_executable() {
    let temp_dir = TempDir::new().unwrap();
    let file_path = temp_dir.path().join("hello.rs");

    fs::write(&file_path, "fn main() {\n    println!(\"Hello, world!\");\n}\n\n#[test]\nfn test_hello() {\n    assert_eq!(1 + 1, 2);\n}").unwrap();

    let context = FileDetector::detect_context(&file_path, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have rustc run commands for single file
    assert!(commands.iter().any(|c| c.id == "rustc-run"));
    assert!(commands.iter().any(|c| c.id == "rustc-test"));
    assert!(commands.iter().any(|c| c.command == "sh"));
}

#[tokio::test]
async fn test_single_file_library() {
    let temp_dir = TempDir::new().unwrap();
    let file_path = temp_dir.path().join("lib.rs");

    fs::write(&file_path, "pub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn test_add() {\n        assert_eq!(add(2, 3), 5);\n    }\n}").unwrap();

    let context = FileDetector::detect_context(&file_path, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have rustc test command for library
    assert!(commands.iter().any(|c| c.id == "rustc-test"));
    // Should NOT have run commands for library
    assert!(!commands.iter().any(|c| c.id == "rustc-run"));
    // Should NOT have rustdoc-test unless there are actual doc tests
    // (our test file doesn't have doc tests, only regular tests)
}

#[tokio::test]
async fn test_cargo_script() {
    let temp_dir = TempDir::new().unwrap();
    let file_path = temp_dir.path().join("script.rs");

    fs::write(&file_path, "#!/usr/bin/env -S cargo +nightly -Zscript\n\nfn main() {\n    println!(\"Hello from script!\");\n}\n\n#[test]\nfn test_script() {\n    assert_eq!(2 + 2, 4);\n}").unwrap();

    let context = FileDetector::detect_context(&file_path, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have cargo script commands
    assert!(commands.iter().any(|c| c.id == "cargo-script-run"));
    assert!(commands.iter().any(|c| c.id == "cargo-script-test"));
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"+nightly".to_string()))
    );
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"-Zscript".to_string()))
    );
}

#[tokio::test]
async fn test_cargo_package_binary() {
    let temp_dir = TempDir::new().unwrap();
    let project_root = temp_dir.path();

    // Create Cargo.toml
    fs::write(
        project_root.join("Cargo.toml"),
        "[package]\nname = \"hello-world\"\nversion = \"0.1.0\"\nedition = \"2021\"",
    )
    .unwrap();

    // Create src directory and main.rs
    fs::create_dir_all(project_root.join("src")).unwrap();
    let main_path = project_root.join("src").join("main.rs");
    fs::write(&main_path, "fn main() {\n    println!(\"Hello, world!\");\n}\n\n#[cfg(test)]\nmod tests {\n    #[test]\n    fn test_main() {\n        assert!(true);\n    }\n}").unwrap();

    let context = FileDetector::detect_context(&main_path, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have cargo run commands
    assert!(commands.iter().any(|c| c.id == "cargo-run"));
    assert!(commands.iter().any(|c| c.command == "cargo"));
    assert!(commands.iter().any(|c| c.args.contains(&"run".to_string())));
    // Should have cargo test commands
    assert!(commands.iter().any(|c| c.id == "cargo-test"));
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"test".to_string()))
    );
}

#[tokio::test]
async fn test_leptos_frontend_library() {
    let temp_dir = TempDir::new().unwrap();
    let project_root = temp_dir.path();

    // Create workspace Cargo.toml
    fs::write(project_root.join("Cargo.toml"), "[workspace]\nmembers = [\"frontend\", \"server\"]\n\n[workspace.dependencies]\nleptos = \"0.6\"\nleptos_axum = \"0.6\"").unwrap();

    // Create frontend package
    fs::create_dir_all(project_root.join("frontend").join("src")).unwrap();
    fs::write(project_root.join("frontend").join("Cargo.toml"), "[package]\nname = \"frontend\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[lib]\ncrate-type = [\"cdylib\"]\n\n[dependencies]\nleptos = { workspace = true }").unwrap();

    let frontend_lib = project_root.join("frontend").join("src").join("lib.rs");
    fs::write(&frontend_lib, "use leptos::*;\n\n#[component]\npub fn App() -> impl IntoView {\n    view! {\n        <h1>\"Hello Leptos!\"</h1>\n    }\n}").unwrap();

    let context = FileDetector::detect_context(&frontend_lib, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have Leptos-specific commands for frontend library
    assert!(commands.iter().any(|c| c.id == "leptos-watch"));
    assert!(commands.iter().any(|c| c.command == "cargo"));
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"leptos".to_string()))
    );
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"watch".to_string()))
    );
}

#[tokio::test]
async fn test_integration_test_file() {
    let temp_dir = TempDir::new().unwrap();
    let project_root = temp_dir.path();

    // Create Cargo.toml
    fs::write(
        project_root.join("Cargo.toml"),
        "[package]\nname = \"test-project\"\nversion = \"0.1.0\"\nedition = \"2021\"",
    )
    .unwrap();

    // Create src/lib.rs
    fs::create_dir_all(project_root.join("src")).unwrap();
    fs::write(
        project_root.join("src").join("lib.rs"),
        "pub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}",
    )
    .unwrap();

    // Create tests directory and integration test
    fs::create_dir_all(project_root.join("tests")).unwrap();
    let test_file = project_root.join("tests").join("integration.rs");
    fs::write(&test_file, "use test_project::add;\n\n#[test]\nfn test_integration_add() {\n    assert_eq!(add(2, 3), 5);\n}").unwrap();

    let context = FileDetector::detect_context(&test_file, None).unwrap();
    let commands = UniversalCommandGenerator::generate_commands(&context, None).unwrap();

    assert!(!commands.is_empty());
    // Should have integration test specific commands
    assert!(commands.iter().any(|c| c.id == "cargo-test"));
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"--test".to_string()))
    );
    assert!(
        commands
            .iter()
            .any(|c| c.args.contains(&"integration".to_string()))
    );
    // Should NOT have run commands for test file
    assert!(!commands.iter().any(|c| c.id == "cargo-run"));
}

#[tokio::test]
async fn test_stateless_operation() {
    let temp_dir = TempDir::new().unwrap();
    let file_path = temp_dir.path().join("standalone.rs");

    fs::write(
        &file_path,
        "fn main() {\n    println!(\"This is a standalone file\");\n}",
    )
    .unwrap();

    // Test from different "working directories" - should always work the same
    let context1 = FileDetector::detect_context(&file_path, None).unwrap();
    let commands1 = UniversalCommandGenerator::generate_commands(&context1, None).unwrap();

    let context2 = FileDetector::detect_context(&file_path, None).unwrap();
    let commands2 = UniversalCommandGenerator::generate_commands(&context2, None).unwrap();

    // Results should be identical regardless of working directory
    assert_eq!(commands1.len(), commands2.len());
    assert_eq!(commands1.first().unwrap().id, commands2.first().unwrap().id);
    assert_eq!(
        commands1.first().unwrap().command,
        commands2.first().unwrap().command
    );

    // Working directory should be set to the file's directory
    assert_eq!(
        commands1.first().unwrap().cwd,
        Some(file_path.parent().unwrap().to_path_buf())
    );
}

#[tokio::test]
async fn test_binary_file_test_commands() {
    // Create a project structure with a binary in src/bin/
    let temp_dir = TempDir::new().unwrap();
    let project_root = temp_dir.path();

    // Create Cargo.toml
    let cargo_toml = r#"
[package]
name = "test-project"
version = "0.1.0"
edition = "2021"

[[bin]]
name = "mybin"
path = "src/bin/mybin.rs"
"#;
    fs::write(project_root.join("Cargo.toml"), cargo_toml).unwrap();

    // Create src/bin directory
    fs::create_dir_all(project_root.join("src/bin")).unwrap();

    // Create binary file with tests
    let binary_content = r#"
fn main() {
    println!("Hello from mybin");
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_something() {
        assert_eq!(1 + 1, 2);
    }
}
"#;

    let binary_path = project_root.join("src/bin/mybin.rs");
    fs::write(&binary_path, binary_content).unwrap();

    // Test command generation with cursor on test
    let context = FileDetector::detect_context(
        &binary_path,
        Some(Position { line: 8, column: 1 }), // On test function
    )
    .unwrap();

    let commands = UniversalCommandGenerator::generate_commands(
        &context,
        Some(Position { line: 8, column: 1 }),
    )
    .unwrap();

    // Find the specific test command
    let test_command = commands
        .iter()
        .find(|cmd| cmd.label.contains("specific test"))
        .expect("Should generate specific test command for binary");

    // Verify the command uses --bin flag
    assert_eq!(test_command.command, "cargo");
    assert!(test_command.args.contains(&"test".to_string()));
    assert!(test_command.args.contains(&"--bin".to_string()));
    assert!(test_command.args.contains(&"mybin".to_string()));

    // The test name should not include bin:: prefix
    let separator_idx = test_command
        .args
        .iter()
        .position(|arg| arg == "--")
        .unwrap();
    let test_name = &test_command.args[separator_idx + 1];
    assert_eq!(test_name, "tests::test_something");
    assert!(test_command.args.contains(&"--exact".to_string()));
    assert!(test_command.args.contains(&"--show-output".to_string()));
}