lernie 0.1.60

lernie: the operator seat — the window and wire client for a yog server
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

//! The fold as a value: what a closed subtree hides, what an open one shows,
//! and that the one list is what both surfaces read.

use crate::reply::convs::ConvRow;
use crate::test_support::window::{conv, seated};
use crate::ui::Model;

/// The session the ball measured, in the shape the wire answers it: a root
/// with four compactors under it, and a second root beside them.
fn session() -> Vec<ConvRow> {
    let mut rows = Vec::new();
    let mut root = conv("c-root", "ShorelineGuppy");
    root.members = 5;
    rows.push(root);
    for name in [
        "CardboardFoothill",
        "CrispGorge",
        "DuneBreeze",
        "TortillaSaucepan",
    ] {
        let mut child = conv(name, name);
        child.depth = 1;
        child.preview = "You are the compactor for branch `20260906T034041Z`.".to_owned();
        rows.push(child);
    }
    rows.push(conv("c-other", "WhiskFrost"));
    rows
}

fn named(model: &Model) -> Vec<String> {
    model.rows().into_iter().map(|row| row.display).collect()
}

#[test]
fn a_conversation_s_machinery_is_under_it_and_not_beside_it() {
    let model = Model {
        convs: session(),
        ..seated()
    };
    assert_eq!(named(&model), vec!["ShorelineGuppy", "WhiskFrost"]);
}

#[test]
fn opening_one_subtree_shows_it_and_leaves_the_others_alone() {
    let mut model = Model {
        convs: session(),
        ..seated()
    };
    model.toggle_subtree("c-root");
    assert!(model.subtree_open("c-root"));
    assert_eq!(
        named(&model),
        vec![
            "ShorelineGuppy",
            "CardboardFoothill",
            "CrispGorge",
            "DuneBreeze",
            "TortillaSaucepan",
            "WhiskFrost",
        ]
    );
    model.toggle_subtree("c-root");
    assert!(!model.subtree_open("c-root"));
    assert_eq!(named(&model), vec!["ShorelineGuppy", "WhiskFrost"]);
}

/// **A subtree under a subtree is its own gesture.** Opening a root shows its
/// children; what hangs under one of THOSE is under it, on the same rule.
#[test]
fn a_deeper_subtree_is_folded_under_the_child_that_holds_it() {
    let mut rows = session();
    let mut deep = conv("c-deep", "MetronomeHumble");
    deep.depth = 2;
    rows.insert(2, deep);
    let mut model = Model {
        convs: rows,
        ..seated()
    };
    model.toggle_subtree("c-root");
    assert!(!named(&model).contains(&"MetronomeHumble".to_owned()));
    model.toggle_subtree("CardboardFoothill");
    assert!(named(&model).contains(&"MetronomeHumble".to_owned()));
}