ruchy 4.1.2

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
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
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328

//! STD-004: Path Module Tests (ruchy/std/path)
//!
//! Test suite for path manipulation operations module.
//! Thin wrappers around Rust's `std::path` with Ruchy-friendly API.
//!
//! EXTREME TDD: These tests are written BEFORE implementation (RED phase).

#![allow(clippy::case_sensitive_file_extension_comparisons)] // Path tests intentionally test exact strings
#![allow(missing_docs)]
#![allow(clippy::collapsible_if)] // Test readability over compactness

use std::path::Path;
use tempfile::TempDir;

/// Helper to create a test file
fn create_test_file(dir: &TempDir, name: &str) -> std::path::PathBuf {
    let file_path = dir.path().join(name);
    std::fs::write(&file_path, "test").expect("Failed to write test file");
    file_path
}

#[test]
fn test_std_004_join_paths() {
    // STD-004: Test joining path components

    // Call ruchy::stdlib::path::join
    let result = ruchy::stdlib::path::join("/home/user", "documents");

    assert!(result.is_ok(), "join should succeed");
    let path_str = result.unwrap();
    assert!(path_str.contains("/home/user"), "Must contain base path");
    assert!(
        path_str.contains("documents"),
        "Must contain appended component"
    );
    assert!(
        path_str.ends_with("documents"),
        "Must end with appended component"
    );
    assert!(!path_str.is_empty(), "Path must not be empty");
}

#[test]
fn test_std_004_join_multiple_components() {
    // STD-004: Test joining multiple path components

    let result = ruchy::stdlib::path::join_many(&["/home", "user", "documents", "file.txt"]);

    assert!(result.is_ok(), "join_many should succeed");
    let path_str = result.unwrap();
    assert!(path_str.contains("home"), "Must contain 'home'");
    assert!(path_str.contains("user"), "Must contain 'user'");
    assert!(path_str.contains("documents"), "Must contain 'documents'");
    assert!(path_str.ends_with("file.txt"), "Must end with 'file.txt'");
    assert!(!path_str.is_empty(), "Path must not be empty");
}

#[test]
fn test_std_004_parent() {
    // STD-004: Test getting parent directory

    let result = ruchy::stdlib::path::parent("/home/user/documents/file.txt");

    assert!(result.is_ok(), "parent should succeed");
    let parent_str = result.unwrap();
    assert!(parent_str.is_some(), "Parent should exist");
    let parent = parent_str.unwrap();
    assert!(
        parent.contains("documents"),
        "Parent must contain 'documents'"
    );
    assert!(
        !parent.contains("file.txt"),
        "Parent must not contain filename"
    );
    assert!(!parent.is_empty(), "Parent must not be empty");
}

#[test]
fn test_std_004_parent_root() {
    // STD-004: Test parent of root path

    let result = ruchy::stdlib::path::parent("/");

    assert!(result.is_ok(), "parent should succeed");
    let parent_str = result.unwrap();
    assert!(parent_str.is_none(), "Root should have no parent");
}

#[test]
fn test_std_004_file_name() {
    // STD-004: Test getting file name from path

    let result = ruchy::stdlib::path::file_name("/home/user/documents/file.txt");

    assert!(result.is_ok(), "file_name should succeed");
    let name = result.unwrap();
    assert!(name.is_some(), "File name should exist");
    let name_str = name.unwrap();
    assert_eq!(name_str, "file.txt", "File name must be exactly 'file.txt'");
    assert_eq!(name_str.len(), 8, "File name length must be 8");
    assert!(!name_str.is_empty(), "File name must not be empty");
}

#[test]
fn test_std_004_file_name_no_name() {
    // STD-004: Test file_name on path with no file name

    let result = ruchy::stdlib::path::file_name("/home/user/");

    assert!(result.is_ok(), "file_name should succeed");
    let _name = result.unwrap();
    // Trailing slash may or may not have file name depending on implementation
    // This is OK - either "user" or None is acceptable
}

#[test]
fn test_std_004_file_stem() {
    // STD-004: Test getting file stem (name without extension)

    let result = ruchy::stdlib::path::file_stem("/home/user/file.txt");

    assert!(result.is_ok(), "file_stem should succeed");
    let stem = result.unwrap();
    assert!(stem.is_some(), "File stem should exist");
    let stem_str = stem.unwrap();
    assert_eq!(stem_str, "file", "File stem must be exactly 'file'");
    assert_eq!(stem_str.len(), 4, "File stem length must be 4");
    assert!(
        !stem_str.contains(".txt"),
        "Stem must not contain extension"
    );
    assert!(!stem_str.is_empty(), "Stem must not be empty");
}

#[test]
fn test_std_004_extension() {
    // STD-004: Test getting file extension

    let result = ruchy::stdlib::path::extension("/home/user/file.txt");

    assert!(result.is_ok(), "extension should succeed");
    let ext = result.unwrap();
    assert!(ext.is_some(), "Extension should exist");
    let ext_str = ext.unwrap();
    assert_eq!(ext_str, "txt", "Extension must be exactly 'txt'");
    assert_eq!(ext_str.len(), 3, "Extension length must be 3");
    assert!(!ext_str.contains('.'), "Extension must not contain dot");
    assert!(!ext_str.is_empty(), "Extension must not be empty");
}

#[test]
fn test_std_004_extension_none() {
    // STD-004: Test path with no extension

    let result = ruchy::stdlib::path::extension("/home/user/file");

    assert!(result.is_ok(), "extension should succeed");
    let ext = result.unwrap();
    assert!(ext.is_none(), "Path without extension should return None");
}

#[test]
fn test_std_004_is_absolute() {
    // STD-004: Test checking if path is absolute

    let result = ruchy::stdlib::path::is_absolute("/home/user/file.txt");
    assert!(result, "Path starting with / must be absolute");

    let result = ruchy::stdlib::path::is_absolute("relative/path");
    assert!(!result, "Path not starting with / must be relative");

    let result = ruchy::stdlib::path::is_absolute("./relative");
    assert!(!result, "Path starting with ./ must be relative");
}

#[test]
fn test_std_004_is_relative() {
    // STD-004: Test checking if path is relative

    let result = ruchy::stdlib::path::is_relative("relative/path");
    assert!(result, "Path without / must be relative");

    let result = ruchy::stdlib::path::is_relative("/home/user");
    assert!(!result, "Absolute path must not be relative");
}

#[test]
fn test_std_004_canonicalize() {
    // STD-004: Test resolving path to canonical form

    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let file_path = create_test_file(&temp_dir, "test.txt");

    let result = ruchy::stdlib::path::canonicalize(file_path.to_str().unwrap());

    assert!(
        result.is_ok(),
        "canonicalize should succeed for existing file"
    );
    let canonical = result.unwrap();
    assert!(!canonical.is_empty(), "Canonical path must not be empty");
    assert!(
        Path::new(&canonical).is_absolute(),
        "Canonical path must be absolute"
    );
    assert!(canonical.contains("test.txt"), "Must contain filename");
}

#[test]
fn test_std_004_canonicalize_nonexistent() {
    // STD-004: Test canonicalize on nonexistent path

    let result = ruchy::stdlib::path::canonicalize("/nonexistent/path/file.txt");

    assert!(
        result.is_err(),
        "canonicalize should fail for nonexistent path"
    );
}

#[test]
fn test_std_004_with_extension() {
    // STD-004: Test replacing extension

    let result = ruchy::stdlib::path::with_extension("/home/user/file.txt", "md");

    assert!(result.is_ok(), "with_extension should succeed");
    let new_path = result.unwrap();
    assert!(new_path.ends_with(".md"), "Must end with new extension");
    assert!(!new_path.ends_with(".txt"), "Must not have old extension");
    assert!(new_path.contains("file"), "Must still contain filename");
    assert!(!new_path.is_empty(), "Path must not be empty");
}

#[test]
fn test_std_004_with_file_name() {
    // STD-004: Test replacing file name

    let result = ruchy::stdlib::path::with_file_name("/home/user/old.txt", "new.txt");

    assert!(result.is_ok(), "with_file_name should succeed");
    let new_path = result.unwrap();
    assert!(new_path.ends_with("new.txt"), "Must end with new filename");
    assert!(
        !new_path.contains("old.txt"),
        "Must not contain old filename"
    );
    assert!(
        new_path.contains("/home/user"),
        "Must retain parent directory"
    );
    assert!(!new_path.is_empty(), "Path must not be empty");
}

#[test]
fn test_std_004_components() {
    // STD-004: Test getting path components

    let result = ruchy::stdlib::path::components("/home/user/file.txt");

    assert!(result.is_ok(), "components should succeed");
    let comps = result.unwrap();
    assert!(!comps.is_empty(), "Components must not be empty");
    assert!(comps.len() >= 3, "Should have at least 3 components");
    assert!(comps.contains(&"home".to_string()), "Must contain 'home'");
    assert!(comps.contains(&"user".to_string()), "Must contain 'user'");
    assert!(
        comps.contains(&"file.txt".to_string()),
        "Must contain 'file.txt'"
    );
}

#[test]
fn test_std_004_normalize() {
    // STD-004: Test normalizing path (removing . and ..)

    let result = ruchy::stdlib::path::normalize("/home/user/../admin/./file.txt");

    assert!(result.is_ok(), "normalize should succeed");
    let normalized = result.unwrap();
    assert!(!normalized.contains(".."), "Must not contain '..'");
    assert!(!normalized.contains("/."), "Must not contain '/.'");
    assert!(normalized.contains("admin"), "Must contain 'admin'");
    assert!(normalized.contains("file.txt"), "Must contain 'file.txt'");
    assert!(!normalized.is_empty(), "Path must not be empty");
}

// ===== Property Tests =====

#[cfg(test)]
mod property_tests {

    use proptest::prelude::*;

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(20))]

        #[test]
        fn test_std_004_join_never_panics(base in "[a-z/]{1,20}", comp in "[a-z]{1,10}") {
            // Property: join should never panic

            let _ = ruchy::stdlib::path::join(&base, &comp);
            // Should not panic
        }

        #[test]
        fn test_std_004_parent_idempotent(path in "/[a-z/]{1,50}") {
            // Property: parent(parent(x)) should equal parent(x) for paths with <=1 component

            if let Ok(Some(parent1)) = ruchy::stdlib::path::parent(&path) {
                if let Ok(p2) = ruchy::stdlib::path::parent(&parent1) {
                    // Both should succeed
                    assert!(p2.is_some() || parent1 == "/");
                }
            }
        }

        #[test]
        fn test_std_004_absolute_relative_inverse(path in "[a-z/]{1,20}") {
            // Property: is_absolute and is_relative should be inverses

            let abs = ruchy::stdlib::path::is_absolute(&path);
            let rel = ruchy::stdlib::path::is_relative(&path);
            assert_ne!(abs, rel, "is_absolute and is_relative must be opposites");
        }
    }
}