yog 0.0.1

yog: a balls-oriented session manager for lernie loops (egui frontend)
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

use super::*;
use std::fs;
use tempfile::tempdir;

/// Percent-encode a path's `/` so it round-trips through a single clone
/// basename (the only escape these fixtures need).
fn enc(path: &str) -> String {
    path.replace('/', "%2F")
}

#[test]
fn delivery_root_is_the_state_roots_bl_delivery_tree() {
    assert_eq!(
        delivery_root(Path::new("/s/balls/clones")),
        Some(PathBuf::from("/s/balls/plugins/bl-delivery")),
    );
    // A rootless clones dir has no state root, so nothing can be internal.
    assert_eq!(delivery_root(Path::new("/")), None);
}

#[test]
fn is_internal_matches_only_under_the_delivery_tree() {
    let d = PathBuf::from("/s/balls/plugins/bl-delivery");
    assert!(is_internal(
        Path::new("/s/balls/plugins/bl-delivery/home/u/p/bl-1"),
        Some(&d),
    ));
    assert!(!is_internal(Path::new("/home/u/p"), Some(&d)));
    // No delivery root ⇒ never internal.
    assert!(!is_internal(Path::new("/anything"), None));
}

#[test]
fn missing_clones_dir_enumerates_empty() {
    let dir = tempdir().unwrap();
    assert!(enumerate(&dir.path().join("absent")).is_empty());
}

#[test]
fn enumerate_decodes_flags_internal_and_skips_non_dirs() {
    let root = tempdir().unwrap();
    let clones = root.path().join("balls").join("clones");
    fs::create_dir_all(&clones).unwrap();
    let delivery = root.path().join("balls/plugins/bl-delivery");

    // A normal project clone and an internal (nested-delivery) one.
    fs::create_dir(clones.join(enc("/home/u/proj"))).unwrap();
    let internal_path = format!("{}/home/u/proj/bl-1", delivery.display());
    fs::create_dir(clones.join(enc(&internal_path))).unwrap();
    // A regular file (not a dir) is skipped.
    fs::write(clones.join("stray-file"), b"x").unwrap();

    let projects = enumerate(&clones);
    assert_eq!(projects.len(), 2, "non-dir entry skipped");
    let normal = projects.iter().find(|p| !p.internal).unwrap();
    assert_eq!(normal.path, PathBuf::from("/home/u/proj"));
    let internal = projects.iter().find(|p| p.internal).unwrap();
    assert_eq!(internal.path, PathBuf::from(internal_path));
    // Sorted by decoded path (deterministic roster order).
    let mut sorted = projects.clone();
    sorted.sort_by(|a, b| a.path.cmp(&b.path));
    assert_eq!(projects, sorted);
}

/// A clone dir whose basename is not valid UTF-8 has no `to_str`, so
/// [`enumerate`] skips it (mod.rs `to_str` guard). The fixture is
/// non-macOS-only: APFS enforces valid-UTF-8 filenames and refuses the
/// creation (EILSEQ), so the input is simply unconstructible on macOS; on
/// ext4 — where tarpaulin runs — the guard is still exercised, so coverage
/// is unaffected.
#[cfg(not(target_os = "macos"))]
#[test]
fn enumerate_skips_non_utf8_basenames() {
    use std::ffi::OsStr;
    use std::os::unix::ffi::OsStrExt;

    let clones = tempdir().unwrap();
    fs::create_dir(clones.path().join(enc("/home/u/proj"))).unwrap();
    fs::create_dir(clones.path().join(OsStr::from_bytes(&[0x66, 0x80]))).unwrap();

    let projects = enumerate(clones.path());
    assert_eq!(projects.len(), 1, "non-UTF-8 basename skipped");
    assert_eq!(projects[0].path, PathBuf::from("/home/u/proj"));
}

#[test]
fn visible_filters_internal_unless_the_toggle_is_on() {
    let projects = vec![
        Project {
            path: PathBuf::from("/a"),
            internal: false,
        },
        Project {
            path: PathBuf::from("/b"),
            internal: true,
        },
    ];
    let shown: Vec<_> = visible(&projects, false).iter().map(|p| &p.path).collect();
    assert_eq!(
        shown,
        vec![&PathBuf::from("/a")],
        "internal hidden by default"
    );
    assert_eq!(visible(&projects, true).len(), 2, "toggle reveals internal");
}